Given an array of N integers, count number of even-odd subarrays. An even – odd subarray is a subarray that contains the same number of even as well as odd integers.

**Examples :**

Input : arr[] = {2, 5, 7, 8} Output : 3 Explanation : There are total 3 even-odd subarrays. 1) {2, 5} 2) {7, 8} 3) {2, 5, 7, 8} Input : arr[] = {3, 4, 6, 8, 1, 10} Output : 3 Explanation : In this case, 3 even-odd subarrays are: 1) {3, 4} 2) {8, 1} 3) {1, 10}

This problem is mainly a variation of count subarrays with equal number of 0s and 1s.

A **naive approach** would be to check for all possible subarrays using two loops, whether they are even-odd subarrays or not. This approach will take time.

An **Efficient approach** solves the problem in O(N) time and it is based on following ideas:

- Even-odd subarrays will always be of even length.
- Maintaining track of the difference between the frequency of even and odd integers.
- Hashing of this difference of frequencies is useful in finding number of even-odd subarrays.

The basic idea is to use the difference between the frequency of odd and even numbers to obtain an optimal solution. We will maintain two integer hash arrays for the positive and negative value of the difference.

-> Example to understand in better way :

-> Consider difference = freq(odd) – freq(even)

-> To calculate this difference, increment the value of ‘difference’ when there is

an odd integer and decrement it when there is an even integer. (initially, difference = 0)

arr[] = {3, 4, 6, 8, 1, 10}

index 0 1 2 3 4 5 6

array 3 4 6 8 1 10

difference 0 1 0 -1 -2 -1 -2

-> Observe that whenever a value ‘k’ repeats in the ‘difference’ array, there exists an

even-odd subarray for each previous occurrence of that value i.e. subarray exists from

index i + 1 to j where difference[i] = k and difference[j] = k.

-> Value ‘0’ is repeated in ‘difference’ array at index 2 and hence subarray exists for

(0, 2] indexes. Similarly, for repetition of values ‘-1’ (at indexes 3 and 5) and ‘-2’ (at

indexes 4 and 6), subarray exists for (3, 5] and (4, 6] indexes.

Below is the **C++** implementation of the **O(N)** solution described above.

[sourcecode language=”CPP” highlight=”6-57″]

/*C++ program to find total number of

even-odd subarrays present in given array*/

#include <iostream>

using namespace std;

// function that returns the count of subarrays that

// contain equal number of odd as well as even numbers

int countSubarrays(int arr[], int n)

{

// initialize difference and answer with 0

int difference = 0;

int ans = 0;

// create two auxiliary hash arrays to count frequency

// of difference, one array for non-negative difference

// and other array for negative difference. Size of these

// two auxiliary arrays is ‘n+1’ because difference can

// reach maximum value ‘n’ as well as minimum value ‘-n’

int hash_positive[n + 1], hash_negative[n + 1];

// initialize these auxiliary arrays with 0

fill_n(hash_positive, n + 1, 0);

fill_n(hash_negative, n + 1, 0);

// since the difference is initially 0, we have to

// initialize hash_positive[0] with 1

hash_positive[0] = 1;

// for loop to iterate through whole

// array (zero-based indexing is used)

for (int i = 0; i < n ; i++)

{

// incrementing or decrementing difference based on

// arr[i] being even or odd, check if arr[i] is odd

if (arr[i] & 1 == 1)

difference++;

else

difference–;

// adding hash value of ‘difference’ to our answer

// as all the previous occurrences of the same

// difference value will make even-odd subarray

// ending at index ‘i’. After that, we will increment

// hash array for that ‘difference’ value for

// its occurrence at index ‘i’. if difference is

// negative then use hash_negative

if (difference < 0)

{

ans += hash_negative[-difference];

hash_negative[-difference]++;

}

// else use hash_positive

else

{

ans += hash_positive[difference];

hash_positive[difference]++;

}

}

// return total number of even-odd subarrays

return ans;

}

// Driver code

int main()

{

int arr[] = {3, 4, 6, 8, 1, 10, 5, 7};

int n = sizeof(arr) / sizeof(arr[0]);

// Printing total number of even-odd subarrays

cout << "Total Number of Even-Odd subarrays"

" are " << countSubarrays(arr,n);

return 0;

}

[/sourcecode]

**Output:**

Total Number of Even-Odd subarrays are 7

**Time Complexity : **O(N), where N is the number of integers.

**Auxiliary Space : **O(2N), where N is the number of integers.

## Recommended Posts:

- Count subarrays with all elements greater than K
- Count Subarrays with Consecutive elements differing by 1
- Count subarrays with equal number of occurrences of two given elements
- Count subarrays having total distinct elements same as original array
- Count subarrays with Prime sum
- Count the number of subarrays having a given XOR
- Subarrays with distinct elements
- Sum of minimum elements of all subarrays
- Count distinct Bitwise OR of all Subarrays
- Count subarrays with equal number of 1's and 0's
- Count Strictly Increasing Subarrays
- Count subarrays consisting of only 0's and only 1's in a binary array
- Find the count of Strictly decreasing Subarrays
- Count of subarrays whose maximum element is greater than k
- Sum of minimum and maximum elements of all subarrays of size k.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.