Merge pull request #1152 from aakhtar3/bit

refactor: js | bit

Author: aakhtar3

javascript/136-Single-Number.js

@@ -1,11 +1,13 @@
 /**
+ * https://leetcode.com/problems/single-number/
+ * Time O(N) | Space O(1)
  * @param {number[]} nums
  * @return {number}
  */
-var singleNumber = function (nums) {
-    let xor_final = 0;
+var singleNumber = function (nums, xor = 0) {
     for (num of nums) {
-        xor_final = xor_final ^ num;
+        xor ^= num;
     }
-    return xor_final;
+
+    return xor;
 };

javascript/190-Reverse-Bits.js

@@ -1,13 +1,15 @@
-var reverseBits = function (n) {
-    let result = 0b0;
-    let curr = n;
-
+/**
+ * https://leetcode.com/problems/reverse-bits/
+ * Time O(1) | Space O(1)
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+var reverseBits = function (n, bit = 0) {
     for (let i = 0; i < 32; i++) {
-        const lastBit = curr & 0b1;
-        result = result << 1;
-        result = result | lastBit;
-        curr = curr >> 1;
+        bit <<= 1;      // Double * 2
+        bit |= (n & 1); // Flip
+        n >>=  1;           // Reduce * 0.5
     }
 
-    return result >>> 0;
+    return bit >>> 0;
 };

javascript/191-Number-of-1-bits.js

@@ -1,12 +1,33 @@
 /**
+ * https://leetcode.com/problems/number-of-1-bits/
+ * Time O(1) | Space (1)
  * @param {number} n - a positive integer
  * @return {number}
  */
-var hammingWeight = function (n) {
-    let output = 0;
-    while (n != 0) {
-        n &= n - 1;
-        output++;
+ var hammingWeight = function(n) {
+    let [ bits, mask ] = [ 0, 1 ]
+    
+    for (let i = 0; i < 32; i++) {
+        const hasBit = ((n & mask) !== 0)
+        if (hasBit) bits++
+        
+        mask <<= 1
     }
-    return output;
+    
+    return bits
 };
+
+/**
+ * https://leetcode.com/problems/number-of-1-bits/
+ * Time O(1) | Space (1)
+ * @param {number} n - a positive integer
+ * @return {number}
+ */
+ var hammingWeight = function(n, sum = 0) {
+    while (n !== 0) {
+        n &= (n - 1)
+        sum++
+    }
+    
+    return sum
+}

javascript/268-Missing-Number.js

@@ -1,19 +1,15 @@
-var missingNumberWithSums = function (nums) {
-    let res = nums.length;
-
+/**
+ * https://leetcode.com/problems/missing-number/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function (nums, missingNumber = nums.length) {
     for (let i = 0; i < nums.length; i++) {
-        res += i - nums[i];
-    }
-
-    return res;
-};
-
-var missingNumberWithBit = function (nums) {
-    let res = nums.length;
+        const xor = (i ^ nums[i]);
 
-    for (let i = 0; i < nums.length; i++) {
-        res = res ^ i ^ nums[i];
+        missingNumber ^= xor;
     }
 
-    return res;
+    return missingNumber;
 };

javascript/338-Counting-Bits.js

@@ -1,11 +1,16 @@
 /**
+ * https://leetcode.com/problems/counting-bits/
+ * Time O(N) | Space (1)
  * @param {number} n
  * @return {number[]}
  */
-var countBits = function (n) {
-    let output = [0];
-    for (let i = 1; i < n + 1; i++) {
-        output.push(output[i >> 1] + (i & 1));
+var countBits = function (n, dp = [ 0 ]) {
+    for (let i = 1; i < (n + 1); i++) {
+        const [ mid, bit ] = [ (i >> 1), (i & 1) ]
+        const bits = (dp[mid] + bit)
+
+        dp.push(bits);
     }
-    return output;
+
+    return dp;
 };

javascript/371-Sum-of-Two-Integers.js

@@ -1,12 +1,17 @@
-var getSum = function (a, b) {
-    let tb = b;
-    let res = a;
+/**
+ * https://leetcode.com/problems/sum-of-two-integers/
+ * Time O(1) | Space O(1)
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+ var getSum = function(a, b) {
+    while (b !== 0) {
+        const [ xor, carry ] = [ (a ^ b), ((a & b) << 1) ];
 
-    while (tb) {
-        let temp = (res & tb) << 1;
-        res = res ^ tb;
-        tb = temp;
+        a = xor;
+        b = carry;
     }
-
-    return res;
-};
+    
+    return a
+};

javascript/7-Reverse-Integer.js

@@ -1,27 +1,30 @@
 /**
+ * https://leetcode.com/problems/reverse-integer/
+ * Time O(log(x)) | Space O(1)
  * @param {number} x
  * @return {number}
  */
-const reverse = function (x) {
-    const max = 2 ** 31 - 1;
-    const min = -(2 ** 31);
-
-    let result = 0;
+var reverse = function(x, result = 0) {
     while (x !== 0) {
-        const digit = x % 10;
-        x = Math.trunc(x / 10);
+        const digit = (x % 10)
 
-        if (result > max / 10 || (result === max / 10 && digit >= max % 10)) {
-            return 0;
-        } else if (
-            result < min / 10 ||
-            (result === max / 10 && digit <= min % 10)
-        ) {
-            return 0;
-        } else {
-            result = result * 10 + digit;
-        }
+        if (isOutOfBounds(digit, result)) return 0;
+
+        x = Math.trunc(x / 10);
+        result = (result * 10) + digit;
     }
 
     return result;
 };
+
+const isOutOfBounds = (digit, result) => {
+    const [ max, min ] = [ ((2 ** 31) - 1), (-(2 ** 31)) ];
+    const [ maxProduct, maxRemainder ] = [ (max / 10), (max % 10) ];
+    const [ minProduct, minRemainder ] = [ (min / 10), (min % 10) ];
+    const isTarget = result === maxProduct;
+
+    const isMaxOut = ((maxProduct < result) || (isTarget && (maxRemainder <= digit)));
+    const isMinOut = ((result < minProduct) || (isTarget && (digit <= minRemainder)));
+
+    return isMaxOut || isMinOut;
+}