Add more bits manipulation

Author: theEmbeddedGeorge

Data_Struct_Implementation/BitsManipulation/SwapBitsInNumber.md

@@ -0,0 +1,86 @@
+## Swap bits in a given number
+
+Given a number x and two positions (from the right side) in the binary representation of x, write a function that swaps n bits at given two positions and returns the result. It is also given that the two sets of bits do not overlap.
+
+    1) Move all bits of the first set to the rightmost side
+    set1 =  (x >> p1) & ((1U << n) - 1)
+    Here the expression (1U << n) - 1 gives a number that 
+    contains last n bits set and other bits as 0. We do & 
+    with this expression so that bits other than the last 
+    n bits become 0.
+
+    2) Move all bits of second set to rightmost side
+    set2 =  (x >> p2) & ((1U << n) - 1)
+
+    3) XOR the two sets of bits
+    xor = (set1 ^ set2) 
+
+    4) Put the xor bits back to their original positions. 
+    xor = (xor << p1) | (xor << p2)
+
+    5) Finally, XOR the xor with original number so 
+    that the two sets are swapped.
+    result = x ^ xor
+
+```c
+#include <stdio.h>
+// C program to swap bits in an integer
+#include<stdio.h>
+ 
+// This function swaps bit at positions p1 and p2 in an integer n
+int swapBit(unsigned int n, unsigned int p1, unsigned int p2)
+{
+    /* Move p1'th to rightmost side */
+    unsigned int bit1 =  (n >> p1) & 1;
+ 
+    /* Move p2'th to rightmost side */
+    unsigned int bit2 =  (n >> p2) & 1;
+ 
+    /* XOR the two bits */
+    unsigned int x = (bit1 ^ bit2);
+ 
+    /* Put the xor bit back to their original positions */
+    x = (x << p1) | (x << p2);
+ 
+    /* XOR 'x' with the original number so that the
+       two sets are swapped */
+    unsigned int result = n ^ x;
+}
+ 
+/* Driver program to test above function*/
+int main()
+{
+    int res =  swapBits(28, 0, 3);
+    printf("Result = %d ", res);
+    return 0;
+}
+
+int swapBits(unsigned int x, unsigned int p1, unsigned int p2, unsigned int n)
+{
+    /* Move all bits of first set to rightmost side */
+    unsigned int set1 = (x >> p1) & ((1U << n) - 1);
+ 
+    /* Move all bits of second set to rightmost side */
+    unsigned int set2 = (x >> p2) & ((1U << n) - 1);
+ 
+    /* XOR the two sets */
+    unsigned int xor = (set1 ^ set2);
+ 
+    /* Put the xor bits back to their original positions */
+    xor = (xor << p1) | (xor << p2);
+ 
+    /* XOR the 'xor' with the original number so that the 
+       two sets are swapped */
+    unsigned int result = x ^ xor;
+ 
+    return result;
+}
+ 
+/* Driver program to test above function*/
+int main()
+{
+    int res = swapBits(28, 0, 3, 2);
+    printf("\nResult = %d ", res);
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/binaryPanlidrom.md

@@ -0,0 +1,45 @@
+## Check if binary representation of a number is palindrome
+
+Given an integer ‘x’, write a C function that returns true if binary representation of x is palindrome else return false.
+For example a numbers with binary representation as 10..01 is palindrome and number with binary representation as 10..00 is not palindrome.
+
+The idea is similar to checking a string is palindrome or not. We start from leftmost and rightmost bits and compare bits one by one. If we find a mismatch, then return false.
+
+```c
+#include<stdio.h>
+#include<stdint.h>
+
+typedef uint32_t (*generalTestFunct)(uint32_t target);
+
+uint32_t isBinaryPanlidrome(uint32_t target) {
+    int i = 0;
+    for (i; i < 32; i++) {
+        if (((target>>i) & 0x1) != ((target>>(32-1-i)) & 0x1))
+            return 0;
+    }
+
+    return 1;
+}
+
+int main(void) {
+    generalTestFunct test_func1 = isBinaryPanlidrome;
+    
+    // test 1:
+    uint32_t test_num1 = 0;
+    printf("%d\n", test_func1(test_num1));
+    
+    // test 2:
+    test_num1 = 0xf000000f;
+    printf("%d\n", test_func1(test_num1));
+    
+    // test 3:
+    test_num1 = 0x11001100;
+    printf("%d\n", test_func1(test_num1));
+
+    // test 4:
+    test_num1 = 0xa0000005;
+    printf("%d\n", test_func1(test_num1));
+    
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/flipBitsNumber.md

@@ -0,0 +1,48 @@
+## Count number of bits to be flipped to convert A to B
+
+Given two numbers ‘a’ and b’. Write a program to count number of bits needed to be flipped to convert ‘a’ to ‘b’.
+
+```c
+#include<stdio.h>
+#include<stdint.h>
+
+typedef uint32_t (*generalTestFunct)(uint32_t num1, uint32_t num2);
+
+uint32_t flipBitsNumber(uint32_t num1, uint32_t num2) {
+    num1 ^= num2;
+
+    int res = 0;
+    while(num1) {
+        res ++;
+        num1 &= num1-1;
+    }
+
+    return res;
+}
+
+int main(void) {
+    generalTestFunct test_func1 = flipBitsNumber;
+    
+    // test 1:
+    uint32_t test_num1 = 1;
+    uint32_t test_num2 = 1;
+    printf("%d\n", test_func1(test_num1, test_num2));
+    
+    // test 2:
+    test_num1 = 0xffff0000;
+    test_num2 = 0x1;
+    printf("%d\n", test_func1(test_num1, test_num2));
+    
+    // test 3:
+    test_num1 = 0x11001100;
+    test_num2 = 1;
+    printf("%d\n", test_func1(test_num1, test_num2));
+
+    // test 4:
+    test_num1 = 0x00110011;
+    test_num2 = 1;
+    printf("%d\n", test_func1(test_num1, test_num2));
+    
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/positionOfSetBit.md

@@ -0,0 +1,40 @@
+```c
+#include<stdio.h>
+#include<stdint.h>
+
+// Task: Find Bit position of the only set bit
+// Tips: right shift until the number becomes zero. Be careful that the index starts with -1 instead of 0!
+typedef int (*generalTestFunct)(uint32_t target);
+
+int setBit_pos(uint32_t target) {
+    int pos = -1;
+    while (target) {
+        pos ++;
+        target >>= 1;
+    }
+    
+    return pos;
+}
+
+int main(void) {
+    generalTestFunct test_func = setBit_pos;
+    
+    // test 1:
+    uint32_t test1 = 0x1;
+    printf("%x\n", test_func(test1));
+    
+    // test 2:
+    uint32_t test2 = 0x8;
+    printf("%x\n", test_func(test2));
+    
+    // test 3:
+    uint32_t test3 = 0x80;
+    printf("%x\n", test_func(test3));
+    
+    // test 4:
+    uint32_t test4 = 0x10000;
+    printf("%x\n", test_func(test4));
+    
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/reverseBits.md

@@ -0,0 +1,40 @@
+## Reverse Bits
+
+```c
+#include<stdio.h>
+#include<stdint.h>
+
+typedef uint32_t (*generalTestFunct)(uint32_t target);
+
+uint32_t reverseBits(uint32_t target) {
+    target = ((target & 0xffff0000) >> 16) | ((target & 0x0000ffff) << 16);
+    target = ((target & 0xff00ff00) >> 8) | ((target & 0x00ff00ff) << 8);
+    target = ((target & 0xf0f0f0f0) >> 4) | ((target & 0x0f0f0f0f) << 4);
+    target = ((target & 0xcccccccc) >> 2) | ((target & 0x33333333) << 2);
+    target = ((target & 0xaaaaaaaa) >> 1) | ((target & 0x55555555) << 1);
+
+    return target;
+}
+
+int main(void) {
+    generalTestFunct test_func1 = reverseBits;
+    
+    // test 1:
+    uint32_t test_num1 = 1;
+    printf("%x\n", test_func1(test_num1));
+    
+    // test 2:
+    test_num1 = 0xffff0000;
+    printf("%x\n", test_func1(test_num1));
+    
+    // test 3:
+    test_num1 = 0x11001100;
+    printf("%x\n", test_func1(test_num1));
+
+    // test 4:
+    test_num1 = 0x00110011;
+    printf("%x\n", test_func1(test_num1));
+    
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/rotateLeftRight.md

@@ -0,0 +1,53 @@
+## Rotate bits of a number
+
+Bit Rotation: A rotation (or circular shift) is an operation similar to shift except that the bits that fall off at one end are put back to the other end.
+In left rotation, the bits that fall off at left end are put back at right end.
+
+In right rotation, the bits that fall off at right end are put back at left end.
+
+```c
+#include<stdio.h>
+#include<stdint.h>
+
+// Task:  Turn off the rightmost set bit
+typedef uint32_t (*generalTestFunct)(uint32_t target, int pos);
+
+uint32_t leftRotate(uint32_t target, int pos) {
+    return (target >> (32 - (pos%32))) | (target << (pos%32));
+}
+
+uint32_t rightRotate(uint32_t target, int pos) {
+    return (target >> (pos%32)) | (target << (32-(pos%32)));
+}
+
+int main(void) {
+    generalTestFunct test_func1 = leftRotate;
+    generalTestFunct test_func2 = rightRotate;
+    
+    // test 1:
+    uint32_t test_num1 = 1;
+    int shift = 33;
+    printf("%x\n", test_func1(test_num1, shift));
+    printf("%x\n", test_func2(test_num1, shift));
+    
+    // test 2:
+    test_num1 = 0x1000;
+    shift = 1;
+    printf("%x\n", test_func1(test_num1, shift));
+    printf("%x\n", test_func2(test_num1, shift));
+    
+    // test 3:
+    test_num1 = 0x1100;
+    shift = 1;
+    printf("%x\n", test_func1(test_num1, shift));
+    printf("%x\n", test_func2(test_num1, shift));
+    
+    // test 4:
+    test_num1 = 0x100010;
+    shift = 1;
+    printf("%x\n", test_func1(test_num1, shift));
+    printf("%x\n", test_func2(test_num1, shift));
+    
+    return 0;
+}
+```

Data_Struct_Implementation/BitsManipulation/signessCheck.md

@@ -0,0 +1,41 @@
+## Detect if two integers have opposite signs
+
+Given two signed integers, write a function that returns true if the signs of given integers are different, otherwise false. For example, the function should return true -1 and +100, and should return false for -100 and -200. The function should not use any of the arithmetic operators.
+
+```c++
+#include<stdio.h>
+#include<stdint.h>
+
+// Task:  Find position of the only set bit
+typedef int (*generalTestFunct)(int target, int target2);
+
+int checkSignDiff(int num1, int num2) {
+    return (num1 ^ num2) < 0;
+}
+
+int main(void) {
+    generalTestFunct test_func = checkSignDiff;
+    
+    // test 1:
+    int test_num1 = 1;
+    int test_num2 = -1;
+    printf("%x\n", test_func(test_num1, test_num2));
+    
+    // test 2:
+    test_num1 = 1;
+    test_num2 = 1;
+    printf("%x\n", test_func(test_num1, test_num2));
+    
+    // test 3:
+    test_num1 = 2121312;
+    test_num2 = 2121;
+    printf("%x\n", test_func(test_num1, test_num2));
+    
+    // test 4:
+    test_num1 = -213;
+    test_num2 = 21443212;
+    printf("%x\n", test_func(test_num1, test_num2));
+    
+    return 0;
+}
+```