Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count pairs of equal array elements remaining after every removal

  • Last Updated : 17 May, 2021

Given an array arr[] of size N, the task for every array element arr[i], is to count the number of pairs of equal elements that can be obtained by removing arr[i] from the array.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { 1, 1, 1, 2 } 
Output: 1 1 1 3 
Explanation: 
Removing arr[0] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[1] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[2] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[3] from the array modifies arr[] to { 1, 1, 1 } and count of pairs of equal elements = 3 
Therefore, the required output is 1 1 1 3.



Input: arr[] = { 2, 3, 4, 3, 2 } 
Output: 1 1 2 1 1

Naive Approach: The simplest approach to solve this problem is to traverse the array and for every ith element remove arr[i] from the array and print the count of pairs of equal array elements remaining in the array. 

Time Complexity: O(N2)
Auxiliary space: O(N)

Efficient Approach: Follow the steps below to solve the problem:

  • Initialize a map, say mp, to store the frequency of each distinct element of the array.
  • Initialize a variable, say cntPairs, to store the total count of pairs of equal array elements.
  • Traverse the map and store the total count of pairs of equal elements by incrementing the value of cntPairs by (mp[i] * (mp[i] – 1)) / 2.
  • Finally, traverse the array. For every ith element, print the value of (cntPairs – mp[i] + 1), which denotes the count of pairs of equal array elements by removing arr[i] from the array.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count pairs of equal elements
// by removing arr[i] from the array
void pairs_after_removing(int arr[], int N)
{
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
 
    // Store frequency of each
    // distinct array element
    unordered_map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        mp[arr[i]]++;
    }
 
    // Traverse the map
    for (auto element : mp) {
 
        // Stores key of an element
        int i = element.first;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed
            = cntPairs + 1 - mp[arr[i]];
 
        cout << pairs_after_arr_i_removed << ' ';
    }
    return;
}
 
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    pairs_after_removing(arr, N);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
  
class GFG{
  
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int arr[], int N)
{
     
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
  
    // Store frequency of each
    // distinct array element
    Map<Integer,
        Integer> mp = new HashMap<Integer,
                                  Integer>();
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update frequency of arr[i]
        mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
    }
  
    // Traverse the map
    for(Map.Entry<Integer,
                  Integer> element : mp.entrySet())
    {
         
        // Stores key of an element
        int i = element.getKey();
        cntPairs += mp.get(i) * (mp.get(i) - 1) / 2;
    }
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp.get(arr[i]);
  
        System.out.print(pairs_after_arr_i_removed + " ");
    }
    return;
}
  
// Driver code
public static void main(String[] args)
{
     
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = arr.length;
  
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga

Python3




# python program to implement
# the above approach
 
# Function to count pairs of equal elements
# by removing arr[i] from the array
def pairs_after_removing(arr, N):
     
    # Stores total count of
    # pairs of equal elements
    cntPairs = 0
 
    # Store frequency of each
    # distinct array element
    mp = {}
 
    # Traverse the array
    for i in arr:
 
        # Update frequency of arr[i]
        mp[i] = mp.get(i, 0) + 1
 
    # Traverse the map
    for element in mp:
 
        # Stores key of an element
        i = element
        cntPairs += mp[i] * (mp[i] - 1) // 2
 
    # Traverse the array
    for i in range(N):
 
        # Stores count of pairs of equal
        # element by removing arr[i]
        pairs_after_arr_i_removed = cntPairs + 1 - mp[arr[i]]
 
        print(pairs_after_arr_i_removed, end = ' ')
    return
 
# Driver Code
if __name__ == '__main__':
   
    # Given Array
    arr = [2, 3, 4, 3, 2]
    N = len(arr)
    pairs_after_removing(arr, N)
 
# This code is contributed by mohit kumar 29

C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
   
class GFG
{
   
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int[] arr, int N)
{
      
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
   
    // Store frequency of each
    // distinct array element
     Dictionary<int,
            int> mp = new Dictionary<int,
                                      int>();
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Update frequency of arr[i]
        if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            else
            {
                mp[arr[i]] = 1;
            }
    }
   
    // Traverse the map
    foreach(KeyValuePair<int,
                             int> element in mp)
    {
          
        // Stores key of an element
        int i = element.Key;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp[arr[i]];
   
        Console.Write(pairs_after_arr_i_removed + " ");
    }
    return;
}
   
// Driver code
public static void Main()
{
      
    // Given Array
    int[] arr = { 2, 3, 4, 3, 2 };
    int N = arr.Length;
   
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by sanjoy_62

Javascript




<script>
 
// JavaScript program to implement
// the above approach
 
// Function to count pairs of equal elements
// by removing arr[i] from the array
function pairs_after_removing(arr, N)
{
    // Stores total count of
    // pairs of equal elements
    var cntPairs = 0;
 
    // Store frequency of each
    // distinct array element
    var mp = new Map();
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        if(mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i])+1);
        }
        else
        {
            mp.set(arr[i], 1);
        }
    }
 
    // Traverse the map
    mp.forEach((value, key) => {
         // Stores key of an element
         var i = key;
        cntPairs += mp.get(i) * (mp.get(i) - 1) / 2;
    });
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
 
        // Stores count of pairs of equal
        // element by removing arr[i]
        var pairs_after_arr_i_removed
            = cntPairs + 1 - mp.get(arr[i]);
 
        document.write( pairs_after_arr_i_removed + ' ');
    }
    return;
}
 
// Driver Code
// Given Array
var arr = [2, 3, 4, 3, 2];
var N = arr.length;
pairs_after_removing(arr, N);
 
 
</script>
Output: 
1 1 2 1 1

 

Time complexity: O(N)
Auxiliary space: O(N)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!