# Find the maximum subset XOR of a given set

Given a set of positive integers. find the maximum XOR subset value in the given set. Expected time complexity O(n).

Examples:

`Input: set[] = {2, 4, 5}Output: 7The subset {2, 5} has maximum XOR valueInput: set[] = {9, 8, 5}Output: 13The subset {8, 5} has maximum XOR valueInput: set[] = {8, 1, 2, 12, 7, 6}Output: 15The subset {1, 2, 12} has maximum XOR valueInput: set[] = {4, 6}Output: 6The subset {6} has maximum XOR value`

Note: This problem is different from the maximum subarray XOR. Here we need to find a subset instead of a subarray.

Recommended Practice

A Simple Solution is to generate all possible subsets of given set, find XOR of every subset and return the subset with maximum XOR.

Below is an Efficient Algorithm that works in O(n) time. The idea is based on below facts:

1. Number of bits to represent all elements is fixed which is 32 bits for integer in most of the compilers.
2. If maximum element has Most Significant Bit MSB at position i, then result is at least 2i
`1. Initialize index of chosen elements as 0. Let this index be    'index'2. Traverse through all bits starting from most significant bit.    Let i be the current bit.......(a) Find the maximum element with i'th bit set.  If there          is no element with i'th bit set, continue to smaller           bit.  ......(b) Let the element with i'th bit set be maxEle and index          of this element be maxInd. Place maxEle at 'index' and          (by swapping set[index] and set[maxInd]) ......(c) Do XOR of maxEle with all numbers having i'th  bit as set.......(d) Increment index 3. Return XOR of all elements in set[]. Note that set[] is modified   in step 2.c.`

Below is the implementation of this algorithm.

