[sonshn] WEEK 01 Solutions

contains-duplicate/sonshn.java

@@ -0,0 +1,16 @@
+/**
+ * HashSet을 사용하여 배열에 중복된 값이 있는지 확인
+ * 시간 복잡도: O(n), 공간 복잡도: O(n)
+ */
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> distinctSet = new HashSet<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            if (distinctSet.contains(nums[i])) return true;
+            distinctSet.add(nums[i]);
+        }
+
+        return false;
+    }
+}

house-robber/sonshn.java

@@ -0,0 +1,21 @@
+/**
+ * DFS를 이용한 재귀 풀이
+ * 
+ * 시간 복잡도: O(2^n), 공간 복잡도: O(n)
+ */
+class Solution {
+    public int rob(int[] nums) {
+        return dfs(nums, 0);
+    }
+
+    private int dfs(int[] nums, int start) {
+        if (start >= nums.length) {
+            return 0;
+        }
+
+        return Math.max(
+            nums[start] + dfs(nums, start + 2),
+            dfs(nums, start + 1)
+        );
+    }
+}

longest-consecutive-sequence/sonshn.java

@@ -0,0 +1,35 @@
+import java.util.*;
+
+/**
+ * 주어진 배열에서 연속된 정수의 가장 긴 길이를 찾는 문제
+ * 
+ * 시간 복잡도: O(n log n), 공간 복잡도: O(1)
+ */
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        Arrays.sort(nums);
+
+        int longest = 0;
+        int length = 1;
+
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                continue;
+            }
+
+            if (nums[i] + 1 == nums[i + 1]) {
+                length++;
+            } else {
+                longest = Math.max(longest, length);
+                length = 1;
+            }
+        }
+
+        longest = Math.max(longest, length);
+        return longest;
+    }
+}

top-k-frequent-elements/sonshn.java

@@ -0,0 +1,40 @@
+
+/**
+ * 풀이
+ * 1. 빈도수 계산
+ * - HashMap<Integer, Integer>을 사용하여 각 숫자의 등장 횟수를 저장
+ * - Key는 숫자, Value는 해당 숫자의 빈도수
+ * 2. 고유 숫자 저장
+ * - counter.keySet()을 ArrayList로 변환하여 중복 없이 숫자들만 저장
+ * 3. 빈도수 기준 내림차순 정렬
+ * - list.sort((a, b) -> Integer.compare(counter.get(b), counter.get(a)))
+ * - HashMap에 저장된 빈도수를 기준으로 많이 등장한 숫자가 앞에 오도록 정렬
+ * 4. 상위 k개 반환
+ * - 정렬된 리스트의 앞에서부터 k개의 숫자를 result 배열에 담아 반환
+ * 
+ * 시간 복잡도: O(n log n)
+ * 공간 복잡도: O(n)
+ */
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+
+        Map<Integer, Integer> counter = new HashMap<>();
+
+        for (int num : nums) {
+            counter.put(num, counter.getOrDefault(num, 0) + 1);
+        }
+
+        List<Integer> list = new ArrayList<>(counter.keySet());
+
+        // 빈도수 내림차순 정렬
+        list.sort((a, b) -> Integer.compare(counter.get(b), counter.get(a)));
+
+        int[] result = new int[k];
+
+        for (int i = 0; i < k; i++) {
+            result[i] = list.get(i);
+        }
+
+        return result;
+    }
+}

two-sum/sonshn.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int length = nums.length;
+
+        for (int first = 0; first < length - 1; first++) {
+            for (int second = first + 1; second < length; second++) {
+                int sum = nums[first] + nums[second];
+
+                if (sum == target) {
+                    return new int[]{first, second};
+                }
+            }
+        }
+
+        return new int[0];
+    }
+}