주어진 정수의 길이만큼의 이진수의 경우의 수를 출력하는 문제인데, 0은 00으로 붙여서 사용해야 했다. 그래서 1인 경우부터 직접 구해서 규칙을 찾아냈다.

public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(br.readLine()); System.out.println(dp(N)); }

public static int dp(int N){
    int[] dp = new int[N + 1];
    dp[1] = 1;
    dp[2] = 2;
    for(int i=3; i<=N; i++){
        dp[i] = 2*(dp[i-1]-1) + 1;
    }
    return dp[N];
}

N이 5인 경우까지 나열해보니 위와 같이 풀으면 될 것 같아서 코딩하고 제출했더니 틀렸다고 나오는 것이었다,,🤔 무엇이 잘못됐는지 다시 나열해보고, 검색도 해보니 N=5인 경우 00000까지 포함시켜서 규칙을 잘못 체크하고 있었었다,,,ㅎ 아주 간단한 피보나치 수열이었는데,,,ㅎ,,,,,,,,😅

그래서 다시 푼 풀이는 아래와 같았다.

public static int dp(int N){ int[] dp = new int[N+1]; dp[1] = 1; dp[2] = 2; for(int i=3; i<=N; i++){ dp[i] = (dp[i-1] + dp[i-2]) % 15746; } return dp[N]; }

피보나치 수열인데 문제에서 15746으로 나눈 나머지 값을 출력하라고 표시되어 있어서 %15746 까지 추가해서 제출을 했는데, 왜,,,어째서,,,,,? 검색해서 다른 분들의 풀이를 봐도 내 풀이가 맞는 것 같은데,,,,왜,,,,?😞 왜 런타임 에러인지는 다음에 알아보도록 하자,,

DP 유형의 문제를 풀어보려고 제일 쉬운 난이도의 문제를 골랐는데,, 그냥 수학적인 접근 방법으로 풀어버렸다,,ㅎ,,,,

public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(br.readLine()); System.out.println(dp(N)); }

public static int dp(int N){
    int answer = 0;
    while(true) {
        if (N % 5 == 0) {
            answer += N / 5;
            break;
        } else if (N < 0) {
            answer = -1;
            break;
        }
        N -= 3;
        answer++;
    }
    return answer;
}

아무래도 아직 DP로 접근하는 방법이 익숙하지 않아서라고 생각하고, DP풀이를 검색해가며 다시 풀어보았다.

public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(br.readLine()); System.out.println(dp(N)); }

public static int dp(int N){
    int[] dp = new int[N+1];

    if(N>=3){
        dp[3] = 1;
    }
    if(N>=5){
        dp[5] = 1;
    }

    for(int i=6; i<=N; i++){
        if(i%5 == 0){
            dp[i] = dp[i-5]+1;
        }else if(i%3 == 0){
            dp[i] = dp[i-3]+1;
        }else{
            if(dp[i-3] != 0 && dp[i-5] != 0){
                dp[i] = Math.min(dp[i-3], dp[i-5]) +1;
            }
        }
    }

    if(dp[N] == 0){
        dp[N] = -1;
    }
    return dp[N];
}

아직 익숙한 풀이 방법이 아니라서 솔직히 100퍼센트 이해하지는 못했다. 하지만 반복이 답이다! 계속 비슷한 유형의 문제를 풀다보면 익숙해져서 이해도 완벽히 하게되는 날이 올 것이라 확신한다!😤

그런데 이 문제는 어렵지 않은 문제라서 그런지,, 수학적으로 접근해서 풀어도 복잡도가 높지 않아서 그런지 두 풀이의 차이가 거의 없었다.

위에가 DP로 푼 결과이고, 아래가 수학적으로 푼 결과이다.

DP 알고리즘의 다른 문제들도 수학적으로 풀 수 있을 것 같으면 두가지 경우 모두 풀어보고 비교해봐야겠다.

