개발 공부기록

import java.util.Stack;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < moves.length; i++) {
            for(int j = 0; j < board.length; j++) {
                if(board[j][moves[i] - 1] > 0) { // 인형이 있을 경우에 뽑기 진행
                	// 스택에 인형이 있고, 현재 뽑은 인형이랑 동일할 경우 터트리기
                    // 아니라면 스택에 인형 넣기
                    if(!stack.isEmpty() && board[j][moves[i] - 1] == stack.peek()) {
                        answer += 2;
                        stack.pop();
                    } else {
                        stack.add(board[j][moves[i] - 1]);
                    }
                    // 인형을 뽑은 자리에 0으로 초기화
                    board[j][moves[i] - 1] = 0;
                    break;
                }
            }
        }
        return answer;
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public int solution(int N, int K, int[] S) {
        int answer = 0, lt = 0, cnt = 0;
        // 오른쪽 포인터가 배열의 끝까지 갈때까지만 진행
        for(int rt = 0; rt < N; rt++) {
            if(S[rt] % 2 != 0) cnt++; // 홀수라면 삭제 횟수 증가
			// 삭제 가능한 횟수를 초과하면 왼쪽 포인터를 오른쪽으로 옮기기
            while(cnt > K) {
                if(S[lt] % 2 != 0) cnt--;
                lt++;
            }
            // rt와 lt의 간격을 계산하고, 삭제한 홀수의 개수만큼 빼주기
            answer = Math.max(answer, rt - lt + 1 - cnt);
        }
        return answer;
    }

    public static void main (String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        Main T = new Main();
        int N = Integer.parseInt(st.nextToken());
        int K = Integer.parseInt(st.nextToken());
        int[] S = new int[N];

        st = new StringTokenizer(br.readLine());
        for(int i = 0; i < N; i++) {
            S[i] = Integer.parseInt(st.nextToken());
        }

        System.out.println(T.solution(N, K, S));
    }

}

SELECT ROUND(long_w, 4)
FROM station
WHERE lat_n < 137.2345
ORDER BY lat_n DESC
LIMIT 1

SELECT name
FROM students
WHERE marks > 75
ORDER BY RIGHT(name, 3), id

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public int solution(int N, int B, int W, char[] arr) {
        int lt = 0, rt = 0; // 왼쪽 포인터, 오른쪽 포인터
        int max = 0;
        int[] stone = new int[2]; // stone[0] = W의 개수, stone[1] = B의 개수

        while(rt < N) {
            // 현재 rt 위치의 돌 추가
            if(arr[rt] == 'B') stone[1]++;
            else stone[0]++;

            // B의 개수가 문제에서 입력받은 B개를 넘어서면
            // 가장 왼쪽에 있던 돌을 빼면서 왼쪽 포인터를 증가
            if(B < stone[1]) {
                if(arr[lt] == 'B') stone[1]--;
                else stone[0]--;
                lt++;
            }
            // W돌의 개수가 입력받은 W개 이상이 되면 최댓값 갱신 
            if(stone[0] >= W) max = Math.max(max, rt - lt + 1);
            rt++; // 오른쪽 포인터 이동
        }
        return max;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        Main T = new Main();

        int N = Integer.parseInt(st.nextToken());
        int B = Integer.parseInt(st.nextToken());
        int W = Integer.parseInt(st.nextToken());

        char[] arr = br.readLine().toCharArray();

        System.out.println(T.solution(N, B, W, arr));
    }
}

설계 시간: 10분

풀이 시간: 32분

디버깅 시간: 20분

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int d = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        int c = Integer.parseInt(st.nextToken());

        int[] sushi = new int[N];
        for(int i = 0; i < N; i++) {
            sushi[i] = Integer.parseInt(br.readLine());
        }

        Map<Integer, Integer> map = new HashMap<>();
        map.put(c, 1);
        for(int i = 0; i < k; i++) {
            map.put(sushi[i], map.getOrDefault(sushi[i], 0) + 1);
        }
        int max = map.size();
        for(int i = k; i < N + k; i++) {
            map.put(sushi[i % N], map.getOrDefault(sushi[i % N], 0) + 1);
            map.put(sushi[(i - k) % N], map.getOrDefault(sushi[(i - k) % N], 0) - 1);
            if(map.get(sushi[i - k]) == 0) {
                map.remove(sushi[i - k]);
            }
            max = Math.max(max, map.size());
        }
        System.out.println(max);
    }
}

작성한 코드 👇

import java.io.IOException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int d = sc.nextInt();

        int deno = b * d;
        int num = (a * d) + (b * c);

        int answer = gdc(Math.max(deno, num), Math.min(deno, num));
        System.out.println(num / answer + " " + deno / answer);
    }

    static int gdc(int a, int b) {
        if(b == 0) return a;
        return gdc(b, a % b);
    }
}

💡 유클리드 호제법이란? 아래 링크 참고 ! 

풀이 : 7분

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int tc = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();

        while(tc-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            char[] arr1 = st.nextToken().toCharArray(); // 문자열을 문자로 쪼개서 배열에 저장
            char[] arr2 = st.nextToken().toCharArray(); // 상동
            sb.append("Distances:");

            for(int i = 0; i < arr1.length; i++) {
                if(arr1[i] <= arr2[i]) sb.append(" ").append((arr2[i] - 48) - (arr1[i] - 48));
                 else sb.append(" ").append((arr2[i] - 22) - (arr1[i] - 48));
            }
            sb.append("\n");
        }
        System.out.println(sb);
    }
}

1. 받은 문자열을 문자로 쪼개서 배열에 저장한다. ABCD -> [A][B][C][D]

2. for문 돌면서 arr1과 arr2 동일 인덱스에 들어있는 문자의 거리를 비교해서 차이 값을 stringBuilder에 저장해준다.