## C++

 `// C++ program to find  ` `// maximum XOR subset ` `#include ` `using` `namespace` `std; ` ` `  `// Number of bits to  ` `// represent int ` `#define INT_BITS 32 ` ` `  `// Function to return ` `// maximum XOR subset ` `// in set[] ` `int` `maxSubsetXOR(``int` `set[], ``int` `n) ` `{ ` `    ``// Initialize index of ` `    ``// chosen elements ` `    ``int` `index = 0; ` ` `  `    ``// Traverse through all ` `    ``// bits of integer  ` `    ``// starting from the most ` `    ``// significant bit (MSB) ` `    ``for` `(``int` `i = INT_BITS-1; i >= 0; i--) ` `    ``{ ` `        ``// Initialize index of ` `        ``// maximum element and ` `        ``// the maximum element ` `        ``int` `maxInd = index; ` `        ``int` `maxEle = INT_MIN; ` `        ``for` `(``int` `j = index; j < n; j++) ` `        ``{ ` `            ``// If i'th bit of set[j] ` `            ``// is set and set[j] is  ` `            ``// greater than max so far. ` `            ``if` `( (set[j] & (1 << i)) != 0  ` `                     ``&& set[j] > maxEle ) ` `                ``maxEle = set[j], maxInd = j; ` `        ``} ` ` `  `        ``// If there was no  ` `        ``// element with i'th ` `        ``// bit set, move to ` `        ``// smaller i ` `        ``if` `(maxEle == INT_MIN) ` `        ``continue``; ` ` `  `        ``// Put maximum element ` `        ``// with i'th bit set  ` `        ``// at index 'index' ` `        ``swap(set[index], set[maxInd]); ` ` `  `        ``// Update maxInd and  ` `        ``// increment index ` `        ``maxInd = index; ` ` `  `        ``// Do XOR of set[maxIndex] ` `        ``// with all numbers having ` `        ``// i'th bit as set. ` `        ``for` `(``int` `j=0; j

## Java

 `// Java program to find ` `// maximum XOR subset ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `// Number of bits to ` `// represent int ` `static` `final` `int` `INT_BITS = ``32``; ` ` `  `// Function to return ` `// maximum XOR subset ` `// in set[] ` `static` `int` `maxSubarrayXOR(``int` `set[], ``int` `n) ` `{ ` `    ``// Initialize index of ` `    ``// chosen elements ` `    ``int` `index = ``0``; ` ` `  `    ``// Traverse through all ` `    ``// bits of integer ` `    ``// starting from the most ` `    ``// significant bit (MSB) ` `    ``for` `(``int` `i = INT_BITS - ``1``; i >= ``0``; i--)  ` `    ``{ ` `    ``// Initialize index of ` `    ``// maximum element and ` `    ``// the maximum element ` `    ``int` `maxInd = index; ` `    ``int` `maxEle = Integer.MIN_VALUE; ` `    ``for` `(``int` `j = index; j < n; j++) { ` `         `  `        ``// If i'th bit of set[j] ` `        ``// is set and set[j] is ` `        ``// greater than max so far. ` `        ``if` `((set[j] & (``1` `<< i)) != ``0` `&& set[j] > maxEle) ` `        ``{ ` `        ``maxEle = set[j]; ` `        ``maxInd = j; ` `        ``} ` `    ``} ` ` `  `    ``// If there was no ` `    ``// element with i'th ` `    ``// bit set, move to ` `    ``// smaller i ` `    ``if` `(maxEle == -``2147483648``) ` `        ``continue``; ` ` `  `    ``// Put maximum element ` `    ``// with i'th bit set ` `    ``// at index 'index' ` `    ``int` `temp = set[index]; ` `    ``set[index] = set[maxInd]; ` `    ``set[maxInd] = temp; ` ` `  `    ``// Update maxInd and ` `    ``// increment index ` `    ``maxInd = index; ` ` `  `    ``// Do XOR of set[maxIndex] ` `    ``// with all numbers having ` `    ``// i'th bit as set. ` `    ``for` `(``int` `j = ``0``; j < n; j++) { ` `         `  `        ``// XOR set[maxInd] those ` `        ``// numbers which have the ` `        ``// i'th bit set ` `        ``if` `(j != maxInd && (set[j] & (``1` `<< i)) != ``0``) ` `        ``set[j] = set[j] ^ set[maxInd]; ` `    ``} ` ` `  `    ``// Increment index of ` `    ``// chosen elements ` `    ``index++; ` `    ``} ` ` `  `    ``// Final result is ` `    ``// XOR of all elements ` `    ``int` `res = ``0``; ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``res ^= set[i]; ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String arg[]) { ` `    ``int` `set[] = {``9``, ``8``, ``5``}; ` `    ``int` `n = set.length; ` ` `  `    ``System.out.print(``"Max subset XOR is "``); ` `    ``System.out.print(maxSubarrayXOR(set, n)); ` `} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python program to find  ` `# maximum XOR subset ` ` `  `# Number of bits to  ` `# represent int ` `INT_BITS``=``32` `  `  `# Function to return ` `# maximum XOR subset ` `# in set[] ` `def` `maxSubarrayXOR(``set``,n): ` ` `  `    ``# Initialize index of ` `    ``# chosen elements ` `    ``index ``=` `0` `  `  `    ``# Traverse through all ` `    ``# bits of integer  ` `    ``# starting from the most ` `    ``# significant bit (MSB) ` `    ``for` `i ``in` `range``(INT_BITS``-``1``,``-``1``,``-``1``): ` `     `  `        ``# Initialize index of ` `        ``# maximum element and ` `        ``# the maximum element ` `        ``maxInd ``=` `index ` `        ``maxEle ``=` `-``2147483648` `        ``for` `j ``in` `range``(index,n): ` `         `  `            ``# If i'th bit of set[j] ` `            ``# is set and set[j] is  ` `            ``# greater than max so far. ` `            ``if` `( (``set``[j] & (``1` `<< i)) !``=` `0`  `                     ``and` `set``[j] > maxEle ): ` `                 `  `                ``maxEle ``=` `set``[j] ` `                ``maxInd ``=` `j ` `         `  `        ``# If there was no  ` `        ``# element with i'th ` `        ``# bit set, move to ` `        ``# smaller i ` `        ``if` `(maxEle ``=``=``-``2147483648``): ` `            ``continue` `  `  `        ``# Put maximum element ` `        ``# with i'th bit set  ` `        ``# at index 'index' ` `        ``temp``=``set``[index] ` `        ``set``[index]``=``set``[maxInd] ` `        ``set``[maxInd]``=``temp ` `  `  `        ``# Update maxInd and  ` `        ``# increment index ` `        ``maxInd ``=` `index ` `  `  `        ``# Do XOR of set[maxIndex] ` `        ``# with all numbers having ` `        ``# i'th bit as set. ` `        ``for` `j ``in` `range``(n): ` `         `  `            ``# XOR set[maxInd] those ` `            ``# numbers which have the ` `            ``# i'th bit set ` `            ``if` `(j !``=` `maxInd ``and` `               ``(``set``[j] & (``1` `<< i)) !``=` `0``): ` `                ``set``[j] ``=` `set``[j] ^ ``set``[maxInd] ` `         `  `  `  `        ``# Increment index of ` `        ``# chosen elements ` `        ``index``=``index ``+` `1` `     `  `  `  `    ``# Final result is  ` `    ``# XOR of all elements ` `    ``res ``=` `0` `    ``for` `i ``in` `range``(n): ` `        ``res ``=``res ^ ``set``[i] ` `    ``return` `res ` ` `  `# Driver code ` ` `  `set``=` `[``9``, ``8``, ``5``] ` `n ``=``len``(``set``) ` ` `  `print``(``"Max subset XOR is "``,end``=``"") ` `print``(maxSubarrayXOR(``set``, n)) ` ` `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# program to find ` `// maximum XOR subset ` `using` `System; ` ` `  `class` `GFG ` `{  ` `     `  `    ``// Number of bits to ` `    ``// represent int ` `    ``static` `int` `INT_BITS = 32; ` `     `  `    ``// Function to return ` `    ``// maximum XOR subset ` `    ``// in set[] ` `    ``static` `int` `maxSubarrayXOR(``int` `[]``set``,  ` `                              ``int` `n) ` `    ``{ ` `         `  `        ``// Initialize index of ` `        ``// chosen elements ` `        ``int` `index = 0; ` `     `  `        ``// Traverse through all ` `        ``// bits of integer ` `        ``// starting from the most ` `        ``// significant bit (MSB) ` `        ``for` `(``int` `i = INT_BITS - 1;  ` `                 ``i >= 0; i--)  ` `        ``{ ` `             `  `        ``// Initialize index of ` `        ``// maximum element and ` `        ``// the maximum element ` `        ``int` `maxInd = index; ` `        ``int` `maxEle = ``int``.MinValue; ` `        ``for` `(``int` `j = index; j < n; j++) ` `        ``{ ` `             `  `            ``// If i'th bit of set[j] ` `            ``// is set and set[j] is ` `            ``// greater than max so far. ` `            ``if` `((``set``[j] & (1 << i)) != 0 && ` `                 ``set``[j] > maxEle) ` `            ``{ ` `                ``maxEle = ``set``[j]; ` `                ``maxInd = j; ` `            ``} ` `        ``} ` `     `  `        ``// If there was no ` `        ``// element with i'th ` `        ``// bit set, move to ` `        ``// smaller i ` `        ``if` `(maxEle == -2147483648) ` `            ``continue``; ` `     `  `        ``// Put maximum element ` `        ``// with i'th bit set ` `        ``// at index 'index' ` `        ``int` `temp = ``set``[index]; ` `        ``set``[index] = ``set``[maxInd]; ` `        ``set``[maxInd] = temp; ` `     `  `        ``// Update maxInd and ` `        ``// increment index ` `        ``maxInd = index; ` `     `  `        ``// Do XOR of set[maxIndex] ` `        ``// with all numbers having ` `        ``// i'th bit as set. ` `        ``for` `(``int` `j = 0; j < n; j++)  ` `        ``{ ` `         `  `            ``// XOR set[maxInd] those ` `            ``// numbers which have the ` `            ``// i'th bit set ` `            ``if` `(j != maxInd && (``set``[j] &  ` `               ``(1 << i)) != 0) ` `            ``set``[j] = ``set``[j] ^ ``set``[maxInd]; ` `    ``} ` ` `  `        ``// Increment index of ` `        ``// chosen elements ` `        ``index++; ` `    ``} ` ` `  `    ``// Final result is ` `    ``// XOR of all elements ` `        ``int` `res = 0; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``res ^= ``set``[i]; ` `        ``return` `res; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]``set` `= {9, 8, 5}; ` `        ``int` `n = ``set``.Length; ` `     `  `        ``Console.Write(``"Max subset XOR is "``); ` `        ``Console.Write(maxSubarrayXOR(``set``, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