public static void main(String[] args) { int N; int M; StringBuilder sb = new StringBuilder(); Scanner sc = new Scanner(System.in); N = sc.nextInt(); int[] nArr = new int[N]; for (int i = 0; i < N; i++) { nArr[i] = sc.nextInt(); } Arrays.sort(nArr); M = sc.nextInt();

    for (int i = 0; i < M; i++) {
        int m = sc.nextInt();
        int left = 0;
        int right = N - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nArr[mid] == m) {
                sb.append(1 + " ");
                break;
            }
            if (nArr[mid] > m) { 
                right = mid - 1;
            } else {
                left = mid + 1;
            }
            if (left > right) {
                sb.append(0 + " ");
                break;
            }
        }
    }
    System.out.println(sb.toString());
}

어제 풀어 본 문제를 해결하지는 못했지만 같은 유형의 문제이기도 하고 이분탐색으로 풀 수 있을 것 같은 마음에 금방 풀겠지,, 했지만,,, 생각보다 너무 오랫동안 풀게 되었다.

일단 위의 코드는 다른 분이 올려두신 코드를 참고하여 제출한 코드이다. 내가 푼 코드는 왜인지 모르겠는데 1을 체크하지 않고 다 0으로만 출력이 되어서 다른 분들 코드를 검색하다가 내 코드와 제일 비슷한 코드를 참고하였다.

미해결 코드

public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(bf.readLine()); int[] n = new int[N]; StringTokenizer st = new StringTokenizer(bf.readLine(), " "); for (int i = 0; i < N; i++) { n[i] = Integer.parseInt(st.nextToken()); } Arrays.sort(n); int M = Integer.parseInt(bf.readLine()); int[] m = new int[M]; st = new StringTokenizer(bf.readLine(), " "); for (int i = 0; i < M; i++) { m[i] = Integer.parseInt(st.nextToken()); }

    StringBuilder sb = new StringBuilder();

    for(int i=0; i<M; i++){
        int start = 0;
        int end = N-1;
        while(start <= end){
            int mid = (start+end)/2;
            if(m[i] == n[mid]){
                sb.append(1 + " ");
                break;
            }
            if(m[i] >= n[mid]){
                end = mid-1;
            }else{
                start = mid+1;
            }
            if (start > end) {
                sb.append(0 + " ");
                break;
            }
        }
    }
    System.out.println(sb);
}

이 코드가 미해결 코드이다. 어제 풀지못한 문제와 함께 이 문제도 다시 봐야할 것 같다,,😞

N개의 정수 중에서 M개의 정수와 일치하는 정수가 몇개인지 확인하는 문제였다.

public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(bf.readLine()); int[] n = new int[N]; StringTokenizer st = new StringTokenizer(bf.readLine(), " "); for(int i=0; i<N; i++) { n[i] = Integer.parseInt(st.nextToken()); } Arrays.sort(n); int M = Integer.parseInt(bf.readLine()); int[] m = new int[M]; st = new StringTokenizer(bf.readLine(), " "); for(int i=0; i<M; i++){ m[i] = Integer.parseInt(st.nextToken()); }

    int[] out = new int[M];
    for(int i=0; i<M; i++){
        int cnt = 0;
        for(int j=0; j<N; j++){
            if(m[i] == n[j]){
                cnt++;
            }
        }
        out[i] = cnt;
    }

    for(int i=0; i<M; i++){
        System.out.print(out[i] + " ");
    }
}

일단 생각나는 대로 푼 코드이다. 이분탐색 알고리즘 문제를 찾아서 풀기 시작했는데,, 이분탐색을 쓰지 않는,,,,😂 결국 시간초과로 틀렸는데 아무리 생각해도 이분탐색으로 어떻게 풀어야 할 지 감이 안와서 결국 검색찬스를 사용했다.

하지만 접근 방법조차 생각나지 않아서인지,,, 아직 이분탐색과 많이 낯설은 것인지,, 다른 분들의 코드와 설명을 봐도 전혀,,,모르겠,,는,,,,,,🙁 이분탐색,,, 너무 어렵다,, 아직 실버4일 뿐인데 너무 어려운 이분탐색. 좀 더 공부해보고 다시 풀어보기로 하자 꼭.

이분탐색 알고리즘에 해당하는 문제 중에서 나름 쉬운 난이도로 골라서 풀었는데,, 너무 서먹하다,,,,,, N개의 정수중에서 정수X가 포함되어 있는지 확인하는 간단한 문제였다.

public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(bf.readLine()); int[] A = new int[N]; StringTokenizer st = new StringTokenizer(bf.readLine(), " "); for(int i=0; i<N; i++) { A[i] = Integer.parseInt(st.nextToken()); } Arrays.sort(A);

    int M = Integer.parseInt(bf.readLine());
    int[] arr = new int[M];
    StringTokenizer st1 = new StringTokenizer(bf.readLine(), " ");
    for(int i=0; i<M; i++) {
        arr[i] = Integer.parseInt(st1.nextToken());
    }

    for(int i=0; i<M; i++){
        int answer = 0;
        int start = 0;
        int end = N-1;
        while (start <= end){
            int mid = (start+end)/2;
            if(A[mid] == arr[i]){
                answer = 1;
            }
            if(A[mid]>arr[i]){
                end = mid-1;
            }else{
                start = mid+1;
            }
        }
        System.out.println(answer);
    }
}

요즘 프로그래머스로 문제를 풀었더니 백준에서 입력 값을 적어주는 부분마저 헷갈려서 구글선생님께 물어물어 풀어보았다,, 코드 중에 반절이 입력에 대한 내용인데,, 좀 더 간단하고 좋은 코드로 바꿀 수 없을까하는 생각이 든다😅

일단 이분탐색에 맞게 처음과 끝을 변수로 선언해주고, 가운데 값부터 비교하는 방법으로 구현해보았다. 입력 값을 적어주고 정렬을 해두었기 때문에 중간 값과 비교하여 앞부분인지 뒷부분인지 판단하여 탐색 속도를 높이는,,, 느낌이다.

이분탐색,, 문제를 풀어보며 좀 친해지도록 노력해야겠다😤

알고리즘 분류는 스택/큐 이며, 다리의 길이(bridge_length), 다리가 견딜 수 있는 무게(weight), 트럭의 무게(truck_weights)를 가지고 모든 트럭이 다리를 건너기까지 걸린 시간을 출력하는 문제였다.

내가 풀면서 살짝 설명이 부족하다고 생각했던 부분은 bridge_length의 1만큼 지날 때 시간이 1만큼 걸린다는 점이었다. 이 부분까지 확인하고 문제를 풀어보았다.

public int solution(int bridge_length, int weight, int[] truck_weights) { int answer = 0; Queue queue = new LinkedList<>(); int sum = 0;

    for(int i=0; i<truck_weights.length; i++) {
        while (true) {
            if(queue.isEmpty()){
                queue.offer(truck_weights[i]);
                answer++;
                sum += truck_weights[i];
                break;
            }else if(queue.size() == bridge_length){
                sum -= queue.poll();
            }else{
                if(sum + truck_weights[i] > weight){
                    queue.offer(0);
                    answer++;
                }else{
                    queue.offer(truck_weights[i]);
                    answer++;
                    sum += truck_weights[i];
                    break;
                }
            }
        }
    }

    return answer + bridge_length;
}

처음에 생각했던 방법은 queue의 크기를 bridge_length로 지정해두고 구현하는 방법을 생각했었는데,, 검색해보니 CircularQueue, EvictingQueue 를 이용해서 풀 수 있다고 하던데,, Apache Commons, Google Guava 와 같은 라이브러리? 를 사용해야 하는 방법이라 포기하고, 큐의 크기를 지정해주는 클래스를 별도로 만들어서 사용하려 하였으나 생각대로 구현이 안돼서 포기하였다😂

결국은 조건문을 이용해서 풀었는데 큐를 다리라고 생각하고 큐가 비어있을 때 트럭을 넣고, 큐에 올라간 트럭의 무게를 int형 변수 sum으로 계산해서 sum이 주어진 weight보다 큰 경우에는 0을 넣어서 다음 트럭이 올라가지 않도록 구현해주었다. 추가로 큐의 크기가 bridge_length와 같을 땐, poll을 해주면서 그 값만큼 sum에서 빠질 수 있도록 구현해주었다.

작업의 순서가 중요하기 때문에 큐를 이용하여 접근하였다.

