Count the number of subarrays having a given XOR - GeeksforGeeks

10 Mar, 2022
Given an array of integers arr[] and a number m, count the number of subarrays having XOR of their elements as m.Examples: 
Input : arr[] = {4, 2, 2, 6, 4}, m = 6
Output : 4
Explanation : The subarrays having XOR of 
              their elements as 6 are {4, 2}, 
              {4, 2, 2, 6, 4}, {2, 2, 6},
               and {6}

Input : arr[] = {5, 6, 7, 8, 9}, m = 5
Output : 2
Explanation : The subarrays having XOR of
              their elements as 5 are {5}
              and {5, 6, 7, 8, 9}
A Simple Solution is to use two loops to go through all possible subarrays of arr[] and count the number of subarrays having XOR of their elements as m. 
C++
Java
Python3
C#
PHP
Javascript
// A simple C++ Program to count all subarrays having// XOR of elements as given value m#include <bits/stdc++.h>using namespace std; // Simple function that returns count of subarrays// of arr with XOR value equals to mlong long subarrayXor(int arr[], int n, int m){    long long ans = 0; // Initialize ans     // Pick starting point i of subarrays    for (int i = 0; i < n; i++) {        int xorSum = 0; // Store XOR of current subarray         // Pick ending point j of subarray for each i        for (int j = i; j < n; j++) {            // calculate xorSum            xorSum = xorSum ^ arr[j];             // If xorSum is equal to given value,            // increase ans by 1.            if (xorSum == m)                ans++;        }    }    return ans;} // Driver program to test above functionint main(){    int arr[] = { 4, 2, 2, 6, 4 };    int n = sizeof(arr) / sizeof(arr[0]);    int m = 6;     cout << "Number of subarrays having given XOR is "         << subarrayXor(arr, n, m);    return 0;}
// A simple Java Program to count all// subarrays having XOR of elements// as given value mpublic class GFG {     // Simple function that returns    // count of subarrays of arr with    // XOR value equals to m    static long subarrayXor(int arr[],                             int n, int m)    {                 // Initialize ans        long ans = 0;         // Pick starting point i of        // subarrays        for (int i = 0; i < n; i++)        {                         // Store XOR of current            // subarray            int xorSum = 0;             // Pick ending point j of            // subarray for each i            for (int j = i; j < n; j++)            {                                 // calculate xorSum                xorSum = xorSum ^ arr[j];                 // If xorSum is equal to                // given value, increase                // ans by 1.                if (xorSum == m)                    ans++;            }        }                 return ans;    }     // Driver code    public static void main(String args[])    {         int[] arr = { 4, 2, 2, 6, 4 };        int n = arr.length;        int m = 6;         System.out.println("Number of subarrays"                       + " having given XOR is "                       + subarrayXor(arr, n, m));    }} // This code is contributed by Sam007.
     # A simple Python3 Program to count all subarrays having# XOR of elements as given value m  # Simple function that returns count of subarrays# of arr with XOR value equals to mdef subarrayXor(arr, n, m):    ans = 0 # Initialize ans      # Pick starting point i of subarrays    for i in range(0,n):                 xorSum = 0 # Store XOR of current subarray          # Pick ending point j of subarray for each i        for j  in range(i,n):            # calculate xorSum            xorSum = xorSum ^ arr[j]              # If xorSum is equal to given value,            # increase ans by 1.            if (xorSum == m):                ans+=1    return ans  # Driver program to test above functiondef main():    arr = [ 4, 2, 2, 6, 4 ]    n = len(arr)    m = 6      print("Number of subarrays having given XOR is "         , subarrayXor(arr, n, m)) if __name__ == '__main__':    main()     #this code contributed by 29AjayKumar