## Javascript

 ``

## PHP

 `= 0; ``\$i``--) ` `    ``{ ` `        ``// Initialize index of maximum element  ` `        ``// and the maximum element ` `        ``\$maxInd` `= ``\$index``; ` `        ``\$maxEle` `= 0; ` `        ``for` `(``\$j` `= ``\$index``; ``\$j` `< ``\$n``; ``\$j``++) ` `        ``{ ` `            ``// If i'th bit of set[j] ` `            ``// is set and set[j] is  ` `            ``// greater than max so far. ` `            ``if` `( (``\$set``[``\$j``] & (1 << ``\$i``)) != 0 &&  ` `                  ``\$set``[``\$j``] > ``\$maxEle` `) ` `            ``{ ` `                ``\$maxEle` `= ``\$set``[``\$j``]; ` `                ``\$maxInd` `= ``\$j``; ` `            ``} ` `        ``} ` ` `  `        ``// If there was no element with i'th ` `        ``// bit set, move to smaller i ` `        ``if` `(``\$maxEle` `== 0) ` `        ``continue``; ` ` `  `        ``// Put maximum element with i'th bit  ` `        ``// set at index 'index' ` `        ``\$t` `= ``\$set``[``\$index``]; ` `        ``\$set``[``\$index``] = ``\$set``[``\$maxInd``]; ` `        ``\$set``[``\$maxInd``] = ``\$t``; ` ` `  `        ``// Update maxInd and increment index ` `        ``\$maxInd` `= ``\$index``; ` ` `  `        ``// Do XOR of set[maxIndex] with all numbers  ` `        ``// having i'th bit as set. ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$n``; ``\$j``++) ` `        ``{ ` `            ``// XOR set[maxInd] those numbers which  ` `            ``// have the i'th bit set ` `            ``if` `(``\$j` `!= ``\$maxInd` `&& ` `               ``(``\$set``[``\$j``] & (1 << ``\$i``)) != 0) ` `                ``\$set``[``\$j``] = ``\$set``[``\$j``] ^ ``\$set``[``\$maxInd``]; ` `        ``} ` ` `  `        ``// Increment index of chosen elements ` `        ``\$index``++; ` `    ``} ` ` `  `    ``// Final result is XOR of all elements ` `    ``\$res` `= 0; ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``\$res` `^= ``\$set``[``\$i``]; ` `    ``return` `\$res``; ` `} ` ` `  `// Driver Code ` `\$set` `= ``array``(9, 8, 5); ` `\$n` `= sizeof(``\$set``); ` `echo` `"Max subset XOR is "``; ` `echo` `maxSubarrayXOR(``\$set``, ``\$n``); ` ` `  `// This code is contributed by ita_c ` `?> `

