Length of the longest subarray whose Bitwise XOR is K

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.

Naive Approach

The idea is to generate all subarrays and find that subarray whose bitwise XOR of all elements is equal to K and has a maximum length

Steps to Implement:

• Initialize a variable “ans” with 0 because if no such subarray exists then it will be the answer
• Run two for loops from 0 to N-1 to generate all subarray
• For each subarray find the XOR of all elements and its length
• If any XOR value got equal to K then update “ans” as the maximum of “ans” and the length of that subarray
• In the last print/return value in ans

Code-

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)``{``    ``//To store final answer``    ``int` `ans=0;``    ` `    ``//Find all subarray``    ``for``(``int` `i=0;i

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)``    ``{``        ``// To store the final answer``        ``int` `ans = ``0``;` `        ``// Find all subarrays``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``// To store the length of the subarray``            ``int` `length = ``0``;``            ``// To store XOR of all elements of the subarray``            ``int` `temp = ``0``;``            ``for` `(``int` `j = i; j < N; j++) {``                ``temp = temp ^ arr[j];``                ``length++;` `                ``// When XOR of all elements of subarray is``                ``// equal to K``                ``if` `(temp == K) {``                    ``// Update ans``                    ``ans = Math.max(ans, length);``                ``}``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``1``, ``2``, ``4``, ``7``, ``2` `};``        ``int` `N = arr.length;``        ``int` `K = ``1``;``        ``System.out.println(LongestLenXORK(arr, N, K));``    ``}``}`

Python3

 `# Python 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):``    ``# To store final answer``    ``ans ``=` `0` `    ``# Find all subarray``    ``for` `i ``in` `range``(N):``        ``# To store length of subarray``        ``length ``=` `0``        ``# To store XOR of all elements of subarray``        ``temp ``=` `0``        ``for` `j ``in` `range``(i, N):``            ``temp ^``=` `arr[j]``            ``length ``+``=` `1` `            ``# When XOR of all elements of subarray equal to K``            ``if` `temp ``=``=` `K:``                ``# Update ans``                ``ans ``=` `max``(ans, length)` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``1``, ``2``, ``4``, ``7``, ``2``]``    ``N ``=` `len``(arr)``    ``K ``=` `1``    ``print``(LongestLenXORK(arr, N, K))`

C#

 `using` `System;` `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)``    ``{``        ``// To store the final answer``        ``int` `ans = 0;` `        ``// Find all subarrays``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``// To store the length of the subarray``            ``int` `length = 0;``            ` `            ``// To store the XOR of all elements of the subarray``            ``int` `temp = 0;` `            ``for` `(``int` `j = i; j < N; j++)``            ``{``                ``temp ^= arr[j];``                ``length++;` `                ``// When XOR of all elements of the subarray is equal to K``                ``if` `(temp == K)``                ``{``                    ``// Update ans``                    ``ans = Math.Max(ans, length);``                ``}``            ``}``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver Code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 1, 2, 4, 7, 2 };``        ``int` `N = arr.Length;``        ``int` `K = 1;``        ``Console.WriteLine(LongestLenXORK(arr, N, K));``    ``}``}` `// This code is contributed by Dwaipayan Bandyopadhyay`

Javascript

 `// Javascript program to implement``// the above approach` `// Function to find the length of the longest ``// subarray whose bitwise XOR is equal to K``function` `LongestLenXORK(arr, N, K) {`` ``//To store final answer``    ``let ans = 0;``//Find all subarray``    ``for` `(let i = 0; i < N; i++) {``        ``let length = 0;``        ``//To store XOR of all elements of subarray``        ``let temp = 0;``        ``for` `(let j = i; j < N; j++) {``            ``temp ^= arr[j];``            ``length += 1;``//When XOR of all elements of subarray equal to K``            ``if` `(temp === K) {``            ``//Update ans``                ``ans = Math.max(ans, length);``            ``}``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``const arr = [1, 2, 4, 7, 2];``const N = arr.length;``const K = 1;``console.log(LongestLenXORK(arr, N, K));`

Output-

`3`

Time Complexity: O(N2), because of two nested loops from 0 to N-1
Auxiliary Space: O(1), because no extra space has been used

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``    ``unordered_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)

Previous
Next