# Length of the longest subarray whose Bitwise XOR is K

• Difficulty Level : Easy
• Last Updated : 17 May, 2021

Given an array arr[] of size N and an integer K, the task is to find the length of the longest subarray having Bitwise XOR of all its elements equal to K.

Examples:

Input: arr[] = { 1, 2, 4, 7, 2 }, K = 1
Output: 3
Explanation:
Subarray having Bitwise XOR equal to K(= 1) are { { 1 }, { 2, 4, 7 }, { 1 } }.
Therefore, the length of longest subarray having bitwise XOR equal to K(= 1) is 3

Input: arr[] = { 2, 5, 6, 1, 0, 3, 5, 6 }, K = 4
Output: 6
Explanation:
Subarray having Bitwise XOR equal to K(= 4) are { { 6, 1, 0, 3 }, { 5, 6, 1, 0, 3, 5 } }.
Therefore, the length of longest subarray having bitwise XOR equal to K(= 4) is 6.

Approach: The problem can be solved using Hashing and Prefix Sum technique. Following are the observation:

a1 ^ a2 ^ a3 ^ ….. ^ an = K

=> a2 ^ a3 ^ ….. ^ an ^ K = a1

Follow the steps below to solve the problem:

• Initialize a variable, say prefixXOR, to store the Bitwise XOR of all elements up to the ith index of the given array.
• Initialize a Map, say mp, to store the indices of the computed prefix XORs of the array.
• Initialize a variable, say maxLen, to store the length of the longest subarray whose Bitwise XOR is equal to K.
• Traverse the array arr[] using variable i. For every ith index, update prefixXOR = prefixXOR ^ arr[i] and check if (prefixXOR ^ K) is present in the Map or not. If found to be true, then update maxLen = max(maxLen, i – mp[prefixXOR ^ K]).
• If prefixXOR is not present in the Map, then insert prefixXOR into the Map.
• Finally, print the value of maxLen.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the length of the longest ` `// subarray whose bitwise XOR is equal to K` `int` `LongestLenXORK(``int` `arr[], ``int` `N, ``int` `K)` `{` `    `  `    ``// Stores prefix XOR` `    ``// of the array` `    ``int` `prefixXOR = 0;`   `    ``// Stores length of longest subarray` `    ``// having bitwise XOR equal to K` `    ``int` `maxLen = 0;`   `    ``// Stores index of prefix` `    ``// XOR of the array` `    ``map<``int``, ``int``> mp;` `    `  `    `  `    ``// Insert 0 into the map` `    ``mp[0] = -1;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// Update prefixXOR` `        ``prefixXOR ^= arr[i];`   `        ``// If (prefixXOR ^ K) present` `        ``// in the map` `        ``if` `(mp.count(prefixXOR ^ K)) {`   `            ``// Update maxLen` `            ``maxLen = max(maxLen,` `               ``(i - mp[prefixXOR ^ K]));` `        ``}` `        `  `        ``// If prefixXOR not present` `        ``// in the Map` `        ``if` `(!mp.count(prefixXOR)) {`   `            ``// Insert prefixXOR ` `            ``// into the map` `            ``mp[prefixXOR] = i;` `        ``}` `    ``}` `    `  `    ``return` `maxLen;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 2, 4, 7, 2 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `K = 1;` `    ``cout<< LongestLenXORK(arr, N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the length of the longest ` `// subarray whose bitwise XOR is equal to K` `static` `int` `LongestLenXORK(``int` `arr[], ` `                          ``int` `N, ``int` `K)` `{` `    `  `    ``// Stores prefix XOR` `    ``// of the array` `    ``int` `prefixXOR = ``0``;`   `    ``// Stores length of longest subarray` `    ``// having bitwise XOR equal to K` `    ``int` `maxLen = ``0``;`   `    ``// Stores index of prefix` `    ``// XOR of the array` `    ``HashMap mp = ``new` `HashMap();` `                                      `  `    ``// Insert 0 into the map` `    ``mp.put(``0``, -``1``);`   `    ``// Traverse the array` `    ``for``(``int` `i = ``0``; i < N; i++) ` `    ``{` `        `  `        ``// Update prefixXOR` `        ``prefixXOR ^= arr[i];`   `        ``// If (prefixXOR ^ K) present` `        ``// in the map` `        ``if` `(mp.containsKey(prefixXOR ^ K))` `        ``{` `            `  `            ``// Update maxLen` `            ``maxLen = Math.max(maxLen,` `               ``(i - mp.get(prefixXOR ^ K)));` `        ``}` `        `  `        ``// If prefixXOR not present` `        ``// in the Map` `        ``if` `(!mp.containsKey(prefixXOR))` `        ``{` `            `  `            ``// Insert prefixXOR ` `            ``// into the map` `            ``mp.put(prefixXOR, i);` `        ``}` `    ``}` `    ``return` `maxLen;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``1``, ``2``, ``4``, ``7``, ``2` `};` `    ``int` `N = arr.length;` `    ``int` `K = ``1``;` `    `  `    ``System.out.print(LongestLenXORK(arr, N, K));` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the length of the longest ` `# subarray whose bitwise XOR is equal to K` `def` `LongestLenXORK(arr, N, K):` `    `  `    ``# Stores prefix XOR` `    ``# of the array` `    ``prefixXOR ``=` `0`   `    ``# Stores length of longest subarray` `    ``# having bitwise XOR equal to K` `    ``maxLen ``=` `0`   `    ``# Stores index of prefix` `    ``# XOR of the array` `    ``mp ``=` `{}`   `    ``# Insert 0 into the map` `    ``mp[``0``] ``=` `-``1`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(N):` `        `  `        ``# Update prefixXOR` `        ``prefixXOR ^``=` `arr[i]`   `        ``# If (prefixXOR ^ K) present` `        ``# in the map` `        ``if` `(prefixXOR ^ K) ``in` `mp:` `            `  `            ``# Update maxLen` `            ``maxLen ``=` `max``(maxLen,` `                        ``(i ``-` `mp[prefixXOR ^ K]))`   `        ``# If prefixXOR not present` `        ``# in the Map` `        ``else``: ` `            `  `            ``# Insert prefixXOR ` `            ``# into the map` `            ``mp[prefixXOR] ``=` `i` `      `  `    ``return` `maxLen`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``arr ``=` `[ ``1``, ``2``, ``4``, ``7``, ``2` `]` `    ``N ``=` `len``(arr)` `    ``K ``=` `1` `    `  `    ``print``(LongestLenXORK(arr, N, K))`   `# This code is contributed by AnkThon`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{`   `// Function to find the length of the longest ` `// subarray whose bitwise XOR is equal to K` `static` `int` `longestLenXORK(``int` `[]arr, ` `                          ``int` `N, ``int` `K)` `{` `    `  `    ``// Stores prefix XOR` `    ``// of the array` `    ``int` `prefixXOR = 0;`   `    ``// Stores length of longest subarray` `    ``// having bitwise XOR equal to K` `    ``int` `maxLen = 0;`   `    ``// Stores index of prefix` `    ``// XOR of the array` `    ``Dictionary<``int``,` `            ``int``> mp = ``new` `Dictionary<``int``,` `                                      ``int``>();` `                                      `  `    ``// Insert 0 into the map` `    ``mp.Add(0, -1);`   `    ``// Traverse the array` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{` `        `  `        ``// Update prefixXOR` `        ``prefixXOR ^= arr[i];`   `        ``// If (prefixXOR ^ K) present` `        ``// in the map` `        ``if` `(mp.ContainsKey(prefixXOR ^ K))` `        ``{` `            `  `            ``// Update maxLen` `            ``maxLen = Math.Max(maxLen,` `               ``(i - mp[prefixXOR ^ K]));` `        ``}` `        `  `        ``// If prefixXOR not present` `        ``// in the Map` `        ``if` `(!mp.ContainsKey(prefixXOR))` `        ``{` `            `  `            ``// Insert prefixXOR ` `            ``// into the map` `            ``mp.Add(prefixXOR, i);` `        ``}` `    ``}` `    ``return` `maxLen;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = {1, 2, 4, 7, 2};` `    ``int` `N = arr.Length;` `    ``int` `K = 1;` `    `  `    ``Console.Write(longestLenXORK(arr, N, K));` `}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`3`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :