# Count subarrays with equal number of occurrences of two given elements

Given an array and two integers say, x and y, find the number of subarrays in which the number of occurrences of x is equal to number of occurrences of y.

Examples:

```Input : arr[] = {1, 2, 1},
x = 1, y = 2
Output : 2
The possible sub-arrays have same equal number
of occurrences of x and y are:
1) {1, 2}, x and y have same occurrence(1).
2) {2, 1}, x and y have same occurrence(1).

Input : arr[] = {1, 2, 1},
x = 4, y = 6
Output : 6
The possible sub-arrays have same equal number of
occurrences of x and y are:
1) {1}, x and y have same occurrence(0).
2) {2}, x and y have same occurrence(0).
3) {1}, x and y have same occurrence(0).
1) {1, 2}, x and y have same occurrence(0).
2) {2, 1}, x and y have same occurrence(0).
3) {1, 2, 1}, x and y have same occurrence(0).

Input : arr[] = {1, 2, 1},
x = 1, y = 1
Output : 6
The possible sub-arrays have same equal number
of occurrences of x and y are:
1) {1}, x and y have same occurrence(1).
2) {2}, x and y have same occurrence(0).
3) {1}, x and y have same occurrence(1).
1) {1, 2}, x and y have same occurrence(1).
2) {2, 1}, x and y have same occurrence(1).
3) {1, 2, 1}, x and y have same occurrences (2).
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Brute Force Approach (Time Complexity – O(N2)):

We can simply generate all the possible sub-arrays and check for each subarray whether the number of occurrence of x is equal to that of y in that particular subarray.

## C++

 `/* C++ program to count number of sub-arrays in which  ` `   ``number of occurrence of x is equal to that of y ` `    ``using brute force */` `#include ` `using` `namespace` `std; ` ` `  `int` `sameOccurrence(``int` `arr[], ``int` `n, ``int` `x, ``int` `y) ` `{ ` `    ``int` `result = 0; ` ` `  `    ``// Check for each subarray for the required condition ` `    ``for` `(``int` `i = 0; i <= n - 1; i++) { ` `        ``int` `ctX = 0,  ctY = 0; ` `        ``for` `(``int` `j = i; j <= n - 1; j++) { ` `            ``if` `(arr[j] == x)  ` `                ``ctX += 1; ` `            ``else` `if` `(arr[j] == y)  ` `                ``ctY += 1; ` `            ``if` `(ctX == ctY)  ` `                ``result += 1;             ` `        ``} ` `    ``} ` ` `  `    ``return` `(result); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 2, 3, 4, 1 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `x = 2, y = 3; ` `    ``cout << sameOccurrence(arr, n, x, y); ` `    ``return` `(0); ` `} `

## Java

 `/* Java program to count number of sub-arrays in which  ` `number of occurrence of x is equal to that of y ` `    ``using brute force */` `import` `java.util.*; ` ` `  `class` `solution ` `{ ` ` `  `static` `int` `sameOccurrence(``int` `arr[], ``int` `n, ``int` `x, ``int` `y) ` `{ ` `    ``int` `result = ``0``; ` ` `  `    ``// Check for each subarray for the required condition ` `    ``for` `(``int` `i = ``0``; i <= n - ``1``; i++) { ` `        ``int` `ctX = ``0``, ctY = ``0``; ` `        ``for` `(``int` `j = i; j <= n - ``1``; j++) { ` `            ``if` `(arr[j] == x)  ` `                ``ctX += ``1``; ` `            ``else` `if` `(arr[j] == y)  ` `                ``ctY += ``1``; ` `            ``if` `(ctX == ctY)  ` `                ``result += ``1``;          ` `        ``} ` `    ``} ` ` `  `    ``return` `(result); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = { ``1``, ``2``, ``2``, ``3``, ``4``, ``1` `}; ` `    ``int` `n = arr.length; ` `    ``int` `x = ``2``, y = ``3``; ` `    ``System.out.println(sameOccurrence(arr, n, x, y)); ` ` `  `} ` `} ` ` `  `// This code is contributed by ` `// Sahil_shelangia `

