Count subarrays with equal number of occurrences of two given elements
Last Updated :
05 Jan, 2023
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 the 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).
We can simply generate all the possible sub-arrays and check for each subarray whether the number of occurrences of x is equal to that of y in that particular subarray.
Implementation:
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 <bits/stdc++.h>
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[0]);
int x = 2, y = 3;
cout << sameOccurrence(arr, n, x, y);
return (0);
}
/* 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
# 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# 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
// PHP program to count number of sub-arrays
// in which number of occurrence of x is equal
// to that of y using brute force
function sameOccurrence($arr, $n, $x, $y)
{
$result = 0;
// Check for each subarray for the
// required condition
for ($i = 0; $i <= $n - 1; $i++)
{
$ctX = 0; $ctY = 0;
for ( $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
$arr = array( 1, 2, 2, 3, 4, 1 );
$n = count($arr);
$x = 2; $y = 3;
echo sameOccurrence($arr, $n, $x, $y);
// This code is contributed by 29AjayKumar
?>
<script>
// Javascript program to count number
// of sub-arrays in which number of
// occurrence of x is equal to that of y
// using brute force
function sameOccurrence(arr, n, x, y)
{
let result = 0;
// Check for each subarray for the
// required condition
for(let i = 0; i <= n - 1; i++)
{
let ctX = 0, ctY = 0;
for(let 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
let arr = [ 1, 2, 2, 3, 4, 1 ];
let n = arr.length;
let x = 2, y = 3;
document.write(sameOccurrence(arr, n, x, y));
// This code is contributed by avanitrachhadiya2155
</script>
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 the 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 the array. Now, store the count of each element of array diff in a map, say m. Initialize result as m[0] since the occurrence of 0 in diff array gives us subarray count where the required condition is followed.
Now, iterate through the map and using handshake formula, update the result, since two same values in diff array indicate that the subarray contains the 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[0] = 1, m[1] = 4, m[2] = 1;
Initialize result as m[0]
i.e result = m[0] = 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.
Implementation:
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 <bits/stdc++.h>
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[0];
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[0]);
int x = 2, y = 3;
cout << sameOccurrence(arr, n, x, y);
return (0);
}
/* 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<Integer,Integer> 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<Integer,Integer> 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 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# 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[0];
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
<script>
/* Javascript 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 */
function sameOccurrence(arr,n,x,y)
{
let countX = new Array(n);
let countY = new Array(n);
let m = new Map();
// To store counts of same diff
// Count occurrences of x and y
for (let 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.has(countX[i] - countY[i]))
{
m.set(countX[i] - countY[i], m.get(countX[i] - countY[i])+1);
}
else
{
m.set(countX[i] - countY[i], 1);
}
}
// Traverse map and commute result.
let result = m.get(0);
for (let [key, value] of m.entries())
result = result + (value) * ((value) - 1) / 2;
return (result);
}
// Driver code
let arr=[1, 2, 2, 3, 4, 1];
let n = arr.length;
let x = 2, y = 3;
document.write(sameOccurrence(arr, n, x, y));
// This code is contributed by rag2127
</script>
Time Complexity - O(N)
Auxiliary Space - O(N)
Similar Reads
Count subarrays with equal count of occurrences of given three numbers
Given an array arr[] and three integers X, Y, Z, the task is to find the number of subarrays from the array in which the number of occurrences of X, Y and Z are equal. Examples: Input: arr[] = {3, 6, 7, 8, 3, 6, 7}, X = 3, Y = 6, Z = 7Output: 8Explanationn: There are 8 such subarrays i.e. {3, 6, 7},
9 min read
Count occurrences of the average of array elements with a given number
Given an array of N integers and an integer x . For every integer of the array a[i], the task is to calculate the count of numbers in the array with value equals to the average of element a[i] and x. That is, the number of occurrences of the (average of element a[i] and x) in the array. Examples: In
7 min read
Count of subarrays of size K with elements having even frequencies
Given an array arr[] and an integer K, the task is to count subarrays of size K in which every element appears an even number of times in the subarray. Examples: Input: arr[] = {1, 4, 2, 10, 2, 10, 0, 20}, K = 4 Output: 1 Explanation: Only subarray {2, 10, 2, 10} satisfies the required condition. In
9 min read
Count subarrays having exactly K elements occurring at least twice
Given an array arr[] consisting of N integers and a positive integer K, the task is to count the number of subarrays having exactly K elements occurring at least twice. Examples: Input: arr[] = {1, 1, 1, 2, 2}, K = 1Output: 7Explanation: The subarrays having exactly 1 element occurring at least twic
11 min read
Count of elements which is the sum of a subarray of the given Array
Given an array arr[], the task is to count elements in an array such that there exists a subarray whose sum is equal to this element.Note: Length of subarray must be greater than 1. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 Explanation: There are 4 such elements in array - arr[2] = 3
7 min read
Total count of elements having frequency one in each Subarray
Given an array arr[] of length N, the task is to find the total number of elements that has frequency 1 in a subarray of the given array. Examples: Input: N = 3, arr[ ] = {2, 4, 2}Output: 8Explanation: All possible subarrays are {2}: elements with frequency one = 1.{4}: elements with frequency one =
13 min read
Count non-overlapping Subarrays of size K with equal alternate elements
Given an array arr[] of length N, the task is to find the count of non-overlapping subarrays of size K such that the alternate elements are equal. Examples: Input: arr[] = {2, 4, 2, 7}, K = 3Output: 1Explanation: Given subarray {2, 4, 2} is a valid array because the elements in even position(index n
7 min read
Count of subarrays which contains a given number exactly K times
Given an array A[] of N elements consisting of values from 1 to N with duplicates, the task is to find the total number of subarrays that contain a given number num exactly K times. Examples: Input: A[] = {1, 2, 1, 5, 1}, num = 1, K = 2 Output: 2 Explanation: Subarrays {1, 2, 1, 5}, {1, 2, 1}, {2, 1
8 min read
Count subarrays with equal number of 1's and 0's
Given an array arr[] of size n containing 0 and 1 only. The problem is to count the subarrays having an equal number of 0's and 1's. Examples: Input: arr[] = {1, 0, 0, 1, 0, 1, 1}Output: 8Explanation: The index range for the 8 sub-arrays are: (0, 1), (2, 3), (0, 3), (3, 4), (4, 5)(2, 5), (0, 5), (1,
14 min read
Count subarrays with same even and odd elements
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
15+ min read