// A simple C# Program to count all// subarrays having XOR of elements// as given value musing System; class GFG {         // Simple function that returns    // count of subarrays of arr    // with XOR value equals to m    static long subarrayXor(int[] arr,                            int n, int m)    {                 // Initialize ans        long ans = 0;         // Pick starting point i of        // subarrays        for (int i = 0; i < n; i++)        {                         // Store XOR of current            // subarray            int xorSum = 0;             // Pick ending point j of            // subarray for each i            for (int j = i; j < n; j++)            {                                 // calculate xorSum                xorSum = xorSum ^ arr[j];                 // If xorSum is equal to                // given value, increase                // ans by 1.                if (xorSum == m)                    ans++;            }        }                 return ans;    }     // Driver Program    public static void Main()    {        int[] arr = { 4, 2, 2, 6, 4 };        int n = arr.Length;        int m = 6;         Console.Write("Number of subarrays"                  + " having given XOR is "                  + subarrayXor(arr, n, m));    }} // This code is contributed by Sam007.
<?php// A simple PHP Program to// count all subarrays having// XOR of elements as given value m // Simple function that returns// count of subarrays of arr// with XOR value equals to mfunction subarrayXor($arr, $n,$m){         // Initialize ans    $ans = 0;     // Pick starting point    // i of subarrays    for ($i = 0; $i < $n; $i++)    {                 // Store XOR of        // current subarray        $xorSum = 0;         // Pick ending point j of        // subarray for each i        for ($j = $i; $j < $n; $j++)        {            // calculate xorSum            $xorSum = $xorSum ^ $arr[$j];             // If xorSum is equal            // to given value,            // increase ans by 1.            if ($xorSum == $m)                $ans++;        }    }    return $ans;}     // Driver Code    $arr = array(4, 2, 2, 6, 4);    $n = count($arr);    $m = 6;     echo "Number of subarrays having given XOR is "         , subarrayXor($arr, $n, $m);          // This code is contributed by anuj_67.?>
<script> // A simple Javascript Program to// count all subarrays having// XOR of elements as given value m // Simple function that// returns count of subarrays// of arr with XOR value equals to mfunction subarrayXor(arr, n, m){    let ans = 0; // Initialize ans     // Pick starting point i of subarrays    for (let i = 0; i < n; i++)    {    // Store XOR of current subarray        let xorSum = 0;         // Pick ending point j of        // subarray for each i        for (let j = i; j < n; j++) {            // calculate xorSum            xorSum = xorSum ^ arr[j];             // If xorSum is equal to given value,            // increase ans by 1.            if (xorSum == m)                ans++;        }    }    return ans;} // Driver program to test above function    let arr = [ 4, 2, 2, 6, 4 ];    let n = arr.length;    let m = 6;     document.write(    "Number of subarrays having given XOR is "         + subarrayXor(arr, n, m)         ); </script>
Output: 
Number of subarrays having given XOR is 4
The Time Complexity of the above solution is O(n2).
Efficient Approach:An Efficient Solution solves the above problem in O(n) time. Let us call the XOR of all elements in the range [i+1, j] as A, in the range [0, i] as B, and in the range [0, j] as C. If we do XOR of B with C, the overlapping elements in [0, i] from B and C zero out, and we get XOR of all elements in the range [i+1, j], i.e. A. Since A = B XOR C, we have B = A XOR C. Now, if we know the value of C and we take the value of A as m, we get the count of A as the count of all B satisfying this relation. Essentially, we get the count of all subarrays having XOR-sum m for each C. As we take the sum of this count overall C, we get our answer.
1) Initialize ans as 0.
2) Compute xorArr, the prefix xor-sum array.
3) Create a map mp in which we store count of 
   all prefixes with XOR as a particular value. 
4) Traverse xorArr and for each element in xorArr
   (A) If m^xorArr[i] XOR exists in map, then 
       there is another previous prefix with 
       same XOR, i.e., there is a subarray ending
       at i with XOR equal to m. We add count of
       all such subarrays to result. 
   (B) If xorArr[i] is equal to m, increment ans by 1.
   (C) Increment count of elements having XOR-sum 
       xorArr[i] in map by 1.