## Python3

 `# Python 3 program to count number of  ` `# sub-arrays in which number of occurrence  ` `# of x is equal to that of y using brute force  ` `def` `sameOccurrence(arr, n, x, y): ` `    ``result ``=` `0` ` `  `    ``# Check for each subarray for  ` `    ``# the required condition ` `    ``for` `i ``in` `range``(n): ` `        ``ctX ``=` `0` `        ``ctY ``=` `0` `        ``for` `j ``in` `range``(i, n, ``1``): ` `            ``if` `(arr[j] ``=``=` `x): ` `                ``ctX ``+``=` `1``; ` `            ``elif` `(arr[j] ``=``=` `y): ` `                ``ctY ``+``=` `1` `            ``if` `(ctX ``=``=` `ctY): ` `                ``result ``+``=` `1` ` `  `    ``return` `(result) ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``1``, ``2``, ``2``, ``3``, ``4``, ``1``] ` `    ``n ``=` `len``(arr) ` `    ``x ``=` `2` `    ``y ``=` `3` `    ``print``(sameOccurrence(arr, n, x, y)) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `/* C# program to count number of sub-arrays in which  ` `number of occurrence of x is equal to that of y ` `using brute force */` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `static` `int` `sameOccurrence(``int``[] arr, ``int` `n,  ` `                            ``int` `x, ``int` `y) ` `{ ` `    ``int` `result = 0; ` ` `  `    ``// Check for each subarray for  ` `    ``// the required condition ` `    ``for` `(``int` `i = 0; i <= n - 1; i++) ` `    ``{ ` `        ``int` `ctX = 0, ctY = 0; ` `        ``for` `(``int` `j = i; j <= n - 1; j++)  ` `        ``{ ` `            ``if` `(arr[j] == x)  ` `                ``ctX += 1; ` `            ``else` `if` `(arr[j] == y)  ` `                ``ctY += 1; ` `            ``if` `(ctX == ctY)  ` `                ``result += 1;          ` `        ``} ` `    ``} ` `    ``return` `(result); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int``[] arr = { 1, 2, 2, 3, 4, 1 }; ` `    ``int` `n = arr.Length; ` `    ``int` `x = 2, y = 3; ` `    ``Console.Write(sameOccurrence(arr, n, x, y)); ` ` `  `} ` `} ` ` `  `// This code is contributed by Ita_c. `

## PHP

 ` `

Output:

```7
```

Time Complexity – O(N^2)
Auxiliary Space – O(1)

Efficient Approach (O(N) Time Complexity) :

In this solution, auxiliary space is O(N) and the time complexity is also O(N). We create two arrays say, countX[] and countY[], which denotes number of occurrences of x and y, respectively, till that point in the array. Then, we evaluate another array, say diff which stores (countX[i]-countY[i]), i be the index of array. Now, store the count of each element of array diff in a map, say m. Initialize result as m, since occurrence of 0 in diff array gives us subarray count where required condition is followed. Now, iterate through map and using handshake formula, update the result, since two same values in diff array indicate that the subarray contains same number of occurrences of x and y.

```Explanation:
arr[] = {1, 2, 2, 3, 4, 1};
x = 2, y = 3;

Two arrays countX[] and countY[] are be evaluated as-
countX[] = {0, 1, 2, 2, 2, 2};
countY[] = {0, 0, 0, 1, 1, 1};

Hence, diff[] = {0, 1, 2, 1, 1, 1};
(diff[i] = countX[i]-countY[i], i be the index of array)

Now, create a map and store the count of each element of diff in it,
so, finally, we get-
m = 1, m = 4, m = 1;

Initialize result as m
i.e result = m = 1

Further, using handshake formula, updating the
result as follows-
result  = result + (1*(1-1))/2 = 1 + 0 = 1
result  = result + (4*(4-1))/2 = 1 + 6 = 7
result  = result + (1*(1-1))/2 = 7 + 0 = 7

so, the final result will be 7, required subarrays having
same number of occurrences of x and y.

```

## C++

 `/* C++ program to count number of sub-arrays in which  ` `  ``number of occurrence of x is equal to that of y using ` `  ``efficient approach in terms of time */` `#include ` `using` `namespace` `std; ` ` `  `int` `sameOccurrence(``int` `arr[], ``int` `n, ``int` `x, ``int` `y) ` `{ ` `    ``int` `countX[n], countY[n]; ` ` `  `    ``map<``int``, ``int``> m; ``// To store counts of same diffs ` ` `  `    ``// Count occurrences of x and y ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``if` `(arr[i] == x) { ` `            ``if` `(i != 0) ` `                ``countX[i] = countX[i - 1] + 1; ` `            ``else` `                ``countX[i] = 1; ` `        ``} ``else` `{ ` `            ``if` `(i != 0) ` `                ``countX[i] = countX[i - 1]; ` `            ``else` `                ``countX[i] = 0; ` `        ``} ` `        ``if` `(arr[i] == y) { ` `            ``if` `(i != 0) ` `                ``countY[i] = countY[i - 1] + 1; ` `            ``else` `                ``countY[i] = 1; ` `        ``} ``else` `{ ` `            ``if` `(i != 0) ` `                ``countY[i] = countY[i - 1]; ` `            ``else` `                ``countY[i] = 0; ` `        ``} ` `   `  `         ``// Increment count of current ` `         ``m[countX[i] - countY[i]]++; ` `    ``} ` ` `  `    ``// Traverse map and commute result.  ` `    ``int` `result = m; ` `    ``for` `(``auto` `it = m.begin(); it != m.end(); it++)  ` `        ``result = result + ((it->second) * ((it->second) - 1)) / 2; ` `     `  `    ``return` `(result); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 2, 3, 4, 1 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `x = 2, y = 3; ` `    ``cout << sameOccurrence(arr, n, x, y); ` `    ``return` `(0); ` `} `

## Java

 `/* Java program to count number of sub-arrays in which  ` `number of occurrence of x is equal to that of y using ` `efficient approach in terms of time */` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `static` `int` `sameOccurrence(``int` `arr[], ``int` `n, ``int` `x, ``int` `y) ` `{ ` `    ``int` `[]countX = ``new` `int``[n]; ` `    ``int` `[]countY = ``new` `int``[n]; ` ` `  `    ``Map m = ``new` `HashMap<>();  ` `     `  `    ``// To store counts of same diff ` `    ``// Count occurrences of x and y ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``if` `(arr[i] == x)  ` `        ``{ ` `            ``if` `(i != ``0``) ` `                ``countX[i] = countX[i - ``1``] + ``1``; ` `            ``else` `                ``countX[i] = ``1``; ` `        ``}  ` `        ``else` `        ``{ ` `            ``if` `(i != ``0``) ` `                ``countX[i] = countX[i - ``1``]; ` `            ``else` `                ``countX[i] = ``0``; ` `        ``} ` `        ``if` `(arr[i] == y) ` `        ``{ ` `            ``if` `(i != ``0``) ` `                ``countY[i] = countY[i - ``1``] + ``1``; ` `            ``else` `                ``countY[i] = ``1``; ` `        ``}  ` `        ``else`  `        ``{ ` `            ``if` `(i != ``0``) ` `                ``countY[i] = countY[i - ``1``]; ` `            ``else` `                ``countY[i] = ``0``; ` `        ``} ` `     `  `        ``// Increment count of current ` `        ``if``(m.containsKey(countX[i] - countY[i])) ` `        ``{ ` `            ``m.put(countX[i] - countY[i], m.get(countX[i] - countY[i])+``1``); ` `        ``} ` `        ``else` `        ``{ ` `            ``m.put(countX[i] - countY[i], ``1``); ` `        ``} ` `    ``} ` ` `  `    ``// Traverse map and commute result.  ` `    ``int` `result = m.get(``0``); ` `    ``for` `(Map.Entry it : m.entrySet())  ` `        ``result = result + ((it.getValue()) * ((it.getValue()) - ``1``)) / ``2``; ` `     `  `    ``return` `(result); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `arr[] = { ``1``, ``2``, ``2``, ``3``, ``4``, ``1` `}; ` `    ``int` `n = arr.length; ` `    ``int` `x = ``2``, y = ``3``; ` `    ``System.out.println(sameOccurrence(arr, n, x, y)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 program to count number of  ` `# sub-arrays in which number of occurrence  ` `# of x is equal to that of y using efficient  ` `# approach in terms of time */ ` `def` `sameOccurrence( arr, n, x, y): ` ` `  `    ``countX ``=` `[``0` `for` `i ``in` `range``(n)] ` `    ``countY ``=` `[``0` `for` `i ``in` `range``(n)] ` ` `  `    ``# To store counts of same diffs ` `    ``m ``=` `dict``()  ` ` `  `    ``# Count occurrences of x and y ` `    ``for` `i ``in` `range``(n): ` `        ``if` `(arr[i] ``=``=` `x): ` `            ``if` `(i !``=` `0``): ` `                ``countX[i] ``=` `countX[i ``-` `1``] ``+` `1` `            ``else``: ` `                ``countX[i] ``=` `1` `        ``else``: ` `            ``if` `(i !``=` `0``): ` `                ``countX[i] ``=` `countX[i ``-` `1``] ` `            ``else``: ` `                ``countX[i] ``=` `0` ` `  `        ``if` `(arr[i] ``=``=` `y): ` `            ``if` `(i !``=` `0``): ` `                ``countY[i] ``=` `countY[i ``-` `1``] ``+` `1` `            ``else``: ` `                ``countY[i] ``=` `1` `        ``else``: ` `            ``if` `(i !``=` `0``): ` `                ``countY[i] ``=` `countY[i ``-` `1``] ` `            ``else``: ` `                ``countY[i] ``=` `0` `         `  `        ``# Increment count of current ` `        ``m[countX[i] ``-` `countY[i]] ``=` `m.get(countX[i] ``-`  `                                         ``countY[i], ``0``) ``+` `1` `     `  `    ``# Traverse map and commute result.  ` `    ``result ``=` `m[``0``] ` `    ``for` `j ``in` `m: ` `        ``result ``+``=` `(m[j] ``*` `(m[j] ``-` `1``)) ``/``/` `2` `     `  `    ``return` `result ` ` `  `# Driver code ` `arr ``=` `[``1``, ``2``, ``2``, ``3``, ``4``, ``1``] ` `n ``=` `len``(arr) ` `x, y ``=` `2``, ``3` `print``(sameOccurrence(arr, n, x, y)) ` `  `  `# This code is contributed ` `# by mohit kumar `

## C#

 `/* C# program to count number of sub-arrays in which  ` `number of occurrence of x is equal to that of y using ` `efficient approach in terms of time */` `using` `System;  ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG ` `{ ` ` `  `static` `int` `sameOccurrence(``int` `[]arr, ``int` `n, ``int` `x, ``int` `y) ` `{ ` `    ``int` `[]countX = ``new` `int``[n]; ` `    ``int` `[]countY = ``new` `int``[n]; ` ` `  `    ``Dictionary<``int``,``int``> m = ``new` `Dictionary<``int``,``int``>(); ` `     `  `    ``// To store counts of same diff ` `    ``// Count occurrences of x and y ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``if` `(arr[i] == x)  ` `        ``{ ` `            ``if` `(i != 0) ` `                ``countX[i] = countX[i - 1] + 1; ` `            ``else` `                ``countX[i] = 1; ` `        ``}  ` `        ``else` `        ``{ ` `            ``if` `(i != 0) ` `                ``countX[i] = countX[i - 1]; ` `            ``else` `                ``countX[i] = 0; ` `        ``} ` `        ``if` `(arr[i] == y) ` `        ``{ ` `            ``if` `(i != 0) ` `                ``countY[i] = countY[i - 1] + 1; ` `            ``else` `                ``countY[i] = 1; ` `        ``}  ` `        ``else` `        ``{ ` `            ``if` `(i != 0) ` `                ``countY[i] = countY[i - 1]; ` `            ``else` `                ``countY[i] = 0; ` `        ``} ` `     `  `        ``// Increment count of current ` `        ``if``(m.ContainsKey(countX[i] - countY[i])) ` `        ``{ ` `            ``var` `v = m[countX[i] - countY[i]]+1; ` `            ``m.Remove(countX[i] - countY[i]); ` `            ``m.Add(countX[i] - countY[i], v); ` `        ``} ` `        ``else` `        ``{ ` `            ``m.Add(countX[i] - countY[i], 1); ` `        ``} ` `    ``} ` ` `  `    ``// Traverse map and commute result.  ` `    ``int` `result = m; ` `    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `m)  ` `        ``result = result + ((it.Value) * ((it.Value) - 1)) / 2; ` `     `  `    ``return` `(result); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[]arr = { 1, 2, 2, 3, 4, 1 }; ` `    ``int` `n = arr.Length; ` `    ``int` `x = 2, y = 3; ` `    ``Console.WriteLine(sameOccurrence(arr, n, x, y)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```7
```

Time Complexity – O(N)
Auxiliary Space – O(N)

This article is contributed by Divyanshu_Gupta. 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.