GeeksforGeeks App
Open App
Browser
Continue

Count subarrays having odd Bitwise XOR

Given an array arr[] of size N, the task is to count the number of subarrays from the given array having odd Bitwise XOR value.

Examples:

Input: arr[] = {1, 4, 7, 9, 10}
Output: 8
Explanation: The subarrays having odd Bitwise XOR are {1}, {1, 4}, {1, 4, 7, 9}, {1, 4, 7, 9, 10}, {7}, {9}, {4, 7}, {9, 10}.

Input: arr[] ={1, 5, 6}
Output: 3
Explanation: The subarrays having odd Bitwise XOR are {1}, {1, 5}, {1, 5, 6}.

Brute Force Approach:

A brute force approach to solve this problem would be to generate all possible subarrays of the given array and check if the Bitwise XOR of that subarray is odd or not. If it is odd, then increment the count of the number of subarrays having odd Bitwise XOR.

Algorithm

1. Initialize a variable “count” to 0 to keep track of the number of subarrays with an odd XOR.
2. Loop through all possible subarrays using two nested loops.
3. For each subarray, initialize a variable “xor_val” to 0
4. Loop through the elements of the subarray using a third loop.
5. For each element, XOR it with the current value of “xor_val”.
6. Check if the XOR value of all the elements in the subarray is odd or not. If it is odd, increment the “count” variable.
7. After the nested loops are complete, print the value of “count” to get the number of subarrays with an odd XOR.

Below is the implementation of the above approach:

C++

 `#include ``using` `namespace` `std;` `void` `oddXorSubarray(``int` `a[], ``int` `n)``{``    ``int` `count = 0;``    ``for``(``int` `i=0;i

Java

 `import` `java.util.*;` `public` `class` `Main {` `  ``public` `static` `void` `oddXorSubarray(``int``[] a, ``int` `n) {``    ``int` `count = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++) {``      ``for` `(``int` `j = i; j < n; j++) {``        ``int` `xor_val = ``0``;``        ``for` `(``int` `k = i; k <= j; k++) {``          ``xor_val ^= a[k];``        ``}``        ``if` `(xor_val % ``2` `!= ``0``) {``          ``count++;``        ``}``      ``}``    ``}``    ``System.out.println(count);``  ``}` `  ``public` `static` `void` `main(String[] args) {``    ``int``[] arr = {``1``, ``4``, ``7``, ``9``, ``10``};``    ``int` `N = arr.length;``    ``oddXorSubarray(arr, N);``  ``}``}`

Python3

 `def` `oddXorSubarray(a, n):``    ``count ``=` `0``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i, n):``            ``xor_val ``=` `0``            ``for` `k ``in` `range``(i, j``+``1``):``                ``xor_val ^``=` `a[k]``            ``if` `xor_val ``%` `2` `!``=` `0``:``                ``count ``+``=` `1``    ``print``(count)` `arr ``=` `[``1``, ``4``, ``7``, ``9``, ``10``]``N ``=` `len``(arr)``oddXorSubarray(arr, N)`

C#

 `using` `System;` `class` `Program {``  ` `    ``// Driver Code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 1, 4, 7, 9, 10 };``        ``int` `N = arr.Length;``        ``oddXorSubarray(arr, N);``    ``}` `    ``// Function to find the odd XOR subarray``    ``static` `void` `oddXorSubarray(``int``[] a, ``int` `n)``    ``{``        ``int` `count = 0;` `        ``// Loop through all possible subarrays``        ``for` `(``int` `i = 0; i < n; i++) {``            ``for` `(``int` `j = i; j < n; j++) {``                ``int` `xor_val = 0;` `                ``// Compute XOR of all elements``                ``// in the subarray``                ``for` `(``int` `k = i; k <= j; k++) {``                    ``xor_val ^= a[k];``                ``}` `                ``// If XOR value is odd, then``                ``// increment the value of count``                ``if` `(xor_val % 2 != 0) {``                    ``count++;``                ``}``            ``}``        ``}` `        ``Console.WriteLine(count);``    ``}``}`

Output

`8`

Time Complexity: O(N3)
Space Complexity: O(1)

Naive Approach: The simplest approach to solve this problem is to check for every subarray whether its Bitwise XOR is odd or not. If found to be odd, then increase the count. Finally, print the count as the result.

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

Efficient Approach: To optimize the above approach, the idea is based on the observation that the Bitwise XOR of the subarray is odd only if the number of odd elements in that subarray is odd. To solve the problem, find the number of subarrays starting from the index 0 and satisfying the given conditions. Then, Traverse the array and update the number of subarrays starting at index i that satisfy the given condition. Follow the steps below to solve the problem:

• Initialize variables Odd, C_odd as 0, to store the number of odd numbers up to ith index and the number of required subarrays starting at ith index respectively.
• Traverse the array arr[] using the variable i and check for the following steps:
• Again, traverse the array arr[] using the variable i and perform the following:
• After completing the above steps, print the value of res as the result.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the number of subarrays``// of the given array having odd Bitwise XOR``void` `oddXorSubarray(``int` `a[], ``int` `n)``{``    ``// Stores number of odd``    ``// numbers upto i-th index``    ``int` `odd = 0;` `    ``// Stores number of required``    ``// subarrays starting from i-th index``    ``int` `c_odd = 0;` `    ``// Store the required result``    ``int` `result = 0;` `    ``// Find the number of subarrays having odd``    ``// Bitwise XOR values starting at 0-th index``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Check if current element is odd``        ``if` `(a[i] & 1) {``            ``odd = !odd;``        ``}` `        ``// If the current value of odd is not``        ``// zero, increment c_odd by 1``        ``if` `(odd) {``            ``c_odd++;``        ``}``    ``}` `    ``// Find the number of subarrays having odd``    ``// bitwise XOR value starting at ith index``    ``// and add to result``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Add c_odd to result``        ``result += c_odd;``        ``if` `(a[i] & 1) {``            ``c_odd = (n - i - c_odd);``        ``}``    ``}` `    ``// Print the result``    ``cout << result;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 1, 4, 7, 9, 10 };` `    ``// Stores the size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``oddXorSubarray(arr, N);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.io.*;``class` `GFG``{``       ` `// Function to count the number of subarrays``// of the given array having odd Bitwise XOR``static` `void` `oddXorSubarray(``int` `a[], ``int` `n)``{``  ` `    ``// Stores number of odd``    ``// numbers upto i-th index``    ``int` `odd = ``0``;` `    ``// Stores number of required``    ``// subarrays starting from i-th index``    ``int` `c_odd = ``0``;` `    ``// Store the required result``    ``int` `result = ``0``;` `    ``// Find the number of subarrays having odd``    ``// Bitwise XOR values starting at 0-th index``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Check if current element is odd``        ``if` `(a[i] % ``2` `!= ``0``)``        ``{``            ``odd = (odd == ``0``) ? ``1` `: ``0``;``        ``}` `        ``// If the current value of odd is not``        ``// zero, increment c_odd by 1``        ``if` `(odd != ``0``)``        ``{``            ``c_odd++;``        ``}``    ``}` `    ``// Find the number of subarrays having odd``    ``// bitwise XOR value starting at ith index``    ``// and add to result``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Add c_odd to result``        ``result += c_odd;``        ``if` `(a[i] % ``2` `!= ``0``)``        ``{``            ``c_odd = (n - i - c_odd);``        ``}``    ``}` `    ``// Print the result``    ``System.out.println(result);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `      ``// Given array``    ``int` `arr[] = { ``1``, ``4``, ``7``, ``9``, ``10` `};` `    ``// Stores the size of the array``    ``int` `N = arr.length;``    ``oddXorSubarray(arr, N);``}``}` `// This code is contributed by Dharanendra L V.`

Python3

 `# Python3 program for the above approach` `# Function to count the number of subarrays``# of the given array having odd Bitwise XOR``def` `oddXorSubarray(a, n):``  ` `    ``# Stores number of odd``    ``# numbers upto i-th index``    ``odd ``=` `0` `    ``# Stores number of required``    ``# subarrays starting from i-th index``    ``c_odd ``=` `0` `    ``# Store the required result``    ``result ``=` `0` `    ``# Find the number of subarrays having odd``    ``# Bitwise XOR values starting at 0-th index``    ``for` `i ``in` `range``(n):` `        ``# Check if current element is odd``        ``if` `(a[i] & ``1``):``            ``odd ``=` `not` `odd``        ` `        ``# If the current value of odd is not``        ``# zero, increment c_odd by 1``        ``if` `(odd):``            ``c_odd ``+``=` `1` `    ``# Find the number of subarrays having odd``    ``# bitwise XOR value starting at ith index``    ``# and add to result``    ``for` `i ``in` `range``(n):` `        ``# Add c_odd to result``        ``result ``+``=` `c_odd``        ``if` `(a[i] & ``1``):``            ``c_odd ``=` `(n ``-` `i ``-` `c_odd)` `    ``# Print the result``    ``print` `(result)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array``    ``arr ``=` `[``1``, ``4``, ``7``, ``9``, ``10``]` `    ``# Stores the size of the array``    ``N ``=` `len``(arr)``    ``oddXorSubarray(arr, N)` `    ``# This code is contributed by mohit kumar 29.`

C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``       ` `// Function to count the number of subarrays``// of the given array having odd Bitwise XOR``static` `void` `oddXorSubarray(``int` `[]a, ``int` `n)``{``    ` `    ``// Stores number of odd``    ``// numbers upto i-th index``    ``int` `odd = 0;` `    ``// Stores number of required``    ``// subarrays starting from i-th index``    ``int` `c_odd = 0;` `    ``// Store the required result``    ``int` `result = 0;` `    ``// Find the number of subarrays having``    ``// odd Bitwise XOR values starting at``    ``// 0-th index``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Check if current element is odd``        ``if` `(a[i] % 2 != 0)``        ``{``            ``odd = (odd == 0) ? 1 : 0;``        ``}` `        ``// If the current value of odd is not``        ``// zero, increment c_odd by 1``        ``if` `(odd != 0)``        ``{``            ``c_odd++;``        ``}``    ``}` `    ``// Find the number of subarrays having odd``    ``// bitwise XOR value starting at ith index``    ``// and add to result``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Add c_odd to result``        ``result += c_odd;``        ` `        ``if` `(a[i] % 2 != 0)``        ``{``            ``c_odd = (n - i - c_odd);``        ``}``    ``}` `    ``// Print the result``    ``Console.WriteLine(result);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 1, 4, 7, 9, 10 };` `    ``// Stores the size of the array``    ``int` `N = arr.Length;``    ``oddXorSubarray(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:

`8`

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

My Personal Notes arrow_drop_up