5) Return ans.
C++
Java
Python3
C#
Javascript
// C++ Program to count all subarrays having// XOR of elements as given value m with// O(n) time complexity.#include <bits/stdc++.h>using namespace std; // Returns count of subarrays of arr with XOR// value equals to mlong long subarrayXor(int arr[], int n, int m){    long long ans = 0; // Initialize answer to be returned     // Create a prefix xor-sum array such that    // xorArr[i] has value equal to XOR    // of all elements in arr[0 ..... i]    int* xorArr = new int[n];     // Create map that stores number of prefix array    // elements corresponding to a XOR value    unordered_map<int, int> mp;     // Initialize first element of prefix array    xorArr[0] = arr[0];     // Computing the prefix array.    for (int i = 1; i < n; i++)        xorArr[i] = xorArr[i - 1] ^ arr[i];     // Calculate the answer    for (int i = 0; i < n; i++) {               // Find XOR of current prefix with m.        int tmp = m ^ xorArr[i];         // If above XOR exists in map, then there        // is another previous prefix with same        // XOR, i.e., there is a subarray ending        // at i with XOR equal to m.        ans = ans + ((long long)mp[tmp]);         // If this subarray has XOR equal to m itself.        if (xorArr[i] == m)            ans++;         // Add the XOR of this subarray to the map        mp[xorArr[i]]++;    }     // Return total count of subarrays having XOR of    // elements as given value m    return ans;} // Driver program to test above functionint main(){    int arr[] = { 4, 2, 2, 6, 4 };    int n = sizeof(arr) / sizeof(arr[0]);    int m = 6;     cout << "Number of subarrays having given XOR is "         << subarrayXor(arr, n, m);    return 0;}
// Java Program to count all subarrays having// XOR of elements as given value m with// O(n) time complexity.import java.util.*; class GFG {     // Returns count of subarrays of arr with XOR    // value equals to m    static long subarrayXor(int arr[], int n, int m)    {        long ans = 0; // Initialize answer to be returned         // Create a prefix xor-sum array such that        // xorArr[i] has value equal to XOR        // of all elements in arr[0 ..... i]        int[] xorArr = new int[n];         // Create map that stores number of prefix array        // elements corresponding to a XOR value        HashMap<Integer, Integer> mp            = new HashMap<Integer, Integer>();         // Initialize first element of prefix array        xorArr[0] = arr[0];         // Computing the prefix array.        for (int i = 1; i < n; i++)            xorArr[i] = xorArr[i - 1] ^ arr[i];         // Calculate the answer        for (int i = 0; i < n; i++) {            // Find XOR of current prefix with m.            int tmp = m ^ xorArr[i];             // If above XOR exists in map, then there            // is another previous prefix with same            // XOR, i.e., there is a subarray ending            // at i with XOR equal to m.            ans = ans                  + (mp.containsKey(tmp) == false                         ? 0                         : ((long)mp.get(tmp)));             // If this subarray has XOR equal to m itself.            if (xorArr[i] == m)                ans++;             // Add the XOR of this subarray to the map            if (mp.containsKey(xorArr[i]))                mp.put(xorArr[i], mp.get(xorArr[i]) + 1);            else                mp.put(xorArr[i], 1);        }         // Return total count of subarrays having XOR of        // elements as given value m        return ans;    }     // Driver code    public static void main(String[] args)    {        int arr[] = { 4, 2, 2, 6, 4 };        int n = arr.length;        int m = 6;         System.out.print(            "Number of subarrays having given XOR is "            + subarrayXor(arr, n, m));    }} // This code is contributed by PrinciRaj1992
# Python3 Program to count all subarrays# having XOR of elements as given value m# with O(n) time complexity. # Returns count of subarrays of arr# with XOR value equals to mdef subarrayXor(arr, n, m):     ans = 0 # Initialize answer to be returned     # Create a prefix xor-sum array such that    # xorArr[i] has value equal to XOR    # of all elements in arr[0 ..... i]    xorArr =[0 for _ in range(n)]     # Create map that stores number of prefix array    # elements corresponding to a XOR value    mp = dict()     # Initialize first element    # of prefix array    xorArr[0] = arr[0]     # Computing the prefix array.    for i in range(1, n):        xorArr[i] = xorArr[i - 1] ^ arr[i]     # Calculate the answer    for i in range(n):                 # Find XOR of current prefix with m.        tmp = m ^ xorArr[i]         # If above XOR exists in map, then there        # is another previous prefix with same        # XOR, i.e., there is a subarray ending        # at i with XOR equal to m.        if tmp in mp.keys():            ans = ans + (mp[tmp])         # If this subarray has XOR        # equal to m itself.        if (xorArr[i] == m):            ans += 1         # Add the XOR of this subarray to the map        mp[xorArr[i]] = mp.get(xorArr[i], 0) + 1     # Return total count of subarrays having    # XOR of elements as given value m    return ans # Driver Codearr = [4, 2, 2, 6, 4]n = len(arr)m = 6 print("Number of subarrays having given XOR is",                        subarrayXor(arr, n, m)) # This code is contributed by mohit kumar
// C# Program to count all subarrays having// XOR of elements as given value m with// O(n) time complexity.using System;using System.Collections.Generic; class GFG {     // Returns count of subarrays of arr with XOR    // value equals to m    static long subarrayXor(int[] arr, int n, int m)    {        long ans = 0; // Initialize answer to be returned         // Create a prefix xor-sum array such that        // xorArr[i] has value equal to XOR        // of all elements in arr[0 ..... i]        int[] xorArr = new int[n];         // Create map that stores number of prefix array        // elements corresponding to a XOR value        Dictionary<int, int> mp            = new Dictionary<int, int>();         // Initialize first element of prefix array        xorArr[0] = arr[0];         // Computing the prefix array.        for (int i = 1; i < n; i++)            xorArr[i] = xorArr[i - 1] ^ arr[i];         // Calculate the answer        for (int i = 0; i < n; i++) {            // Find XOR of current prefix with m.            int tmp = m ^ xorArr[i];             // If above XOR exists in map, then there            // is another previous prefix with same            // XOR, i.e., there is a subarray ending            // at i with XOR equal to m.            ans = ans                  + (mp.ContainsKey(tmp) == false                         ? 0                         : ((long)mp[tmp]));             // If this subarray has XOR equal to m itself.            if (xorArr[i] == m)                ans++;             // Add the XOR of this subarray to the map            if (mp.ContainsKey(xorArr[i]))                mp[xorArr[i]] = mp[xorArr[i]] + 1;            else                mp.Add(xorArr[i], 1);        }         // Return total count of subarrays having XOR of        // elements as given value m        return ans;    }     // Driver code    public static void Main(String[] args)    {        int[] arr = { 4, 2, 2, 6, 4 };        int n = arr.Length;        int m = 6;         Console.Write(            "Number of subarrays having given XOR is "            + subarrayXor(arr, n, m));    }} // This code is contributed by Rajput-Ji
<script>// Javascript Program to count all subarrays having// XOR of elements as given value m with// O(n) time complexity.         // Returns count of subarrays of arr with XOR    // value equals to m    function subarrayXor(aee,n,m)    {        let ans = 0; // Initialize answer to be returned          // Create a prefix xor-sum array such that        // xorArr[i] has value equal to XOR        // of all elements in arr[0 ..... i]        let xorArr = new Array(n);          // Create map that stores number of prefix array        // elements corresponding to a XOR value        let mp = new Map();          // Initialize first element of prefix array        xorArr[0] = arr[0];          // Computing the prefix array.        for (let i = 1; i < n; i++)            xorArr[i] = xorArr[i - 1] ^ arr[i];          // Calculate the answer        for (let i = 0; i < n; i++) {            // Find XOR of current prefix with m.            let tmp = m ^ xorArr[i];              // If above XOR exists in map, then there            // is another previous prefix with same            // XOR, i.e., there is a subarray ending            // at i with XOR equal to m.            ans = ans                  + (mp.has(tmp) == false                         ? 0                         : (mp.get(tmp)));              // If this subarray has XOR equal to m itself.            if (xorArr[i] == m)                ans++;              // Add the XOR of this subarray to the map            if (mp.has(xorArr[i]))                mp.set(xorArr[i], mp.get(xorArr[i]) + 1);            else                mp.set(xorArr[i], 1);        }          // Return total count of subarrays having XOR of        // elements as given value m        return ans;    }          // Driver code    let arr=[4, 2, 2, 6, 4];         let n = arr.length;    let m = 6;    document.write("Number of subarrays having given XOR is "            + subarrayXor(arr, n, m));     // This code is contributed by unknown2108</script>
Output: 
Number of subarrays having given XOR is 4
Time Complexity: O(n) Alternate Approach: Using Python Dictionary to store Prefix XOR
Python3
from collections import defaultdictdef subarrayXor(arr, n, m):    HashTable=defaultdict(bool)    HashTable[0]=1    count=0    curSum=0    for i in arr:        curSum^=i        if HashTable[curSum^m]:            count+=HashTable[curSum^m]        HashTable[curSum]+=1    return(count)          # Driver program to test above functiondef main():    arr = [ 5, 6, 7, 8, 9 ]    n = len(arr)    m = 5     print("Number of subarrays having given XOR is "        , subarrayXor(arr, n, m)) if __name__ == '__main__':    main()      # This code is contributed by mrmechanical26052000
Output:
Number of subarrays having given XOR is 4
Time Complexity: O(n)
Space Complexity: O(n)
This article is contributed by Anmol Ratnam. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Sam007
vt_m
29AjayKumar
mohit kumar 29
princiraj1992
Rajput-Ji
mrmechanical26052000
vibalijoshi
rishavmahato348
unknown2108
simmytarika5
Bitwise-XOR
Arrays
Hash
Arrays
Hash
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Multidimensional Arrays in Java
Introduction to Arrays
Python | Using 2D arrays/lists the right way
Linked List vs Array
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Hashing | Set 3 (Open Addressing)
Count pairs with given sum