public static ArrayList solution(int[] progresses, int[] speeds) { ArrayList answer = new ArrayList<>(); Queue queue = new LinkedList<>(); int index = 0;

    for (int i = 0; i < progresses.length; i++) {
        queue.offer(progresses[i]);
    }

    while(!queue.isEmpty()){
        int cnt = 0;
        for (int i = index; i < speeds.length; i++) {
            queue.offer(queue.poll() + speeds[i]);
        }
        while (!queue.isEmpty() && queue.peek() >= 100) {
                if(queue.peek() >= 100){
                    cnt++;
                    index++;
                    queue.poll();
                }
        }
        if(cnt != 0){
            answer.add(cnt);
        }
    }
    return answer;
}

일단 입력된 progresses를 큐에 넣어주고, 배열의 길이만큼 반복해서 모든 progresses에 해당 인덱스의 speeds를 더할 수 있도록 해주었다. 다음으로 첫번째 progresses가 100이 되었을 때 배포가 가능하므로 해당 부분을 구현해주었는데, 그 다음 progresses도 100이라면 같이 배포되어야 하고 배포되는 progresses의 갯수를 cnt로 카운트하여 출력할 수 있도록 구현하였다.

public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String[] input = bf.readLine().split(" "); int N = Integer.parseInt(input[0]); int M = Integer.parseInt(input[1]); int R = Integer.parseInt(input[2]); int[][] board = new int[N][M]; for (int i = 0; i < N; i++) { String[] st = bf.readLine().split(" "); for (int j = 0; j < M; j++) { board[i][j] = Integer.parseInt(st[j]); } }

    int part = Math.min(N,M) / 2;
    for (int i = 0; i < R; i++) {
        int[][] out = new int[N][M];
        for (int j = 0; j < part; j++) {
            for (int k = j+1; k < M-j; k++) {
                out[j][k-1] = board[j][k];
            }
            for (int l = j; l < M-1-j ; l++) {
                out[N-1-j][l+1] = board[N-1-j][l];
            }
            for (int h = N-1-j; h > j; h--) {
                out[h][j] = board[h-1][j];
            }
            for (int g = N-1-j; g > j; g--) {
                out[g-1][M-1-j] = board[g][M-1-j];
            }
        }
        board = out.clone();
    }

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            System.out.print(board[i][j] + " ");
        }
        System.out.println();
    }
}

풀이를 말로 설명하기 어렵지만, 설명을 적어보자면 회전하는 구역(part)를 우선적으로 알아야하는데 주어진 이차원 배열을 표로 만들었을 때 가장 바깥에서 회전하는 구역부터 가장 안쪽의 구역까지 회전을 시켜야 하기 때문이다. 그 다음으로 그 구역에서 상하좌우가 움직이는 방향이 모두 다르므로 각각의 방향마다 for문으로 구현을 해주었다. 이 부분에서 for문의 조건부분과 실행부분에 맞는 값을 생각하는 것이 가장 어려웠다.

과연 시간제한이 있다면 시간안에 풀어낼 수 있을지,, 걱정이다😅

위의 내용을 체크하고 처음 생각했던 로직은 666을 하나의 문자(예를 들면 'A')로 만들어서 1A, 2A, 3A ... 로 나열되도록 구현하려고 하였으나,, 자리 이동이 어려울 듯 하여 다른 방법을 생각해냈다.

public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(bf.readLine()); int version = 0; int n = 0;

    while(n != N){
        version++;
        if(String.valueOf(version).contains("666")){
            n++;
        }
    }
    System.out.println(version);
}

영화 시리즈의 번호(version)를 1씩 증가시키면서 그 수에 '666'이 포함되어 있을 때, 입력값 N 과 비교할 변수 n을 1씩 증가시켜서 n이 N과 같아지는 순간의 version을 출력하는 방법으로 구현했다.

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(bf.readLine()); int[][] list = new int[N][2]; for(int i=0; i<N; i++){ String[] st = bf.readLine().split(" "); list[i][0] = Integer.parseInt(st[0]); list[i][1] = Integer.parseInt(st[1]); }

    int[] rank = new int[N];

    for(int i=0; i<N; i++){
        rank[i] = 1;
    }

    for(int i=0; i<N-1; i++){
        for(int j=i+1; j<N; j++) {
            if (list[i][0] > list[j][0] && list[i][1] > list[j][1]){
                rank[j]++;
            }else if(list[i][0] < list[j][0] && list[i][1] < list[j][1]){
                rank[i]++;
            }
        }
    }
