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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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
?>

chevron_right



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[0], 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[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.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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

chevron_right


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.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


Be the First to upvote.


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