TIL 혼자 정리

프로그래머스 (PCCE 기출) | 10번. 데이터 분석 - 구현 문풀 (Java)

혼자 정리 — Tue, 16 Jul 2024 17:19:13 +0900

⬛ 프로그래머스 (PCCE 기출) | 10번. 데이터 분석 - 구현 문풀 (Java)

문제 설명

문제 접근 방식

문제에서는 data[][] 2차원 배열로 들어오는 정보를 뽑아낼 ext 값을 기준으로 int val_ext 보다 작은 값만 추출한 뒤, 그들을 다시 sort_by 값을 기준으로 오름차순 정렬한 데이터를 2차원 배열 형태로 반환하라고 하고 있다.

우선 Data 클래스를 하나 선언했다. 이 안에서 내부적으로 2차원 배열과 동일한 셋을 가지되, sortby 값을 모두 갖게끔 만들어서 정렬 시 그 값을 기준으로 오름차순 정렬하도록 compareTo 메소드를 재정의 해뒀다.
PriorityQueue 우선순위 큐에 Data 객체 값을 가질 건데, 어차피 이 자료구조에 담게 되면 자동정렬 될 거니까. ext값이 ext_Val 값보다 큰 값은 안담을 거라 continue 처리하고 그들을 제외한 값은 모두 담게 만들어서 자동 정렬 시켰다.
이후 answer 2차원 배열에다가 pQ에 있는 Data 객체를 하나씩 뽑아서 담고 최종적으로 리턴하면 정답 처리가 된다.

제출 코드

import java.util.*;
class Data implements Comparable<Data>{
    int code;
    int date;
    int maximum;
    int remain;
    String target; //정렬 기준어 
    Data(int code, int date, int maximum, int remain, String target){
        this.code = code;
        this.date = date;
        this.maximum = maximum;
        this.remain = remain;
        this.target = target;
    }
    
    @Override
    public int compareTo(Data o){ // 각 비교 기준에 따라 정렬 
        if(this.target.equals("code")){
            return this.code - o.code;//오름차순 정렬 
        }
        if(this.target.equals("date")){
            return this.date - o.date;
        }
        if(this.target.equals("maximum")){
            return this.maximum - o.maximum;
        }
        if(this.target.equals("remain")){
            return this.remain - o.remain;//더 적게 남은 거 우선 정렬 
        }
        
        return this.code - o.code;
    }
}
class Solution {
    //솔루션 함수 
    public int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {

        PriorityQueue<Data> pQ = new PriorityQueue<>();
        
        //data에서 ext값이 val_ext 값보다 작은 데이터만 추출한 후 
        
        //[코드번호, 제조일, 최대수량, 현재수량] 순으로 들어옴 
        for(int[] x : data){
            //아래 기준에서 반대 되는 건 continue;
            if(ext.equals("date")){
                //제조일 기준일 때 더 크다면 넘김 
                if(val_ext <= x[1]) continue;
            }
            if(ext.equals("code")){
                if(val_ext <= x[0]) continue;
            }
            if(ext.equals("maximum")){
                if(val_ext <= x[2]) continue;
            }
            if(ext.equals("remain")){
                if(val_ext <= x[3]) continue;
            }
            //위에서 걸리지 않은 애들은 다담음 - 모두 ext 기준값보다 작은 애들만 남은 상황 
            pQ.offer(new Data(x[0], x[1], x[2], x[3], sort_by));
        }
    
        int len = pQ.size();
        
        int[][] answer = new int[len][4];
        
        for(int i=0; i<len; i++){
            Data cur = pQ.poll();
            answer[i][0] = cur.code;
            answer[i][1] = cur.date;
            answer[i][2] = cur.maximum;
            answer[i][3] = cur.remain;
        }
        
        
        
        return answer;
    }
}

프로그래머스 (카카오) | LV. 1차 비밀지도 - 구현 문풀 (Java)

혼자 정리 — Fri, 12 Jul 2024 13:23:28 +0900

⬛ 프로그래머스 (카카오) | LV. 1차 비밀지도 - 구현 문풀 (Java)

문제 설명

문제 접근 방식

우선 처음에는 10진수로 들어온 값을 2진수로 변형
변형된 값을 n의 자릿수로 맞춰줘야 함
두 arr 비교하여 둘다 0이면 공백, 하나라도 1이면 #을 붙이는 식으로 answer 세팅

