Merge pull request #7 from ZapDos7/feature/binary-hacks

Binary hacks

Author: ZapDos7

README.md

@@ -53,6 +53,12 @@
 - [x] Hamming Weight implementation (return 1-bits of a binary representation of a number)
 - [x] [Binary to Decimal Converter](https://tausiq.wordpress.com/2009/07/27/uab-2005-problem-3-binary-to-decimal-converter/)
 - [x] [Reverse bits](https://leetcode.com/problems/reverse-bits/)
+- [x] [Bit Hacks — Part 1 (Basic)](http://www.techiedelight.com/bit-hacks-part-1-basic/)
+- [x] [Bit Hacks — Part 2 (Playing with k’th bit)](http://www.techiedelight.com/bit-hacks-part-2-playing-kth-bit/)
+- [x] [Bit Hacks — Part 3 (Playing with rightmost set bit of a number)](http://www.techiedelight.com/bit-hacks-part-3-playing-rightmost-set-bit-number/)
+- [x] [Bit Hacks — Part 4 (Playing with letters of English alphabet)](http://www.techiedelight.com/bit-hacks-part-4-playing-letters-english-alphabet/)
+- [x] [Bit Hacks — Part 5 (Find absolute value of an integer without branching)](http://www.techiedelight.com/bit-hacks-part-5-find-absolute-value-integer-without-branching/)
+- [x] [Bit Hacks — Part 6 (Random Problems)](http://www.techiedelight.com/bit-hacks-part-6-random-problems/)
 
 ## Algorithms
 
@@ -170,12 +176,6 @@
 ## To Do
 
 - Bits Manipulation
-    - [ ] [Bit Hacks — Part 1 (Basic)](http://www.techiedelight.com/bit-hacks-part-1-basic/)
-    - [ ] [Bit Hacks — Part 2 (Playing with k’th bit)](http://www.techiedelight.com/bit-hacks-part-2-playing-kth-bit/)
-    - [ ] [Bit Hacks — Part 3 (Playing with rightmost set bit of a number)](http://www.techiedelight.com/bit-hacks-part-3-playing-rightmost-set-bit-number/)
-    - [ ] [Bit Hacks — Part 4 (Playing with letters of English alphabet)](http://www.techiedelight.com/bit-hacks-part-4-playing-letters-english-alphabet/)
-    - [ ] [Bit Hacks — Part 5 (Find absolute value of an integer without branching)](http://www.techiedelight.com/bit-hacks-part-5-find-absolute-value-integer-without-branching/)
-    - [ ] [Bit Hacks — Part 6 (Random Problems)](http://www.techiedelight.com/bit-hacks-part-6-random-problems/)
     - [ ] [Brian Kernighan’s Algorithm to count set bits in an integer](http://www.techiedelight.com/brian-kernighans-algorithm-count-set-bits-integer/)
     - [ ] [Compute parity of a number using lookup table](http://www.techiedelight.com/compute-parity-number-using-lookup-table/)
     - [ ] [Count set bits using lookup table](http://www.techiedelight.com/count-set-bits-using-lookup-table/)

src/binary/BitManipulation.java

@@ -1,5 +1,6 @@
 package binary;
 
+/* Also check: https://www.techiedelight.com/bit-hacks-part-2-playing-kth-bit/ */
 public class BitManipulation {
     public static void main(String[] args) {
         int num = 42; // 0b101010

src/binary/absoluteCalculator/AbsolutNumCalculator.java

@@ -0,0 +1,39 @@
+package binary.absoluteCalculator;
+
+import utils.InputReader;
+
+// Given an integer, compute its absolute value (abs) without branching.
+public class AbsolutNumCalculator {
+
+    public static void main(String[] args) {
+        System.out.println("Provide input number: ");
+        int input = InputReader.readInt();
+        System.out.println("No  branching: " + absoluteNoBranch(input));
+        System.out.println("Yes branching: " + absoluteYesBranch(input));
+    }
+
+    private static int absoluteNoBranch(int x) {
+        final int mask = x >> 31; // correct for 32-bit int
+        return ((x + mask) ^ mask);
+        // Explanation:
+        // mask = x >> 31 gives:
+        //      0 if x ≥ 0
+        //      -1 (all 1s) if x < 0 (in two's complement)
+        // Then:
+        //      x + mask subtracts 1 from x if mask == -1
+        //      XOR with mask flips bits if mask == -1
+        // Equivalent to x >= 0 ? x : -x
+    }
+
+    private static int absoluteYesBranch(int n) {
+        return ((n >> 31) & 1) == 1 ? -n : n; // ((n >> 31) & 1) ? (~n + 1) : n;
+        // Explanation:
+        // 1. shift 31 bits: keep sign bit (leftmost)
+        // that's 0 for even nums and 1 for odd ones
+        // 2. masking with 1
+        // (0 for positives, 1s from two's complement for negatives)
+        // 3. AND 1 to extract the least significant bit
+        // If n >= 0, (n >> 31) is 0, so (n >> 31) & 1 = 0.
+        // If n < 0, (n >> 31) is -1 (binary 111...111), so (n >> 31) & 1 = 1.
+    }
+}

src/binary/binCheckOddOrEven/BinaryCheckOddEvenNum.java

@@ -0,0 +1,17 @@
+package binary.binCheckOddOrEven;
+
+import utils.InputReader;
+
+// The expression n & 1 returns value 1 or 0 depending upon whether n is odd or even.
+public class BinaryCheckOddEvenNum {
+    public static void main(String[] args) {
+        System.out.print("Input a number: ");
+        int n = InputReader.readInt();
+        if ((n & 1) != 0) {
+            System.out.println(n + " is odd");
+        }
+        else {
+            System.out.println(n + " is even");
+        }
+    }
+}

src/binary/compareSigns/IntSignsComparator.java

@@ -0,0 +1,20 @@
+package binary.compareSigns;
+
+import utils.InputReader;
+
+// x ^ y is negative if x and y have opposite signs
+public class IntSignsComparator {
+    public static void main(String[] args) {
+        System.out.print("Input a number: ");
+        int x = InputReader.readInt();
+        System.out.print("Input another number: ");
+        int y = InputReader.readInt();
+
+        if ((x ^ y) < 0) {
+            System.out.println("They have opposite signs");
+        }
+        else {
+            System.out.println("They have the same sign");
+        }
+    }
+}

src/binary/hammingWeight/HammingWeight.java

@@ -20,6 +20,15 @@ static int getHammingWeight2(int input) {
         return res;
     }
 
+    // Parity
+    public static int findParity(int n) {
+        return getHammingWeight(n) % 2;
+    }
+
+    public static boolean isParityEven(int n) {
+        return findParity(n) / 2 == 0;
+    }
+
     // String logic
     static int getHammingWeight(int input) {
         var toBinary = Integer.toBinaryString(input);

src/binary/letters/UpperLowercaseSwapper.java

@@ -0,0 +1,43 @@
+package binary.letters;
+
+public class UpperLowercaseSwapper {
+    public static void main(String[] args) {
+        // to lowercase
+        for (char ch = 'A'; ch <= 'Z'; ch++) {
+            System.out.print((char) (ch | ' ')); // OR space
+        }
+        System.out.println();
+        // to uppercase
+        for (char ch = 'a'; ch <= 'z'; ch++) {
+            System.out.print((char) (ch & '_')); // AND underscore
+        }
+
+        /* Why does this work?
+        * Character	ASCII (Decimal)	ASCII (Binary)  Changes
+            'A'	    65	            01000001
+            'a'	    97	            01100001        'A' → 'a' adds 32 → sets bit 5 (counting from 0)
+            ' '	    32	            00100000        OR'ing with space sets bit 5, XOR'ing with space flips bit 5 so swaps the case
+            '_'	    95	            01011111        AND'ing with underscore clears bit 5
+        * */
+
+        System.out.println();
+        System.out.println();
+        // to invert
+        // lowercase uppercase
+        for (char ch = 'a'; ch <= 'z'; ch++) {
+            System.out.print((char) (ch ^ ' ')); // XOR space
+        }
+        System.out.println();
+        // same for uppercase to lowercase
+        for (char ch = 'A'; ch <= 'Z'; ch++) {
+            System.out.print((char) (ch ^ ' ')); // XOR space
+        }
+
+        System.out.println();
+        System.out.println();
+        // find letter's position in alphabet - AND 31
+        for (char ch = 'a'; ch <= 'z'; ch++) {
+            System.out.println(ch + " is in alphabet index " + (ch & 31)); // AND 31 (00011111)
+        }
+    }
+}

src/binary/rightmostBit/OnlySetBitFinder.java

@@ -0,0 +1,26 @@
+package binary.rightmostBit;
+
+import utils.InputReader;
+
+public class OnlySetBitFinder {
+    public static void main(String[] args) {
+        System.out.print("Input a number: ");
+        int x = InputReader.readInt();
+        System.out.print("Position of only set bit: " + positionOfSet(x));
+    }
+
+    public static int positionOfSet(int n) {
+        // unset the rightmost bit and check if the number is non-zero
+        if ((n & (n - 1)) != 0)
+        {
+            System.out.println("Wrong input");
+            return 1;
+        }
+        // If 0, we can find the position of the only set bit by directly using log2(n) + 1.
+        return log(n, 2) + 1;
+    }
+
+    public static int log(int x, int base) {
+        return (int) (Math.log(x) / Math.log(base));
+    }
+}

src/binary/rightmostBit/RightmostBitPositionFinder.java

@@ -0,0 +1,33 @@
+package binary.rightmostBit;
+
+import utils.InputReader;
+
+public class RightmostBitPositionFinder {
+    public static void main(String[] args) {
+        System.out.print("Input a number: ");
+        int x = InputReader.readInt();
+        //unset the rightmost bit of number & XOR the result with number
+        System.out.print("Result: " + positionOfRightmostSetBit(x));
+    }
+
+    static int positionOfRightmostSetBit(int n)
+    {
+        // if the number is odd, return 1
+        if ((n & 1) != 0) {
+            return 1;
+        }
+
+        // unset rightmost bit and xor with the number itself
+        n = n ^ (n & (n - 1));
+
+        // find the position of the only set bit in the result;
+        // we can directly return `log2(n) + 1` from the function
+        int pos = 0;
+        while (n != 0)
+        {
+            n = n >> 1;
+            pos++;
+        }
+        return pos;
+    }
+}

src/binary/rightmostBit/Unsetter.java

@@ -0,0 +1,16 @@
+package binary.rightmostBit;
+
+import utils.InputReader;
+
+// The expression n & (n-1) will turn off the rightmost set bit of a number n
+public class Unsetter {
+    public static void main(String[] args) {
+        System.out.print("Input a number: ");
+        int x = InputReader.readInt();
+        System.out.print("Unsetting the rightmost bit: " + unset(x));
+    }
+
+    public static int unset(int x) {
+        return x & (x-1);
+    }
+}