Minimum XOR Value Pair in Java

Given an array containing non-negative numbers, our task is to find out a value that represents the minimum XOR value of two numbers from the given array. Consider the following examples.

Example 1:

Input: int a[] = {10, 8, 5, 3, 1};

Output: 2

Explanation: In the given array, we can make 10 pairs

(10, 8) = 10 ^ 8 = 2		(10, 5) = 10 ^ 5 = 15
(10, 3) = 10 ^ 3 = 9		(10, 1) = 10 ^ 1 = 11
(8, 5) = 8 ^ 5 = 13		(8, 3) = 8 ^ 3 = 11
(8, 1) = 8 ^ 1 = 9		(5, 3) = 5 ^ 3 = 6
(5, 1) = 5 ^ 1 = 4		(3, 1) = 3 ^ 1 = 2

We see that the minimum XOR value of all the above pairs is 2.
Note that there is no need to make another pair (8, 10). It is because the XOR operation is commutative, and pair (10, 8) has already been considered.

Example 2:

Input: int a[] = {3, 5, 7, 2};

Output: 1

Explanation: In the given array, we can make 6 pairs.

(3, 5) = 3 ^ 5 = 6		(3, 7) = 3 ^ 7 = 4
(3, 2) = 3 ^ 2 = 1		(5, 7) = 5 ^ 7 = 2
(5, 2) = 5 ^ 2 = 7		(7, 2) = 7 ^ 2 = 5

We see that the minimum XOR value of all the above pairs is 1.

Naive Approach

The approach is straightforward, find out every pair of the elements present in the given array. Compute the XOR for every pair and find out the minimum XOR value. Let's see it happening in the following program.

FileName: MinXORVal.java

public class MinXORVal
{

// a method that finds the minimum between a & b
public int min(int a, int b)
{
    return (a > b) ? b : a;
}

// a method that finds the minimum XOR value
public int findMinXorVal(int arr[], int size)
{
    int ans = Integer.MAX_VALUE;
    for(int i = 0; i < size; i++)
    {
        for(int j = i + 1; j < size; j++)
        {
            ans = min(ans, (arr[i] ^ arr[j]));
        }
    }
    
    return ans;
}


// main method
public static void main(String argvs[])
{
// creating an object of the class MinXORVal
MinXORVal obj = new MinXORVal();

// input array
int a[] = {10, 8, 5, 3, 1};

int size = a.length;

int minVal = obj.findMinXorVal(a, size);

System.out.println("For the array: "); 

for(int idx = 0; idx < size; idx++)
{
System.out.print(a[idx] + " "); 
}
System.out.println();
System.out.println("The minimum XOR value is: " + minVal);
System.out.println();

// input array
int a1[] = {3, 5, 7, 2};

size = a1.length;

minVal = obj.findMinXorVal(a1, size);

System.out.println("For the array: "); 

for(int idx = 0; idx < size; idx++)
{
System.out.print(a1[idx] + " "); 
}
System.out.println();
System.out.println("The minimum XOR value is: " + minVal);
}
}

Output:

For the array: 
10 8 5 3 1 
The minimum XOR value is: 2

For the array: 
3 5 7 2 
The minimum XOR value is: 1

Time Complexity: In the above program, we have used two-degree nesting of the for-loops in the method findMinXorVal(). Since for each iteration of the outer loop, the inner loop has a time complexity of O(n). Therefore, the overall time complexity of the program is O(n2), where n is the total number of elements present in the input array.

Using Sorting

In this approach, we will sort the input array and will find the minimum XOR value using a single loop. The sorting approach works because the XOR of two numbers that are nearer to each other has a lower XOR value as compared to the numbers that are distant. For example: 1 ^ 8 = 9 & 4 ^ 5 = 1. It is because the gap between 4 & 5 is 1 and 1 & 8 is 7. Therefore, when we do sorting, the numbers that are nearer to one another come one after the other, and then all we have to do is to run a single loop and find XOR of consecutive elements. Observe the following program.

FileName: MinXORVal1.java

// import statement
import java.util.Arrays;

public class MinXORVal1
{

// a method that finds the minimum between a & b
public int min(int a, int b)
{
    return (a > b) ? b : a;
}

// a method that finds the minimum XOR value
public int findMinXorVal(int arr[], int size)
{
    int ans = Integer.MAX_VALUE;    
    Arrays.parallelSort(arr); // sorting the array
    for(int i = 0; i < size - 1; i++)
    {
        // computing XOR of consecutive elements after
        // sorting the array and finding the minimum of those XOR values
        ans = min(ans, (arr[i] ^ arr[i + 1]));    
    }    
    return ans;
}
// main method
public static void main(String argvs[])
{
// creating an object of the class MinXORVal1
MinXORVal1 obj = new MinXORVal1();
// input array
int a[] = {10, 8, 5, 3, 1};
int size = a.length;
System.out.println("For the array: "); 
for(int idx = 0; idx < size; idx++)
{
System.out.print(a[idx] + " "); 
}
System.out.println();
int minVal = obj.findMinXorVal(a, size);
System.out.println("The minimum XOR value is: " + minVal);
System.out.println();
// input array
int a1[] = {3, 5, 7, 2};
size = a1.length;
System.out.println("For the array: "); 
for(int idx = 0; idx < size; idx++)
{
System.out.print(a1[idx] + " "); 
}
System.out.println();
minVal = obj.findMinXorVal(a1, size);
System.out.println("The minimum XOR value is: " + minVal);
}
}