문제는 중간에 2) 를 처리할 때, String.format(”%0xd”, int) 이 함수를 활용하는 과정에서 문제가 생겼다. 착각한 것인데 이 문제는 n이 매개변수로 들어오기 때문에, 각 케이스별로 다른 자릿수를 요구하고 있는데 내 마음대로 저 함수를 활용해버린 것이다.

그래서 직관적으로 len 길이를 매번 n에서 뺀 후 앞에 0을 붙여줄 값을 구해서 for문으로 이어붙이는 방식을 택했다.

제출 코드

import java.util.*;
class Solution {
    /*이 문제는 String.format으로 길이 맞출 수 가 없음
    그럴 경우 n자릿수가 다 다른데 어떻게 처리할 거임 ? */

    //솔루션 함수 
    public List<String> solution(int n, int[] arr1, int[] arr2) {
        //정답 배열이고 
        List<String> answer = new ArrayList<>();
        
        //(1) 10진수를 2진수로 변환을 시켜야 하는데 
        List<String> list1 = new ArrayList<>();
        
        for(int x : arr1){
           String tmp = Integer.toBinaryString(x);
           if(tmp.length() != n){ //다른 경우 앞에 0을 붙여줘야 됨 
               String zero = "";
               int len = n- tmp.length();//모자란 자릿수 
               for(int i=0; i<len; i++){
                   zero += "0";
               }
               //얘를 앞에 붙이기 
               tmp = zero + tmp;
               list1.add(tmp);
               System.out.println(tmp);
           }else{
               list1.add(tmp);
               System.out.println(tmp);
           }
        }    
        
        List<String> list2 = new ArrayList<>();
        for(int x : arr2){
           String tmp = Integer.toBinaryString(x);
           if(tmp.length() != n){ //다른 경우 앞에 0을 붙여줘야 됨 
               String zero = "";
               int len = n- tmp.length();//모자란 자릿수 
               for(int i=0; i<len; i++){
                   zero += "0";
               }
               //얘를 앞에 붙이기 
               tmp = zero + tmp;
               list2.add(tmp);
               System.out.println(tmp);               
           }else{
               list2.add(tmp);
               System.out.println(tmp);
           }
        }
        
        //(3) 정답 세팅하기 
        for(int i=0; i<n; i++){
            String a = list1.get(i);
            String b = list2.get(i);
            
            String ans = "";
            for(int j=0; j<a.length(); j++){
                if(a.charAt(j) == '0' && b.charAt(j) == '0') {
                    ans += " ";//공백 붙이고 
                }else{
                    ans += "#"; //그 외에는 모두 # 붙임 
                }
            }
            
            answer.add(ans);
        }
        
        return answer;
    }
}

회고

한달 정도 안했더니 많이 버벅거리긴 했다. 그래도 차근 차근 풀었다 .

백준 | 2211번. 네트워크 복구 - 다익스트라 문풀 (java)

혼자 정리 — Thu, 9 May 2024 14:35:16 +0900

⬛ 백준 2211번. 네트워크 복구 - 다익스트라 문풀 (java)

https://www.acmicpc.net/problem/2211

문제

N(1 ≤ N ≤ 1,000)개의 컴퓨터로 구성된 네트워크가 있다. 이들 중 몇 개의 컴퓨터들은 서로 네트워크 연결이 되어 있어 서로 다른 두 컴퓨터 간 통신이 가능하도록 되어 있다. 통신을 할 때에는 서로 직접 연결되어 있는 회선을 이용할 수도 있으며, 회선과 다른 컴퓨터를 거쳐서 통신을 할 수도 있다.

각 컴퓨터들과 회선은 그 성능이 차이가 날 수 있다. 따라서 각각의 직접 연결되어 있는 회선을 이용해서 통신을 하는데 걸리는 시간이 서로 다를 수 있다. 심지어는 직접 연결되어 있는 회선이 오히려 더 느려서, 다른 컴퓨터를 통해서 통신을 하는 것이 더 유리할 수도 있다. 직접 연결되어 있는 회선을 사용할 경우에는 그 회선을 이용해서 통신을 하는 데 드는 시간만큼이 들게 된다. 여러 개의 회선을 거치는 경우에는 각 회선을 이용해서 통신을 하는 데 드는 시간의 합만큼의 시간이 걸리게 된다.

어느 날, 해커가 네트워크에 침입하였다. 네트워크의 관리자는 우선 모든 회선과 컴퓨터를 차단한 후, 해커의 공격을 막을 수 있었다. 관리자는 컴퓨터에 보안 시스템을 설치하려 하였는데, 버전 문제로 보안 시스템을 한 대의 슈퍼컴퓨터에만 설치할 수 있었다. 한 컴퓨터가 공격을 받게 되면, 네트워크를 통해 슈퍼컴퓨터에 이 사실이 전달이 되고, 그러면 슈퍼컴퓨터에서는 네트워크를 이용해서 보안 패킷을 전송하는 방식을 사용하기로 하였다. 준비를 마친 뒤, 관리자는 다시 네트워크를 복구하기로 하였다. 이때, 다음의 조건들이 만족되어야 한다.

해커가 다시 공격을 할 우려가 있기 때문에, 최소 개수의 회선만을 복구해야 한다. 물론, 그렇다면 아무 회선도 복구하지 않으면 되겠지만, 이럴 경우 네트워크의 사용에 지장이 생기게 된다. 따라서 네트워크를 복구한 후에 서로 다른 두 컴퓨터 간에 통신이 가능하도록 복구해야 한다.
네트워크를 복구해서 통신이 가능하도록 만드는 것도 중요하지만, 해커에게 공격을 받았을 때 보안 패킷을 전송하는 데 걸리는 시간도 중요한 문제가 된다. 따라서 슈퍼컴퓨터가 다른 컴퓨터들과 통신하는데 걸리는 최소 시간이, 원래의 네트워크에서 통신하는데 걸리는 최소 시간보다 커져서는 안 된다.

원래의 네트워크에 대한 정보가 주어졌을 때, 위의 조건을 만족하면서 네트워크를 복구하는 방법을 알아내는 프로그램을 작성하시오.

입력

첫째 줄에 두 정수 N, M이 주어진다. 다음 M개의 줄에는 회선의 정보를 나타내는 세 정수 A, B, C가 주어진다. 이는 A번 컴퓨터와 B번 컴퓨터가 통신 시간이 C (1 ≤ C ≤ 10)인 회선으로 연결되어 있다는 의미이다. 컴퓨터들의 번호는 1부터 N까지의 정수이며, 1번 컴퓨터는 보안 시스템을 설치할 슈퍼컴퓨터이다. 모든 통신은 완전쌍방향 방식으로 이루어지기 때문에, 한 회선으로 연결된 두 컴퓨터는 어느 방향으로도 통신할 수 있다.

출력

첫째 줄에 복구할 회선의 개수 K를 출력한다. 다음 K개의 줄에는 복구한 회선을 나타내는 두 정수 A, B를 출력한다. 이는 A번 컴퓨터와 B번 컴퓨터를 연결하던 회선을 복구한다는 의미이다. 출력은 임의의 순서대로 하며, 답이 여러 개 존재하는 경우에는 아무 것이나 하나만 출력하면 된다.

문제 접근 방식

전형적인 다익스트라 문제이다.

그런데 경로를 저장하는 부분이 좀 헷갈렸다.

1) 슈퍼컴퓨터 1번과 최소 경로로 연결하는 간선 정보를 구하는 문제이므로 다익스트라를 활용한다.

2) 일반 다익스트라 알고리즘을 활용하여 distance[]로 다른 정점에 대한 최단 경로를 구하되, 이 과정에서 갱신할 때마다 routine[]배열에 서로 갱신한 두 정점에 대한 정보를 세팅한다.

3) 만약 routine[i] = 0 인 정점이 있다는 것은 (갱신 안되어 초기값 갖는 것이므로) 다른 노드와 연결되지 않은 컴퓨터라 ‘복구 컴퓨터’에 포함되지 않는다. 그래서 무시한다.

4) 그외의 경우에는 모두 해당 idx와 routine[idx] 값을 차례로 출력하면 된다.

제출 코드

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;

class Edge implements Comparable<Edge>{
    int e, val;
    Edge(int e, int val){
        this.e =e;
        this.val = val;
    }
    @Override
    public int compareTo(Edge o) {
        return this.val- o.val;//가중치 오름차순
    }
}

