Number of Mismatching Bits in Java

In this tutorial, we are going to discuss the problem number of mismatching bits in Java. In this problem, two numbers (f1 and f2) are given to us. Our task is to find the number of mismatching bits when we compare the binary representation of both numbers. Assume that every number fits in 8 bits.

Example 1:

Input

int f1 = 9

int f2 = 15

Output

The total number of mismatching bits is 2.

Explanation:

The binary representation of the number 9 in 8 bits is 00001001, and the binary representation of the number 15 in 8 bits is 00001111. If we compare both binary representations from left to right, we find that the first five bits match. The sixth and seventh bits do not match as both the bits are zero for the number 9 and 1 for the number 15. Hence, there are two bits that do not match. Therefore, the output is 2.

Example 2:

Input

int f1 = 32

int f2 = 31

Output

The total number of mismatching bits is 6.

Explanation:

The binary representation of the number 32 in 8 bits is 00100000, and the binary representation of the number 31 in 8 bits is 00011111. If we compare both binary representations from left to right, we find that the first two bits match. After that, there is a mismatch till the eighth bit. The third bit is 1 for the number 32 and 0 for the number 31, and for the rest of the other bits, the value is 0 for the number 32 and 1 for the number 31. Hence, there are 6 bits that do not match. Therefore, the output is 6.

Example 3:

Input

int f1 = 40

int f2 = 40

Output

The total number of mismatching bits is 0.

Explanation:

Since both numbers are the same, their binary representation will also be the same. Hence, there will be zero mismatching bits. Therefore, the output is 0.

Simple Approach

The simple approach is to first convert both the numbers (f1 and f2) into their binary representation. Then store their binary representation in array lists (one for the binary representation of f1 and the other for the binary representation of f2). After that, using a loop, we can compare the bits and find out the answer. Observe the following program.

FileName: MismatchingBits.java

// importing ArrayList as it is 
// required by the program
import java.util.ArrayList;

public class MisMatchingBits
{
// a method that finds the number of mismatching bits
// in the numbers a and b
public int countMisMatchBit(int a, int b)
{
    // handling the base case
    // if both the numbers are the same, then 
    // the number of mismatching bits is zero.
    if(a == b)
    {
        return 0;
    }
    
    // for storing the count of the mismatching bits
    int countMisMatchBits = 0;
    
    // two lists that represent the binary representation in reverse order
    // of the numbers a and b in 8 bits
    ArrayList<Integer> list1 = new ArrayList<Integer>();
    ArrayList<Integer> list2 = new ArrayList<Integer>();
    
    // loop that converts the number a
    // from decimal (base-10) to binary (base-2)
    while(a != 0)
    {
        int n = a % 2;
        a = a / 2;
        list1.add(n);
    }
    
    // loop that converts the number b
    // from decimal (base-10) to binary (base-2)
    while(b != 0)
    {
        int n = b % 2;
        b = b / 2;
        list2.add(n);
    }
    
    // the lists size have to be 8
    
    // if the size of the lists is less than 8 and 
    // increase the size upto 8 by adding 0 to it.
    while(list1.size() != 8)
    {
        list1.add(0);
    }
    
    while(list2.size() != 8)
    {
        list2.add(0);
    }
    
    // loop that makes the comparison of bits of the numbers a and b
    for(int i = 0; i < 8; i++)
    {
        if(list1.get(i) != list2.get(i))
        {
            // mismatch occurred. Hence, increase the count by 1
            countMisMatchBits = countMisMatchBits + 1;
        }
    }
    
    // return the count
    return countMisMatchBits;
}
// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MisMatchingBits
    MisMatchingBits obj = new MisMatchingBits( );
    
    // the two input numbers
    int f1 = 9;
    int f2 = 15;
    
    int ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    System.out.println( );
    
    
    // the two input numbers
    f1 = 32;
    f2 = 31;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    
    System.out.println( );
    
    
    // the two input numbers
    f1 = 40;
    f2 = 40;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
}

}

Output:

The number of mismatching bits for the numbers 9 and 15 is: 2

The number of mismatching bits for the numbers 32 and 31 is: 6

The number of mismatching bits for the numbers 40 and 40 is: 0

Complexity Analysis: There are four while loops and one for-loop used in the program. In all of these five loops, the two while loops and the one for loop will only run for a constant time. The last two while loops and the for loops take O(8) time in the worst-case scenario, which is constant. So, the overall time complexity of the program depends on the first two while-loops. The first while-loop takes O(dig1) time and the second loop takes O(dig2) time. Thus, the overall time complexity of the program is O(dig1 + dig2), where dig1 is the total number of digits present in the number f1, and dig2 is the total number of digits present in the number f2. The space complexity of the program takes O(8) times, which is constant.

