[JeonJe] WEEK 01 Solutions

contains-duplicate/JeonJe.java

@@ -0,0 +1,16 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            if (set.contains(num)) {
+                return true;
+            }
+            set.add(num);
+        }
+        return false;
+    }
+}

longest-consecutive-sequence/JeonJe.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums.length == 0 || nums.length == 1) {
+            return nums.length;
+        }
+
+
+        HashSet<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+
+        int answer = 1;
+        for (Integer cur : set) {
+            if (set.contains(cur - 1)) {
+                continue;
+            }
+
+            int right = cur;
+            while (set.contains(right + 1)) {
+                right++;
+            }
+            answer = Math.max(answer, right - cur + 1);
+        }
+
+        return answer;
+    }
+}

top-k-frequent-elements/JeonJe.java

@@ -0,0 +1,24 @@
+import java.util.*;
+
+// TC: O(n log n)
+// SC: O(n)
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            Integer freq = map.getOrDefault(num, 0);
+            map.put(num, freq + 1);
+        }
+
+        List<Map.Entry<Integer, Integer>> freqList = new ArrayList<>(map.entrySet());
+
+        return freqList.stream()
+                .sorted(Comparator.comparing(Map.Entry::getValue, Comparator.reverseOrder()))
+                .map(Map.Entry::getKey)
+                .limit(k)
+                .mapToInt(Integer::intValue)
+                .toArray();
+
+    }
+}

two-sum/JeonJe.java

@@ -0,0 +1,17 @@
+import java.util.*;
+
+// TC: O(n)
+// SC: O(n)
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            if(map.containsKey((target - nums[i])) && map.get(target - nums[i]) != i) {
+                return new int[]{i, map.get(target - nums[i])};
+            }
+            map.put(nums[i], i);
+        }
+
+        return new int[0];
+    }
+}