Merge pull request #2392 from soobing/week1

[soobing] WEEK 01 solutions

Author: SamTheKorean

contains-duplicate/soobing3.ts

@@ -0,0 +1,11 @@
+function containsDuplicate(nums: number[]): boolean {
+  const checkMap = new Map();
+  for(const n of nums) {
+      if(checkMap.has(n)) {
+          return true;
+      } else {
+          checkMap.set(n, 1);
+      }
+  }
+  return false;
+};

house-robber/soobing3.ts

@@ -0,0 +1,10 @@
+function rob(nums: number[]): number {
+  const dp = new Array(nums.length);
+  dp[0] = nums[0];
+  dp[1] = Math.max(nums[0], nums[1]);
+  
+  for(let i = 2; i < nums.length; i++) {
+      dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
+  }
+  return dp[nums.length - 1];
+};

longest-consecutive-sequence/soobing3.ts

@@ -0,0 +1,16 @@
+function longestConsecutive(nums: number[]): number {
+  const set = new Set<number>(nums);
+  let maxLength = nums.length > 0 ? 1 : 0;
+  for(const num of set) {
+      if(!set.has(num - 1)) {
+          let length = 1;
+          let current = num;
+          while(set.has(current + 1)) {
+              length++;
+              current++;
+          }
+          maxLength = Math.max(maxLength, length);
+      }
+  }
+  return maxLength;
+};

top-k-frequent-elements/soobing3.ts

@@ -0,0 +1,99 @@
+class MyMinPriorityQueue<T> {
+  private heap: T[] = [];
+  private compare: (a: T, b: T) => number;
+
+  constructor(compare: (a: T, b: T) => number) {
+    this.compare = compare;
+  }
+
+  public get size() {
+    return this.heap.length;
+  }
+
+  public get peek() {
+    return this.heap[0];
+  }
+
+  public toArray() {
+    return this.heap;
+  }
+
+  public push(value: T) {
+    this.heap.push(value);
+    this.bubbleUp();
+  }
+
+  public pop() {
+    if(this.heap.length === 0) {
+        return undefined;
+    }
+
+    const min = this.heap[0];
+    const last = this.heap.pop();
+    if(this.heap.length === 0) {
+        return min;
+    }
+
+    this.heap[0] = last ?? undefined as T;
+    this.bubbleDown();
+
+    return min;
+  }
+
+  private bubbleDown() {
+    let index = 0;
+
+    while(true) {
+        let smallestIndex = index;
+        let leftIndex = 2 * index + 1;
+        let rightIndex = 2 * index + 2;
+
+        if(leftIndex < this.size && this.compare(this.heap[leftIndex], this.heap[smallestIndex]) < 0) {
+            smallestIndex = leftIndex;
+        }
+
+        if(rightIndex < this.size && this.compare(this.heap[rightIndex], this.heap[smallestIndex]) < 0) {
+            smallestIndex = rightIndex;
+        }
+
+        if(index === smallestIndex) break;
+        [this.heap[index], this.heap[smallestIndex]] = [this.heap[smallestIndex],  this.heap[index]];
+        index = smallestIndex;
+    }
+  }
+
+  private bubbleUp() {
+    let index = this.size - 1;
+    
+    while(index > 0) {
+        const parentIndex = Math.floor((index - 1) / 2)
+        if (this.compare(this.heap[parentIndex], this.heap[index]) > 0) {
+            [this.heap[parentIndex], this.heap[index]] = [this.heap[index],  this.heap[parentIndex]]
+        }
+
+        index = parentIndex;
+    }
+  }
+}
+
+function topKFrequent(nums: number[], k: number): number[] {
+    const map = new Map<number, number>();
+    
+    for (const n of nums) {
+        map.set(n, (map.get(n) ?? 0) + 1);
+    }
+
+    const minHeap = new MyMinPriorityQueue((a: number, b: number) => {
+         return (map.get(a) ?? 0) - (map.get(b) ?? 0)
+    });
+
+    for(const [key, count] of map) {
+        if(minHeap.size < k) {
+            minHeap.push(key)
+        } else if((map.get(minHeap.peek) ?? 0) < (map.get(key) ?? 0)) {
+            minHeap.pop()
+            minHeap.push(key)
+        }
+    }
+    return minHeap.toArray()
+}

two-sum/soobing3.ts

@@ -0,0 +1,29 @@
+function twoSum(nums: number[], target: number): number[] {
+  const map = new Map<number, number[]>();
+  for(let i = 0; i < nums.length; i++) {
+      const current = map.get(nums[i]);
+      if(current) {
+          current.push(i);
+      } else {
+          map.set(nums[i], [i]);
+      }
+  }
+
+  nums.sort((a, b) => a - b);
+  let left = 0;
+  let right = nums.length - 1;
+
+  while(left < right) {
+      if(nums[left] + nums[right] === target) {
+          return [map.get(nums[left])?.pop() ?? 0, map.get(nums[right])?.pop() ?? 0];
+      }
+
+      if(nums[left] + nums[right] > target) {
+          right--;
+      } else {
+          left++;
+      }
+  }
+
+  return [];
+};