[geegong] WEEK 01 solutions

contains-duplicate/Geegong.java

@@ -0,0 +1,29 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+public class Geegong {
+
+
+    /**
+     * time complexity : O(n)
+     * space complexity : o(n)
+     * @param nums
+     * @return
+     */
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> uniques = new HashSet<>();
+
+        for (int num : nums) {
+            if (uniques.contains(num)) {
+                return true;
+            }
+
+            uniques.add(num);
+        }
+
+        return false;
+    }
+
+}
+

longest-consecutive-sequence/Geegong.java

@@ -0,0 +1,49 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+/**
+ * time complexity : O(n)
+ */
+public class Geegong {
+
+    public int longestConsecutive(int[] nums) {
+        HashSet<Integer> setOfNums = new HashSet<>();
+        // key : startIndex , value : length
+        Map<Integer, Integer> lengthMap = new HashMap<>();
+
+        // sort..? 를 해야될까 싶음..
+
+        // initialize
+        for (int num : nums) {
+            setOfNums.add(num);
+        }
+
+        Integer longest = 0;
+
+        for (Integer num : setOfNums) {
+            int length = iterate(setOfNums, num, 0, lengthMap);
+            longest = Math.max(longest, length);
+        }
+
+        return longest;
+    }
+
+    public Integer iterate(HashSet<Integer> hashSet, int currIndex, int currLength, Map<Integer, Integer> lengthMap) {
+        if (lengthMap.containsKey(currIndex)) {
+            return lengthMap.get(currIndex);
+        }
+
+        if (hashSet.contains(currIndex)) {
+            currLength++;
+            return iterate(hashSet, currIndex+1, currLength, lengthMap);
+
+        } else {
+            lengthMap.put(currIndex, currLength);
+            return currLength;
+        }
+
+    }
+
+}
+

top-k-frequent-elements/Geegong.java

@@ -0,0 +1,75 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+public class Geegong {
+
+
+    public int[] topKFrequent(int[] nums, int k) {
+        int[] result = new int[k];
+
+        // key : num element in nums / value : frequency of num elements
+        Map<Integer, Integer> numMap = new HashMap<>();
+
+        // key : frequency of num elements / value : HashSet<Integer> num elements
+        Map<Integer, HashSet<Integer>> frequencyMap = new HashMap<>();
+
+        // most frequent numbers
+        int maxCount = 0;
+
+        // initialize numMap
+        for (int num : nums) {
+            if (numMap.containsKey(num)) {
+                Integer alreadyCounted = numMap.get(num);
+                numMap.put(num, alreadyCounted + 1);
+            } else {
+                numMap.put(num, 1);
+            }
+        }
+
+
+        //numHashSetMap
+        for (int num : numMap.keySet()) {
+            int frequencyOfNum = numMap.get(num);
+            maxCount = Math.max(maxCount, frequencyOfNum);
+
+            if (frequencyMap.containsKey(frequencyOfNum)) {
+                HashSet<Integer> alreadySet = frequencyMap.get(frequencyOfNum);
+                alreadySet.add(num);
+
+                frequencyMap.put(frequencyOfNum, alreadySet);
+
+            } else {
+                HashSet<Integer> newHashSet = new HashSet<>();
+                newHashSet.add(num);
+
+                frequencyMap.put(frequencyOfNum, newHashSet);
+            }
+        }
+
+
+        // maxCount 부터 decreasing
+        int resultIndex=0;
+        for(int frequency=maxCount; frequency>=0; frequency--) {
+            if (resultIndex >= result.length) {
+                return result;
+            }
+
+            if (frequencyMap.containsKey(frequency)) {
+                HashSet<Integer> numElements = frequencyMap.get(frequency);
+
+                for (int numElement : numElements) {
+                    result[resultIndex] = numElement;
+                    resultIndex++;
+
+
+                    if (resultIndex >= result.length) {
+                        return result;
+                    }
+                }
+            }
+        }
+
+        return result;
+}
+

two-sum/Geegong.java

@@ -0,0 +1,36 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Geegong {
+
+    /**
+     * time complexity : O(n)
+     * space complexity : O(n)
+     * @param nums
+     * @param target
+     * @return
+     */
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int[] result = new int[2];
+
+        // if target = -9 / num = 1 , num = -10
+        for (int index=0; index<nums.length; index++) {
+            map.put(nums[index], index);
+        }
+
+        for (int index=0; index<nums.length; index++) {
+            int difference = target - nums[index];
+
+            if (map.containsKey(difference)
+                    && map.get(difference) != index) {
+                result[0] = index;
+                result[1] = map.get(difference);
+                return result;
+            }
+        }
+
+        return result;
+    }
+}
+