Merge pull request #100 from yolophg/main

[Helena] Week 5 solutions

Author: DaleSeo

3sum/yolophg.js

@@ -0,0 +1,34 @@
+// Time Complexity: O(n^2)
+// Space Complexity: O(n)
+
+// Time Complexity: O(n^2)
+// Space Complexity: O(n)
+
+var threeSum = function(nums) {
+    nums.sort((a, b) => a - b);
+    // create a set to store triplets.
+    const result = new Set();
+
+    // loop through the array, but stop 2 elements before the end.
+    for (let i = 0; i < nums.length - 2; i++) {
+        // if the current element is the same as the one before it, skip it to avoid duplicates.
+        if (i > 0 && nums[i] === nums[i - 1]) continue;
+    
+        // create a set to keep track of the complements.
+        const complements = new Set();
+        // start another loop from the next element.
+        for (let j = i + 1; j < nums.length; j++) {
+            const complement = -nums[i] - nums[j];
+            // check if the current number is in the set.
+            if (complements.has(nums[j])) {
+                // if it is, found a triplet. Add it to the result set as a sorted string to avoid duplicates.
+                result.add(JSON.stringify([nums[i], complement, nums[j]].sort((a, b) => a - b)));
+            } else {
+                complements.add(complement);
+            }
+        }
+    }
+
+    // convert set of strings back to arrays.
+    return Array.from(result).map(triplet => JSON.parse(triplet));
+};

encode-and-decode-strings/yolophg.js

@@ -0,0 +1,14 @@
+// Time Complexity: O(n), O(n)
+// Space Complexity: O(n), O(n)
+
+class Solution {
+    encode(strs) {
+        // join the array into a single string using a delimiter, '|'.
+        return strs.join('|');
+    }
+
+    decode(str) {
+        // split the string using the delimiter '|' and return the array.
+        return str.split('|');
+    }
+}

longest-consecutive-sequence/yolophg.js

@@ -0,0 +1,31 @@
+// Time Complexity: O(n log n)
+// Space Complexity: O(n)
+
+var longestConsecutive =  function(nums) {
+    if (nums.length === 0) return 0;
+
+    nums.sort((a, b) => a - b);
+
+    let longestStreak = 1;
+    let currentStreak = 1;
+
+    // iterate through the sorted array.
+    for (let i = 1; i < nums.length; i++) {
+        // check for duplicates.
+        if (nums[i] !== nums[i - 1]) { 
+            if (nums[i] === nums[i - 1] + 1) {
+                // if current element is consecutive, increment current streak.
+                currentStreak++;
+            } else {
+                // if not, update longest streak and reset current streak.
+                longestStreak = Math.max(longestStreak, currentStreak);
+                currentStreak = 1;
+            }
+        }
+    }
+
+    // final comparison to ensure the longest streak is captured.
+    longestStreak = Math.max(longestStreak, currentStreak);
+
+    return longestStreak;
+}

product-of-array-except-self/yolophg.js

@@ -0,0 +1,26 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+var productExceptSelf = function(nums) {
+    const n = nums.length;
+    const leftProducts = new Array(n).fill(1);
+    const rightProducts = new Array(n).fill(1);
+    const result = new Array(n);
+
+    // leftProduct will be the product of all elements to the left of index i.
+    for (let i = 1; i < n; i++) {
+        leftProducts[i] = leftProducts[i - 1] * nums[i - 1];
+    }
+
+    // rightProduct will be the product of all elements to the right of index i.
+    for (let i = n - 2; i >= 0; i--) {
+        rightProducts[i] = rightProducts[i + 1] * nums[i + 1];
+    }
+
+    // result will be the product of leftProduct and rightProduct.
+    for (let i = 0; i < n; i++) {
+        result[i] = leftProducts[i] * rightProducts[i];
+    }
+
+    return result;
+};

top-k-frequent-elements/yolophg.js

@@ -0,0 +1,26 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+var topKFrequent = function(nums, k) {
+    const frequencyMap = new Map();
+    // for each number in the array, update frequency.
+    for (const num of nums) {
+        frequencyMap.set(num, (frequencyMap.get(num) || 0) + 1);
+    }
+
+    // create buckets where index represents frequency.
+    const buckets = Array(nums.length + 1).fill().map(() => []);
+    // place each number into the bucket corresponding to frequency.
+    for (const [num, frequency] of frequencyMap.entries()) {
+        buckets[frequency].push(num);
+    }
+
+    const result = [];
+    // iterate from the highest possible frequency down to the lowest.
+    for (let i = buckets.length - 1; i >= 0 && result.length < k; i--) {
+        result.push(...buckets[i]);
+    }
+
+    // ensure the result length is k.
+    return result.slice(0, k); 
+};