45주차

Author: J-MU

src/main/java/org/example/_44week/SuccessfulPairsOfSpellsAndPotions.java

@@ -5,29 +5,49 @@
 public class SuccessfulPairsOfSpellsAndPotions {
 
     public static void main(String[] args) {
-        int[] spells = {5,1,3};
-        int[] potions = {1,2,3,4,5};
+        int[] spells = {5, 1, 3};
+        int[] potions = {1, 2, 3, 4, 5};
         int success = 7;
 
         int[] answers = successfulPairs(spells, potions, success);
-        Arrays.stream(answers).forEach(i -> System.out.print(i+" "));
+        Arrays.stream(answers).forEach(i -> System.out.print(i + " "));
     }
 
-    // 안부전해줘야되고 준우형이 보고싶어한다고 해줘야하고.
-    // 안보고싶다하면 그렇게 말할줄 알았다고 말했다고 해야하고
     public static int[] successfulPairs(int[] spells, int[] potions, long success) {
-        int[] sortedPotions = Arrays.stream(potions).sorted().toArray();
-
+        int[] answers = new int[spells.length];
+        potions = Arrays.stream(potions).sorted().toArray();
+
+        for (int i = 0; i < spells.length; i++) {
+            int sp = 0;
+            int ep = potions.length - 1;
+
+            while (sp <= ep) {
+                int mid = (sp + ep) / 2;
+                if ((long) potions[mid] * spells[i] >= success) {
+                    ep = mid - 1;
+                } else {
+                    sp = mid + 1;
+                }
+            }
+
+            answers[i] = potions.length - sp;
+        }
 
+        return answers;
     }
 
-    private static class Spell implements Comparable<Spell>{
-        int value;
-        int idx;
-
-        @Override
-        public int compareTo(Spell o) {
-            return Integer.compare(this.value, o.value);
-        }
-    }
+//    private static class Spell implements Comparable<Spell>{
+//        int value;
+//        int idx;
+//
+//        public Spell(int value, int idx) {
+//            this.value = value;
+//            this.idx = idx;
+//        }
+//
+//        @Override
+//        public int compareTo(Spell o) {
+//            return Integer.compare(this.value, o.value);
+//        }
+//    }
 }

src/main/java/org/example/_45week/FindPeakElement.java

@@ -0,0 +1,79 @@
+package org.example._45week;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class FindPeakElement {
+
+    private final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    private final static int SLASH = 0;
+    private final static int BACK_SLASH = 1;
+    private final static int V = 2;
+    private final static int ㅅ = 3;
+
+    public static void main(String[] args) {
+//        int[] nums = {1, 2, 1, 3, 5, 6, 4};
+        int[] nums = {1, 2, 3, 1};
+
+        int peakElement = findPeakElement(nums);
+        System.out.println(peakElement);
+    }
+
+    public static int findPeakElement(int[] nums) {
+        if(nums.length==1){
+            return nums[0];
+        }
+
+        int sp = -1;
+        int ep = nums.length;
+
+        int mid = 0;
+        while (sp < ep) {
+            mid = (sp + ep) / 2;
+
+            int shape = getSahpe(mid, nums);
+            if (shape == SLASH) {
+                sp = mid + 1;
+            } else if (shape == BACK_SLASH) {
+                ep = mid - 1;
+            } else if (shape == V) {
+                sp = mid + 1;
+            } else if (shape == ㅅ) {
+                return mid;
+            }
+        }
+
+        return (sp+ep)/2;
+    }
+
+    private static int getSahpe(int mid, int[] nums) {
+        if (mid == 0) {
+            if (nums[mid] < nums[mid + 1]) {
+                return SLASH;
+            } else if (nums[mid] > nums[mid + 1]) {
+                return ㅅ;
+            }
+        } else if (mid == nums.length - 1) {
+            if (nums[mid - 1] < nums[mid]) {
+                return ㅅ;
+            } else if (nums[mid - 1] > nums[mid]) {
+                return BACK_SLASH;
+            }
+        } else {
+            int left = nums[mid - 1] > nums[mid] ? 1 : -1;
+            int right = nums[mid + 1] > nums[mid] ? 1 : -1;
+            if (left > 0 && right > 0) {
+                return V;
+            } else if (left > 0 && right < 0) {
+                return BACK_SLASH;
+            } else if (left < 0 && right > 0) {
+                return SLASH;
+            } else {
+                return ㅅ;
+            }
+        }
+
+        return -1;
+    }
+}

