Jummi10: 2021.06.23

Jeongmi/Programmers/2020 카카오 인턴십/키패드_누르기.java

@@ -0,0 +1,84 @@
+package practice.programmers.kakao_2020_intership;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class 키패드_누르기 {
+    private static final Scanner SCANNER = new Scanner(System.in);
+    private static final String DELIMITER = ", ";
+    private static final char LEFT = 'L';
+    private static final char RIGHT = 'R';
+    private static final String LEFT_HAND = "left";
+    private static final String RIGHT_HAND = "right";
+    private static int[] leftThumbPosition = {3, 0}; // *로 초기화.
+    private static int[] rightThumbPosition = {3, 2}; // #로 초기화.
+    private static StringBuilder BUILDER = new StringBuilder();
+
+    // 몫 = (number - 1) / 3, 나머지 = (number - 1) % 3, 키패드 0을 11로 치환.
+    // (0, 0) (0, 1) (0, 2)
+    // (1, 0) (1, 1) (1, 2)
+    // (2, 0) (2, 1) (2, 2)
+    //   (x)  (3, 1)   (x)
+
+    public static void main(String[] args) {
+        String numbers = SCANNER.nextLine();
+        String hand = SCANNER.nextLine();
+        solution(convertStringNumbersIntoInts(numbers), hand);
+    }
+
+    private static int[] convertStringNumbersIntoInts(String numbers) {
+        String[] splitNumbers = numbers.split(DELIMITER);
+        return Arrays.stream(splitNumbers)
+            .mapToInt(Integer::parseInt)
+            .toArray();
+    }
+
+    private static void solution(int[] numbers, String hand) {
+        for (int number : numbers) {
+            if (number == 0) {
+                number += 11;
+            }
+            if ((number - 1) % 3 == 0) {  // 왼쪽 열
+                moveLeftThumbPosition(number);
+            } else if ((number - 1) % 3 == 2) {   // 오른쪽 열
+                moveRightThumbPosition(number);
+            } else if ((number - 1) % 3 == 1) {    // number가 가운데 열의 숫자일 경우: 2, 5, 8, 0
+                compareDistance(number, hand);
+            }
+        }
+
+        System.out.println(BUILDER.toString());
+    }
+
+    private static void compareDistance(int number, String hand) {
+        int leftDistance = calculateDistance(number, leftThumbPosition);
+        int rightDistance = calculateDistance(number, rightThumbPosition);
+
+        if (leftDistance < rightDistance || (leftDistance == rightDistance && hand.equals(LEFT_HAND))) {
+            moveLeftThumbPosition(number);
+        } else if (leftDistance > rightDistance || (leftDistance == rightDistance && hand.equals(RIGHT_HAND))) {
+            moveRightThumbPosition(number);
+        }
+    }
+
+    private static int calculateDistance(int number, int[] thumbPosition) {
+        int numberX = (number - 1) / 3;
+        int numberY = 1;
+        int thumbPositionX = thumbPosition[0];
+        int thumbPositionY = thumbPosition[1];
+
+        return Math.abs(numberX - thumbPositionX) + Math.abs(numberY - thumbPositionY);
+    }
+
+    private static void moveLeftThumbPosition(int number) {
+        leftThumbPosition[0] = (number - 1) / 3;
+        leftThumbPosition[1] = (number - 1) % 3;
+        BUILDER.append(LEFT);
+    }
+
+    private static void moveRightThumbPosition(int number) {
+        rightThumbPosition[0] = (number - 1) / 3;
+        rightThumbPosition[1] = (number - 1) % 3;
+        BUILDER.append(RIGHT);
+    }
+}

Jeongmi/Programmers/2020 카카오 채용/괄호_변환.java

