# Find the maximum subarray XOR in a given array

Given an array of integers. The task is to find the maximum subarray XOR value in the given array.

Examples:

Input: arr[] = {1, 2, 3, 4}
Output: 7
Explanation: The subarray {3, 4} has maximum XOR value

Input: arr[] = {8, 1, 2, 12, 7, 6}
Output: 15
Explanation: The subarray {1, 2, 12} has maximum XOR value

Input: arr[] = {4, 6}
Output: 6
Explanation: The subarray {6} has maximum XOR value

Recommended Practice

Naive Approach: Below is the idea to solve the problem:

Create all possible subarrays and calculate the XOR of the subarrays. The maximum among them will be the required answer.

Follow the steps mentioned below to implement the idea:

• Iterate from i  = 0 to N-1:
• Initialize a variable (say curr_xor = 0) to store the XOR value of subarrays starting from i
• Run a nested loop from j =  i to N-1:
• The value j determines the ending point for the current subarray starting from i.
• Update curr_xor by performing XOR of curr_xor with arr[j].
• If the value is greater than the maximum then update the maximum value also.
• The maximum value is the required answer.

Below is the Implementation of the above approach:

## C++

 `// A simple C++ program to find max subarray XOR``#include``using` `namespace` `std;` `int` `maxSubarrayXOR(``int` `arr[], ``int` `n)``{``    ``int` `ans = INT_MIN;     ``// Initialize result` `    ``// Pick starting points of subarrays``    ``for` `(``int` `i=0; i

## Java

 `// A simple Java program to find max subarray XOR``class` `GFG {``    ``static` `int` `maxSubarrayXOR(``int` `arr[], ``int` `n)``    ``{``        ``int` `ans = Integer.MIN_VALUE; ``// Initialize result``     ` `        ``// Pick starting points of subarrays``        ``for` `(``int` `i=``0``; i

## Python3

 `# A simple Python program``# to find max subarray XOR` `def` `maxSubarrayXOR(arr,n):` `    ``ans ``=` `-``2147483648`     `#Initialize result`` ` `    ``# Pick starting points of subarrays``    ``for` `i ``in` `range``(n):``        ` `        ``# to store xor of current subarray``        ``curr_xor ``=` `0`` ` `        ``# Pick ending points of``        ``# subarrays starting with i``        ``for` `j ``in` `range``(i,n):``        ` `            ``curr_xor ``=` `curr_xor ^ arr[j]``            ``ans ``=` `max``(ans, curr_xor)``        ` `    ` `    ``return` `ans`  `# Driver code` `arr ``=` `[``8``, ``1``, ``2``, ``12``]``n ``=` `len``(arr)` `print``(``"Max subarray XOR is "``,``     ``maxSubarrayXOR(arr, n))` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// A simple C# program to find ``// max subarray XOR``using` `System;` `class` `GFG``{``    ` `    ``// Function to find max subarray``    ``static` `int` `maxSubarrayXOR(``int` `[]arr, ``int` `n)``    ``{``        ``int` `ans = ``int``.MinValue; ``        ``// Initialize result``    ` `        ``// Pick starting points of subarrays``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``// to store xor of current subarray ``            ``int` `curr_xor = 0; ``    ` `            ``// Pick ending points of ``            ``// subarrays starting with i``            ``for` `(``int` `j = i; j < n; j++)``            ``{``                ``curr_xor = curr_xor ^ arr[j];``                ``ans = Math.Max(ans, curr_xor);``            ``}``        ``}``        ``return` `ans;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = {8, 1, 2, 12};``        ``int` `n = arr.Length;``        ``Console.WriteLine(``"Max subarray XOR is "` `+ ``                           ``maxSubarrayXOR(arr, n));``    ``}``}` `// This code is contributed by Sam007.`

## PHP

 ``

## Javascript

 ``

Output
`Max subarray XOR is 15`

Time Complexity: O(N2).
Auxiliary Space: O(1)

## Find the maximum subarray XOR in a given array using trie Data Structure.

Maximize the xor subarray by using trie data structure to find the binary inverse of current prefix xor inorder to set the left most unset bits and maximize the value.

Follow the below steps to Implement the idea:

• Create an empty Trie. Every node of Trie is going to contain two children, for 0 and 1 values of a bit.
• Initialize pre_xor = 0 and insert into the Trie, Initialize result = INT_MIN
• Traverse the given array and do the following for every array element arr[i].
• pre_xor  = pre_xor  ^ arr[i], pre_xor now contains xor of elements from arr[0] to arr[i].
• Query the maximum xor value ending with arr[i] from Trie.
• Update the result if the value obtained above is more than the current value of the result.

Illustration:

