[Zioq] Week3

combination-sum/Zioq.js

@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function(candidates, target) {
+    let result = [];
+
+    function find_combination(index, target, current) {
+        if (target === 0) {
+            result.push([...current]);
+            return;
+        }
+
+        for (let i = index; i < candidates.length; i++) {
+            // Only proceed if current number doesn't exceed target
+            if (candidates[i] <= target) {
+                // Include current number in combination
+                current.push(candidates[i]);
+
+                // Recursive call with:
+                // - same index i (allowing reuse of same number)
+                // - reduced target by current number
+                find_combination(i, target - candidates[i], current);
+
+                // Backtrack: remove the last added number to try other combinations
+                current.pop();
+            }
+        }
+    }
+
+    find_combination(0, target, []);
+    return result;
+};
+
+/* 
+
+
+
+*/
+
+console.log(combinationSum([2,3,6,7], 7))
+
+

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

@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {    
+    let result =  Array.from({length: nums.length}, () => 1) // Initialize return array
+
+    // Iterate left to right
+    let left = 1;
+    for( let i =0 ; i<nums.length; i++ ) {
+        result[i] *= left;
+        left *= nums[i];
+    }
+
+    // Iterate right to left based on the result arr above
+    let right = 1;
+    for( let i=nums.length -1; i >=0; i-- ) {
+        result[i] *= right;
+        right *= nums[i];
+    }
+
+    // console.log(result)
+    return result
+};
+
+/* 
+    Time Complexity: O(n): Loop the nth nums array length
+    Space Complexity: O(1)
+*/
+
+
+
+console.log(productExceptSelf([1,2,3,4])) 
+console.log(productExceptSelf([-1,1,0,-3,3]))  
+
+

reverse-bits/Zioq.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+var reverseBits = function(n) {
+    let result = 0; //Initial value
+    for (let i=0; i < 32; i++) { //The loop iterates 32 times, as the input n is a 32-bit unsigned integer
+        result = (result << 1) | (n & 1); // Shift the result to the left by 1 bit OR it with the least significant bit of n.
+        n >>= 1; // Shifts the bits of n one place to the right, effectively "removing" the processed LSB.
+    }
+    return result >>> 0;    
+};
+/* 
+    Time Complexity: O(1), because we always loop exactly 32 times, regardless of the input.
+    Space Complexity: O(1), because we use a constant amount of space.
+*/
+
+
+

two-sum/Zioq.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    // Initialize object to save remained value with index
+    let remain_with_index_obj = {}
+
+    for ( let i =0; i<nums.length++; i++ ) {
+        let remain = target - nums[i]; // Calculate reamined value to check 
+
+        // If remained value found in the object, return current index and object's key
+        if( remain_with_index_obj.hasOwnProperty(remain) ) {
+            return [i, remain_with_index_obj[remain]]
+        }
+
+        // Save the valu as key
+        remain_with_index_obj[nums[i]] = i;
+    }
+    return null
+};
+
+/* 
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+*/
+
+console.log(twoSum([2,7,11,15], 9));
+console.log(twoSum([3,2,4], 6));