feat : 2025-08-15,16,17,18 programmers lv.2 question solved.

Author: Hojip-Kim

2025-08-15/김호집/N개의 최소공배수.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Solution {
+    public int solution(int[] arr) {
+        int answer = -1;
+        int cnt = 1;
+        boolean isCorrect = true;
+        while(true) {
+            for(int elem : arr) {
+                if (cnt % elem != 0){
+                    isCorrect = false;
+                    break;
+                }
+            }
+            if(!isCorrect) {
+                cnt++;
+            }else {
+                answer = cnt;
+                break;
+            }
+            isCorrect = true;
+
+        }
+        return answer;
+    }
+}

2025-08-15/김호집/땅따먹기.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+class Solution {
+
+    private static int[][] dp;
+
+    int solution(int[][] land) {
+        int answer = 0;
+
+        dp = land; // in-place 업데이트
+
+        for (int i = 0; i < land.length; i++) {
+            for (int j = 0; j < land[i].length; j++) {
+                int up = i - 1;
+
+                if (0 <= up) {
+                    int bestUp = 0;
+                    for (int k = 0; k < land[up].length; k++) {
+                        if (k == j) continue;
+                        bestUp = Math.max(bestUp, dp[up][k]);
+                    }
+                    dp[i][j] += bestUp;
+                }
+            }
+        }
+
+        for (int i = 0; i < 4; i++) {
+            answer = Math.max(answer, dp[dp.length-1][i]);
+        }
+
+        return answer;
+    }
+}

2025-08-15/김호집/멀리뛰기.java

@@ -0,0 +1,23 @@
+class Solution {
+    private static int[] dp;
+    // dp문제
+    public long solution(int n) {
+        long answer = 0;
+        // 한 번에 1칸 또는 2칸 1 1 1 1 1 1
+        //n : 6 => 13, n : 5 => 8, n : 4 => 5, n : 3 => 3, n : 2 => 2, n : 1 : 1
+
+        if (n <= 2) {
+            return n;
+        }
+
+        dp = new int[n+1];
+
+        dp[1] = 1;
+        dp[2] = 2;
+
+        for(int i = 3; i < n+1; i++) {
+            dp[i] = (dp[i-2] + dp[i-1]) % 1234567;
+        }
+        return dp[n];
+    }
+}

2025-08-16/김호집/롤케이크자르기.java

@@ -0,0 +1,36 @@
+import java.util.*;
+
+class Solution {
+    public int solution(int[] topping) {
+        int answer = 0;
+        Map<Integer, Integer> leftHashMap = new HashMap<>();
+        Map<Integer, Integer> rightHashMap = new HashMap<>();
+
+        leftHashMap.put(topping[0], 1);
+
+        for(int i = 1; i < topping.length; i++){
+            rightHashMap.put(topping[i], rightHashMap.getOrDefault(topping[i], 0) + 1);
+        }
+
+        if(rightHashMap.size() == leftHashMap.size()){
+            answer++;
+        }
+
+        for(int i = 1; i < topping.length; i++){
+            leftHashMap.put(topping[i], leftHashMap.getOrDefault(topping[i], 0) + 1);
+            if(rightHashMap.get(topping[i]) == 1){
+                rightHashMap.remove(topping[i]);
+            }else {
+                int value = rightHashMap.get(topping[i]);
+                value--;
+                rightHashMap.put(topping[i], value);
+            }
+            if(rightHashMap.size() == leftHashMap.size()){
+                answer++;
+            }
+        }
+
+
+        return answer;
+    }
+}

2025-08-16/김호집/전화번호목록.java

@@ -0,0 +1,28 @@
+import java.util.*;
+
+class Solution {
+    public boolean solution(String[] phone_book) {
+        Map<String, Integer> map = new HashMap<>();
+
+        boolean answer = true;
+
+        for(String book : phone_book){
+            if(!map.containsKey(book)){
+                map.put(book, 0);
+            }else{
+                int value = map.get(book);
+                value++;
+                map.put(book, value);
+            }
+        }
+
+        for(int i = 0; i < phone_book.length; i++){
+            for(int j = 1; j < phone_book[i].length(); j++){
+                if(map.containsKey(phone_book[i].substring(0, j))){
+                    return false;
+                }
+            }
+        }
+        return answer;
+    }
+}

2025-08-16/김호집/할인행사.java