src/main/java/org/example/_45week/HouseRobber.java

@@ -0,0 +1,19 @@
+package org.example._45week;
+
+class HouseRobber {
+    private final int O = 0;
+    private final int X = 1;
+    public int rob(int[] nums) {
+        int[][] money = new int[2][nums.length];
+
+        money[O][0] = nums[0];
+        money[X][0] = 0;
+
+        for(int i=1; i<nums.length; i++){
+            money[O][i] = money[X][i-1] + nums[i];
+            money[X][i] = Math.max(money[X][i-1],money[O][i-1]);
+        }
+
+        return Math.max(money[O][nums.length-1],money[X][nums.length-1]);
+    }
+}

src/main/java/org/example/_45week/JewelShopping.java

@@ -0,0 +1,70 @@
+package org.example._45week;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class JewelShopping {
+
+    public static void main(String[] args) {
+//        String[] gems = {"DIA", "RUBY", "RUBY", "DIA", "DIA", "EMERALD", "SAPPHIRE", "DIA"};
+        String[] gems = {"AA", "AB", "AC", "AA", "AC"};
+        int[] answers = solution(gems);
+        for (int answer : answers) {
+            System.out.print(answer + ", ");
+        }
+    }
+
+    public static int[] solution(String[] gems) {
+        Set<String> gemCategories = Arrays.stream(gems).collect(Collectors.toSet());
+        Map<String, Integer> countMap = new HashMap<>();
+
+        int start = 0;
+        int end = 0;
+
+        int answerStart = 0;
+        int answerEnd = Integer.MAX_VALUE;
+
+        for (end = 0; end < gems.length; end++) {
+            String currentGem = gems[end];
+            countMap.put(currentGem, countMap.getOrDefault(currentGem, 0) + 1);
+
+//            if (gems[start].equals(currentGem)) {
+//                start++;
+//                countMap.put(currentGem, countMap.get(currentGem) - 1);
+//            }
+
+            // 종류가 한개씩 들어갈 때 까지
+            if (countMap.size() == gemCategories.size()) {
+                // 1. start 가능한 만큼 땡기기.
+                start = updateStart(start, gems, countMap);
+                // 2. 최고 기록과 비교
+                // 3. 갱신.
+                if ((answerEnd - answerStart) > (end - start)) {
+                    answerEnd = end;
+                    answerStart = start;
+                }
+            }
+        }
+
+
+        return new int[]{answerStart + 1, answerEnd + 1};
+    }
+
+    private static int updateStart(int start, String[] gems, Map<String, Integer> countMap) {
+        int newStart = 0;
+        for (newStart = start; ; newStart++) {
+            Integer count = countMap.get(gems[newStart]);
+
+            if (count > 1) {
+                countMap.put(gems[newStart], count - 1);
+            } else {
+                break;
+            }
+        }
+
+        return newStart;
+    }
+}

src/main/java/org/example/_45week/LockAndKey.java