Output:

`Max subset XOR is 13`

Time Complexity: O(n)

Auxiliary Space: O(1)

Illustration:

`Let the input set be : {9, 8, 5}We start from 31st bit [Assuming Integers are 32 bit long]. The loop will continue without doing anything till 4'th bit.The 4th bit is set in set i.e. 9 and this is the maximumelement with 4th bit set. So we choose this element and checkif any other number has the same bit set. If yes, we XOR that number with 9. The element set, i.e., 8 also has 4'th bit set. Now set[] becomes {9, 1, 5}.  We add 9 to the list of chosen elements by incrementing 'index'We move further and find the maximum number with 3rd bit setwhich is set i.e. 5  No other number in the array has 3rdbit set. 5 is also added to the list of chosen element.We then iterate for bit 2 (no number for this) and then for 1 which is 1. But numbers 9 and 5 have the 1st bit set. Thuswe XOR 9 and 5 with 1 and our set becomes (8, 1, 4)Finally, we XOR current elements of set and get the resultas 8 ^ 1 ^ 4 = 13.`

Approach:
We first find the maximum number in the input list nums using the built-in max function.

If the maximum number is 0, it means that all the numbers in the list are also 0, and so the maximum XOR value will also be 0. So we return 0.

Otherwise, we calculate the maximum bit position of the maximum number using the math.log2 function.

We initialize the ans variable to 0, which will eventually hold the maximum XOR value we find.

We also initialize a mask variable to 0, which we will use to generate a set of prefixes for each bit position.

We loop through the bit positions in descending order from the maximum bit position to 0.

In each iteration, we set the mask variable to the current bit position by left-shifting 1 by the bit position and subtracting 1. For example, if the bit position is 2, mask will be set to 0b00000100.

We generate a set of prefixes for the current bit position by applying the mask to each number in the input list using the bitwise AND operator (&). This results in a set of numbers where the rightmost bits up to the current bit position are all 0.

We initialize a candidate variable to the current ans value with the bit at the current bit position set to 1 using the bitwise OR operator (|).

We loop through each prefix in the set of prefixes we generated in step 8.

For each prefix, we check if there exists another prefix in the set that, when XORed with the candidate variable, results in another prefix in the set. If such a prefix exists, it means that we can use the candidate variable as the new ans value, since it indicates that we can form a larger XOR value by setting the bit at the current bit position to 1.

If we find such a prefix, we set the ans variable to the candidate value and break out of the loop.

We return the ans variable at the end of the loop, which should contain the maximum XOR value we found.