public class Main {
    static List<List<Edge>> graph;
    static int N, M;
    static int[] distance;
    static int[] routine;
    //간선 연결 정보를 현재 정점-다음 정점 순으로 담아야 되나 ?

    //dijkstra
    static void dijkstra(int st){
        PriorityQueue<Edge> pQ = new PriorityQueue<>();
        distance[st] = 0;
        pQ.offer(new Edge(st, 0));
        
        while(!pQ.isEmpty()) {
            Edge cur = pQ.poll();
            if (cur.val > distance[cur.e])
                continue;
            for (Edge nx : graph.get(cur.e)) {
                if (distance[nx.e] > distance[cur.e] + nx.val) {
                    distance[nx.e] = distance[cur.e] + nx.val;
                    pQ.offer(new Edge(nx.e, distance[nx.e]));
                    routine[nx.e] = cur.e;
                }
            }
        }
    }

    //실행 메인
    public static void main(String[] args) {
        Scanner kb=  new Scanner(System.in);
        N = kb.nextInt();
        M = kb.nextInt();

        distance = new int[N+1];
        Arrays.fill(distance, Integer.MAX_VALUE);

        graph = new ArrayList<>();
        for(int i=0; i<=N; i++){
            graph.add(new ArrayList<>());
        }

        //데이터 입력
        for(int i=0; i<M; i++){
            int a = kb.nextInt();
            int b = kb.nextInt();
            int v = kb.nextInt();
            //양바향 간선
            graph.get(a).add(new Edge(b, v));
            graph.get(b).add(new Edge(a, v));
        }
        
        routine = new int[N+1];
        
        dijkstra(1);
        
        StringBuilder sb = new StringBuilder();
        
        int cnt = 0;
        for(int i=2; i<=N; i++) {
        	if(routine[i]==0) continue;
        	cnt++;
        	sb.append(i+ " " + routine[i] + "\\n");
        }
        
        System.out.println(cnt);
        System.out.println(sb.toString());
    }
}

회고

다익스트로 매번 최단 경로를 구하는 것에 그치지 않고, 갱신된 경로(정점)을 중복 없이 만들 수 있는지가 핵심인 문제였다. routine[인덱스]=값에 서로 연결된 정점을 담긴 할 건데 1번 정점은 슈퍼 컴퓨터이므로 제외하고, 값이 0인 경우는 연결이 안된 정점이라 제외한다면 StringBuilder로 각 정점들의 값을 담아 출력하면 됐다. 비슷한 아이디어를 잘 참고하여 다음에 비슷한 문제를 헤매지 않도록 하자.

프로그래머스 (PCCP) | LV.1 이웃한 칸 - BFS 문풀 (Java)

혼자 정리 — Thu, 9 May 2024 09:37:40 +0900

⬛ 프로그래머스 (PCCP) | LV.1 이웃한 칸 - BFS 문풀 (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/250125

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 설명

문제 접근 방식

처음에는 BFS함수를 만들어서 풀고자 했는데 문제를 제대로 읽어보면 현재 정점은 h,w로 고정이고 움직임 없이 현재 정점 기준으로 상하좌우에 인접한 동일 색깔 개수만 구하면 되는 문제였다. 그러니 BFS로 현재 정점을 계속 갱신하면서 풀 이유가 없는 문제였다.

BFS 로직처럼 생각하되 현재 정점을 따로 갱신할 Queue는 불필요하므로 4가지 방향 전환만 해주며 풀면 쉽게 풀리는 문제이다. 데이터 길이는 매우 작아서 따로 효율성을 심각하게 고려할 문제는 아니었다.

1) dx, dy로 4방향 지칭용 변수를 선언한다.

2) 문제에서 board는 정사각형이다. 가로 세로가 n으로 같다. 이 값을 경계값으로 활용하여 경계를 넘는 경우 continue;

3) 매번 nx, ny로 현재 정점 (h,w) 기준으로 4방향을 탐색할 때 동일한 색깔 갖는 애 보면 answer++처리

4) return answer 하면 정답 반환된다.

제출 코드

import java.util.*;
class Solution {
    //4방향 변수 
    static int[] dx = {0, 0, 1, -1};
    static int[] dy = {1, -1, 0, 0};
    
