Related Articles

# 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:

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 ``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 mp = ``new` `HashMap();`` ` `    ``// 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 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

 ``
Output:
`1 1 2 1 1`

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

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.

My Personal Notes arrow_drop_up