Skip to content
Related Articles

Related Articles

Maximum XOR of Two Numbers in an Array
  • Difficulty Level : Hard
  • Last Updated : 11 Dec, 2020

Given an array Arr of non-negative integers of size N. The task is to find the maximum possible xor between two numbers present in the array.

Example:

Input: Arr = {25, 10, 2, 8, 5, 3}
Output: 28
The maximum result is 5 ^ 25 = 28

Input: Arr = {1, 2, 3, 4, 5, 6, 7}
Output: 7
The maximum result is 1 ^ 6 = 7

Naive Approach: A Simple Solution is to generate all pairs of the given array and compute XOR of the pairs. Finally, return maximum XOR value. This solution takes O(N^{2}) time.



Below is the implementation of the above approach:

C++




// C++ implementation
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the
// maximum xor
int max_xor(int arr[], int n)
{
  
    int maxXor = 0;
  
    // Calculating xor of each pair
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            maxXor = max(maxXor,
                         arr[i] ^ arr[j]);
        }
    }
    return maxXor;
}
  
// Driver Code
int main()
{
  
    int arr[] = { 25, 10, 2, 8, 5, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << max_xor(arr, n) << endl;
    return 0;
}
Java



// Java implementation of the approach
class GFG 
{
  
    // Function to return the
    // maximum xor
    static int max_xor(int arr[], int n) 
    {
        int maxXor = 0;
  
        // Calculating xor of each pair
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j < n; j++) 
            {
                maxXor = Math.max(maxXor,
                        arr[i] ^ arr[j]);
            }
        }
        return maxXor;
    }
  
    // Driver Code
    public static void main(String[] args) 
    {
        int arr[] = {25, 10, 2, 8, 5, 3};
        int n = arr.length;
  
        System.out.println(max_xor(arr, n));
    }
} 
  
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation
  
# Function to return the
# maximum xor
def max_xor(arr, n):
  
    maxXor = 0;
  
    # Calculating xor of each pair
    for i in range(n):
        for j in range(i + 1, n):
            maxXor = max(maxXor,\
                         arr[i] ^ arr[j]);
  
    return maxXor;
  
# Driver Code
if __name__ == '__main__':
  
    arr = [ 25, 10, 2, 8, 5, 3 ];
    n = len(arr);
  
    print(max_xor(arr, n));
  
# This code is contributed by 29AjayKumar
C#



// C# implementation of the approach
using System;
  
class GFG 
{
  
// Function to return the
// maximum xor
static int max_xor(int []arr, int n) 
{
    int maxXor = 0;
  
    // Calculating xor of each pair
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++) 
        {
            maxXor = Math.Max(maxXor,
                              arr[i] ^ arr[j]);
        }
    }
    return maxXor;
}
  
// Driver Code
public static void Main() 
{
    int []arr = {25, 10, 2, 8, 5, 3};
    int n = arr.Length;
  
    Console.WriteLine(max_xor(arr, n));
}
}
  
// This code is contributed by AnkitRai01
Output:
28

Time Complexity: O(N^{2}), where N is the size of the array
Efficient Approach: The approach is similar to this article where the task is to find maximum AND value pair.
So the idea is to change the problem statement from finding maximum xor of two numbers in an array to -> find two numbers in an array, such that xor of which equals to a number X. In this case, X will be the maximum number we want to achieve till i-th bit.
To find the largest value of an XOR operation, the value of xor should have every bit to be a set bit i.e 1. In a 32 bit number, the goal is to get the most 1 set starting left to right.
To evaluate each bit, there is a mask needed for that bit. A mask defines which bit should present in the answer and which bit is not. Here we will use mask to keep the prefix for every number ( means by taking the ans with the mask how many bits are remaining from the number ) in the input till the i-th bit then with the list of possible numbers in our set, after inserting the number we will evaluate if we can update the max for that bit position to be 1.
Below is the implementation of the above approach:
C++



// C++ implementation of the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the
// maximum xor
int max_xor(int arr[], int n)
{
    int maxx = 0, mask = 0;
  
    set<int> se;
  
    for (int i = 30; i >= 0; i--) {
  
        // set the i'th bit in mask
        // like 100000, 110000, 111000..
        mask |= (1 << i);
  
        for (int i = 0; i < n; ++i) {
  
            // Just keep the prefix till
            // i'th bit neglecting all
            // the bit's after i'th bit
            se.insert(arr[i] & mask);
        }
  
        int newMaxx = maxx | (1 << i);
  
        for (int prefix : se) {
  
            // find two pair in set
            // such that a^b = newMaxx
            // which is the highest
            // possible bit can be obtained
            if (se.count(newMaxx ^ prefix)) {
                maxx = newMaxx;
                break;
            }
        }
  
        // clear the set for next
        // iteration
        se.clear();
    }
  
    return maxx;
}
  