    //솔루션 함수 
    public int solution(String[][] board, int h, int w) {
        int answer = 0;
        int n = board.length;

        for(int k=0; k<4; k++){
            int nx = h + dx[k];
            int ny = w + dy[k];
            if(nx < 0 || ny < 0 || nx >=n || ny>=n) continue;
            if(board[nx][ny].equals(board[h][w])) answer++;
        }
        
        return answer;
    }
}

프로그래머스 (PCCP) | LV.2 석유 시추 - BFS/DFS + 구현 문풀 (Java)

혼자 정리 — Fri, 3 May 2024 17:05:58 +0900

⬛ 프로그래머스 (PCCP) | LV.2 석유 시추 - BFS/DFS + 구현 문풀 (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/250136

프로그래머스

programmers.co.kr

문제 설명

문제 설명 2

문제 접근 방식

정확성과 효율성을 모두 통과해야 되는 문제이다.

일단 시추로 각 열에 대해 쭉 들어갔을 때 터치하는 석유 크기는 모두 합해야하는데, 중복되진 않게 세는 게 중요하다.

1) BFS로 land가 들어왔을 때 1로 찍힌 부분을 모두 진입하면서 연결된 덩어리 크기를 구하여 반환시킨다.

→ 처음에는 이걸 다시 BFS로 돌면서 해당 덩어리 크기를 갖는 애를 다시 방문하며 세팅할 생각을 했지만 그걸 2번씩 매번 도는 게 시간이 많이 쓰일 거 같았고 이 문제가 효율성도 중요하기 때문에 다른 방법을 택했다.

2) BFS 호출 시 세팅할 value로 index값을 매번 덩어리마다 다르게 세팅해서 각 덩어리를 구분시켜주었다.

3) BFS 가 반환해준 그 크기는 Map<Integer, Integer> 로 각 index(덩어리구분용 key) 에 대한 value 로서 세팅해준다.

4) 이제 각 열에 대하여 모든 행을 돌면서 쭉 진입했을 때 터치하는 덩어리를 봐야 되는데 중복되지 않도록 countMap 선언하여 진입한 덩어리를 분별되게 담도록 했다.

5) 담겨진 덩어리에서의 key를 꺼내서 이전 map에 있던 값을 꺼내고 sum ++ 처리하고 이 누적된 값을 최종 list에 세팅해서 해당 열로 진입 시 만날 덩어리 최종 누적값을 세팅했고 그 중 max인 값을 반환했다.

제출 코드

import java.util.*;

class Solution {
    //4 방향 
    static int[] dx = {0, 0, 1, -1};
    static int[] dy = {1, -1, 0, 0};
    //visited
    static boolean[][] visited;
    
    //BFS 탐색용 -> 해당 범위 val 반환용 
    static int BFS(int[][] land, int x, int y, int val){
        Queue<int[]> Q = new LinkedList<>();
        visited[x][y] = true;
        Q.offer(new int[] {x, y});
        land[x][y] = val;//세팅 
        int cnt = 1;
        while(!Q.isEmpty()){
            int[] cur = Q.poll();
            for(int k=0; k<4; k++){
                int nx = cur[0] + dx[k];
                int ny = cur[1] + dy[k];
                if(nx < 0 || nx >= land.length || ny <0 || ny >= land[0].length || visited[nx][ny] || land[nx][ny] == 0) continue;
                
                //유효하고 1인 값에 대하여 
                visited[nx][ny] = true;
                land[nx][ny] = val;//값 세팅 
                cnt++;
                Q.offer(new int[] {nx, ny});
            }
        }
        
        return cnt;
    }

    //솔루션 함수 
    public int solution(int[][] land) {
  
        visited = new boolean[land.length][land[0].length];
        
        int index = 10; 
        Map<Integer, Integer> map = new HashMap<>();
        
        //1) BFS 전범위 돌면서 1가진 값에 대한 value 얻어오기 
        for(int i=0; i<land.length; i++){
            for(int j=0; j<land[0].length; j++){
                if(!visited[i][j] && land[i][j] == 1){
                    int val = BFS(land, i, j, index); //얻은 점수 세팅을 
                    map.put(index, val);//해당 인덱스의 값을 val 로 세팅 
                    index++; //구분하기 위함 
                }
            }
        }
        
        List<Integer> list = new ArrayList<>();
        
        //만난 key에 대한 카운팅해서 식별용 
        Map<Integer, Integer> countMap;
        
        
        //각 열에 대한 모든 행에서의 합을 구할 거임 
        for(int i=0; i<land[0].length; i++){ //각 열에 대하여 
            countMap =  new HashMap<>();
            for(int j=0; j<land.length; j++){ //모든 행을 돌거임 
                if(land[j][i] == 0) continue;
                countMap.put(land[j][i], countMap.getOrDefault(land[j][i], 0) + 1);
            }
            
            int sum = 0;
            //탈출 후 
            for(int key : countMap.keySet()){
                sum += map.get(key);
            }
            list.add(sum);
        }
        
        int max = Integer.MIN_VALUE;
        for(int x : list){
            max = Math.max(x, max);
        }
        
        
        return max;
    }
}