@@ -0,0 +1,60 @@
+import java.util.*;
+
+class Solution {
+    private static Map<String, Integer> map;
+    private static int[] slidingWindow;
+    private static int answer;
+    public int solution(String[] want, int[] number, String[] discount) {
+        answer = 0;
+        map = new HashMap<>();
+        for(int i = 0; i < want.length; i++) {
+            map.put(want[i], i);
+        }
+
+        slidingWindow = firstScanDiscount(want, number, discount);
+
+        for(int i = 10; i < discount.length; i++){
+            int curLeft = i-10;
+            int nextRight = i;
+            if(map.containsKey(discount[curLeft])){
+                slidingWindow[map.get(discount[curLeft])]--;
+            }
+            if(map.containsKey(discount[nextRight])){
+                slidingWindow[map.get(discount[nextRight])]++;
+            }
+            if(isValidArr(number, slidingWindow)){
+                answer++;
+            }
+        }
+
+        return answer;
+    }
+
+    private int[] firstScanDiscount(String[] want, int[] number, String[] discount) {
+        int[] arr = new int[number.length];
+        for(int i = 0; i < 10; i++) {
+            for(int j = 0; j < want.length; j++){
+                if(discount[i].equals(want[j])) {
+                    arr[j]++;
+                }
+            }
+        }
+
+        if(isValidArr(number, arr)){
+            answer++;
+        }
+
+        return arr;
+    }
+
+    private boolean isValidArr(int[] arr1, int[] arr2){
+        boolean isValid = true;
+        for(int i = 0; i < arr1.length; i++){
+            if(arr1[i] > arr2[i]){
+                isValid = false;
+                break;
+            }
+        }
+        return isValid;
+    }
+}

2025-08-17/김호집/더 맵게.java

@@ -0,0 +1,39 @@
+import java.util.*;
+
+class Solution {
+    public int solution(int[] scoville, int K) {
+        PriorityQueue<Long> pq = new PriorityQueue<>();
+        int answer = 0;
+        boolean isFound = false;
+
+        for(int elem : scoville){
+            pq.add((long)elem);
+        }
+
+        if (!pq.isEmpty() && pq.peek() >= K) return 0;
+
+        while(!pq.isEmpty()) {
+
+            if(pq.size() > 1 && pq.peek() < K){
+                long lowestScoville = pq.poll();
+                long secondLowestScoville = pq.poll();
+                long newestScoville = lowestScoville + secondLowestScoville * 2;
+                pq.add(newestScoville);
+                answer++;
+            }else {
+                break;
+            }
+
+            if(pq.peek() >= K){
+                isFound = true;
+                break;
+            }
+        }
+        if(isFound){
+            return answer;
+        }else {
+            return -1;
+        }
+
+    }
+}

2025-08-17/김호집/소수찾기.java

@@ -0,0 +1,48 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    private static Set<Integer> set;
+    private static boolean[] visited = new boolean[7];
+
+    public int solution(String numbers) {
+        int answer = 0;
+        set = new HashSet<>();
+
+        dfs(numbers, "", 0);
+
+        for (int num : set) {
+            if (isPrime(num)) {
+                answer++;
+            }
+        }
+        return answer;
+    }
+
+    private void dfs(String numbers, String str, int depth) {
+        if (depth > numbers.length()) {
+            return;
+        }
+
+        for (int i = 0; i < numbers.length(); i++) {
+            if(!visited[i]) {
+                visited[i] = true;
+                set.add(Integer.parseInt(str + numbers.charAt(i)));
+                dfs(numbers ,str + numbers.charAt(i), depth + 1);
+                visited[i] = false;
+            }
+        }
+    }
+
+    private boolean isPrime(int prime) {
+        if (prime < 2) {
+            return false;
+        }
+        for (int i = 2; i <= (int) Math.sqrt(prime); i++) {
+            if (prime % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

2025-08-17/김호집/의상.java

@@ -0,0 +1,18 @@
+import java.util.*;
+
+class Solution {
+    public int solution(String[][] clothes) {
+        Map<String, Integer> countByType = new HashMap<>();
+
+        for (String[] cloth : clothes) {
+            String type = cloth[1];
+            countByType.put(type, countByType.getOrDefault(type, 0) + 1);
+        }
+
+        int ways = 1;
+        for (int c : countByType.values()) {
+            ways *= (c + 1); // 안 입음(1) 포함
+        }
+        return ways - 1; // 전부 안 입는 경우 제외
+    }
+}

2025-08-18/김호집/타겟넘버.java

@@ -0,0 +1,27 @@
+class Solution {
+    private static int answer = 0;
+    public int solution(int[] numbers, int target) {
+        recursion(numbers, target, 0, 0);
+
+        return answer;
+    }
+
+    public void recursion(int[] numbers, int target, int depth, int result) {
+        if(depth == numbers.length){
+            if(target == result){
+                answer++;
+            }
+            return;
+        }
+
+
+        int plus = result + numbers[depth];
+        int minus = result - numbers[depth];
+
+        recursion(numbers, target, depth+1, plus);
+        recursion(numbers, target, depth+1, minus);
+
+    }
+
+
+}