Merge pull request ByteByteGoHq#51 from ongshunping/cpp-solutions-bit-manipulation

Add C++ solutions for Chapter 18 (Bit Manipulation)

Author: Destiny-02

cpp/Bit Manipulation/hamming_weights_of_integers.cpp

@@ -0,0 +1,22 @@
+#include <vector>
+
+std::vector<int> hammingWeightsOfIntegers(int n) {
+    std::vector<int> res;
+    res.reserve(n + 1); 
+    for (int x = 0; x <= n; x++) {
+        res.push_back(countSetBits(x));
+    }
+    return res;
+}
+
+int countSetBits(int x) {
+    int count = 0;
+    // Count each set bit of 'x' until 'x' equals 0.
+    while (x > 0) {
+        // Increment the count if the LSB is 1.
+        count += x & 1;
+        // Right shift 'x' to shift the next bit to the LSB position.
+        x >>= 1;
+    }
+    return count;
+}

cpp/Bit Manipulation/hamming_weights_of_integers_dp.cpp

@@ -0,0 +1,13 @@
+#include <vector>
+
+std::vector<int> hammingWeightsOfIntegersDp(int n) {
+    // Base case: the number of set bits in 0 is just 0.
+    // We set dp[0] to 0 by initializing the entire DP array to 0.
+    std::vector<int> dp(n + 1, 0);
+    for (int x = 1; x <= n; x++) {
+        // 'dp[x]' is obtained using the result of 'dp[x >> 1]', plus 
+        // the LSB of 'x'.
+        dp[x] = dp[x >> 1] + (x & 1);
+    }
+    return dp;
+}

cpp/Bit Manipulation/lonely_integer.cpp

@@ -0,0 +1,13 @@
+#include <vector>
+
+int lonelyInteger(std::vector<int>& nums) {
+    int res = 0;
+    // XOR each element of the array so that duplicate values will
+    // cancel each other out (x ^ x == 0).
+    for (int i = 0; i < nums.size(); i++) {
+        res ^= nums[i];
+    }
+    // 'res' will store the lonely integer because it would not have
+    // been canceled out by any duplicate.
+    return res;
+}

cpp/Bit Manipulation/swap_odd_and_even_bits.cpp

@@ -0,0 +1,9 @@
+unsigned int swapOddAndEvenBits(unsigned int n) {
+    unsigned int evenMask = 0x55555555; // 01010101010101010101010101010101
+    unsigned int oddMask  = 0xAAAAAAAA; // 10101010101010101010101010101010
+    unsigned int evenBits = n & evenMask;
+    unsigned int oddBits  = n & oddMask;
+    // Shift the even bits to the left, the odd bits to the right, and
+    // merge these shifted values together.
+    return (evenBits << 1) | (oddBits >> 1);
+}