회고

좀 복잡했지만 생각한대로 풀이를 쭉 밀고 갔더니 잘 풀렸다. 다행이다.

프로그래머스 | LV.1 모의고사 - 완전탐색 DFS 문풀 (Java)

혼자 정리 — Thu, 2 May 2024 14:47:19 +0900

⬛ 프로그래머스 | LV.1 모의고사 - 완전탐색 DFS 문풀 (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/42840?language=java

프로그래머스

programmers.co.kr

문제 설명

문제 접근 방식

정답 문자열 길이만큼 1~3번 학생의 반복 문자열을 재구성하는 함수가 따로 구현되어 있어야 하고, 그 lv 만큼 DFS 탐색하면서 각 lv 에 대응하는 숫자가 일치할 때마다 count++처리해주면 된다.

1) getProblem() 함수로 반복 문자열을 len 길이와 비교하여 크다면 자르고 작다면 재구성하며 새 비교 문자열을 구성한다.

2) DFS를 호출하여 매번 lv에 대응하는 숫자를 비교하여 count++처리한다.

3) 그들 중 max 값을 사전에 구한 뒤, 그 max에 대응되는 인덱스 갖는 애를 answer 리스트에 차례로 담으면 정답 처리가 된다.

제출 코드

import java.util.*;
class Solution {
    static int count;
    //len 길이에 맞게 구성
    static String getProblem(String tmp, int len){
        String ans = "";
        if(tmp.length() >= len){ //크다면 자르기
             ans = tmp.substring(0, len);//길이만큼 자름
        }else{//작다면 그 길이 만큼 맞춰 구성
            int n = len / tmp.length();
            int m = len % tmp.length();
            
            for(int i=0; i<n; i++){ //몫 횟수만큼 구성해두고 
                ans += tmp;
            }
            
            ans += tmp.substring(0, m);//나머지만큼 문자열 구성 
        }
        return ans;
    }
    
    //DFS  
    static void DFS(int lv, String num, int[] answers){
        if(lv == answers.length){
            return;
        }
        
        //현재 lv의 숫자 == answer[lv] 이면 count++처리해서 다음 깊이 탐색 
        if(Character.getNumericValue(num.charAt(lv)) == answers[lv]) count++;
        
        DFS(lv+1, num, answers);
       
    }
    
    //솔루션 함수 
    public List<Integer> solution(int[] answers) {
        List<Integer> answer= new ArrayList<>();
        
        int len = answers.length;
        
        //정답 길이만큼만 답지 문장려을 재구성을 한다.
        String first  = getProblem("12345", len);
        String second = getProblem("21232425", len);
        String third = getProblem("3311224455", len);
        
        int[] cnt = new int[4];
        //DFS 각 탐색하여 일치 문자열 개수 count 리턴받기
        count = 0;
        DFS(0, first, answers);
        int one = count;
        cnt[1] = one; 
        
        count = 0;
        DFS(0, second, answers);
        int two = count;
        cnt[2] = two;
        
        count = 0;
        DFS(0, third, answers);
        int three = count;
        cnt[3] = three;
        
        int max = Math.max(one, Math.max(two, three));
        
        for(int i=0; i<cnt.length; i++){
            if(cnt[i] == max){
                answer.add(i);//그 인덱스를 담음 
            }
        }
    
        return answer;
    }
}

프로그래머스 (카카오) | LV.1 숫자 문자열과 영단어 - 구현 문풀 (Java)

혼자 정리 — Thu, 2 May 2024 10:32:33 +0900

