Merge pull request neetcode-gh#1152 from aakhtar3/bit

refactor: js | bit

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;
+}