Maximum XOR Value in Java

Two arrays containing non-negative numbers are given to us as input. Our task is to find the maximum value of p ^ q, where p is any element from the first array and q is any element from the second array. Along with the maximum value, display the pair whose XOR gives the maximum value. If there is more than one pair that gives the maximum XOR value, then print that pair whose p value comes first in the first input array.

Example 1:

Input

int inArr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
int inArr2[] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11}

Output

30, pair: 10, 30

Explanation:

The maximum XOR value for the given input arrays is 30 in all of the possible pairs, and it comes with the elements 10 (from the first array) and 20 (from the second array).

Example 2:

Input

int inArr1[] = {25, 10, 2, 8, 5, 3}
int inArr2[] = {25, 10, 2, 8, 5, 3}

Output

28, pair: 25, 5

Explanation:

The maximum XOR value for the given input arrays is 28, and it comes with the elements 25 (from the first array) and 5 (from the second array). Note that if we take element five from the first array and element 25 from the second array, we will get the same result. However, element 5 is from the first array and comes after element 25. Hence, it is avoided.

Simple Approach: Using Nested For-Loops

Using the nested for-loops, we can find the maximum value. The outer loop iterates through the first array. For each iteration of the outer loop, traverse through each element of the second array with the help of the inner for-loop. For each iteration of the inner loop, find the XOR value of the elements pointed by the loop variables of the outer and inner for-loops, respectively. Also, compare the current XOR value with the maximum XOR value found till now. Update the maximum XOR value if the current XOR value is more than the maximum XOR value found till now. The elements involved in the maximum XOR value are the pair.

FileName: MaxXorVal.java

public class MaxXorVal 
{
// for storing the pair
// that gives the maximum XOR value
static int a1;
static int a2;

// a method that finds the maximum XOR value and the pair
// that is responsible for that maximum XOR value
public int findMaximumXorVal(int inArr1[], int inArr2[])
{
// size of the input arrays 
int s1 = inArr1.length;
int s2 = inArr2.length;

int maxVal = -1; 

// outer loop for traversing through the array inArr1
for(int p = 0; p < s1; p++)
{
// inner loop for traversing through the array inArr2
for(int q = 0; q < s2; q++)
{
int tmpVal = inArr1[p] ^ inArr2[q];

if(tmpVal > maxVal)
{
    // storing the maximum value and
    // the elements that are responsible 
    // for the maximum value
    maxVal = tmpVal;
    a1 = inArr1[p];
    a2 = inArr2[q];
}
}
}

return maxVal;
}


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

  // input arrays 
  int inArr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  int inArr2[] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11};
  
  int ans = obj.findMaximumXorVal(inArr1, inArr2);
  System.out.println("The maximum XOR value is: " + ans);
  System.out.println("The pair that gives the max XOR value is: (" + a1 + ", " + a2 + ")");
  System.out.println("\n");
  
  // input arrays 
  int inArr3[] = {25, 10, 2, 8, 5, 3};
  int inArr4[] = {25, 10, 2, 8, 5, 3};
  
  ans = obj.findMaximumXorVal(inArr3, inArr4);
  System.out.println("The maximum XOR value is: " + ans);
  System.out.println("The pair that gives the max XOR value is: (" + a1 + ", " + a2 + ")");
  System.out.println("\n");


}
}

Output:

The maximum XOR value is: 30
The pair that gives the max XOR value is: (10, 20)


The maximum XOR value is: 28
The pair that gives the max XOR value is: (25, 5)

Complexity Analysis: The program uses the nested for-loops, in which the outer loop runs O(m) time, and for each iteration of the outer loop the inner loop runs O(n) times. Therefore, the time complexity of the program is O(m x n), where m is the total number of elements present in the first array and n is the total number of elements present in the second array. The space complexity of the program is O(1), as the program is not using any extra space.

Now, it is time to do some optimization.

Approach: Using TRIE

We can achieve the maximum XOR value by finding those elements whose leftmost bits differ in value. In other words, if the value of the jth bit is 1 for an element 'P' taken from the first array, then the jth bit should be 0 for the element 'Q' taken from the second array and vice-versa. To find those elements, we will start from the most significant bit (the leftmost bit) and will proceed toward the right direction till we find a bit whose value is different in the binary representation of the elements 'P' and 'Q'.

In order to efficiently check the value in the first array, we can use a TRIE data structure for every element present in the second array. For every element of the second array, we do the binary conversion and insert every bit into the TRIE. Note that the root will be the most significant bit.

Now, we will traverse through every element of the first array and change it into the binary representation and will traverse through all of the bits beginning from the most significant bit. If the current bit is '0', then we move to '1' child in trie if available and vice versa. Finally, we will find a corresponding element from the first array such that its XOR value with the current element of the second array is maximum. In the end, we will return the maximum of all such XOR values found.

