Add chapter 18 - Bit manipulation

* Hamming Weights Of Integers
* Lonely Integer
* Swap Odd And Even Bits

Author: marttp

kotlin/Bit Manipulation/HammingWeightsOfIntegers.kt

@@ -0,0 +1,16 @@
+fun hammingWeightsOfIntegers(n: Int): List<Int> {
+    return (1..n).map { countSetBits(it) }
+}
+
+fun countSetBits(n: Int): Int {
+    var x = n
+    var 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.and(1)
+        // Right shift 'x' to shift the next bit to the LSB position.
+        x = x.shr(1)
+    }
+    return count
+}

kotlin/Bit Manipulation/HammingWeightsOfIntegersDp.kt

@@ -0,0 +1,11 @@
+fun hammingWeightsOfIntegersDp(n: Int): List<Int> {
+    // 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.
+    val dp = IntArray(n + 1)
+    for (x in 1..n) {
+        // 'dp[x]' is obtained using the result of 'dp[x >> 1]', plus
+        // the LSB of 'x'.
+        dp[x] = dp[x ushr 1] + (x and 1)
+    }
+    return dp.toList()
+}

kotlin/Bit Manipulation/LonelyInteger.kt

@@ -0,0 +1,11 @@
+fun lonelyInteger(nums: List<Int>): Int {
+    var res = 0
+    // XOR each element of the array so that duplicate values will
+    // cancel each other out (x ^ x == 0).
+    for (n in nums) {
+        res = res.xor(n)
+    }
+    // 'res' will store the lonely integer because it would not have
+    // been canceled out by any duplicate.
+    return res
+}

kotlin/Bit Manipulation/SwapOddAndEvenBits.kt

@@ -0,0 +1,11 @@
+fun swapOddAndEvenBits(n: Long): Long {
+    val evenMask: Long = 0x55555555   // 01010101010101010101010101010101
+    val oddMask: Long = 0xAAAAAAAA  // 10101010101010101010101010101010
+    val evenBits = n.toLong() and evenMask
+    val oddBits = n.toLong() and oddMask
+    // Shift the even bits to the left, the odd bits to the right, and 
+    // merge these shifted values together.
+    // shl - signed shift left
+    // ushr - unsigned shift right
+    return (evenBits shl 1) or (oddBits ushr 1)
+}