Bit manipulation

Author: Deepak Malik

src/com/deepak/algorithms/BitManipulation/BitsConversion.java

@@ -0,0 +1,15 @@
+/**
+ * Algorithms-in-Java
+ * BitsConversion.java
+ */
+package com.deepak.algorithms.BitManipulation;
+
+/**
+ * Class to hold methods to convert byte to binary and int to binary 
+ * @author Deepak
+ */
+public class BitsConversion {
+	
+	
+
+}

src/com/deepak/algorithms/BitManipulation/CommonOperations.java

@@ -0,0 +1,146 @@
+/**
+ * Algorithms-in-Java
+ * CommonOperations.java
+ */
+package com.deepak.algorithms.BitManipulation;
+
+/**
+ * Collection of some common operations on bits
+ * 
+ * @author Deepak
+ */
+public class CommonOperations {
+	
+	/**
+	 * Returns the bit present at the position, either true(1) or false(0)
+	 * 
+	 * @param num - Number 
+	 * @param i - Position, from which bit has to be fetched
+	 * @return {@link boolean} - True, if 1 is there on position, else false
+	 */
+	public static boolean getBit(int num, int i) {
+		return ((num & (1 << i)) != 0);
+	}
+
+	/**
+	 * Returns the number after updating the bit to either 0 or 1
+	 * 
+	 * @param num - Number
+	 * @param i - Position, for which bit has to be updated
+	 * @param v - Value of new bit
+	 * @return {@link int} - New updated number
+	 */
+	public static int updateBit(int num, int i, int v) {
+		int mask = ~(1 << i);
+		return (num & mask) | (v << i);
+	}
+	
+	/**
+	 * Returns the number after setting the bit to 1 at given position
+	 * If bit at that position is already 1, then it returns the same number
+	 * 
+	 * @param num - Number
+	 * @param i - Position for which bit has to be set
+	 * @return {@link int} - New updated number
+	 */
+	public static int setBit(int num, int i) {
+		return num | (1 << i);
+	}
+
+	/**
+	 * Returns the number after clearing the bit at given position i.e setting the bit to 0
+	 * If bit at that position is already 0, then it returns the same number
+	 * 
+	 * @param num - Number
+	 * @param i - Position for which bit has to be cleared
+	 * @return {@link int} - New updated number
+	 */
+	public static int clearBit(int num, int i) {
+		int mask = ~(1 << i);
+		return num & mask;
+	}
+
+	public static int clearBitsMSBthroughI(int num, int i) {
+		int mask = (1 << i) - 1;
+		return num & mask;
+	}
+
+	public static int clearBitsIthrough0(int num, int i) {
+		int mask = ~((1 << (i + 1)) - 1);
+		return num & mask;
+	}
+
+	/**
+	 * Prints the full binary number in String format
+	 * 
+	 * @param num - Number
+	 */
+	private static void toFullBinaryString(int num) {
+		/* Create a display mask on the last bit */
+		int displayMask = 1 << 7;
+		/* Loop through all the bits and print accordingly */
+		for (int bit = 1; bit <= 8; bit++) {
+			System.out.print((num & displayMask) == 0 ? '0' : '1');
+			num <<= 1;
+			/* Create space after 4 bits */
+			if ((bit % 4) == 0) {
+				System.out.print(' ');
+			}
+		}
+	}
+
+	/**
+	 * Dealing with 8 bit representation to make it simple
+	 * @param args
+	 */
+	// TODO : Clean this up
+	public static void main(String[] args) {
+		int number = 21;
+		System.out.println("Testing with number: " + number);
+		toFullBinaryString(number);
+		
+		/* Get bit */
+		System.out.println();
+		System.out.println("\nGet Bit (Original)");
+		for (int i = 7; i >= 0; i--) {
+			int res = getBit(number, i) ? 1 : 0;
+			System.out.print(res);
+			if ((i % 4) == 0) {
+				System.out.print(' ');
+			}
+		}
+		
+		/* Set bit */
+		System.out.println("\n\nSetting Bit at position 3");
+		int res1 = setBit(number, 3);
+		toFullBinaryString(res1);
+
+		/* Update Bit */
+		System.out.println("\n\nUpdating Bit at position 2 with 0");
+		int result = updateBit(number, 2, 0);
+		toFullBinaryString(result);
+		
+		/* Clear Bit */
+		System.out.println("\n\nClearing Bit at position 0");	
+		int clearedBitResult = clearBit(number, 0);
+		toFullBinaryString(clearedBitResult);
+		
+		/**/
+		int number1 = 255;
+		System.out.println("\n\nBinary representation of " + number1);
+		toFullBinaryString(number1);
+		System.out.println("\nClear bits MSB through 4");	
+		int num3 = clearBitsMSBthroughI(number1, 4);
+		toFullBinaryString(num3);
+		
+			
+		int number2 = 255;
+		System.out.println("\n\nBinary representation of " + number2);
+		toFullBinaryString(number2);
+		System.out.println("\nClear bits 3 through 0");
+		int num4 = clearBitsIthrough0(number2, 3);
+		toFullBinaryString(num4);
+		
+	}
+
+}

src/com/deepak/algorithms/BitManipulation/Introduction.md

@@ -0,0 +1,44 @@
+## Introduction to Bit Manipulation
+
+The direct manipulation of bits or often called as **Bit twiddling** is often necessary while building softwares.
+
+**Bitwise Operators**
+- Individual and blocks of bits in _integer_ and _byte_ variables can be modified with bitwise operators, which are, 
+
+<img width="361" alt="screen shot 2016-10-08 at 5 28 24 pm" src="https://cloud.githubusercontent.com/assets/3439029/19216713/aee07c52-8d7c-11e6-8e7a-7af27705be7a.png">
+
+**Bitwise AND**
+This is represented as single ampersand, **&** and marks a resulting bit as _1_ when both the bits are _1_. Think about it as _THIS_ **AND** _THIS_ has to be 1 i.e both has to be true. Here is a sample, 
+```
+01001000 & 
+10111000 = 
+--------
+00001000
+```
+
+**Bitwise OR**
+This is represented as single pipe symbol, **|** and marks a resulting bit as _1_ when either of the bits is _1_. Think about it as _THIS_ **OR** _THIS_ has to be 1 i.e one of them has to be true. Here is a sample, 
+```
+01001000 | 
+10111000 = 
+--------
+11111000
+```
+
+**Bitwise Exclusive OR (XOR)**
+This is represented as, **^** and marks a resulting bit as _1_ when either of the bits is _1_ but NOT if both are. XOR of 2 same bits is 0. Here is a sample, 
+```
+01110010 ^
+10101010 
+--------
+11011000
+```
+Suppose, we have some bit, either 1 or 0, that we'll call Z. When we take Z XOR 0, then we always get Z back: if Z is 1, we get 1, and if Z is 0, we get 0. On the other hand, when we take Z XOR 1, we flip Z. If Z is 0, we get 1; if Z is 1, we get 0:
+
+**myBits ^ 0** : No change
+**myBits ^ 1** : Flip 
+It's a kind of selective twiddle(~)..
+So, if we do XOR against 111...1111, all the bits of myBits flipped. It's equivalent of doing twiddle(~)..
+
+Another interesting trick using the XOR: It does in place swap of integers.
+If we apply the XOR operation twice -- say we have a bit, A, and another bit B, and we set C equal to A XOR B, and then take C XOR B: we get A XOR B XOR B, which essentially either flips every bit of A twice, or never flips the bit, so we just get back A. (We can also think of B XOR B as cancelling out.)