Find number of subarrays with XOR value a power of 2

• Difficulty Level : Expert
• Last Updated : 12 Nov, 2021

Given an integer array, arr[] of size N. The XOR value of any subarray of arr[] is defined as the xor of all the integers in that subarray. The task is to find the number of sub-arrays with XOR value a power of 2. (1, 2, 4, 8, 16, ….)
Examples:

```Input :  arr[] = {2, 6, 7, 5, 8}
Output : 6
Subarrays : {2, 6}, {2}, {6, 7},  {6, 7, 5}, {7, 5}, {8}

Input : arr[] = {2, 4, 8, 16}
Output : 4 ```

Approach

1. Maintain a hashmap which stores all the prefix XOR values and their counts.
2. At any index i, we need to find the number of subarrays which end at i and have XOR value a power of 2. We need to find for all the power of 2, the number of subarrays possible. For example. : Suppose current XOR value till index i is X, we need to find the number of subarrays which result in 16 (say S), so we need the count of prefix XOR Y such that (X^Y) = S or Y = S^X. Y can be find using Hash Map.
3. Perform Step 2, for all the index, add the output.

Below is the implementation of the above approach:

C++

 `// C++ Program to count number of subarrays``// with Bitwise-XOR as power of 2` `#include ``#define ll long long int``#define MAX 10``using` `namespace` `std;` `// Function to find number of subarrays``int` `findSubarray(``int` `array[], ``int` `n)``{``    ``// Hash Map to store prefix XOR values``    ``unordered_map<``int``, ``int``> mp;` `    ``// When no element is selected``    ``mp.insert({ 0, 1 });` `    ``int` `answer = 0;``    ``int` `preXor = 0;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `value = 1;``        ``preXor ^= array[i];` `        ``// Check for all the powers of 2,``        ``// till a MAX value``        ``for` `(``int` `j = 1; j <= MAX; j++) {``            ``int` `Y = value ^ preXor;``            ``if` `(mp.find(Y) != mp.end()) {``                ``answer += mp[Y];``            ``}``            ``value *= 2;``        ``}` `        ``// Insert Current prefixxor in Hash Map``        ``if` `(mp.find(preXor) != mp.end()) {``            ``mp[preXor]++;``        ``}``        ``else` `{``            ``mp.insert({ preXor, 1 });``        ``}``    ``}` `    ``return` `answer;``}` `// Driver Code``int` `main()``{``    ``int` `array[] = { 2, 6, 7, 5, 8 };``    ` `    ``int` `n = ``sizeof``(array) / ``sizeof``(array[0]);``    ` `    ``cout << findSubarray(array, n) << endl;` `    ``return` `0;``}`

Java

 `// Java Program to count number of subarrays``// with Bitwise-XOR as power of 2``import` `java.util.*;` `class` `GFG``{` `static` `int` `MAX = ``10``;` `// Function to find number of subarrays``static` `int` `findSubarray(``int` `array[], ``int` `n)``{``    ``// Hash Map to store prefix XOR values``    ``HashMap mp = ``new` `HashMap();` `    ``// When no element is selected``    ``mp.put(``0``, ``1``);` `    ``int` `answer = ``0``;``    ``int` `preXor = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `value = ``1``;``        ``preXor ^= array[i];` `        ``// Check for all the powers of 2,``        ``// till a MAX value``        ``for` `(``int` `j = ``1``; j <= MAX; j++)``        ``{``            ``int` `Y = value ^ preXor;``            ``if` `(mp.containsKey(Y))``            ``{``                ``answer += mp.get(Y);``            ``}``            ``value *= ``2``;``        ``}` `        ``// Insert Current prefixxor in Hash Map``        ``if` `(mp.containsKey(preXor))``        ``{``            ``mp.put(preXor,mp.get(preXor) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(preXor, ``1``);``        ``}``    ``}``    ``return` `answer;``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `array[] = { ``2``, ``6``, ``7``, ``5``, ``8` `};``    ` `    ``int` `n = array.length;``    ` `    ``System.out.println(findSubarray(array, n));``}``}` `// This code is contributed by PrinciRaj1992`

Python3

 `# Python3 Program to count number of subarrays``# with Bitwise-XOR as power of 2``MAX` `=` `10` `# Function to find number of subarrays``def` `findSubarray(array, n):``    ` `    ``# Hash Map to store prefix XOR values``    ``mp ``=` `dict``()` `    ``# When no element is selected``    ``mp[``0``] ``=` `1` `    ``answer ``=` `0``    ``preXor ``=` `0``    ``for` `i ``in` `range``(n):``        ``value ``=` `1``        ``preXor ^``=` `array[i]` `        ``# Check for all the powers of 2,``        ``# till a MAX value``        ``for` `j ``in` `range``(``1``, ``MAX` `+` `1``):``            ``Y ``=` `value ^ preXor``            ``if` `( Y ``in` `mp.keys()):``                ``answer ``+``=` `mp[Y]` `            ``value ``*``=` `2` `        ``# Insert Current prefixxor in Hash Map``        ``if` `(preXor ``in` `mp.keys()):``            ``mp[preXor] ``+``=` `1` `        ``else``:``            ``mp[preXor] ``=` `1` `    ``return` `answer` `# Driver Code``array ``=` `[``2``, ``6``, ``7``, ``5``, ``8``]` `n ``=` `len``(array)` `print``(findSubarray(array, n))` `# This code is contributed by Mohit Kumar`

C#

 `// C# Program to count number of subarrays``// with Bitwise-XOR as power of 2``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `int` `MAX = 10;` `// Function to find number of subarrays``static` `int` `findSubarray(``int` `[]array, ``int` `n)``{``    ``// Hash Map to store prefix XOR values``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``// When no element is selected``    ``mp.Add(0, 1);` `    ``int` `answer = 0;``    ``int` `preXor = 0;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``int` `value = 1;``        ``preXor ^= array[i];` `        ``// Check for all the powers of 2,``        ``// till a MAX value``        ``for` `(``int` `j = 1; j <= MAX; j++)``        ``{``            ``int` `Y = value ^ preXor;``            ``if` `(mp.ContainsKey(Y))``            ``{``                ``answer += mp[Y];``            ``}``            ``value *= 2;``        ``}` `        ``// Insert Current prefixxor in Hash Map``        ``if` `(mp.ContainsKey(preXor))``        ``{``            ``mp[preXor] = mp[preXor] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(preXor, 1);``        ``}``    ``}``    ``return` `answer;``}` `// Driver Code``public` `static` `void` `Main (String[] args)``{``    ``int` `[]array = { 2, 6, 7, 5, 8 };``    ` `    ``int` `n = array.Length;``    ` `    ``Console.WriteLine(findSubarray(array, n));``}``}``    ` `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:

`6`

Time Complexity: O(n * MAX)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up