@@ -0,0 +1,93 @@
+package practice.programmers.kakao_2020_recruitment;
+
+import java.util.Scanner;
+
+public class 괄호_변환 {
+    private static final Scanner SCANNER = new Scanner(System.in);
+    private static final char OPEN_PARENTHESIS = '(';
+    private static final char CLOSE_PARENTHESIS = ')';
+
+    public static void main(String[] args) {
+        String p = SCANNER.nextLine();
+        solution(p);
+    }
+
+    private static String solution(String p) {
+        if (p.isBlank()) {
+            return p;
+        }
+
+        String answer = correctBalancedParenthesis(p);
+        System.out.println(answer);
+        return answer;
+    }
+
+    private static String correctBalancedParenthesis(String balancedParenthesis) {
+        // 1. 입력이 빈 문자열인 경우, 빈 문자열을 반환
+        if (balancedParenthesis.isBlank()) {
+            return balancedParenthesis;
+        }
+
+        // 2. w를 두 "균형잡힌 괄호 문자열" u, v로 분리
+        String u = "", v = "";
+        int divisionPoint = getDivisionPoint(balancedParenthesis);
+        if (divisionPoint == balancedParenthesis.length() - 1) {
+            u = balancedParenthesis;  // v는 빈 문자열
+        } else {
+            u = balancedParenthesis.substring(0, divisionPoint + 1);
+            v = balancedParenthesis.substring(divisionPoint + 1);
+        }
+
+        boolean correctness = isCorrectParenthesis(u);
+        // 4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행한다.
+        if (!correctness) {
+            StringBuilder correctParenthesis = new StringBuilder(Character.toString(OPEN_PARENTHESIS));
+            correctParenthesis.append(correctBalancedParenthesis(v)).append(CLOSE_PARENTHESIS);
+            for (int j = 1; j < u.length() - 1; j++) {
+                if (u.charAt(j) == OPEN_PARENTHESIS) {
+                    correctParenthesis.append(CLOSE_PARENTHESIS);
+                } else {
+                    correctParenthesis.append(OPEN_PARENTHESIS);
+                }
+            }
+            return correctParenthesis.toString();
+        }
+
+        // 3. u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행한다.
+        u += correctBalancedParenthesis(v);
+        return u;
+    }
+
+    private static int getDivisionPoint(String balancedParenthesis) { // w를 u와 v로 나누는 분할점을 찾는다.
+        int openParenNums = 0;
+        int closeParenNums = 0;
+        for (int i = 0; i < balancedParenthesis.length(); i++) {
+            if (balancedParenthesis.charAt(i) == OPEN_PARENTHESIS) {  // 여는 괄호이면
+                openParenNums += 1;
+            } else {    // 닫는 괄호이면
+                closeParenNums += 1;
+            }
+
+            if (openParenNums == closeParenNums) {  // w의 index i까지의 substring이 균형잡힌 괄호 문자열일 경우
+                return i;
+            }
+        }
+        return balancedParenthesis.length() - 1;
+    }
+
+    private static boolean isCorrectParenthesis(String u) {
+        int correctness = 0;
+        for (int i = 0; i < u.length(); i++) {
+            if (u.charAt(i) == OPEN_PARENTHESIS) {
+                correctness += 1;
+            } else {
+                correctness -= 1;
+            }
+
+            if (correctness < 0) {  // 올바른 문자열이 아니라면
+                return false;
+            }
+        }
+        return true;
+    }
+}

Jeongmi/Programmers/2021 dev matching/로또의_최고_순위와_최저_순위.java

@@ -0,0 +1,79 @@
+package practice.programmers.dev_matching_2021;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class 로또의_최고_순위와_최저_순위 {
+    private static final Scanner SCANNER = new Scanner(System.in);
+    private static final String DELIMITER = ", ";
+
+    public static void main(String[] args) {
+        String lottosInput = SCANNER.nextLine();
+        String winNumsInput = SCANNER.nextLine();
+
+        int[] lottos = Arrays.stream(lottosInput.split(DELIMITER))
+            .mapToInt(Integer::parseInt)
+            .toArray();
+        int[] winNums = Arrays.stream(winNumsInput.split(DELIMITER))
+            .mapToInt(Integer::parseInt)
+            .toArray();
+        solution(lottos, winNums);
+    }
+
+    private static int[] solution(int[] lottos, int[] winNums) {
+        int unknownCounts = 0; // 알아볼 수 없는 번호의 개수
+        int matchingCounts = 0; // 당첨 번호와 일치한 구매번호 개수
+        List<Integer> rank = new ArrayList<>();
+
+        Arrays.sort(lottos);
+        for (int lotto : lottos) {
+            if (lotto == 0) {
+                unknownCounts += 1;
+            } else {
+                break;
+            }
+        }
+
+        List<Integer> winNumsInts = new ArrayList<>();
+        for (int winNumber : winNums) {
+            winNumsInts.add(winNumber);
+        }
+
+        matchingCounts = (int)Arrays.stream(lottos)
+            .filter(winNumsInts::contains)
+            .count();
+
+        // 당첨이 가능한 최고 순위: 알아볼 수 있는 번호 + 알아볼 수 있는 번호 모두 당첨 번호와 일치한 경우
+        rank.add(getRankFromMatchingCounts(matchingCounts + unknownCounts));
+        // 당첨이 가능한 최저 순위: 알아볼 수 있는 번호만 당첨 번호와 일치한 경우
+        rank.add(getRankFromMatchingCounts(matchingCounts));
+
+        return convertIntegers(rank);
+    }
+
+    private static int getRankFromMatchingCounts(int matchingCounts) {
+        if (matchingCounts == 6) {
+            return 1;
+        } else if (matchingCounts == 5) {
+            return 2;
+        } else if (matchingCounts == 4) {
+            return 3;
+        } else if (matchingCounts == 3) {
+            return 4;
+        } else if (matchingCounts == 2) {
+            return 5;
+        } else {
+            return 6;
+        }
+    }
+
+    private static int[] convertIntegers(List<Integer> integers) {
+        int[] result = new int[integers.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = integers.get(i);
+        }
+        return result;
+    }
+}

