Skip to content
Related Articles

Related Articles

Improve Article

Number of mismatching bits in the binary representation of two integers

  • Difficulty Level : Easy
  • Last Updated : 15 Jun, 2021

Given two integers(less than 2^31) A and B. The task is to find the number of bits that are different in their binary representation.

Examples: 

Input :  A = 12, B = 15
Output : Number of different bits : 2
Explanation: The binary representation of 
12 is 1100 and 15 is 1111.
So, the number of different bits are 2.

Input : A = 3, B = 16
Output : Number of different bits : 3

Approach:  

  • Run a loop from ‘0’ to ’31’ and right shift the bits of A and B by ‘i’ places, then check whether the bit at the ‘0th’ position is different.
  • If the bit is different then increase the count.
  • As the numbers are less than 2^31, we only have to run the loop ’32’ times i.e. from ‘0’ to ’31’.
  • We can get the 1st bit if we bitwise AND the number by 1.
  • At the end of the loop display the count.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// compute number of different bits
void solve(int A, int B)
{
    int count = 0;
 
    // since, the numbers are less than 2^31
    // run the loop from '0' to '31' only
    for (int i = 0; i < 32; i++) {
 
        // right shift both the numbers by 'i' and
        // check if the bit at the 0th position is different
        if (((A >> i) & 1) != ((B >> i) & 1)) {
            count++;
        }
    }
 
    cout << "Number of different bits : " << count << endl;
}
 
// Driver code
int main()
{
    int A = 12, B = 15;
 
    // find number of different bits
    solve(A, B);
 
    return 0;
}

Java




// Java implementation of the approach
 
import java.io.*;
 
class GFG {
 
// compute number of different bits
static void solve(int A, int B)
{
    int count = 0;
 
    // since, the numbers are less than 2^31
    // run the loop from '0' to '31' only
    for (int i = 0; i < 32; i++) {
 
        // right shift both the numbers by 'i' and
        // check if the bit at the 0th position is different
        if (((A >> i) & 1) != ((B >> i) & 1)) {
            count++;
        }
    }
 
    System.out.println("Number of different bits : " + count);
}
 
// Driver code
 
 
    public static void main (String[] args) {
        int A = 12, B = 15;
 
    // find number of different bits
    solve(A, B);
 
    }
}
// this code is contributed by anuj_67..

Python3




# Python3 implementation of the approach
 
# compute number of different bits
def solve( A,  B):
  
    count = 0
 
    # since, the numbers are less than 2^31
    # run the loop from '0' to '31' only
    for i in range(0,32):
 
        # right shift both the numbers by 'i' and
        # check if the bit at the 0th position is different
        if ((( A >>  i) & 1) != (( B >>  i) & 1)):
             count=count+1
          
      
 
    print("Number of different bits :",count)
  
 
# Driver code
A = 12
B = 15
 
# find number of different bits
solve( A,  B)
 
 
# This code is contributed by ihritik

C#




// C# implementation of the approach
 
using System;
class GFG
{
    // compute number of different bits
    static void solve(int A, int B)
    {
        int count = 0;
     
        // since, the numbers are less than 2^31
        // run the loop from '0' to '31' only
        for (int i = 0; i < 32; i++) {
     
            // right shift both the numbers by 'i' and
            // check if the bit at the 0th position is different
            if (((A >> i) & 1) != ((B >> i) & 1)) {
                count++;
            }
        }
     
        Console.WriteLine("Number of different bits : " + count);
    }
     
    // Driver code
    public static void  Main()
    {
        int A = 12, B = 15;
     
        // find number of different bits
        solve(A, B);
     
    }
 
}
 
// This code is contributed by ihritik

PHP




<?php
// PHP implementation of the approach
 
// compute number of different bits
function solve($A, $B)
{
    $count = 0;
 
    // since, the numbers are less than 2^31
    // run the loop from '0' to '31' only
    for ($i = 0; $i < 32; $i++) {
 
        // right shift both the numbers by 'i' and
        // check if the bit at the 0th position is different
        if ((($A >> $i) & 1) != (($B >> $i) & 1)) {
            $count++;
        }
    }
 
    echo "Number of different bits : $count";
}
 
// Driver code
$A = 12;
$B = 15;
 
// find number of different bits
solve($A, $B);
 
// This code is contributed by ihritik
?>

Javascript




<script>
 
// Javascript implementation of the approach
 
// Compute number of different bits
function solve(A, B)
{
    var count = 0;
 
    // Since, the numbers are less than 2^31
    // run the loop from '0' to '31' only
    for(i = 0; i < 32; i++)
    {
         
        // Right shift both the numbers by 'i'
        // and check if the bit at the 0th
        // position is different
        if (((A >> i) & 1) != ((B >> i) & 1))
        {
            count++;
        }
    }
    document.write("Number of different bits : " +
                   count);
}
 
// Driver code   
var A = 12, B = 15;
 
// Find number of different bits
solve(A, B);
 
// This code is contributed by Rajput-Ji
 
</script>
Output



Number of different bits : 2

A different approach using xor(^):  

  • Find XOR (^) of two number, say A and B.
  • And let their result of XOR(^) of A & B be C;
  • Count number of set bits (1’s ) in the  binary representation of C;
  • Return the count;

Example:

  • Let A = 10 (01010) and B  = 20 (10100)
  • After xor of A and B, we get XOR = 11110. ( Check XOR table if necessary).
  • Counting the number of 1’s in XOR gives the count of bit differences in A and B. (using Brian Kernighan’s Algorithm)

Below is the implementation of the above approach:  

Java




/*package whatever //do not write package name here */
// Java implementation of the approach
import java.io.*;
 
class GFG {
 
    // compute number of different bits
    static int solve(int A, int B)
    {
        int XOR = A ^ B;
        // Check for 1's in the binary form using
        // Brian Kerninghan's Algorithm
        int count = 0;
        while (XOR > 0) {
            XOR = XOR & (XOR - 1);
            count++;
        }
        // return the count of different bits
        return count;
    }
 
    public static void main(String[] args)
    {
        int A = 12, B = 15;
    
        // find number of different bits
        int result = solve(A, B);
        System.out.println("Number of different bits : "
                           + result);
    }
}
// the code is by Samarpan Chakraborty

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// compute number of different bits
int solve(int A, int B)
{
    int XOR = A ^ B;
    // Check for 1's in the binary form using
    // Brian Kerninghan's Algorithm
    int count = 0;
    while (XOR) {
        XOR = XOR & (XOR - 1);
        count++;
    }
    return count;
}
 
// Driver code
int main()
{
    int A = 12, B = 15;
    // 12 = 1100 & 15 = 1111
    int result = solve(A, B);
    cout << "Number of different bits : " << result;
 
    return 0;
}
// the code is by Samarpan Chakraborty

Python3




# code
def solve(A, B):
    XOR = A ^ B
    count = 0
    # Check for 1's in the binary form using
    # Brian Kernighan's Algorithm
    while (XOR):
        XOR = XOR & (XOR - 1)
        count += 1
    return count
 
 
result = solve(3, 16)
# 3 = 00011 & 16 = 10000
print("Number of different bits : ", result)
 
# the code is by Samarpan Chakraborty
Output
Number of different bits : 2

Brian Kernighan’s Algorithm 




My Personal Notes arrow_drop_up
Recommended Articles
Page :