FileName: MaxXorVal1.java

public class MaxXorVal1 
{
// for storing the pair
// that gives the maximum XOR value
static int a1;
static int a2;

// it is because we are dealing with the 32 bits numbers
private static final int INT_SIZE = 32;

// a class for implementing the TRIE data structure
class TrieNode 
{

public int val;

// values for keeping in the leaf node
public TrieNode children[];

public TrieNode() 
{
children = new TrieNode[2];
val = 0;
children[0] = null;
children[1] = null;
}
}

// Utility method for creating a new node
private TrieNode getNode() 
{
TrieNode newNde = new TrieNode();
newNde.val = 0;
newNde.children[0] = newNde.children[1] = null;
return newNde;
}


// Utility method for inserting a new key in TRIE.
private void insertKey(TrieNode  rt, int ky) 
{
TrieNode tmp = rt;

// Starting from the most significant bit, 
// insert all of the bits of ky into TRIE one by one.
for (int j = INT_SIZE - 1; j >= 0; j--) 
{
	// Find the current bit in the given prefix
	int currBit =  (ky & (1 << j)) >= 1 ? 1 : 0;

	// Adding a new Node into TRIE
	if (tmp.children[currBit] == null) 
	{
		tmp.children[currBit] = getNode();
	}

	tmp = tmp.children[currBit];
}

// Storing value of the ky in the leafNode
tmp.val = ky ;
}

// Utility method for finding the maximum XOR value of an integer inserted in TRIE and 
// given key. 
private int[] findMaximum(TrieNode rt, int key) 
{
TrieNode tmp = rt;

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

	// Traversing TRIE, looking for the prefix that has the opposite bit.
	if (tmp.children[1 - currBit] != null) 
	{
		tmp = tmp.children[1 - currBit];
	}
	// If there is no opposite bit, then look for the same bit.
	else if (tmp.children[currBit] != null) 
	{
		tmp = tmp.children[currBit];
	}
}

int tempArr[] = new int[2];

tempArr[0] = tmp.val;
tempArr[1] = key ^ tmp.val;

// Returning XOR with the value at the leaf node.
return tempArr;
}

public int findMaximumXorVal(int list1[], int list2[], int s1, int s2) 
{
// Initializing the result.
int maximumVal = Integer.MIN_VALUE;

// Create a TRIE and insert all of the elements of the first array into TRIE.
TrieNode  rt = getNode();

for (int j = 0; j < s1; j++) 
{
	insertKey(rt, list1[j]);
}

// For every element in the second array, compute the maximum XOR value from TRIE.
for (int j = 0 ; j < s2; j++) 
{
	// Finding the maximum XOR value of the current element with 
	// the elements inserted in TRIE.
	int tempArr[] = findMaximum(rt, list2[j]);
	
	if(tempArr[1] > maximumVal)
	{
	    // if the control reaches here
	    // then it means we have found a value that is more than the current 
        // maximum value. Hence, we have to update the pair as well as the
        // maximum value. 
	    a1 = list2[j]; // for pair
	    a2 = tempArr[0]; // for pair
	    maximumVal = tempArr[1]; // for maximum XOR value
	    
	}
}

return maximumVal;
}


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

// input arrays 
int inArr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int inArr2[] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11};

int ans = obj.findMaximumXorVal(inArr2, inArr1, inArr2.length, inArr1.length);
System.out.println("The maximum XOR value is: " + ans);
System.out.println("The pair that gives the max XOR value is: (" + a1 + ", " + a2 + ")");
System.out.println("\n");

// input arrays 
int inArr3[] = {25, 10, 2, 8, 5, 3};
int inArr4[] = {25, 10, 2, 8, 5, 3};

ans = obj.findMaximumXorVal(inArr4, inArr3, inArr4.length, inArr3.length);
System.out.println("The maximum XOR value is: " + ans);
System.out.println("The pair that gives the max XOR value is: (" + a1 + ", " + a2 + ")");
System.out.println("\n");


}
}

Output:

The maximum XOR value is: 30
The pair that gives the max XOR value is: (10, 20)


The maximum XOR value is: 28
The pair that gives the max XOR value is: (25, 5)

Complexity Analysis: The program uses two loops, one for the first array and the other for the second array. Also, the loops are not nested. For every number in the given arrays, we also run a loop from 32 to 0. Hence, the time complexity of the program is O(32 x (m + n)). Also, the program uses a TRIE data structure, which is used to store 32-bit numbers of the second array. Therefore, the space complexity of the program is O(32 x n), where m is the size of the first array, and n is the size of the second array.

Next TopicHow to Add Hours to The Date Object in Java

← prev next →