// Driver Code
int main()
{
  
    int arr[] = { 25, 10, 2, 8, 5, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << max_xor(arr, n) << endl;
  
    return 0;
}
Java



// Java implementation of the above approach
import java.util.*;
class GFG
{
  
// Function to return the
// maximum xor
static int max_xor(int arr[], int n)
{
    int maxx = 0, mask = 0;
  
    HashSet<Integer> se = new HashSet<Integer>();
  
    for (int i = 30; i >= 0; i--) 
    {
  
        // set the i'th bit in mask
        // like 100000, 110000, 111000..
        mask |= (1 << i);
  
        for (int j = 0; j < n; ++j) 
        {
  
            // Just keep the prefix till
            // i'th bit neglecting all
            // the bit's after i'th bit
            se.add(arr[j] & mask);
        }
  
        int newMaxx = maxx | (1 << i);
  
        for (int prefix : se)
        {
  
            // find two pair in set
            // such that a^b = newMaxx
            // which is the highest
            // possible bit can be obtained
            if (se.contains(newMaxx ^ prefix))
            {
                maxx = newMaxx;
                break;
            }
        }
  
        // clear the set for next
        // iteration
        se.clear();
    }
    return maxx;
}
  
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 25, 10, 2, 8, 5, 3 };
    int n = arr.length;
  
    System.out.println(max_xor(arr, n));
}
} 
  
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation of the above approach 
  
# Function to return the 
# maximum xor 
def max_xor( arr , n):
      
    maxx = 0
    mask = 0; 
  
    se = set()
      
    for i in range(30, -1, -1):
          
        # set the i'th bit in mask 
        # like 100000, 110000, 111000..
        mask |= (1 << i)
        newMaxx = maxx | (1 << i)
      
        for i in range(n):
              
            # Just keep the prefix till 
            # i'th bit neglecting all 
            # the bit's after i'th bit 
            se.add(arr[i] & mask)
  
        for prefix in se:
              
            # find two pair in set 
            # such that a^b = newMaxx 
            # which is the highest 
            # possible bit can be obtained
            if (newMaxx ^ prefix) in se:
                maxx = newMaxx
                break
                  
        # clear the set for next 
        # iteration 
        se.clear()
    return maxx
  
# Driver Code 
arr = [ 25, 10, 2, 8, 5, 3 ]
n = len(arr)
print(max_xor(arr, n)) 
  
# This code is contributed by ANKITKUMAR34
C#



// C# implementation of the above approach
using System;
using System.Collections.Generic;
      
class GFG
{
  
// Function to return the
// maximum xor
static int max_xor(int []arr, int n)
{
    int maxx = 0, mask = 0;
  
    HashSet<int> se = new HashSet<int>();
  
    for (int i = 30; i >= 0; i--) 
    {
  
        // set the i'th bit in mask
        // like 100000, 110000, 111000..
        mask |= (1 << i);
  
        for (int j = 0; j < n; ++j) 
        {
  
            // Just keep the prefix till
            // i'th bit neglecting all
            // the bit's after i'th bit
            se.Add(arr[j] & mask);
        }
  
        int newMaxx = maxx | (1 << i);
  
        foreach (int prefix in se)
        {
  
            // find two pair in set
            // such that a^b = newMaxx
            // which is the highest
            // possible bit can be obtained
            if (se.Contains(newMaxx ^ prefix))
            {
                maxx = newMaxx;
                break;
            }
        }
  
        // clear the set for next
        // iteration
        se.Clear();
    }
    return maxx;
}
  
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 25, 10, 2, 8, 5, 3 };
    int n = arr.Length;
  
    Console.WriteLine(max_xor(arr, n));
}
}
  
// This code is contributed by Princi Singh
Output:
28

Time Complexity: O(Nlog(M)), where N is the size of the array and M is the maximum number present in the array.
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
My Personal Notes
arrow_drop_up
first_page
Previous
Find the maximum subarray XOR in a given array
Next
last_page
Maximum AND value of a pair in an array
Recommended Articles
Page :
Maximum XOR of Two Numbers in an Array | Set 2
01, Oct 20
Find XOR of two number without using XOR operator
21, Oct 15
Maximum XOR value of maximum and second maximum element among all possible subarrays
08, Jan 20
Partition array into two subsets with minimum Bitwise XOR between their maximum and minimum
20, Jan 21
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
23, Sep 19
Given a set, find XOR of the XOR's of all subsets.
27, Dec 15
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Choose X such that (A xor X) + (B xor X) is minimized
03, May 19
Maximum of XOR of first and second maximum of all subarrays
30, Mar 20
Maximum sum of Bitwise XOR of all elements of two equal length subsets
21, Aug 20
Maximum XOR using K numbers from 1 to n
06, Jan 18
Maximum possible XOR of every element in an array with another array
04, Oct 17
Find Two Missing Numbers | Set 2 (XOR based solution)
06, Sep 16
Number of ways to change the XOR of two numbers by swapping the bits
13, Sep 18
Find two numbers from their sum and XOR
19, Nov 17
Find two numbers from their sum and XOR | Set 2
25, Nov 20
XOR of two numbers after making length of their binary representations equal
03, Feb 18
Generate an array of minimum sum whose XOR of same-indexed elements with given array are Prime Numbers
06, Jan 21
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Find the maximum subarray XOR in a given array
31, Oct 15
Find Maximum XOR value of a sub-array of size k
09, Dec 16
Number whose sum of XOR with given array range is maximum
11, Apr 18
Maximum value of XOR among all triplets of an array
02, Nov 18
Find maximum xor of k elements in an array
19, Jul 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
yadavakash
@yadavakash
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox