Merge pull request #1199 from mintheon/main

[mintheon] WEEK 01 solutions

Author: mintheon

longest-consecutive-sequence/mintheon.java

@@ -1,30 +1,28 @@
-import java.util.HashSet;
-import java.util.Set;
-
 class Solution {
   public int longestConsecutive(int[] nums) {
     Set<Integer> numSet = new HashSet<>();
+    int max = 0;
 
     for(int num : nums) {
       numSet.add(num);
     }
 
-    int longestSize = 0;
-
     for(int num : numSet) {
-      if(!numSet.contains(num - 1)) {
-        int current = num;
-        int count = 1;
+      if(numSet.contains(num - 1)) {
+        continue;
+      }
 
-        while(numSet.contains(current + 1)) {
-          count++;
-          current++;
-        }
+      int count = 1;
+      int curNum = num;
 
-        longestSize = Math.max(count, longestSize);
+      while(numSet.contains(curNum + 1)) {
+        count++;
+        curNum++;
       }
+
+      max = Math.max(max, count);
     }
 
-    return longestSize;
+    return max;
   }
 }

merge-intervals/mintheon.java

@@ -0,0 +1,19 @@
+import java.util.Arrays;
+import java.util.LinkedList;
+
+class Solution {
+  public int[][] merge(int[][] intervals) {
+    Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+    LinkedList<int[]> merged = new LinkedList<>();
+
+    for(int[] interval : intervals) {
+      if(merged.isEmpty() || merged.getLast()[1] < interval[0]) {
+        merged.add(interval);
+      } else {
+        merged.getLast()[1] = Math.max(merged.getLast()[1], interval[1]);
+      }
+    }
+
+    return merged.toArray(new int[merged.size()][]);
+  }
+}

top-k-frequent-elements/mintheon.java

@@ -1,22 +1,22 @@
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.PriorityQueue;
-
 class Solution {
   public int[] topKFrequent(int[] nums, int k) {
     int[] answer = new int[k];
-    Map<Integer, Integer> frequent = new HashMap<>();
+    Map<Integer, Integer> count = new HashMap<>();
 
-    for(int num: nums) {
-      frequent.put(num, frequent.getOrDefault(num, 1) + 1);
+    for(int i = 0; i < nums.length; i++) {
+      count.put(nums[i], count.getOrDefault(nums[i], 0) + 1);
     }
 
-    PriorityQueue<Entry<Integer, Integer>> pq = new PriorityQueue<>((a, b) -> b.getValue().compareTo(a.getValue()));
-    pq.addAll(frequent.entrySet());
+    PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
+
+    for(int key : count.keySet()) {
+      queue.offer(new int[]{key, count.get(key)});
+    }
 
     for(int i = 0; i < k; i++) {
-      answer[i] = pq.poll().getKey();
+      int[] num = queue.poll();
+
+      answer[i] = num[0];
     }
 
     return answer;

two-sum/mintheon.java

@@ -2,25 +2,19 @@
 import java.util.Map;
 
 class Solution {
-  /**
-   공간복잡도: O(n)
-   시간복잡도: O(n)
-   */
-
   public int[] twoSum(int[] nums, int target) {
-    Map<Integer, Integer> numMap = new HashMap<>();
+    Map<Integer, Integer> indexMap = new HashMap<>();
 
     for(int i = 0; i < nums.length; i++) {
-      numMap.put(nums[i], i);
-    }
+      int remain = target - nums[i];
 
-    for(int i = 0; i < nums.length; i++) {
-      int pairNum = target - nums[i];
-      if(numMap.containsKey(pairNum) && numMap.get(pairNum) != i) {
-        return new int[]{i, numMap.get(target - nums[i])};
+      if(indexMap.containsKey(remain)) {
+        return new int[] {i, indexMap.get(remain)};
       }
+
+      indexMap.put(nums[i], i);
     }
 
-    return new int[2];
+    return new int[]{};
   }
 }