XNOR operator in Java

The opposite of the binary equivalent of XOR is given by XNOR.

Truth table:

If the bits are the same, it returns 1, else it returns 0.

Examples: 

Input: 10 20

Output : 1

A Binary of 20 is 10100

A Binary of 10 is  1010

So the XNOR is  00001

So the output is 1

Input  : 10 10

Output : 15

A Binary of 10 is  1010

A Binary of 10 is  1010

So the XNOR is   1111

So the output is 15

Method 1:- (O(logn))

In this solution, each bit is checked separately. If two bits match, we output 1; otherwise, we output 0.

Let's explain it using the following code.

XNORExpl1.java

// Java program to calculate
// XNOR of two numbers
import java.util.*;
import java.lang.*;
 
public class XNORExpl1 {
 
    public static int xnor(int x, int y)
    {
        // x should be larger
        if (x < y) {
            // swapping x and y;
            int temp = x;
            x = y;
            y = temp;
        }
 
        if (x == 0 && y == 0)
            return 1;
 
        // for last bit of x
        int x_rem = 0;
 
        // for the last bit of y
        int y_rem = 0;
 
        // counter for c bit
        // and set bit in xnorn
        int c = 0;
 
        // to make new xnor number
        int xnorn = 0;
 
        // for set bits in new xnor number
        while (true) {
            // get last bit of x
            x_rem = x & 1;
 
            // get the last bit of y
            y_rem = y & 1;
 
            // Checking if the current two bits are the same
            if (x_rem == y_rem)
                xnorn |= (1 << c);
 
            // counter for c bit
            c++;
            x = x >> 1;
            y = y >> 1;
            if (x < 1)
                break;
        }
        return xnorn;
    }
 
    // Driver code
    public static void main(String args[])
    {
        int x = 10, y = 50;
        System.out.println(xnor(x, y));
    }
}

Output:

Second Method:- O(1) 

1) Determine the maximum of the two provided numbers.

2) Flip the highest two numbers' bits.

3) Return the XOR of the bigger original number and the smaller changed number.

XNORExpl2.java

// Java program to calculate XNOR
// of two numbers
import java.io.*;
 
class XNORExpl2 {
     
    
    static int togglebit(int m)
    {
        if (m == 0)
            return 1;
 
        // copying m as we are
        // going to change it.
        int j = m;
 
        // Below steps set bits after
        // MSB (including MSB)
 
        m |= m >> 1;
 
        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        m |= m >> 2;
        m |= m >> 4;
        m |= m >> 8;
        m |= m >> 16;
 
        return j ^ m;
    }
 
    // Returns XNOR of n1 and n2
    static int xnor(int n1, int n2)
    {
        // if n2 is greater then
        // swap this number in n1 
        if (n1 < n2)
        {
            int t = n1;
            n1 = n2;
            n2 = t;
        }
     
        n1 = togglebit(n1);
     
        return n1 ^ n2;
    }
 
    /* Driver code to test above method */
    public static void main(String args[])
    {
        int x = 10, y = 20;    
        System.out.println(xnor(x, y));
    }
}

Output:

Third Method: Using XOR

Simply said, A XOR B is the opposite of XNOR of A and B. A bit mask must be created in order to only retrieve the real bits from an inverted binary number because directly inverting any binary number also flips the leading zeroes.

Below is an example of this implementation:

XNORExpl3.java

// Java program to find XNOR of two numbers.
class XNORExpl3 {
 
  // Returns XNOR of n1 and n2
  static int XNOR(int x, int y)
  {
    // getting the number of bits from
    // max of x and y to construct the bit mask
    int nOB = (int)(Math.log(Math.max(x, y)) / Math.log(2));
 
    // constructing the bit m
    int m = (1 << nOB) - 1;
 
    // x = inverted xor
    int x1 = ~(x ^ y);
 
    // getting only the required bits
    // using the m
    return x1 & m;
  }
 
  // Main method
  public static void main(String args[])
  {
    int n1 = 7, n2 = 19;
 
    // calling the function
    System.out.print(XNOR(n1, n2));
  }
}

Output:

Time Complexity: O(1)

Auxiliary Space: O(1)