It can be observed from the above algorithm that we build a Trie that contains XOR of all prefixes of given array. To find the maximum XOR subarray ending with arr[i], there may be two cases.

• The prefix itself has the maximum XOR value ending with arr[i]. For example if i=2 in {8, 2, 1, 12}, then the maximum subarray xor ending with arr[2] is the whole prefix.
• Remove some prefix (ending at index from 0 to i-1). For example if i=3 in {8, 2, 1, 12}, then the maximum subarray xor ending with arr[3] starts with arr[1] and we need to remove arr[0].
• To find the prefix to be removed, find the entry in Trie that has maximum XOR value with current prefix. If we do XOR of such previous prefix with current prefix, get the maximum XOR value ending with arr[i].
• If there is no prefix to be removed (case i), then we return 0 (that’s why we inserted 0 in Trie).

Below is the implementation of the above idea :

## C++

 `// C++ program for a Trie based O(n) solution to find max``// subarray XOR``#include``using` `namespace` `std;` `// Assumed int size``#define INT_SIZE 32` `// A Trie Node``struct` `TrieNode``{``    ``int` `value;  ``// Only used in leaf nodes``    ``TrieNode *arr[2];``};` `// Utility function to create a Trie node``TrieNode *newNode()``{``    ``TrieNode *temp = ``new` `TrieNode;``    ``temp->value = 0;``    ``temp->arr[0] = temp->arr[1] = NULL;``    ``return` `temp;``}` `// Inserts pre_xor to trie with given root``void` `insert(TrieNode *root, ``int` `pre_xor)``{``    ``TrieNode *temp = root;` `    ``// Start from the msb, insert all bits of``    ``// pre_xor into Trie``    ``for` `(``int` `i=INT_SIZE-1; i>=0; i--)``    ``{``        ``// Find current bit in given prefix``        ``bool` `val = pre_xor & (1<arr[val] == NULL)``            ``temp->arr[val] = newNode();` `        ``temp = temp->arr[val];``    ``}` `    ``// Store value at leaf node``    ``temp->value = pre_xor;``}` `// Finds the maximum XOR ending with last number in``// prefix XOR 'pre_xor' and returns the XOR of this maximum``// with pre_xor which is maximum XOR ending with last element``// of pre_xor.``int` `query(TrieNode *root, ``int` `pre_xor)``{``    ``TrieNode *temp = root;``    ``for` `(``int` `i=INT_SIZE-1; i>=0; i--)``    ``{``        ``// Find current bit in given prefix``        ``bool` `val = pre_xor & (1<arr[1-val]!=NULL)``            ``temp = temp->arr[1-val];` `        ``// If there is no prefix with opposite``        ``// bit, then look for same bit.``        ``else` `if` `(temp->arr[val] != NULL)``            ``temp = temp->arr[val];``    ``}``    ``return` `pre_xor^(temp->value);``}` `// Returns maximum XOR value of a subarray in arr[0..n-1]``int` `maxSubarrayXOR(``int` `arr[], ``int` `n)``{``    ``// Create a Trie and insert 0 into it``    ``TrieNode *root = newNode();``    ``insert(root, 0);` `    ``// Initialize answer and xor of current prefix``    ``int` `result = INT_MIN, pre_xor =0;` `    ``// Traverse all input array element``    ``for` `(``int` `i=0; i

## Java

 `// Java program for a Trie based O(n) solution to ``// find max subarray XOR``class` `GFG ``{``    ``// Assumed int size``    ``static` `final` `int` `INT_SIZE = ``32``;``     ` `    ``// A Trie Node``    ``static` `class` `TrieNode``    ``{``        ``int` `value;  ``// Only used in leaf nodes``        ``TrieNode[] arr =  ``new` `TrieNode[``2``];``        ``public` `TrieNode() {``            ``value = ``0``;``            ``arr[``0``] = ``null``;``            ``arr[``1``] = ``null``;``        ``}``    ``}``    ``static` `TrieNode root;``    ` `    ``// Inserts pre_xor to trie with given root``    ``static` `void` `insert(``int` `pre_xor)``    ``{``        ``TrieNode temp = root;``     ` `        ``// Start from the msb, insert all bits of``        ``// pre_xor into Trie``        ``for` `(``int` `i=INT_SIZE-``1``; i>=``0``; i--)``        ``{``            ``// Find current bit in given prefix``            ``int` `val = (pre_xor & (``1``<=``1` `? ``1` `: ``0``;``     ` `            ``// Create a new node if needed``            ``if` `(temp.arr[val] == ``null``)``                ``temp.arr[val] = ``new` `TrieNode();``     ` `            ``temp = temp.arr[val];``        ``}``     ` `        ``// Store value at leaf node``        ``temp.value = pre_xor;``    ``}``     ` `    ``// Finds the maximum XOR ending with last number in``    ``// prefix XOR 'pre_xor' and returns the XOR of this ``    ``// maximum with pre_xor which is maximum XOR ending ``    ``// with last element of pre_xor.``    ``static` `int` `query(``int` `pre_xor)``    ``{``        ``TrieNode temp = root;``        ``for` `(``int` `i=INT_SIZE-``1``; i>=``0``; i--)``        ``{``            ``// Find current bit in given prefix``            ``int` `val = (pre_xor & (``1``<= ``1` `? ``1` `: ``0``;``     ` `            ``// Traverse Trie, first look for a``            ``// prefix that has opposite bit``            ``if` `(temp.arr[``1``-val] != ``null``)``                ``temp = temp.arr[``1``-val];``     ` `            ``// If there is no prefix with opposite``            ``// bit, then look for same bit.``            ``else` `if` `(temp.arr[val] != ``null``)``                ``temp = temp.arr[val];``        ``}``        ``return` `pre_xor^(temp.value);``    ``}``     ` `    ``// Returns maximum XOR value of a subarray in ``        ``// arr[0..n-1]``    ``static` `int` `maxSubarrayXOR(``int` `arr[], ``int` `n)``    ``{``        ``// Create a Trie and insert 0 into it``        ``root = ``new` `TrieNode();``        ``insert(``0``);``     ` `        ``// Initialize answer and xor of current prefix``        ``int` `result = Integer.MIN_VALUE;``        ``int` `pre_xor =``0``;``     ` `        ``// Traverse all input array element``        ``for` `(``int` `i=``0``; i