⬛ 프로그래머스 (카카오) | LV.1 숫자 문자열과 영단어 - 구현 문풀 (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/81301

프로그래머스

programmers.co.kr

문제 설명

문제 접근 방식

주어진 문자열에 존재하는 ‘영단어’ 문자열을 replace로 숫자값을 대체한 뒤, 마지막에 int형으로 변환시켜서 반환하면 되는 문제이다.

1) List상에 String 타입으로 zero~nine 까지 차례로 담는다.

2) for문 돌면서 해당 String 숫자문자열에 대한 치환을 시도하는데 치환 대상 문자는 인덱스로 접근한다.

3) 최종 string에 대해 answer로 int형변환 시도 후 리턴하면 된다.

제출 코드

import java.util.*;
class Solution {
    public int solution(String s) {
        int answer = 0;
        List<String> num = List.of("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine");
        
        for(int i=0; i<num.size(); i++){
            s = s.replaceAll(num.get(i), String.valueOf(i));
        }
        
        answer = Integer.parseInt(s);
        return answer;
    }
}

프로그래머스 | LV.2 2개 이하로 다른 비트 - 구현 문풀 (Java)

혼자 정리 — Wed, 1 May 2024 10:49:41 +0900

⬛ 프로그래머스 | LV.2 2개 이하로 다른 비트 - 구현 문풀 (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/77885

프로그래머스

programmers.co.kr

문제 설명

문제 접근 방식

처음에 든 풀이법은 while 문으로 주어진 배열 값 각각을 1씩 증가시켜 비트와 주어진 수를 비교하다가 다른 비트가 2개 이하면 break; 걸어주어서 개수를 리턴하는 단순한 방식이었다. 그런데 이 방식은 시간초과가 난다. 제한사항에서 numbers의 모든 수가 10^15이하이기 때문에 더 효율적인 풀이 방법을 생각해내야 한다.

내 힘으로 완전히 해결을 못했고, 비트의 패턴 규칙성을 토대로 문제를 푼 코드를 참고했다.

1) 일단 짝수인 경우, 2진수 상의 1의 자리 비트에 1더한 값이 반드시 답이 된다.

2) 홀수라면 비트 끝부터 탐색하여 0이 나온 지점에 ‘10’ 비트를 넣어주면 답이 된다. (→ 만약 0인 지점이 없다면 맨 앞에 10을 붙여줌)

제출 코드

import java.util.*;

class Solution {
    //솔루션 함수 
    public List<Long> solution(long[] numbers) {
        List<Long> answer = new ArrayList<>();
        
        for(long num : numbers){
            String target = Long.toBinaryString(num);//이진수 변환 
            
            if(num % 2 == 0){ //현재 수가 짝수
                //1더한 값을 변환한 게 정답
                answer.add(num+1);
            }else{ //현재 수가 홀수 
                int idx = target.lastIndexOf("0");
                if(idx == -1){//없다면 맨 앞에 10 붙임
                    String tmp = "10" + target.substring(1, target.length());
                    answer.add(Long.parseLong(tmp, 2));  //2진수를 정수로 변환 
                }else{
                    String tmp = target.substring(0, idx) + "10" + target.substring(idx+2, target.length());
                    answer.add(Long.parseLong(tmp, 2)); //2진수를 정수로 변환 
                }  
            }            
        }
        return answer;
    }
}

프로그래머스 | LV.3 업그레이드 할 수 없는 아이템 구하기 (MySQL)

혼자 정리 — Mon, 29 Apr 2024 15:00:30 +0900

⬛ 프로그래머스 | LV.3 업그레이드 할 수 없는 아이템 구하기 (MySQL)

https://school.programmers.co.kr/learn/courses/30/lessons/273712

프로그래머스

programmers.co.kr

문제 설명

문제 접근 방식

ITEM_INFO와 ITEM_TREE 두 개의 테이블이 있는데, ITEM_TREE 상의 PARENT_ID에서 NULL이 아니면서, 해당하는 부모가 되는 애들을 제외 (NOT IN)한 ITEM_ID를 구하면 ‘업그레이드 할 수 없는’ 아이템을 뽑아내게 된다.

1) 서브쿼리로 PARENT_ITEM_ID가 NULL인 것 제외한 PARENT_ID를 뽑음

2) 그 ID에 해당하지 않는 ITEM_ID를 최종 SELECT 하면 됨

제출 코드

