[sora0319] WEEK 01 solutions

contains-duplicate/sora0319.java

@@ -0,0 +1,12 @@
+import java.util.*;
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Arrays.sort(nums);
+
+        for(int i = 0; i < nums.length-1; i++){
+            if(nums[i] == nums[i+1]) return true;
+        }
+        return false;
+    }
+}
+

house-robber/sora0319.java

@@ -0,0 +1,20 @@
+import java.util.*;
+class Solution {
+    public int rob(int[] nums) {
+        int[] house = new int[nums.length];
+        Arrays.fill(house, -1);
+        return maxRobbery(0, nums, house);
+    }
+
+    private int maxRobbery(int index, int[] nums, int[] house) {
+        if (index >= nums.length) return 0;
+        if (house[index] != -1) return house[index];
+
+        int rob = nums[index] + maxRobbery(index + 2, nums, house);
+        int skip = maxRobbery(index + 1, nums, house);
+
+        house[index] = Math.max(rob, skip);
+        return house[index];
+    }
+}
+

longest-consecutive-sequence/sora0319.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> checkList = new HashSet<>();
+        int seqCnt = 0;
+        int start = Integer.MIN_VALUE;
+
+        for(int n : nums){
+            checkList.add(n);
+        }
+
+        for (int n : nums) {
+            int seq = 1;
+            int target = n+1;
+            if(checkList.contains(n-1))continue;
+
+            while(checkList.contains(target)){
+                checkList.remove(target);
+                seq++;
+                target++;
+            }
+
+            if(seqCnt < seq){
+                seqCnt = seq;
+                start = n;
+            }
+        }
+        return seqCnt;
+    }
+}
+

top-k-frequent-elements/sora0319.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Solution {
+    public int[] topKFrequent(int[] nums, int k) {
+        Map<Integer,Integer> counts = new HashMap<>();
+        List<Integer> ordering = new ArrayList<>();
+        int[] results = new int[k];
+
+        for(int n : nums){
+            if(counts.containsKey(n)){
+                counts.put(n, counts.get(n)+1);
+                continue;
+            }
+            counts.put(n, 1);
+            ordering.add(n);
+        }
+
+        ordering.sort((o1,o2) -> counts.get(o2) - counts.get(o1));
+        for(int i = 0; i < k; i++){
+            results[i] = ordering.get(i);
+        }
+
+        return results;
+    }
+}
+

two-sum/sora0319.java

@@ -0,0 +1,30 @@
+import java.util.*;
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer,Integer> element = new HashMap<>();
+
+        for(int i = 0; i < nums.length; i++){
+            element.put(i, nums[i]);
+        }
+
+        int[] result = new int[2];
+        int n = 0;
+        for(int i = 0; i < nums.length; i++){
+            element.remove(i);
+            n = target - nums[i];
+            if(element.containsValue(n)){
+                result[0] = i;
+                break;
+            }
+        }
+
+        for(int i = 0; i < nums.length; i++){
+            if(nums[i] == n && i != result[0]){
+                result[1] = i;
+                break;
+            }
+        }
+        return result;
+    }
+}
+