Jeongmi/Programmers/2021 카카오 채용/신규_아이디_추천.java

@@ -0,0 +1,79 @@
+package practice.programmers.kakao_2021_recruitment;
+
+import java.util.Scanner;
+
+public class 신규_아이디_추천 {
+    private static final Scanner SCANNER = new Scanner(System.in);
+
+    public static void main(String[] args) {
+        String newId = SCANNER.nextLine();
+        String recommendedId = solution(newId);
+        System.out.println(recommendedId);
+    }
+
+    private static String solution(String newId) {
+        String recommendedId;
+        recommendedId = verifyUpperCase(newId); // phase 1: 모든 대문자를 소문자로 치환
+        recommendedId = verifySpecialCharacter(recommendedId);  // phase 2: 알파벳 소문자, 숫자, -, ., _ 제외한 모든 문자 제거
+        recommendedId = verifyContinuousPeriods(recommendedId); // phase 3: 2번 이상 연속된 .를 하나의 .로 치환
+        recommendedId = verifyFirstOrLastPeriod(recommendedId); // phase 4: .가 처음이나 끝에 위치하면 제거
+        recommendedId = verifyBlankString(recommendedId); //phase 5: 빈 문자열이면 a 대입
+        recommendedId = verifyExceededLength(recommendedId); //phase 6: 16자 이상이면 나머지 문제 제거
+        recommendedId = verifyShorterLength(recommendedId); //phase 7: 2자 이하이면 3자까지 마지막 문자 반복
+
+        return recommendedId;
+    }
+
+    private static String verifyUpperCase(String id) {
+        return id.toLowerCase();
+    }
+
+    private static String verifySpecialCharacter(String id) {
+        String regex = "[^0-9a-z_.-]";
+        return id.replaceAll(regex, "");
+    }
+
+    private static String verifyContinuousPeriods(String id) {
+        String regex = "\\.+";
+        return id.replaceAll(regex, ".");
+    }
+
+    private static String verifyFirstOrLastPeriod(String id) {
+        char period = '.';
+        String modifiedId = id;
+
+        // s = s.replaceAll("^[.]|[.]$", "");
+        if (!id.isBlank() && id.charAt(0) == period) {
+            modifiedId = modifiedId.substring(1);
+        }
+        if (!id.isBlank() && modifiedId.charAt(modifiedId.length() - 1) == period) {
+            modifiedId = modifiedId.substring(0, modifiedId.length() - 1);
+        }
+
+        return modifiedId;
+    }
+
+    private static String verifyBlankString(String id) {
+        return id.isBlank() ? "a" : id;
+    }
+
+    private static String verifyExceededLength(String id) {
+        String modifiedId = id;
+        if (id.length() > 15) {
+            modifiedId = id.substring(0, 15);
+        }
+        modifiedId = verifyFirstOrLastPeriod(modifiedId);
+        return modifiedId;
+    }
+
+    private static String verifyShorterLength(String id) {
+        String modifiedId = id;
+        if (id.length() < 3) {
+            char lastCharacter = id.charAt(id.length() - 1);
+            for (int i = id.length(); i < 3; i++) {
+                modifiedId += lastCharacter;
+            }
+        }
+        return modifiedId;
+    }
+}

Jeongmi/Programmers/연습문제/나머지_한_점_hash.java

@@ -0,0 +1,52 @@
+package practice.programmers.연습문제;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class 나머지_한_점_hash {
+    // private static final Scanner SCANNER = new Scanner(System.in);
+
+    public static void main(String[] args) {
+        int[][] v = {{1, 4}, {3, 4}, {3, 10}};
+        solution(v);
+    }
+
+    private static int[] solution(int[][] v) {
+        List<Integer> answer = new ArrayList<>();
+        Map<Integer, Integer> xPositions = new HashMap<>();
+        Map<Integer, Integer> yPositions = new HashMap<>();
+        int x = 0;
+        int y = 0;
+
+        for (int[] position : v) {
+            xPositions.put(position[0], xPositions.getOrDefault(position[0], 0) + 1);
+            yPositions.put(position[1], yPositions.getOrDefault(position[1], 0) + 1);
+        }
+        for (int xKey : xPositions.keySet()) {
+            if (xPositions.get(xKey) == 1) {
+                x = xKey;
+                break;
+            }
+        }
+        for (int yKey : yPositions.keySet()) {
+            if (yPositions.get(yKey) == 1) {
+                y = yKey;
+                break;
+            }
+        }
+
+        answer.add(x);
+        answer.add(y);
+        return convertIntegers(answer);
+    }
+
+    private static int[] convertIntegers(List<Integer> integers) {
+        int[] result = new int[integers.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = integers.get(i);
+        }
+        return result;
+    }
+}