## Python3

 `"""Python implementation for a Trie based solution``to find max subArray XOR"""` `# Structure of Trie Node``class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data``        ` `        ``# left node for 0``        ``self``.left ``=` `None``        ` `        ``# right node for 1``        ``self``.right ``=` `None` `# Class for implementing Trie``class` `Trie:` `    ``def` `__init__(``self``):` `        ``self``.root ``=` `Node(``0``)` `    ``# Insert pre_xor to trie with given root``    ``def` `insert(``self``, pre_xor):` `        ``self``.temp ``=` `self``.root` `        ``# Start from msb, insert all bits of pre_xor``        ``# into the Trie``        ``for` `i ``in` `range``(``31``, ``-``1``, ``-``1``):` `            ``# Find current bit in prefix sum``            ``val ``=` `pre_xor & (``1``<

## C#

 `using` `System;` `// C# program for a Trie based O(n) solution to  ``// find max subarray XOR ``public` `class` `GFG``{``    ``// Assumed int size ``    ``public` `const` `int` `INT_SIZE = 32;` `    ``// A Trie Node ``    ``public` `class` `TrieNode``    ``{``        ``public` `int` `value; ``// Only used in leaf nodes``        ``public` `TrieNode[] arr = ``new` `TrieNode[2];``        ``public` `TrieNode()``        ``{``            ``value = 0;``            ``arr[0] = ``null``;``            ``arr[1] = ``null``;``        ``}``    ``}``    ``public` `static` `TrieNode root;` `    ``// Inserts pre_xor to trie with given root ``    ``public` `static` `void` `insert(``int` `pre_xor)``    ``{``        ``TrieNode temp = root;` `        ``// Start from the msb, insert all bits of ``        ``// pre_xor into Trie ``        ``for` `(``int` `i = INT_SIZE-1; i >= 0; i--)``        ``{``            ``// Find current bit in given prefix ``            ``int` `val = (pre_xor & (1 << i)) >= 1 ? 1 : 0;` `            ``// Create a new node if needed ``            ``if` `(temp.arr[val] == ``null``)``            ``{``                ``temp.arr[val] = ``new` `TrieNode();``            ``}` `            ``temp = temp.arr[val];``        ``}` `        ``// Store value at leaf node ``        ``temp.value = pre_xor;``    ``}` `    ``// Finds the maximum XOR ending with last number in ``    ``// prefix XOR 'pre_xor' and returns the XOR of this  ``    ``// maximum with pre_xor which is maximum XOR ending  ``    ``// with last element of pre_xor. ``    ``public` `static` `int` `query(``int` `pre_xor)``    ``{``        ``TrieNode temp = root;``        ``for` `(``int` `i = INT_SIZE-1; i >= 0; i--)``        ``{``            ``// Find current bit in given prefix ``            ``int` `val = (pre_xor & (1 << i)) >= 1 ? 1 : 0;` `            ``// Traverse Trie, first look for a ``            ``// prefix that has opposite bit ``            ``if` `(temp.arr[1 - val] != ``null``)``            ``{``                ``temp = temp.arr[1 - val];``            ``}` `            ``// If there is no prefix with opposite ``            ``// bit, then look for same bit. ``            ``else` `if` `(temp.arr[val] != ``null``)``            ``{``                ``temp = temp.arr[val];``            ``}``        ``}``        ``return` `pre_xor ^ (temp.value);``    ``}` `    ``// Returns maximum XOR value of a subarray in  ``        ``// arr[0..n-1] ``    ``public` `static` `int` `maxSubarrayXOR(``int``[] arr, ``int` `n)``    ``{``        ``// Create a Trie and insert 0 into it ``        ``root = ``new` `TrieNode();``        ``insert(0);` `        ``// Initialize answer and xor of current prefix ``        ``int` `result = ``int``.MinValue;``        ``int` `pre_xor = 0;` `        ``// Traverse all input array element ``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``// update current prefix xor and insert it  ``                ``// into Trie ``            ``pre_xor = pre_xor ^ arr[i];``            ``insert(pre_xor);` `            ``// Query for current prefix xor in Trie and  ``            ``// update result if required ``            ``result = Math.Max(result, query(pre_xor));` `        ``}``        ``return` `result;``    ``}` `    ``// Driver program to test above functions ``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = ``new` `int``[] {8, 1, 2, 12};``        ``int` `n = arr.Length;``        ``Console.WriteLine(``"Max subarray XOR is "` `+ maxSubarrayXOR(arr, n));``    ``}``}` `  ``// This code is contributed by Shrikant13`

