Exercise 07: Code Challenges 1 to 8

Author: deltanode

exercise_07_bitmasking/01_playing_with_bits.cpp

@@ -0,0 +1,89 @@
+/*
+    Problem Name - Playing With Bits
+
+    Raman likes to play with bits. One day Raman decides to assign a task to his student Sanya. 
+    You have to help Sanya to complete this task. 
+    Task is as follows - Raman gives Q queries each query containing two integers a and b. 
+    Your task is to count the no of set-bits in for all numbers between a and b (both inclusive)
+
+    Input Format:  Read Q - No of Queries, Followed by Q lines containing 2 integers a and b.
+
+    Constraints:   Q,a,b are integers.
+
+    Output Format: Q lines, each containing an output for your query.
+
+    Sample Input:  2
+                   1 1
+                   10 15
+
+    Sample Output:  1
+                    17
+
+*/
+
+
+#include <iostream>
+using namespace std;
+
+// function to count set bits
+int countBits(int n)
+{
+    int count=0;
+    while(n)
+    {
+        n = n & (n-1);
+        count++;
+    }
+    return count;
+}
+
+// function to count set bits between range I to J
+int countSetBitIToJ(int start, int end)
+{
+    int count = 0;
+    for(int i=start; i <= end; i++)
+    {
+        count += countBits(i);
+    }
+    return count;
+}
+
+
+// function to drive code
+int main()
+{
+    int testcase;
+    cout << "Enter total testcases: ";
+    cin >> testcase;
+
+    while(testcase--)
+    {
+        int i, j;
+        cout << "Enter Range [i & j]: ";
+        cin >> i >> j;
+
+        cout << "Total Set Bits: ";
+        cout << countSetBitIToJ(i,j) << endl;
+    }
+
+    return 0;
+}
+
+/* 
+
+OUTPUT:
+    Enter total testcases: 2
+
+    Enter Range [i & j]: 1 1
+    Total Set Bits: 1
+
+    Enter Range [i & j]: 10 15
+    Total Set Bits: 17
+
+
+APPROACH:
+
+    This is a quite simple problem to tackle. Just loop through all the numbers between a and b and 
+    calculate the no of set bits using either brian kernighan algo or the inbuilt function for 
+    counting set bits
+*/

exercise_07_bitmasking/02_unique_number_I.cpp

@@ -0,0 +1,65 @@
+/*
+    Problem Name - Unique Number - I
+
+    We are given an array containg n numbers. All the numbers are present twice except for one number 
+    which is only present once. Find the unique number without taking any extra spaces and in linear time.
+    (Hint - Use Bitwise)
+
+    Input Format: First line contains the number n. 
+                  Second line contains n space separated number.
+
+    Constraints:  n < 10^5
+
+    Output Format: Output a single line containing the unique number
+
+    Sample Input:  7
+                   1 1 2 2 3 3 4 
+
+    Sample Output: 4
+
+    Explanation:   4 is present only once
+*/
+
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    int total_num, num, ans=0;
+
+    cout << "Enter total numbers: ";
+    cin >> total_num;
+
+    cout << "Enter numbers: ";
+    for(int i=0; i<total_num; i++)
+    {
+        cin >> num;
+        // Using bitwise XOR Operator to solve, It helped to not use any storage
+        ans = ans^num;
+    }
+    
+    cout<<"Unique No. is : "<< ans << endl;
+
+    return 0;
+}
+
+/* 
+
+OUTPUT:
+
+    Enter total numbers: 7
+    Enter numbers: 1 1 2 2 3 3 4
+    Unique No. is : 4
+
+
+APPROACH:
+
+    Use property of xor function to solve this problem. 
+
+    Concept :
+        If we take XOR of zero and some bit, it will return that bit: a^0 = a
+        If we take XOR of two same bits, it will return 0: a^a=0
+        a^b^a = (a^a)^b = 0^b = b
+        So we can XOR all bits together to find the unique number.
+*/

exercise_07_bitmasking/03_xor_profit_problem.cpp

