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

My Personal Notes arrow_drop_up
Related Articles