We can avoid the use of array lists for storing the bits of the given number. The following program shows the same.

FileName: MisMatchBits1.java

public class MisMatchingBits1
{

// a method that finds the number of mismatching bits
// in the numbers a and b
public int countMisMatchBit(int a, int b)
{
    // handling the base case
    // if both the numbers are the same, then 
    // the number of mismatching bits is zero.
    if(a == b)
    {
        return 0;
    }
    
    // for storing the count of the mismatching bits
    int countMisMatchBits = 0;
    
     // it is given in the problem that every number will 
     // fit in 8 bits. Hence, the loop runs till the eighth bit
     // Here, zero-indexing is used.
    for (int pos = 0; pos < 8; pos++) 
    {
 
        // right shifting both of the numbers by 'pos' and
        // checking whether the bit at the position pos is different
        // or not
        if (((a >> pos) & 1) != ((b >> pos) & 1)) 
        {
            countMisMatchBits = countMisMatchBits + 1;
        }
    }
    
    // return the count
    return countMisMatchBits;
}

// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MisMatchingBits1
    MisMatchingBits1 obj = new MisMatchingBits1( );
    
    // the two input numbers
    int f1 = 9;
    int f2 = 15;
    
    int ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    System.out.println( );
    
    
    // the two input numbers
    f1 = 32;
    f2 = 31;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    
    System.out.println( );
    
    
    // the two input numbers
    f1 = 40;
    f2 = 40;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
}
}

Output:

The number of mismatching bits for the numbers 9 and 15 is: 2

The number of mismatching bits for the numbers 32 and 31 is: 6

The number of mismatching bits for the numbers 40 and 40 is: 0

Complexity Analysis: The program uses only one loop that runs only O(8) times which is constant. Also, the program is not using any extra space. Thus, the time, as well as the space complexity of the program, is O(1).

Using XOR Operator

Another way to find the number of mismatching bits is to use bitwise XOR. Whenever we apply bitwise XOR on two numbers, we get a number whose those bits are set that are not matching in the two numbers. Now, compute the number of set bits in the XOR value. That computed value is our answer. Let's take an example to understand this.

We take two numbers, 10 and 2. Now, 10 ^ 2 = 8. It is because 1010 ^ 0010 = 1000 (value is 8). We see that the first bit (starting from right to left) is set to 1 as the first bit is 1 for number 10 and 0 for number 2 (a mismatch). The rest of the other bits match both numbers. Hence, the rest of the bits are 0 in the XOR value.

In the XOR value, we see that only one bit is set. Hence, the number of mismatched bits for the numbers 10 and 2 is 1. Observe the following program.

FileName: MismatchingBits2.java

public class MisMatchingBits2
{
// a method that finds the number of mismatching bits
// in the numbers a and b
public int countMisMatchBit(int a, int b)
{
    // handling the base case
    // if both the numbers are the same, then 
    // the number of mismatching bits is zero.
    if(a == b)
    {
        return 0;
    }
    
    // for storing the count of the mismatching bits
    int countMisMatchBits = 0;
    
     int xorVal = a ^ b;
     
     // loop that counts the number of set bits in the 
     // value xorVal
     while(xorVal != 0)
     {
         xorVal = xorVal & (xorVal - 1);
         countMisMatchBits = countMisMatchBits + 1;
     }
    
    // return the count
    return countMisMatchBits;
}

// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MisMatchingBits2
    MisMatchingBits2 obj = new MisMatchingBits2( );
    
    // the two input numbers
    int f1 = 9;
    int f2 = 15;
    
    int ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    System.out.println( );
    
    
    // the two input numbers
    f1 = 32;
    f2 = 31;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
    
    System.out.println( );
    
    
    // the two input numbers
    f1 = 40;
    f2 = 40;
    
    ans = obj.countMisMatchBit(f1, f2);
    System.out.println("The number of mismatching bits for the numbers " + f1 + " and " + f2 + " is: " + ans);
}
}

Output:

The number of mismatching bits for the numbers 9 and 15 is: 2

The number of mismatching bits for the numbers 32 and 31 is: 6

The number of mismatching bits for the numbers 40 and 40 is: 0

Complexity Analysis: The time, as well as the space complexity of the program, is constant, i.e., O(1).