[junzero741] WEEK 1 Solutions

contains-duplicate/junzero741.ts

@@ -0,0 +1,6 @@
+// TC: O(n)
+// SC: O(n)
+function containsDuplicate(nums: number[]): boolean {
+    const uniqueNums = new Set<number>(nums);
+    return uniqueNums.size < nums.length
+};

longest-consecutive-sequence/junzero741.ts

@@ -0,0 +1,23 @@
+// TC: O(N)
+// SC: O(N)
+function longestConsecutive(nums: number[]): number {
+     let finalMaxSequence = 0;
+
+    // O(n)
+     const numsSet = new Set(nums);
+
+    // O(n)
+     for(const num of numsSet) {
+        if(numsSet.has(num - 1)) {
+            continue;
+        }
+        let currentMaxSequence = 1;
+        while(numsSet.has(num + currentMaxSequence)) {
+            currentMaxSequence++;
+        }
+        finalMaxSequence = Math.max(finalMaxSequence, currentMaxSequence);
+     }
+
+     return finalMaxSequence;
+
+};

top-k-frequent-elements/junzero741.ts

@@ -0,0 +1,37 @@
+
+// TC: O(NlogN)
+// SC: O(N)
+function topKFrequent(nums: number[], k: number): number[] {
+
+    /**
+    Map ( O(N) )
+    1 : 4
+    4 : 1
+    3 : 3
+    2 : 2 
+
+    -> convert it to array ( O(N) ) : [[1,4], [4,1], [3,3], [2,2]] 
+    -> sort by value ( O(NlogN) ): [[1,4], [3,3], [2,2], [4,1]]
+    -> slice(0,k) ( (O(N) ) : [[1,4], [3,3]] 
+    -> make array from keys ( (O(N) ) : [1,4]
+     */
+
+     const numMap = new Map<number, number>();
+     const n = nums.length;
+
+     for(let i = 0; i < n; i++) {
+        const num = nums[i];
+        const frequency = (numMap.get(num) || 0)
+        numMap.set(num, frequency + 1);
+     }
+
+
+    const numFrequencyArr = Array.from(numMap);
+    const sortedNumFrequencyKeysArr = 
+        numFrequencyArr
+            .sort((a,b) => b[1]-a[1])
+            .map((entry) => entry[0]);
+
+
+     return sortedNumFrequencyKeysArr.slice(0, k)
+};

two-sum/junzero741.ts

@@ -0,0 +1,18 @@
+// TC: O(n)
+// SC: O(n)
+function twoSum(nums: number[], target: number): number[] {
+    const n = nums.length;
+    const complementMap = new Map<number, number>();
+
+    for(let aIndex = 0; aIndex < n; aIndex++) {
+        const a = nums[aIndex];
+        const b = target - a;
+
+        if(complementMap.has(b)) {
+            return [complementMap.get(b) || -1, aIndex];
+        }
+        complementMap.set(a, aIndex);
+    }
+
+    return [-1, -1];
+};