SELECT ITEM_ID, ITEM_NAME, RARITY FROM ITEM_INFO
WHERE ITEM_ID NOT IN (SELECT PARENT_ITEM_ID
                      FROM ITEM_TREE 
                      WHERE  PARENT_ITEM_ID IS NOT NULL)
ORDER BY ITEM_ID DESC;

프로그래머스 (카카오) | LV.2 메뉴 리뉴얼 - DFS (Java)

혼자 정리 — Mon, 29 Apr 2024 13:27:17 +0900

⬛ 프로그래머스 (카카오) | LV.2 메뉴 리뉴얼 - DFS (Java)

https://school.programmers.co.kr/learn/courses/30/lessons/72411

프로그래머스

programmers.co.kr

문제설명

문제 접근 방식

내 생각으로는 각 orders의 문자열에 대해서 course 개수만큼 nCr 조합을 구성해서 그 구성의 개수를 Map으로 카운팅하면서 구현하면 될 거라고 생각했다.

char[] 배열로 매번 lv 깊이의 인덱스에 선택한 문자를 담도록 구성했는데, 중복없이 구현하기 위해 start 인덱스도 매번 DFS에 주도록하여 중복되지 않은 선택을 하도록 했다.

1) orders[] 주문으로 들어온 애들이 정렬된 애들은 아니다. 얘를 대상으로 DFS탐색을 할거라 문자열도 정렬 시킨다.

2) course는 선택한 메뉴 조합인데, 나의 경우 course[i] 값보다 menu길이가 작다면 nCr 불가능하기 때문에 continue 해주고 그 외의 경우에는 DFS 탐색을 시도했다.

//그니까 해당 문자열에 대해 course 개수만큼 깊이 조합을 구성하는 것

3) DFS를 탐색

lv이 타겟lv과 같아지면 sorting 후 map에 담는다.
그 외의 경우 start 인덱스부터 방문 전인 문자에 대해 문자열을 구성해주며 다음 깊이로 간다.

4) 모든 DFS탐색을 마친 상태에서는 각 orders 메뉴로 구성할 수 있는 course 조합을 카운팅한 map이 생성된 상태이다.

5) 이 상태에서 map에 구성된 counting이 가장 많은 maxCount를 찾고, 주문이 2개 이상이면서 maxCount와 같은 애들에 대해 List에 담아 오름차순 정렬 후 반환하면 된다.

제출 코드

import java.util.*;
class Solution {
    //얘네 두개는 구성 길이 정해지면 초기화해서 DFS 호출
    static char[] arrChar;
    static boolean[] visited;
    //얜 완전 전체 공유 
    static Map<String, Integer> map;
    //DFS
    static void DFS(String str, int lv, int targetLv, int st){
        if(lv == targetLv){
            Arrays.sort(arrChar);
            map.put(String.valueOf(arrChar), map.getOrDefault(String.valueOf(arrChar), 0) + 1);
            return;
        }
        
        for(int i=st; i<str.length(); i++){
            if(!visited[i]){
                visited[i] = true;
                arrChar[lv] = str.charAt(i);
                DFS(str, lv+1, targetLv, i+1);
                visited[i] = false;
            }
        }
    }
    
    // 솔루션 함수
    public String[] solution(String[] orders, int[] course) {
        List<String> answerList = new ArrayList<>(); // 정답을 저장할 리스트 생성
        int idx= 0;
        for(String x : orders){
            char[] tmp = x.toCharArray();
            Arrays.sort(tmp);
            orders[idx++] = String.valueOf(tmp);
        }
        
        for (int x : course) { 
            map = new HashMap<>(); 
            int maxCount = 0;
 
            // 모든 주문 메뉴에 대해 DFS를 통해 조합
            for (String menu : orders) {
                if (menu.length() < x) continue; // 메뉴 길이가 x보다 작으면 건너뜀
                arrChar = new char[x];
                visited = new boolean[menu.length()];
                DFS(menu, 0, x, 0);
            }
            
            for(String key : map.keySet()) {
                maxCount = Math.max(maxCount, map.get(key));
            }
            
            for(String key : map.keySet()){
                if(map.get(key) >= 2 && maxCount == map.get(key)){
                    answerList.add(key);
                }
            }
        }

        String[] answer = new String[answerList.size()];
        answerList.toArray(answer);
        Arrays.sort(answer); 
        return answer;
    }
}