@@ -0,0 +1,96 @@
+package org.example._45week;
+
+public class LockAndKey {
+
+    private static int N = 0;
+    private static int M = 0;
+
+    public static void main(String[] args) {
+//        int[][] key = {{0, 0, 0}, {1, 0, 0}, {0, 1, 1}};
+//        int[][] lock = {{0, 0, 0}, {1, 0, 0}, {0, 1, 1}};
+
+        int[][] key = {{0, 0}, {1, 0}};
+        int[][] lock = {{0, 0, 0}, {1, 0, 0}, {0, 1, 1}};
+
+        boolean solution = solution(key, lock);
+        System.out.println(solution);
+    }
+
+    public static boolean solution(int[][] key, int[][] lock) {
+        N = lock.length;
+        M = key.length;
+
+        int[][][] keys = makeRotationKeys(key);
+        int[][] newLock = makeExtensionLock(lock);
+
+        for (int row = 0; row < newLock.length; row++) {
+            for (int col = 0; col < newLock.length; col++) {
+                for (int rotation = 0; rotation < 4; rotation++) {
+                    boolean isMatch = isMatch(keys[rotation], newLock, row, col);
+                    if (isMatch) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static int[][] makeExtensionLock(int[][] lock) {
+        int newLength = N + 2 * M - 2;
+        int[][] newLock = new int[newLength][newLength];
+
+        for (int row = 0; row < newLength; row++) {
+            for (int col = 0; col < newLength; col++) {
+                newLock[row][col] = 3;
+            }
+        }
+
+        for (int row = M - 1, originalRow = 0; row < M - 1 + N; row++, originalRow++) {
+            for (int col = M - 1, originalCol = 0; col < M - 1 + N; col++, originalCol++) {
+                newLock[row][col] = lock[originalRow][originalCol];
+            }
+        }
+
+        return newLock;
+    }
+
+    public static boolean isMatch(int[][] key, int[][] lock, int rowIndex, int colIndex) {
+        for (int row = M - 1; row < M - 1 + N; row++) {
+            for (int col = M - 1; col < M - 1 + N; col++) {
+                if (lock[row][col] == 0){
+                    if (((row - rowIndex) < M - 1 || (row - rowIndex) > N + 2 * M - 2) || ((col - colIndex) < M - 1 || (col - colIndex) > N + 2 * M - 2)) {
+                        return false;
+                    }
+
+
+                    if(key[row - rowIndex][col - colIndex] == 0){
+                        return false;
+                    }
+                }
+
+                if (lock[row][col] == 1 && key[row - rowIndex][col - colIndex] == 1) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static int[][][] makeRotationKeys(int[][] key) {
+        int[][][] keys = new int[4][key.length][key[0].length];
+        keys[0] = key;
+
+        for (int i = 1; i < 4; i++) {
+            for (int row = 0; row < key.length; row++) {
+                for (int col = 0; col < key[0].length; col++) {
+                    keys[i][row][col] = keys[i - 1][key.length - 1 - col][row];
+                }
+            }
+        }
+
+        return keys;
+    }
+}

src/main/java/org/example/_45week/MinimumFlipsToMakeAORBEqualToC.java

@@ -0,0 +1,55 @@
+package org.example._45week;
+
+public class MinimumFlipsToMakeAORBEqualToC {
+
+    public static void main(String[] args) {
+        int answer = minFlips(8, 3, 5);
+        System.out.println(answer);
+    }
+
+    public static int minFlips(int a, int b, int c) {
+        String binaryA = Integer.toBinaryString(a);
+        String binaryB = Integer.toBinaryString(b);
+        String binaryC = Integer.toBinaryString(c);
+        String binaryAOrB = Integer.toBinaryString(a|b);
+
+        int maxLength = Math.max(Math.max(binaryA.length(),binaryB.length()),Math.max(binaryC.length(),binaryAOrB.length()));
+        binaryA = convertBinaryString(binaryA,maxLength);
+        binaryB = convertBinaryString(binaryB,maxLength);
+        binaryC = convertBinaryString(binaryC,maxLength);
+        binaryAOrB = convertBinaryString(binaryAOrB,maxLength);
+
+        System.out.println(binaryA);
+        System.out.println(binaryB);
+        System.out.println(binaryAOrB);
+        System.out.println(binaryC);
+        int count =0;
+        for(int i = 0; i<maxLength; i++){
+            if(binaryC.charAt(i) !=binaryAOrB.charAt(i)){
+                if(binaryC.charAt(i)=='0'){
+                    if(binaryA.charAt(i)=='1'){
+                        count++;
+                    }
+                    if(binaryB.charAt(i)=='1'){
+                        count++;
+                    }
+                }else{
+                    count++;
+                }
+            }
+        }
+
+        return count;
+    }
+
+    public static String convertBinaryString(String a, int maxLength){
+        StringBuilder sb = new StringBuilder();
+        for(int i=0; i< maxLength-a.length(); i++){
+            sb.append(0);
+        }
+
+        sb.append(a);
+
+        return sb.toString();
+    }
+}