# Maximum possible XOR of every element in an array with another array

Two arrays A and B consisting of N elements are given. The task is to compute the maximum possible XOR of every element in array A with array B.

Examples:

```Input :
A : 7 3 9 12
B : 1 3 5 2
Output : 6 6 12 15
Explanation : 1 xor 7 = 6, 5 xor 3 = 6, 5
xor 9 = 12, 3 xor 12 = 15.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A naive approach to solve this problem would be to check every element of array A with every other element of array B and print the maximum xor.

Time Complexity : O(n^2)

An efficient solution is to use Trie Data Structure.
We maintain a Trie for the binary representation of all elements in array B.
Now, for every element of A, we find the maximum xor in trie.
Let’s say our number A[i] is {b1, b2…bn}, where b1, b2…bn are binary bits. We start from b1.
Now for the xor to be maximum, we’ll try to make most significant bit 1 after performing
the xor. So, if b1 is 0, we’ll need a 1 and vice versa. In the trie, we go to the required
bit side. If favourable option is not there, we’ll go other side. Doing this all over,
we’ll get the maximum XOR possible.

Below is the implementation

## C++

 `// CPP code to find the maximum possible X-OR of ` `// every array element with another array ` `#include ` `using` `namespace` `std; ` ` `  `// Structure of Trie DS ` `struct` `trie ` `{ ` `    ``int` `value; ` `    ``trie *child; ` `}; ` ` `  `// Function to initialise a Trie Node ` `trie * get() ` `{ ` `    ``trie * root = ``new` `trie; ` `    ``root -> value = 0; ` `    ``root -> child = NULL; ` `    ``root -> child = NULL; ` `    ``return` `root; ` `} ` ` `  `// Computing max xor ` `int` `max_xor(trie * root, ``int` `key) ` `{ ` `    ``trie * temp = root; ` `     `  `    ``// Checking for all bits in integer range ` `    ``for` `(``int` `i = 31; i >= 0; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``bool` `current_bit = ( key & ( 1 << i) ); ` `  `  `        ``// Traversing Trie for different bit, if found ` `        ``if` `(temp -> child[1 - current_bit] != NULL) ` `            ``temp = temp -> child[1 - current_bit]; ` `  `  `        ``// Traversing Trie for same bit ` `        ``else` `            ``temp = temp -> child[current_bit]; ` `    ``} ` `  `  `    ``// Returning xor value of maximum bit difference  ` `    ``// value. Thus, we get maximum xor value ` `    ``return` `(key ^ temp -> value); ` `} ` ` `  `// Inserting B[] in Trie ` `void` `insert(trie * root, ``int` `key) ` `{ ` `    ``trie * temp = root; ` `     `  `    ``// Storing 31 bits as integer representation ` `    ``for` `(``int` `i = 31; i >= 0; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``bool` `current_bit = key & (1 << i); ` `         `  `        ``// New node required ` `        ``if` `(temp -> child[current_bit] == NULL)         ` `            ``temp -> child[current_bit] = get(); ` ` `  `        ``// Traversing in Trie ` `        ``temp = temp -> child[current_bit]; ` `    ``} ` `    ``// Assigning value to the leaf Node ` `    ``temp -> value = key; ` `} ` ` `  `int` `main() ` `{ ` `    ``int` `A[] = {7, 3, 9, 12}; ` `    ``int` `B[] = {1, 3, 5, 2}; ` `     `  `    ``int` `N = ``sizeof``(A)/``sizeof``(A); ` `     `  `    ``// Forming Trie for B[] ` `    ``trie * root = get(); ` `    ``for` `(``int` `i = 0; i < N; i++) ` `        ``insert(root, B[i]); ` `     `  `    ``for` `(``int` `i = 0; i < N; i++) ` `        ``cout << max_xor(root, A[i]) << endl; ` `     `  `    ``return` `0; ` `} `

## Java

 `// Java code to find the maximum possible X-OR of ` `// every array element with another array ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Structure of Trie DS ` `static` `class` `trie ` `{ ` `    ``int` `value; ` `    ``trie []child = ``new` `trie[``2``]; ` `}; ` ` `  `// Function to initialise a Trie Node ` `static` `trie get() ` `{ ` `    ``trie root = ``new` `trie(); ` `    ``root.value = ``0``; ` `    ``root.child[``0``] = ``null``; ` `    ``root.child[``1``] = ``null``; ` `    ``return` `root; ` `} ` ` `  `// Computing max xor ` `static` `int` `max_xor(trie root, ``int` `key) ` `{ ` `    ``trie temp = root; ` `     `  `    ``// Checking for all bits in integer range ` `    ``for` `(``int` `i = ``31``; i >= ``0``; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``int` `current_bit = (key & (``1` `<< i)); ` `        ``if``(current_bit > ``0``) ` `            ``current_bit = ``1``; ` `             `  `        ``// Traversing Trie for different bit, if found ` `        ``if` `(temp.child[``1` `- current_bit] != ``null``) ` `            ``temp = temp.child[``1` `- current_bit]; ` ` `  `        ``// Traversing Trie for same bit ` `        ``else` `            ``temp = temp.child[current_bit]; ` `    ``} ` ` `  `    ``// Returning xor value of maximum bit difference  ` `    ``// value. Thus, we get maximum xor value ` `    ``return` `(key ^ temp.value); ` `} ` ` `  `// Inserting B[] in Trie ` `static` `void` `insert(trie root, ``int` `key) ` `{ ` `    ``trie temp = root; ` `     `  `    ``// Storing 31 bits as integer representation ` `    ``for` `(``int` `i = ``31``; i >= ``0``; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``int` `current_bit = key & (``1` `<< i); ` `        ``if``(current_bit > ``0``) ` `            ``current_bit = ``1``; ` `             `  `        ``//System.out.println(current_bit); ` `        ``// New node required ` `        ``if` `(temp.child[current_bit] == ``null``)      ` `            ``temp.child[current_bit] = get(); ` ` `  `        ``// Traversing in Trie ` `        ``temp = temp.child[current_bit]; ` `    ``} ` `    ``// Assigning value to the leaf Node ` `    ``temp.value = key; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `A[] = {``7``, ``3``, ``9``, ``12``}; ` `    ``int` `B[] = {``1``, ``3``, ``5``, ``2``}; ` `     `  `    ``int` `N = A.length; ` `     `  `    ``// Forming Trie for B[] ` `    ``trie root = get(); ` `    ``for` `(``int` `i = ``0``; i < N; i++) ` `        ``insert(root, B[i]); ` `     `  `    ``for` `(``int` `i = ``0``; i < N; i++) ` `        ``System.out.println(max_xor(root, A[i])); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `// C# code to find the maximum possible X-OR of ` `// every array element with another array ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Structure of Trie DS ` `class` `trie ` `{ ` `    ``public` `int` `value; ` `    ``public` `trie []child = ``new` `trie; ` `}; ` ` `  `// Function to initialise a Trie Node ` `static` `trie ``get``() ` `{ ` `    ``trie root = ``new` `trie(); ` `    ``root.value = 0; ` `    ``root.child = ``null``; ` `    ``root.child = ``null``; ` `    ``return` `root; ` `} ` ` `  `// Computing max xor ` `static` `int` `max_xor(trie root, ``int` `key) ` `{ ` `    ``trie temp = root; ` `     `  `    ``// Checking for all bits in integer range ` `    ``for` `(``int` `i = 31; i >= 0; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``int` `current_bit = (key & (1 << i)); ` `        ``if``(current_bit > 0) ` `            ``current_bit = 1; ` `             `  `        ``// Traversing Trie for different bit, if found ` `        ``if` `(temp.child[1 - current_bit] != ``null``) ` `            ``temp = temp.child[1 - current_bit]; ` ` `  `        ``// Traversing Trie for same bit ` `        ``else` `            ``temp = temp.child[current_bit]; ` `    ``} ` ` `  `    ``// Returning xor value of maximum bit difference  ` `    ``// value. Thus, we get maximum xor value ` `    ``return` `(key ^ temp.value); ` `} ` ` `  `// Inserting B[] in Trie ` `static` `void` `insert(trie root, ``int` `key) ` `{ ` `    ``trie temp = root; ` `     `  `    ``// Storing 31 bits as integer representation ` `    ``for` `(``int` `i = 31; i >= 0; i--) ` `    ``{ ` `        ``// Current bit in the number ` `        ``int` `current_bit = key & (1 << i); ` `        ``if``(current_bit > 0) ` `            ``current_bit = 1; ` `             `  `        ``// System.out.println(current_bit); ` `        ``// New node required ` `        ``if` `(temp.child[current_bit] == ``null``)      ` `            ``temp.child[current_bit] = ``get``(); ` ` `  `        ``// Traversing in Trie ` `        ``temp = temp.child[current_bit]; ` `    ``} ` `     `  `    ``// Assigning value to the leaf Node ` `    ``temp.value = key; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]A = {7, 3, 9, 12}; ` `    ``int` `[]B = {1, 3, 5, 2}; ` `     `  `    ``int` `N = A.Length; ` `     `  `    ``// Forming Trie for B[] ` `    ``trie root = ``get``(); ` `    ``for` `(``int` `i = 0; i < N; i++) ` `        ``insert(root, B[i]); ` `     `  `    ``for` `(``int` `i = 0; i < N; i++) ` `        ``Console.WriteLine(max_xor(root, A[i])); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```6
6
12
15
```

Trie formation : O(N x MAX_BITS) where MAX_BITS is maximum number of bits in binary representation of numbers.
Calculating max bit difference : O(N x MAX_BITS)
Time Complexity : O(N x MAX_BITS)

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Improved By : 29AjayKumar

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.