update questions

Author: maxyzli

README.md

@@ -5,6 +5,7 @@ LeetCode Solution in Java
 ## Topics
 
 - [Math](#math)
+- [Bit](#math)
 - [Array/String](#stringarray)
     - [Two Pointers](#two-pointers)
     - [Matrix](#matrix)
@@ -34,6 +35,16 @@ LeetCode Solution in Java
 |989|[Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/)|[Java](math/add-to-array-form-of-integer/README.md)|Easy|
 |1232|[Check If It Is a Straight Line](https://leetcode.com/problems/check-if-it-is-a-straight-line/)|[Java](math/check-if-it-is-a-straight-line/README.md)|Easy|
 
+## Bit
+
+| # | Title | Solution | Difficulty |
+|:-:|-|-|-|
+|191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)|[Java](bit/number-of-1-bits/README.md)|Easy|
+|231|[Power of Two](https://leetcode.com/problems/power-of-two/)|[Java](bit/power-of-two/README.md)|Easy|
+|371|[Sum of Two Integers](https://leetcode.com/problems/sum-of-two-integers/)|[Java](bit/sum-of-two-integers/README.md)|Medium|
+|461|[Hamming Distance](https://leetcode.com/problems/hamming-distance/)|[Java](bit/hamming-distance/README.md)|Easy|
+|477|[Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance/)|[Java](bit/total-hamming-distance/README.md)|Medium|
+
 ## Array/String
 
 | # | Title | Solution | Difficulty |

bit/hamming-distance/README.md

@@ -0,0 +1,47 @@
+# Hamming Distance
+
+## Solution 1
+
+```java
+/**
+ * Question   : 461. Hamming Distance
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int hammingDistance(int x, int y) {
+        int res = 0;
+        while (x != 0 || y != 0) {
+            if ((x & 1) != (y & 1)) {
+                res++;
+            }
+            x >>>= 1;
+            y >>>= 1;
+        }
+        return res;
+    }
+}
+```
+
+## Solution 2
+
+```java
+/**
+ * Question   : 461. Hamming Distance
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int hammingDistance(int x, int y) {
+        int res = 0;
+        int diff = x ^ y;
+        
+        while (diff != 0) {
+            res++;
+            diff = diff & (diff - 1);
+        }
+        
+        return res;
+    }
+}
+```

bit/number-of-1-bits/README.md

@@ -0,0 +1,62 @@
+# Number of 1 Bits
+
+# Solution 1
+
+```java
+/**
+ * Question   : 191. Number of 1 Bits
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+public class Solution {
+    public int hammingWeight(int n) {
+        int count = 0;
+        for (int i = 0; i < 32; i++) {
+            count += n & 1;
+            n >>>= 1;
+        }
+        return count;
+    }
+}
+```
+
+# Solution 2
+
+```java
+/**
+ * Question   : 191. Number of 1 Bits
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+public class Solution {
+    public int hammingWeight(int n) {
+        int count = 0;
+        for (int i = 0; i < 32; i++) {
+            if ((n & (1 << i)) != 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
+```
+
+# Solution 3
+
+```java
+/**
+ * Question   : 191. Number of 1 Bits
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+public class Solution {
+    public int hammingWeight(int n) {
+        int count = 0;
+        while (n != 0) {
+            count++;
+            n = n & (n - 1);
+        }
+        return count;
+    }
+}
+```

bit/power-of-two/README.md

@@ -0,0 +1,51 @@
+# Power of Two
+
+## Solution 1
+
+```java
+/**
+ * Question   : 231. Power of Two
+ * Complexity : Time: O(log(n)) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if (n == 0) {
+            return false;
+        }
+        if (n == 1) {
+            return true;
+        }
+        if (n % 2 != 0) {
+            return false;
+        }
+        return isPowerOfTwo(n / 2);
+    }
+}
+```
+
+## Solution 2
+
+```java
+/**
+ * Question   : Power of Two
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if (n < 0) {
+            return false;
+        }
+
+        int count = 0;
+
+        while (n != 0) {
+            count++;
+            n = n & (n - 1);
+        }
+
+        return count == 1;
+    }
+}
+```

bit/sum-of-two-integers/README.md

@@ -0,0 +1,33 @@
+# Sum of Two Integers
+
+## Solution 1
+
+```java
+/**
+ * Question   : 371. Sum of Two Integers
+ * Complexity : Time: O(1) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int getSum(int a, int b) {
+        while (b != 0) {
+            int carry = (a & b) << 1;
+            a = a ^ b;
+            b = carry;
+        }
+
+        // Round1:
+        // a: 0111
+        // b: 0110
+        //  (a & b) << 1 = 0110 << 1 = 1100 (carry part)
+        //  (a ^ b)                  = 0001 (add without carry)
+        // Round2:
+        // a: 0001
+        // b: 1100
+        //  (a & b) << 1 = 0000 << 1 = 0000 (carry part)
+        //  (a ^ b)                  = 1101 (add without carry)
+
+        return a;
+    }
+}
+```

bit/total-hamming-distance/README.md

@@ -0,0 +1,74 @@
+# Total Hamming Distance
+
+## Solution 1
+
+Time Limit Exceeded
+
+```java
+/**
+ * Question   : 477. Total Hamming Distance
+ * Complexity : Time: O(n^2) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int totalHammingDistance(int[] nums) {
+        int total = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                total += hammingDistance(nums[i], nums[j]);
+            }
+        }
+
+        return total;
+    }
+
+    private int hammingDistance(int a, int b) {
+        int diff = a ^ b;
+
+        int res = 0;
+        while (diff != 0) {
+            res++;
+            diff = diff & (diff - 1);
+        }
+
+        return res;
+    }
+}
+```
+
+## Solution 2
+
+```java
+/**
+ * Question   : 477. Total Hamming Distance
+ * Complexity : Time: O(n) ; Space: O(1)
+ * Topics     : Bit
+ */
+class Solution {
+    public int totalHammingDistance(int[] nums) {
+        int n = nums.length;
+
+        // count stores the number of 1 in each bit.
+        int[] count = new int[32];
+
+        for (int i = 0; i < n; i++) {
+            int num = nums[i];
+            int j = 0;
+            while (num > 0) {
+                count[j] += num & 1;
+                num >>>= 1;
+                j++;
+            }
+        }
+
+        int res = 0;
+        for (int i = 0; i < count.length; i++) {
+            // (number of 1) * (number of 0) in this bit.
+            res += count[i] * (n - count[i]);
+        }
+
+        return res;
+    }
+}
+```