//        System.out.println(Arrays.toString(rank));
    for(int i=0; i<N; i++){
        System.out.print(rank[i] + " ");
    }

2차원 배열로 N의 갯수만큼 몸무게와 키를 입력하고, 자신보다 덩치가 큰 경우를 카운트해서 등수를 나타내는 배열(rank)에 값을 저장하여 출력하도록 구현해보았다.

백준을 풀다보면 입력값과 출력값을 예제와 동일하게 맞춰주어야 하는데,, 이 부분을 자꾸 놓치는 것 같다.

입력된 정수만큼의 수를 나열해서 맨 처음 수를 지우고, 두번째수는 맨 뒤로 보내는 것을 반복하여 마지막에 남는 최후의 숫자를 출력하는 문제였다. 나열된 수에서 가장 앞에 있는 정수에 대해 처리를 하는 문제이기 때문에 큐를 이용해서 구현하였다.

public static void main(String[] args) { Scanner input = new Scanner(System.in); int N = input.nextInt(); Queue queue = new LinkedList();

    for(int i=0; i<N; i++){
        queue.add(i+1);
    }
    while(queue.size() != 1){
        queue.remove();
        queue.add(queue.peek());
        queue.remove();
    }
    System.out.println(queue.peek());
}

}

1부터 입력된 정수(N)까지의 수를 queue에 넣어주고, queue에 들어있는 값이 하나가 될 때까지 값을 삭제하고, 맨 뒤로 보내는 것을 반복하도록 구현하였다.

public static void main(String[] args) { Scanner input = new Scanner(System.in); int[] arr = new int[9]; int[] out = new int[7]; for(int i=0; i<9; i++){ arr[i] = input.nextInt(); }

    for(int i=0; i<3; i++){
        for(int j=1; j<4; j++){
            for(int k=2; k<5; k++){
                for(int l=3; l<6; l++){
                    for(int m=4; m<7; m++){
                        for(int n=5; n<8; n++){
                            for(int o=6; o<9; o++){
                                if(arr[i]+arr[j]+arr[k]+arr[l]+arr[m]+arr[n]+arr[o] == 100){
                                    out = new int[]{arr[i], arr[j], arr[k], arr[l], arr[m], arr[n], arr[o]};
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    Arrays.sort(out);
    System.out.println(Arrays.toString(out));
}

일단 어제 풀다 만 코드는 이렇다,,ㅎ 브루트 포스로 분류되어 있어서 그냥 for문을 일곱번 돌리면서 풀어놨는데 오늘 다시 생각해보니 for문을 이렇게 돌리면 중복되는 인덱스가 나오기때문에 틀렸던 것이었다.

#2022.11.29#

public static void main(String[] args) { Scanner input = new Scanner(System.in); int[] arr = new int[9]; int[] out = new int[7]; for(int i=0; i<9; i++){ arr[i] = input.nextInt(); }

    for(int i=0; i<3; i++){
        for(int j=i+1; j<4; j++){
            for(int k=j+1; k<5; k++){
                for(int l=k+1; l<6; l++){
                    for(int m=l+1; m<7; m++){
                        for(int n=m+1; n<8; n++){
                            for(int o=n+1; o<9; o++){
                                if(arr[i]+arr[j]+arr[k]+arr[l]+arr[m]+arr[n]+arr[o] == 100){
                                    out = new int[]{arr[i], arr[j], arr[k], arr[l], arr[m], arr[n], arr[o]};
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    Arrays.sort(out);
    for(int i=0; i<7; i++){
        System.out.println(out[i]);
    }
}

for문의 조건을 이전 for문의 초기값에서 +1한 값을 초기값으로 주었다. 이렇게 하면 중복되는 인덱스없이 동작이 가능하다.

사실 이렇게 풀기 전에 ArrayList로 푸는 방법도 생각했는데 뭔가 될듯하면서 자꾸 안되는것이,,, 아주 서터레스다,,😞 주말이나 시간날 때 더 풀어보고 추가로 기록할 수 있도록 해야겠다

입력값에서 반쪽짜리 괄호들을 하나의 괄호로 만들기 위해 필요한 괄호의 수(cnt)를 구하는 문제였다.

public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); Stack stack = new Stack(); int cnt = 0; String input = br.readLine();

    for(int i=0; i<input.length(); i++){
        if(input.charAt(i) == ')' && stack.isEmpty()){
            cnt++;
            continue;
        }
        if(input.charAt(i) == '('){
            stack.add(input.charAt(i));
        }else if(input.charAt(i) == ')' && !stack.isEmpty()){
            stack.pop();
        }
    }
    if(!stack.isEmpty()){
        cnt += stack.size();
    }
    System.out.println(cnt);
}

입력받은 문자열이 처음부터 닫힌 괄호로 시작하는 경우는 무조건 열린 괄호를 추가해야 하기때문에 cnt를 증가시킨다.

열린 괄호로 시작하는 경우에는 일단 스택에 저장해두고, 이후에 닫힌 괄호가 나올 때 스택에서 삭제를 하기 위해 닫힌 괄호일때 AND로 스택이 비어있지 않은 경우까지 추가하여 구현하였다. 이 부분을 구현하면서 처음부터 닫힌 괄호로 시작하는 경우에도 AND로 스택이 비어있는 경우를 추가해주었다.

입력 문자열을 다 확인했으면 그 때 스택에 남아있는 값들은 닫힌 괄호를 못 만난 반쪽짜리 열린 괄호이므로 cnt에 추가해준다.

막대가 생기는 조건? 에 대해 이해하는게 굉장히 어려웠다. 처음에는 괄호 두개가 연속으로 있을때("((" 혹은 "))") 막대가 생기는 건가,, 싶었는데 그렇게 했을 때 예시로 보여주는 것과 다른 결과가 나왔다

회사에서 일을 하면서 계속 생각하고 생각한 결과, 그냥 앞에서부터 한자리씩 옮겨가며 확인하면서 괄호가 열린 부분이 막대의 시작부분이고, 닫힌 괄호가 막대의 끝 부분이라고 생각하고 적용해보니 예시와 같은 결과가 나왔다!! (단, 열린 괄호와 닫힌 괄호가 연속으로 나온 경우("()")는 레이저의 경우이므로 제외)

public static void main(String[] args) { Scanner scan = new Scanner(System.in); String input = scan.next(); int start = 0; int out = 0;

    for(int i=0; i<input.length(); i++){
        if(input.charAt(i) == '('){
            start++;
        }else {
            start--;
            if(input.charAt(i-1) == '('){
                out += start;
            }else{
                out++;
            }
        }
    }
    System.out.println(out);
}

변수를 선언할 때 단순히 막대의 시작 부분이라고 생각해서 변수명을 start로 잡아두긴 했지만,, 막대의 갯수? 라고 생각하면 편할 것 같다.

입력된 문자열에서 자리를 하나씩 옮겨가며 괄호가 열려 있을때는 막대의 갯수(start)를 1씩 증가시켜주고, 괄호가 닫혀 있을때는 막대의 갯수(start)를 1씩 감소시켜줬다. 이렇게 구현하면 레이저의 경우에는 막대의 갯수(start)가 결국 0이 되므로 막대의 갯수를 체크할 수 있다.

그리고 레이저가 생성되는 부분("()")에서는 잘라진 막대(out)이 생기므로 그 때의 막대의 갯수(start)를 더해주고, 막대의 끝 부분에서는 잘라진 막대 하나가 생기는 것과 같으므로 out에 1씩 더해주면 완성이다,,!

그런데,, 여기에는 함정카드가 숨어있다. 알고리즘 분류는 스택이었으나,, 스택없이 풀어버렸다,,,,,,,,,,ㅎ,,,,

static int cnt = 0; public static int recursion(String s, int l, int r){ cnt++; if(l >= r){ return 1; } else if(s.charAt(l) != s.charAt(r)) return 0; else return recursion(s, l+1, r-1); }

public static int isPalindrome(String s){
    return recursion(s, 0, s.length()-1);
}

public static void main(String[] args){
    Scanner input = new Scanner(System.in);
    int T = input.nextInt();
    for(int i=0; i<T; i++) {
        cnt = 0;
        String S = input.next();
        System.out.println(isPalindrome(S) + " " + cnt);
    }
}

다른 부분은 힌트에서 다 구현되어 있었고, 재귀함수가 몇 번 호출하는지만 추가 구현하면 되는 문제였다. 그래서 recursion함수 안에서 카운트되도록 하면 되는데, main에서도 쓰여야하는 변수이기때문에 전역변수로 cnt를 선언해주고, recursion 함수에 cnt++를 추가하여 실행될때마다 카운트될 수 있도록 구현해주었다. ✌

public static void main(String[] args) { Scanner num = new Scanner(System.in); int input = num.nextInt();

    System.out.println(recursive(input));
}

public static int recursive(int input){
    int result = 0;
    int num1 = 0;
    int num2 = 1;

    if(input == 0){
        result = 0;
    }else if(input == 1){
        result = 1;
    }else{
        for(int i=2; i<=input; i++){
            result = num1 + num2;
            num1 = num2;
            num2 = result;
        }
    }
    return result;
}

피보나치 수열은 처음 시작하는 두 수의 예외처리만 고려하면, 어렵지 않다고 생각한다. 생각보다 쉽게 풀어서 한 문제를 더 풀어봐야하나 고민이 되지만,,, 진도를 따라가기 위해서 여기까지 마무리하고 강의를 들으러 가본다,,😅

for문으로 간단하게 해결할 수도 있지만 재귀함수의 숙련도를 높이기 위해 팩토리얼을 재귀함수로 풀어보았다.

public static void main(String[] args) { Scanner num = new Scanner(System.in); int input = num.nextInt();

    System.out.println(Factorial(input));
}

public static int Factorial(int input){
    if(input <= 1){
        return 1;
    }else {
        return Factorial(input - 1) * input;
    }
}

티어가 낮은만큼 간단한 문제였지만,, 재귀,,, 아직 너무 헷갈린다,, 주말에 더 여러 유형의 재귀함수 문제를 풀어봐야겠다,,😤

오늘 풀어본 문제는 어제와 같은 브루트 포스에 있는 2231번 분해합이라는 문제이다. 문제를 본 직후에는 좀 어렵나,, 생각했는데 조금만 생각을 해보니 어떻게 풀어야할지 감이 왔다.

생성자를 구하는 문제였고, 반복문으로 0에서부터 돌려보면서 조건에 맞는 생성자를 찾으면 될 것 같다고 생각이 들었지만 역시나 한번에 통과하지는 못했다,,🤣

public static void main(String[] args) { Scanner num = new Scanner(System.in); int input = num.nextInt(); int M = 0; int mM = 0; int sum = 0;

    for(int i=0; i<input; i++) {
        while (mM != 0) {
            sum += mM % 10;
            mM /= 10;
        }

        if(sum + M == input){
            break;
        }
    }
    System.out.println(M);
}

처음 제출한 코드이다. 사용되는 변수가 많다보니까 변수에 대한 역할이 100% 정리되지 않은 상태였고, 그 상태로 '이거겠지~'하는 생각으로 코드를 짜다보니 실수가 나왔다.

public static void main(String[] args) { Scanner num = new Scanner(System.in); int input = num.nextInt(); int M = 0; int sum = 0;

    for(int i=0; i<input; i++) {
        int number = i;
        sum = 0;

        while (number!= 0) {
            sum += number % 10;
            number /= 10;
        }

        if(sum + i == input){
            M = i;
            break;
        }
    }
    System.out.println(M);
}

사실 지금도 집중하지 않으면 왜 이렇게 했지,,? 하는 생각이 들기도 한다,,,ㅎ 조건에 맞는 수를 찾기위해 0에서부터 세어나갈때 그 수(i)를 나머지를 구하거나, 나누기를 한다던가 하면서 계산에 들어갈 변수를 하나 지정해서 넣어두고, i는 고정되어 있도록 해야하는 점. 내가 코드를 짜면서 안일하게 생각했던 부분이다.

이런 사소한 실수를 줄일 수 있도록 더 집중해서 풀어야겠다!!!!