Merge pull request #96 from yolophg/main

[Helena] Week 4 solutions

Author: SamTheKorean

counting-bits/yolophg.js

@@ -0,0 +1,13 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+var countBits = function(n) {
+    // initialize an array to hold the result.
+    let ans = new Array(n + 1).fill(0);
+    
+    // iterate through all numbers from 1 to n.
+    for (let i = 1; i <= n; i++) {
+        ans[i] = ans[i >> 1] + (i & 1);
+    }
+    return ans;
+};

group-anagrams/yolophg.js

@@ -0,0 +1,25 @@
+// Time Complexity: O(n * k)
+// Space Complexity: O(n * k)
+
+var groupAnagrams = function(strs) {
+    const map = new Map();
+    for (const str of strs) {
+        // initialize an array to count the frequency of characters.
+        const count = new Array(26).fill(0); 
+        // increment the count for each character.
+        for (const char of str) {
+            count[char.charCodeAt(0) - 'a'.charCodeAt(0)]++; 
+        }
+        // generate a unique key based on character frequencies.
+        const key = count.join('#'); 
+        // if the key exists, push the original string to its group.
+        if (map.has(key)) {
+            map.get(key).push(str); 
+        } else { // else, create a new group with the key.
+            map.set(key, [str]);
+        }
+    }
+
+    // return the groups of the map as an array.
+    return Array.from(map.values()); 
+};

missing-number/yolophg.js

@@ -0,0 +1,13 @@
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+
+var missingNumber = function(nums) {
+    const n = nums.length;
+    // sum of numbers from 0 to n.
+    const expectedSum = (n * (n + 1)) / 2; 
+    // sum of numbers in the array.
+    const actualSum = nums.reduce((acc, curr) => acc + curr, 0); 
+
+    // the difference is the missing number.
+    return expectedSum - actualSum; 
+};

number-of-1-bits/yolophg.js

@@ -0,0 +1,14 @@
+// Time Complexity: O(log n)
+// Space Complexity: O(1)
+
+var hammingWeight = function(n) {
+    let count = 0;
+    while (n !== 0) {
+        // add 1 to count if the last bit is 1.
+        count += n & 1; 
+        // unsigned right shift to process the next bit.
+        n = n >>> 1;    
+    }
+    
+    return count;
+};

reverse-bits/yolophg.js

@@ -0,0 +1,16 @@
+// Time Complexity: O(1)
+// Space Complexity: O(1)
+
+var reverseBits = function(n) {
+    let result = 0;
+    // iterate 32 times since it's a 32-bit integer.
+    for (let i = 0; i < 32; i++) {
+        // shift the result to the left by 1 bit and OR it with the least significant bit of n.
+        result = (result << 1) | (n & 1);
+        // right shift n by 1 to consider the next bit.
+        n >>>= 1;
+    }
+    
+    // convert to unsigned integer.
+    return result >>> 0; 
+};