## Javascript

 `// JavaScript program for a Trie based O(n) solution to find max subarray XOR` `// Assumed int size``const INT_SIZE = 32;` `// A Trie Node``class TrieNode {``  ``constructor() {``    ``this``.value = 0; ``// Only used in leaf nodes``    ``this``.arr = [``null``, ``null``];``  ``}``}` `let root;` `// Inserts pre_xor to trie with given root``function` `insert(pre_xor) {``  ``let temp = root;` `  ``// Start from the msb, insert all bits of``  ``// pre_xor into Trie``  ``for` `(let i = INT_SIZE - 1; i >= 0; i--) {``    ``// Find current bit in given prefix``    ``let val = (pre_xor & (1 << i)) >= 1 ? 1 : 0;` `    ``// Create a new node if needed``    ``if` `(temp.arr[val] === ``null``) {``      ``temp.arr[val] = ``new` `TrieNode();``    ``}` `    ``temp = temp.arr[val];``  ``}` `  ``// Store value at leaf node``  ``temp.value = pre_xor;``}` `// Finds the maximum XOR ending with last number in``// prefix XOR 'pre_xor' and returns the XOR of this``// maximum with pre_xor which is maximum XOR ending``// with last element of pre_xor.``function` `query(pre_xor) {``  ``let temp = root;``  ``for` `(let i = INT_SIZE - 1; i >= 0; i--) {``    ``// Find current bit in given prefix``    ``let val = (pre_xor & (1 << i)) >= 1 ? 1 : 0;` `    ``// Traverse Trie, first look for a``    ``// prefix that has opposite bit``    ``if` `(temp.arr[1 - val] !== ``null``) {``      ``temp = temp.arr[1 - val];``    ``}` `    ``// If there is no prefix with opposite``    ``// bit, then look for same bit.``    ``else` `if` `(temp.arr[val] !== ``null``) {``      ``temp = temp.arr[val];``    ``}``  ``}``  ``return` `pre_xor ^ temp.value;``}` `// Returns maximum XOR value of a subarray in arr[0..n-1]``function` `maxSubarrayXOR(arr, n) {``  ``// Create a Trie and insert 0 into it``  ``root = ``new` `TrieNode();``  ``insert(0);` `  ``// Initialize answer and xor of current prefix``  ``let result = Number.MIN_SAFE_INTEGER;``  ``let pre_xor = 0;` `  ``// Traverse all input array element``  ``for` `(let i = 0; i < n; i++) {``    ``// update current prefix xor and insert it``    ``// into Trie``    ``pre_xor ^= arr[i];``    ``insert(pre_xor);` `    ``// Query for current prefix xor in Trie and``    ``// update result if required``    ``result = Math.max(result, query(pre_xor));``  ``}``  ``return` `result;``}` `// Driver program to test above functions``let arr = [8, 1, 2, 12];``let n = arr.length;``console.log(``"Max subarray XOR is "` `+ maxSubarrayXOR(arr, n));`

Output
`Max subarray XOR is 15`

Time Complexity: O(N).
Auxiliary Space: O(N)

Exercise: Extend the above solution so that it also prints starting and ending indexes of subarray with maximum value (Hint: we can add one more field to Trie node to achieve this

Previous
Next