@@ -0,0 +1,116 @@
+/*
+    Problem Name - XOR Profit Problem
+
+    We are given two coins of value x and y. We have to find the maximum of value of a XOR b 
+    where x <= a <= b <= y.
+
+    Input Format: We are given two integers x and y
+
+    Constraints:  l <= r <= 1000
+
+    Output Format: Print the maximum value of a XOR b
+
+    Sample Input:  5
+                   6
+
+    Sample Output: 3
+
+    Explanation: If a and b are taken to be 5. Then a xor b = 0
+                 If a and b are taken to be 6. Then a xor b = 0
+                 If a is 5 and b is 6. Then a xor b is 3.
+*/
+
+
+#include <iostream>
+using namespace std;
+
+/*  
+    function to find maximum xor value between range x & y 
+    Approach 1: A brute force solution is to generate all pairs. find their XOR values and finally return
+    the maximum XOR value 
+*/
+int max_xor_value(int x, int y)
+{
+    int result = 0;
+    for(int i=x; i<=y; i++)
+    {
+        for(int j=x+1; j<=y; j++)
+        {
+            result = max(i^j, result); 
+        }
+    }   
+    return result;
+}
+
+
+// Approach 2: A efficient solution is to consider pattern of binary values from L to R.
+int max_xor_value_optimised(int x, int y)
+{
+    int num = x^y;
+
+    int msb = 0;
+    while(num)
+    {
+        msb++;
+        num = num>>1;
+    }
+
+    int result = 1;
+    while(msb)
+    {
+        result = result<<1;
+        msb--;
+    }
+    return result-1;
+}
+
+// function to drive code
+int main()
+{
+    int x, y;
+
+    cout << "Enter Coin values: ";
+    cin >> x >> y;
+
+    
+    cout<<"Max XOR Value: ";
+    // cout << max_xor_value(x,y);               // Approach 1 (Brute Force)
+    cout << max_xor_value_optimised(x,y);        // Approach 2 (considering pattern of binary values)
+
+    cout << endl;
+    return 0;
+}
+
+/* 
+
+OUTPUT:
+
+Case 1:
+    Enter Coin values: 5 6
+    Max XOR Value: 3
+
+Case 2:
+    Enter Coin values: 5 10
+    Max XOR Value: 15
+
+
+APPROACH:
+
+    - Brute Force Approach
+      A simple solution is to generate all pairs, find their XOR values and finally return the 
+      maximum XOR value.
+    
+    - Optimised Approach
+      An efficient solution is to consider pattern of binary values from L to R. 
+      
+      We can see that first bit from L to R either changes from 0 to 1 or it stays 1 
+      i.e. if we take the XOR of any two numbers for maximum value their first bit will be fixed which
+      will be same as first bit of XOR of L and R itself. 
+      
+      After observing the technique to get first bit, we can see that if we XOR L and R, 
+      the most significant bit of this XOR will tell us the maximum value we can achieve 
+      i.e. let XOR of L and R is 1xxx where x can be 0 or 1 then maximum XOR value we can get is 1111
+      because from L to R we have all possible combination of xxx and it is always possible to choose
+      these bits in such a way from two numbers such that their XOR becomes all 1.
+
+*/

exercise_07_bitmasking/04_count_set_bits.cpp

@@ -0,0 +1,99 @@
+/*
+    Problem Name - Count Set Bits
+
+    count number of 1s in binary representation of an integer
+
+    Input Format:  Input N = Number of Test Cases, followed by N numbers
+
+    Output Format: Number of Set Bits in each number each in a new line
+
+    Sample Input:   3
+                    5
+                    4
+                    15
+
+    Sample Output:  2
+                    1
+                    4
+
+    Explanation:  Convert Binary to Decimal first and then count number of 1's present in all digits.
+*/
+
+
+#include <iostream>
+using namespace std;
+
+// function to count set bits
+int coutSetBits(int n)
+{
+    int count = 0;
+    while(n)
+    {
+        n = n & (n-1);        // removing the last set bits
+        count++;              // count is the no. of times loop run
+    }
+    return count;
+}
+
+
+// function to drive code
+int main()
+{
+    int testcase, num;
+    
+    cout << "Enter total testcases: ";
+    cin >> testcase;
+
+    while(testcase--)
+    {
+        cout << "Enter Number: ";
+        cin >> num;
+
+        cout << "Total Set Bits: ";
+        cout << coutSetBits(num) << endl;
+    }
+
+    return 0;
+}
+
+/* 
+
+OUTPUT:
+
+    Enter total testcases: 3
+
+    Enter Number: 5
+    Total Set Bits: 2
+
+    Enter Number: 4
+    Total Set Bits: 1
+
+    Enter Number: 15
+    Total Set Bits: 4
+
+
+APPROACH:
+
+    With bitwise operations, we can use an algorithm whose running time depends on the 
+    number of ones present in the binary form of the given number.
+
+        int count_set_nits (int n)
+        {
+            while( n > 0)
+            {
+            n = n&(n-1);
+            count++;
+            }
+            return count;
+        }
+    
+    How does this algorithm work? 
+    
+    We can observe that there is a relationship between a number N and N-1. 
+    N-1 will have all the bits same as x except for the rightmost 1 in x and all the bits to 
+    the right of rightmost 1 in x. 
+    So as in x-1, the rightmost 1 and bits right to it is flipped, then by performing x&(x-1), 
+    and storing it in x, will reduce x to a number containing number of ones(in its binary form) 
+    less than the previous state of x, thus increasing the value of count in each iteration. 
+    This is also known as Brian Kernighan Algorithm.
+*/