Count subarrays having odd Bitwise XOR

• Last Updated : 03 Jun, 2021

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}.

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 XORvoid 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 Codeint main(){    // Given array    int arr[] = { 1, 4, 7, 9, 10 };     // Stores the size of the array    int N = sizeof(arr) / sizeof(arr);     oddXorSubarray(arr, N);     return 0;}

Java

 // Java program for the above approachimport java.io.*;class GFG{        // Function to count the number of subarrays// of the given array having odd Bitwise XORstatic 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 Codepublic 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 XORdef 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 Codeif __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 approachusing System; class GFG{        // Function to count the number of subarrays// of the given array having odd Bitwise XORstatic 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 Codepublic 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