Output:

For the array: 
10 8 5 3 1 
The minimum XOR value is: 2
For the array: 
3 5 7 2 
The minimum XOR value is: 1

Time Complexity: In the above program, we have used sorting and a single for-loop. Sorting takes O(nlog(n)) time, and the loop takes O(n) time. Therefore, the overall time complexity of the above program is O(n + nlog(n)), where n is the total number of elements present in the input array. Note that this approach is better than the previous one.

Using TRIE

Using TRIE, we will get the most optimized solution as we can solve the problem in even lesser time than O(nlog(n)). Let's see the algorithm of it.

Step 1: Make an empty TRIE such that each node of the TRIE has two children, one for the 0 and the other for the 1 bit.

Step 2: Do the Initialization of minXorVal as INT_MAX, and insert a[0] into TRIE.

Step 3: Traverse all the elements of the array one by one, beginning from the second element, and do the following:

First, look for the minimum set bit value difference in TRIE. Then do the XOR of the current element with the minimum set bit that differs from that value.
Update the minXorVal value, if required
Insert the current element of the array

Step 4: return the minXorVal

FileName: MinXORVal2.java

public class MinXORVal2 
{
// a method that finds the minimum between a & b
public static int min(int a, int b)
{
return (a > b) ? b : a;
}

// maximum no of bits present in a number
public static final int MAX_SIZE = 32;

// a class for Trie Trie
static class Trie 
{
int val; // is used in the leaf node


Trie[] children = new Trie[2];

public Trie()
{
val = 0;
children[0] = null;
children[1] = null;
}
}
static Trie rt;

// a method that inserts the number num in the TRIE
public static void insert(int num)
{
Trie tmp = rt;

// starting from the most significant bit, we insert all the bit
// of the num one-by-one in the TRIE
for (int j = MAX_SIZE - 1; j >= 0; j--) 
{
// Finding the current bit in the given prefix
int currentBit = (num & (1 << j)) >= 1 ? 1 : 0;

// Adding a new node in the TRIE
if (tmp != null && tmp.children[currentBit] == null)
{
tmp.children[currentBit] = new Trie();
}

tmp = tmp.children[currentBit];
}

// storing the value at the leaf node
tmp.val = num;
}

// Returns minimum XOR value of an integer inserted
// in Trie and given key.
static int minXORUtil(int num)
{
Trie tmp = rt;

for (int j = MAX_SIZE - 1; j >= 0; j--) 
{
// Finding the current bit in the given prefix
int currentBit = (num & (1 << j)) >= 1 ? 1 : 0;

// Traversing Trie, to look after the prefix that has
// the same bit
if (tmp.children[currentBit] != null)
{
tmp = tmp.children[currentBit];
}

// if no same bit is found then look for 
// the opposite bit
else if (tmp.children[1 - currentBit] != null)
{
tmp = tmp.children[1 - currentBit];
}
}

// return XOR value of minimum bit difference value
// so that we get minimum xor value
return num ^ tmp.val;
}

// a method that returns the minimum XOR value of a pair in the array a[0 ... size - 1]
public int findMinXOR(int a[], int size)
{
int minXorVal = Integer.MAX_VALUE; // Initialize the result

// creating a Trie node and inserting the first element in it
rt = new Trie();
insert(a[0]);

// Traversing all the elements of the array and finding the minimum XOR
// for each & every element
for (int j = 1; j < size; j++) 
{
// Finding the minimum XOR value of the current element 
// with the previous elements that has been inserted in TRIE
minXorVal = Math.min(minXorVal, minXORUtil(a[j]));

// insert current array value into Trie
insert(a[j]);
}
return minXorVal;
}

// Main Method
public static void main(String argvs[])
{
// creating an object of the class MinXORVal2
MinXORVal2 obj = new MinXORVal2();

// input array
int a[] = {10, 8, 5, 3, 1};

int size = a.length;

System.out.println("For the array: "); 

for(int idx = 0; idx < size; idx++)
{
System.out.print(a[idx] + " "); 
}
System.out.println();
int minVal = obj.findMinXOR(a, size);

System.out.println("The minimum XOR value is: " + minVal);

System.out.println();

// input array
int a1[] = {3, 5, 7, 2};

size = a1.length;

System.out.println("For the array: "); 

for(int idx = 0; idx < size; idx++)
{
System.out.print(a1[idx] + " "); 
}
System.out.println();
minVal = obj.findMinXOR(a1, size);
System.out.println("The minimum XOR value is: " + minVal);

}
}

Output:

For the array: 
10 8 5 3 1 
The minimum XOR value is: 2

For the array: 
3 5 7 2 
The minimum XOR value is: 1

Time Complexity: The time complexity of the above program is O(n), where n is the total number of elements present in the array.

Next TopicIccanobif Numbers in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Minimum XOR Value Pair in Java

Naive Approach

Using Sorting

Using TRIE

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA