[JinuCheon] Week 01 solutions (#2668)

* 217. Contains Duplicate

* Two Sum

Author: JinuCheon

contains-duplicate/JinuCheon.java

@@ -0,0 +1,28 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    /**
+     * 79/79 cases passed (19 ms)
+     * Your runtime beats 32.04 % of java submissions
+     * Your memory usage beats 6.16 % of java submissions (108.1 MB)
+     *
+     * When I changed HashSet to LinkedHashSet, the runtime and memory usage increased a little bit.
+     *
+     * Improvement:
+     * if (!set.add(num)) return true;  // when num is already in the set, return true.
+     * It looks like more simple.
+     */
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> exist = new HashSet<>();
+
+        for (int num : nums) {
+            if (exist.contains(num)) {
+                return true;
+            } else {
+                exist.add(num);
+            }
+        }
+        return false;
+    }
+}

two-sum/JinuCheon.java

@@ -0,0 +1,36 @@
+// Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?
+// O(n2)
+// class Solution1 {
+//     public int[] twoSum(int[] nums, int target) {
+//         int size = nums.length;
+//         for (int i=0; i<size; i++) {
+//             for (int j=0; j<size; j++) {
+//                 if (i==j) continue;
+//                 if (nums[i] + nums[j] == target) {
+//                     return new int[]{i, j};
+//                 }
+//             }
+//         }
+//         throw new IllegalArgumentException();
+//     }
+// }
+
+
+// I spent almost 20m thinking about this, but couldn't come up any ideas.
+// Finally I asked to LLM, there was a crazy solution.
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            int pair = target - nums[i];
+
+            if (map.containsKey(pair)) {
+                return new int[]{i, map.get(pair)};
+            }
+
+            map.put(nums[i], i);
+        }
+        throw new IllegalArgumentException();
+    }
+}