## C++

 `#include ` `using` `namespace` `std; ` ` `  `//this solution gets from discussion ` `int` `findMaximumXOR(``int` `nums[], ``int` `n) { ` ` `  `    ``int` `result = 0; ` `    ``int` `mask = 0; ` ` `  `    ``//let's check every possible positive integer number ` `    ``for``(``int` `i=31;i>=0;i--){ ` ` `  `        ``//mask start from most significant bit-1, 01000...00,->01100...00,->>>>>> 01111...11 ` `        ``mask = mask | (1< set; ` `        ``for``(``int` `j=0; j B^candidateResult = A ` `            ``if``(set.find(candidateResult^prefix) != set.end()){ ` ` `  `                ``//it is possible, so store this result ` `                ``result = candidateResult; ` `                ``break``; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Driver code ` `int` `main() { ` `    ``int` `set[] = {9, 8, 5}; ` `    ``int` `n = ``sizeof``(set)/``sizeof``(set); ` `  `  `    ``cout << ``"Max subset XOR is "` `<< findMaximumXOR(set,n); ` `}`

## Java

 `import` `java.util.*; ` `class` `Solution { ` ` `  `    ``//this solution gets from discussion ` `    ``public` `static` `int` `findMaximumXOR(``int``[] nums) { ` ` `  `        ``int` `result = ``0``; ` `        ``int` `mask = ``0``; ` ` `  `        ``//let's check every possible positive integer number ` `        ``for``(``int` `i=``31``;i>=``0``;i--){ ` ` `  `            ``//mask start from most significant bit-1, 01000...00,->01100...00,->>>>>> 01111...11 ` `            ``mask = mask | (``1``< set = ``new` `HashSet<>(); ` `            ``for``(``int` `num : nums){ ` `                ``set.add(num & mask); ` `            ``} ` ` `  `            ``//let's check evey prefix ` `            ``for``(``int` `prefix : set){ ` ` `  `                ``//so..if candidateResult is the existed result, how could that happen? ` `                ``//the tricky viewpoint is: ` `                ``//A^B = candidateResult <=> B^candidateResult = A ` `                ``if``(set.contains(candidateResult^prefix)){ ` ` `  `                    ``//it is possible, so store this result ` `                    ``result = candidateResult; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `result; ` `    ``} ` `  ``// Driver code ` `public` `static` `void` `main(String arg[]) { ` `    ``int` `set[] = {``9``, ``8``, ``5``}; ` `  `  `    ``System.out.print(``"Max subset XOR is "``); ` `    ``System.out.print(findMaximumXOR(set)); ` `} ` `}`

