Update

Author: ndb796

Diff for: 12/1.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+public class Main {
+
+    public static String str;
+    public static int summary = 0;
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        str = sc.next();
+
+        // 왼쪽 부분의 자릿수의 합 더하기
+        for (int i = 0; i < str.length() / 2; i++) {
+            summary += str.charAt(i) - '0';
+        }
+
+        // 오른쪽 부분의 자릿수의 합 빼기
+        for (int i = str.length() / 2; i < str.length(); i++) {
+            summary -= str.charAt(i) - '0';
+        }
+
+        // 왼쪽 부분과 오른쪽 부분의 자릿수 합이 동일한지 검사
+        if (summary == 0) System.out.println("LUCKY");
+        else System.out.println("READY");
+    }
+}

Diff for: 12/2.java

@@ -0,0 +1,37 @@
+import java.util.*;
+
+public class Main {
+
+    public static String str;
+    public static ArrayList<Character> result = new ArrayList<Character>();
+    public static int value = 0;
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        str = sc.next();
+
+        // 문자를 하나씩 확인하며
+        for (int i = 0; i < str.length(); i++) {
+            // 알파벳인 경우 결과 리스트에 삽입
+            if (Character.isLetter(str.charAt(i))) {
+                result.add(str.charAt(i));
+            }
+            // 숫자는 따로 더하기
+            else {
+                value += str.charAt(i) - '0';
+            }
+        }
+
+        // 알파벳을 오름차순으로 정렬
+        Collections.sort(result);
+
+        // 알파벳을 차례대로 출력
+        for (int i = 0; i < result.size(); i++) {
+            System.out.print(result.get(i));
+        }
+
+        // 숫자가 하나라도 존재하는 경우 가장 뒤에 출력
+        if (value != 0) System.out.print(value);
+        System.out.println();
+    }
+}

Diff for: 12/3.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+class Solution {
+
+    public int solution(String s) {
+        int answer = s.length();
+        // 1개 단위(step)부터 압축 단위를 늘려가며 확인
+        for (int step = 1; step < s.length() / 2 + 1; step++) {
+            String compressed = "";
+            String prev = s.substring(0, step); // 앞에서부터 step만큼의 문자열 추출
+            int cnt = 1;
+            // 단위(step) 크기만큼 증가시키며 이전 문자열과 비교
+            for (int j = step; j < s.length(); j += step) {
+                // 이전 상태와 동일하다면 압축 횟수(count) 증가
+                String sub = "";
+                for (int k = j; k < j + step; k++) {
+                    if (k < s.length()) sub += s.charAt(k);
+                }
+                if (prev.equals(sub)) cnt += 1;
+                // 다른 문자열이 나왔다면(더 이상 압축하지 못하는 경우라면)
+                else {
+                    compressed += (cnt >= 2)? cnt + prev : prev;
+                    sub = "";
+                    for (int k = j; k < j + step; k++) {
+                        if (k < s.length()) sub += s.charAt(k);
+                    }
+                    prev = sub; // 다시 상태 초기화
+                    cnt = 1;
+                }
+            }
+            // 남아있는 문자열에 대해서 처리
+            compressed += (cnt >= 2)? cnt + prev : prev;
+            // 만들어지는 압축 문자열이 가장 짧은 것이 정답
+            answer = Math.min(answer, compressed.length());
+        }
+        return answer;
+    } 
+}

Diff for: 12/4.java

@@ -0,0 +1,67 @@
+import java.util.*;
+
+class Solution {
+
+    // 2차원 리스트 90도 회전하기
+    public static int[][] rotateMatrixBy90Degree(int[][] a) {
+        int n = a.length;
+        int m = a[0].length;
+        int[][] result = new int[n][m]; // 결과 리스트
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                result[j][n - i - 1] = a[i][j];
+            }
+        }
+        return result;
+    }
+
+    // 자물쇠의 중간 부분이 모두 1인지 확인
+    public static boolean check(int[][] newLock) {
+        int lockLength = newLock.length / 3;
+        for (int i = lockLength; i < lockLength * 2; i++) {
+            for (int j = lockLength; j < lockLength * 2; j++) {
+                if (newLock[i][j] != 1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public boolean solution(int[][] key, int[][] lock) {
+        int n = lock.length;
+        int m = key.length;
+        // 자물쇠의 크기를 기존의 3배로 변환
+        int[][] newLock = new int[n * 3][n * 3];
+        // 새로운 자물쇠의 중앙 부분에 기존의 자물쇠 넣기
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                newLock[i + n][j + n] = lock[i][j];
+            }
+        }
+
+        // 4가지 방향에 대해서 확인
+        for (int rotation = 0; rotation < 4; rotation++) {
+            key = rotateMatrixBy90Degree(key); // 열쇠 회전
+            for (int x = 0; x < n * 2; x++) {
+                for (int y = 0; y < n * 2; y++) {
+                    // 자물쇠에 열쇠를 끼워 넣기
+                    for (int i = 0; i < m; i++) {
+                        for (int j = 0; j < m; j++) {
+                            newLock[x + i][y + j] += key[i][j];
+                        }
+                    }
+                    // 새로운 자물쇠에 열쇠가 정확히 들어 맞는지 검사
+                    if (check(newLock)) return true;
+                    // 자물쇠에서 열쇠를 다시 빼기
+                    for (int i = 0; i < m; i++) {
+                        for (int j = 0; j < m; j++) {
+                            newLock[x + i][y + j] -= key[i][j];
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

Diff for: 12/5.java

@@ -0,0 +1,126 @@
+import java.util.*;
+
+class Node {
+
+    private int time;
+    private char direction;
+
+    public Node(int time, char direction) {
+        this.time = time;
+        this.direction = direction;
+    }
+
+    public int getTime() {
+        return this.time;
+    }
+
+    public char getDirection() {
+        return this.direction;
+    }
+}
+
+class Position {
+
+    private int x;
+    private int y;
+
+    public Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return this.x;
+    }
+
+    public int getY() {
+        return this.y;
+    }
+}
+
+public class Main {
+
+    public static int n, k, l;
+    public static int[][] arr = new int[101][101]; // 맵 정보
+    public static ArrayList<Node> info = new ArrayList<>(); // 방향 회전 정보
+
+    // 처음에는 오른쪽을 보고 있으므로(동, 남, 서, 북)
+    public static int dx[] = {0, 1, 0, -1};
+    public static int dy[] = {1, 0, -1, 0};
+
+    public static int turn(int direction, char c) {
+        if (c == 'L') direction = (direction == 0)? 3 : direction - 1;
+        else direction = (direction + 1) % 4;
+        return direction;
+    }
+
+    public static int simulate() {
+        int x = 1, y = 1; // 뱀의 머리 위치
+        arr[x][y] = 2; // 뱀이 존재하는 위치는 2로 표시
+        int direction = 0; // 처음에는 동쪽을 보고 있음
+        int time = 0; // 시작한 뒤에 지난 '초' 시간
+        int index = 0; // 다음에 회전할 정보
+        // 뱀이 차지하고 있는 위치 정보(꼬리가 앞쪽)
+        Queue<Position> q = new LinkedList<>();
+        q.offer(new Position(x, y));
+        
+        while (true) {
+            int nx = x + dx[direction];
+            int ny = y + dy[direction];
+            // 맵 범위 안에 있고, 뱀의 몸통이 없는 위치라면
+            if (1 <= nx && nx <= n && 1 <= ny && ny <= n && arr[nx][ny] != 2) {
+                // 사과가 없다면 이동 후에 꼬리 제거
+                if (arr[nx][ny] == 0) {
+                    arr[nx][ny] = 2;
+                    q.offer(new Position(nx, ny));
+                    Position prev = q.poll();
+                    arr[prev.getX()][prev.getY()] = 0;
+                }
+                // 사과가 있다면 이동 후에 꼬리 그대로 두기
+                if (arr[nx][ny] == 1) {
+                    arr[nx][ny] = 2;
+                    q.offer(new Position(nx, ny));
+                }
+            }
+            // 벽이나 뱀의 몸통과 부딪혔다면
+            else {
+                time += 1;
+                break;
+            }
+            // 다음 위치로 머리를 이동
+            x = nx;
+            y = ny;
+            time += 1;
+            if (index < l && time == info.get(index).getTime()) { // 회전할 시간인 경우 회전
+                direction = turn(direction, info.get(index).getDirection());
+                index += 1;
+            }
+        }
+        return time;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        
+        n = sc.nextInt();
+        k = sc.nextInt();
+
+        // 맵 정보(사과 있는 곳은 1로 표시)
+        for (int i = 0; i < k; i++) {
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            arr[a][b] = 1;
+        }
+
+        // 방향 회전 정보 입력
+        l = sc.nextInt();
+        for (int i = 0; i < l; i++) {
+            int x = sc.nextInt();
+            char c = sc.next().charAt(0);
+            info.add(new Node(x, c));
+        }
+  
+        System.out.println(simulate());
+    }
+
+}

Diff for: 17/1.java

@@ -0,0 +1,63 @@
+import java.util.*;
+
+public class Main {
+
+    public static final int INF = (int) 1e9; // 무한을 의미하는 값으로 10억을 설정
+    // 노드의 개수(N), 간선의 개수(M)
+    public static int n, m;
+    // 2차원 배열(그래프 표현)를 만들기
+    public static int[][] graph = new int[101][101];
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        n = sc.nextInt();
+        m = sc.nextInt();
+
+        // 최단 거리 테이블을 모두 무한으로 초기화
+        for (int i = 0; i < 101; i++) {
+            Arrays.fill(graph[i], INF);
+        }
+
+        // 자기 자신에서 자기 자신으로 가는 비용은 0으로 초기화
+        for (int a = 1; a <= n; a++) {
+            for (int b = 1; b <= n; b++) {
+                if (a == b) graph[a][b] = 0;
+            }
+        }
+
+        // 각 간선에 대한 정보를 입력 받아, 그 값으로 초기화
+        for (int i = 0; i < m; i++) {
+            // A에서 B로 가는 비용은 C라고 설정
+            int a = sc.nextInt();
+            int b = sc.nextInt();
+            int c = sc.nextInt();
+            // 가장 짧은 간선 정보만 저장
+            if (c < graph[a][b]) graph[a][b] = c;
+        }
+
+        // 점화식에 따라 플로이드 워셜 알고리즘을 수행
+        for (int k = 1; k <= n; k++) {
+            for (int a = 1; a <= n; a++) {
+                for (int b = 1; b <= n; b++) {
+                    graph[a][b] = Math.min(graph[a][b], graph[a][k] + graph[k][b]);
+                }
+            }
+        }
+
+        // 수행된 결과를 출력
+        for (int a = 1; a <= n; a++) {
+            for (int b = 1; b <= n; b++) {
+                // 도달할 수 없는 경우, 무한(INFINITY)이라고 출력
+                if (graph[a][b] == INF) {
+                    System.out.print(0 + " ");
+                }
+                // 도달할 수 있는 경우 거리를 출력
+                else {
+                    System.out.print(graph[a][b] + " ");
+                }
+            }
+            System.out.println();
+        }
+    }
+}