## Python

 `class` `Solution: ` ` `  `    ``@staticmethod` `    ``def` `findMaximumXOR(nums): ` ` `  `        ``result ``=` `0` `        ``mask ``=` `0` ` `  `        ``# let's check every possible positive integer number ` `        ``for` `i ``in` `range``(``31``, ``-``1``, ``-``1``): ` ` `  `            ``# mask start from most significant bit-1,  ` `            ``# 01000...00,->01100...00,->>>>>> 01111...11 ` `            ``mask ``=` `mask | (``1` `<< i) ` ` `  `            ``# we have already had a result, just make result's  ` `            ``# effective bit position extend to right one more ` `            ``# for example: 0110100..00 is result, let's check if 0110110..00  ` `            ``# is the result ` `            ``# let's check if the candidateResult is possible? ` `            ``# (candidateResult as a result candidate) ` `            ``candidateResult ``=` `result | (``1` `<< i) ` ` `  `            ``# record all prefixes(we only need to operate  ` `            ``# the specific bit positions) ` `            ``s ``=` `set``() ` `            ``for` `num ``in` `nums: ` `                ``s.add(num & mask) ` ` `  `            ``# let's check every prefix ` `            ``for` `prefix ``in` `s: ` ` `  `                ``# so..if candidateResult is the existed result,  ` `                ``# how could that happen? ` `                ``# the tricky viewpoint is: ` `                ``# A^B = candidateResult <=> B^candidateResult = A ` `                ``if` `(candidateResult ^ prefix) ``in` `s: ` ` `  `                    ``# it is possible, so store this result ` `                    ``result ``=` `candidateResult ` `                    ``break` ` `  `        ``return` `result ` ` `  ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``set_ ``=` `[``9``, ``8``, ``5``] ` `    ``print``(``"Max subset XOR is "``, Solution.findMaximumXOR(set_)) `

## C#

 `using` `System; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `MaximumXORFinder ` `{ ` `    ``// Function to find the maximum XOR value of subsets ` `    ``public` `static` `int` `FindMaximumXOR(``int``[] nums, ``int` `n) ` `    ``{ ` `        ``int` `result = 0; ` `        ``int` `mask = 0; ` ` `  `        ``// Let's check every possible positive integer number ` `        ``for` `(``int` `i = 31; i >= 0; i--) ` `        ``{ ` `            ``// Mask starts from the most significant bit-1, ` `            ``// e.g., 01000...00 -> 01100...00 ->>>>>> 01111...11 ` `            ``mask = mask | (1 << i); ` ` `  `            ``// If we have already found a result, ` `            ``// we extend the effective bit position of the result one more to the right ` `            ``// For example: If 0110100..00 is the result, let's check if 0110110..00 is the result ` `            ``// Let's check if the candidateResult is possible ` `            ``int` `candidateResult = result | (1 << i); ``// (candidateResult as a result candidate) ` ` `  `            ``// Record all prefixes (we only need to operate the specific bit positions) ` `            ``HashSet<``int``> ``set` `= ``new` `HashSet<``int``>(); ` `            ``for` `(``int` `j = 0; j < n; j++) ` `            ``{ ` `                ``set``.Add(nums[j] & mask); ` `            ``} ` ` `  `            ``// Let's check every prefix ` `            ``foreach` `(``int` `prefix ``in` `set``) ` `            ``{ ` `                ``// So, if the candidateResult is the existed result, how could that happen? ` `                ``// The tricky viewpoint is: A^B = candidateResult <=> B^candidateResult = A ` `                ``if` `(``set``.Contains(candidateResult ^ prefix)) ` `                ``{ ` `                    ``// It is possible, so store this result ` `                    ``result = candidateResult; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `        ``return` `result; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``int``[] ``set` `= { 9, 8, 5 }; ` `        ``int` `n = ``set``.Length; ` ` `  `        ``Console.WriteLine(``"Max subset XOR is "` `+ FindMaximumXOR(``set``, n)); ` `    ``} ` `} `

## Javascript

 `function` `findMaximumXOR(nums) { ` `    ``let result = 0; ` `    ``let mask = 0; ` ` `  `    ``// Let's check every possible positive integer number ` `    ``for` `(let i = 31; i >= 0; i--) { ` `        ``// Mask starts from the most significant bit-1, ` `        ``// e.g., 01000...00 -> 01100...00 ->>>>>> 01111...11 ` `        ``mask = mask | (1 << i); ` ` `  `        ``// If we have already found a result, ` `        ``// we extend the effective bit position of the result one more to the right ` `        ``// For example: If 0110100..00 is the result, let's check if 0110110..00 is the result ` `        ``// Let's check if the candidateResult is possible ` `        ``const candidateResult = result | (1 << i); ``// (candidateResult as a result candidate) ` ` `  `        ``// Record all prefixes (we only need to operate the specific bit positions) ` `        ``const set = ``new` `Set(); ` `        ``for` `(let j = 0; j < nums.length; j++) { ` `            ``set.add(nums[j] & mask); ` `        ``} ` ` `  `        ``// Let's check every prefix ` `        ``for` `(const prefix of set) { ` `            ``// So, if the candidateResult is the existed result, how could that happen? ` `            ``// The tricky viewpoint is: A^B = candidateResult <=> B^candidateResult = A ` `            ``if` `(set.has(candidateResult ^ prefix)) { ` `                ``// It is possible, so store this result ` `                ``result = candidateResult; ` `                ``break``; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Driver code ` `const set = [9, 8, 5]; ` `console.log(``"Max subset XOR is"``, findMaximumXOR(set)); `

Output

```Max subset XOR is 13
```

#### Time Complexity : O(nxlogm)

How does this work?

Let us first understand a simple case when all elements have Most Significant Bits (MSBs) at different positions. The task in this particular case is simple, we need to do XOR of all elements.
If the input contains multiple numbers with the same MSB, then it’s not obvious which of them we should choose to include in the XOR. What we do is reduce the input list into an equivalent form that doesn’t contain more than one number of the same length. By taking the maximum element, we know that the MSB of this is going to be there in output. Let this MSB be at position i. If there are more elements with i’th set (or same MSB), we XOR them with the maximum number so that the i’th bit becomes 0 in them and the problem reduces to i-1 bits.

Note: The above method is similar to Gaussian elimination. Consider a matrix of size 32 x n where 32 is number of bits and n is number of elements in array.