# Count pairs of equal elements possible by excluding each array element once

• Last Updated : 14 May, 2021

Given an array arr[] of N integers, the task for each array element is to find the number of ways of choosing a pair of two equal elements excluding the current element.

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, 2, 1, 2}
Output: 2 2 3 2 3
Explanation:
For arr[0] (= 1): The remaining array elements are {1, 2, 1, 2}. Possible choice of pairs are (1, 1), (2, 2). Therefore, count is 2.
For arr[1] (= 1): The remaining array elements are {1, 2, 1, 2}. Therefore, count is 2.
For arr[2] (= 2): The remaining array elements are {1, 1, 1, 2}. Possible choice of pairs are (arr[0], arr[1]), (arr[1], arr[2]) and (arr[0], arr[2]). Therefore, count is 3.
For arr[3] (= 1): The remaining elements are {1, 1, 2, 2}. Therefore, count is 2.
For arr[4] (= 2): The remaining elements are {1, 1, 2, 1}. Therefore, count is 3.

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

Naive Approach: The simplest approach to solve this problem is to traverse the array for each array element, count all possible pairs of equal elements from the remaining array.

Time Complexity: O(N3)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized based on the observation that, for any ith index (1 â‰¤ i â‰¤ N), calculate the following two values:

• The number of ways to choose two distinct elements having equal values from the array.
• The number of ways to choose an element from the N âˆ’ 1 array elements other than the ith element such that their values are the same as the value of the ith element.

Follow the steps below to solve the problem:

1. Initialize a map, say mp, to store the frequency of every array element.
2. Traverse the map to count the number of pairs made up of equal values. Store the count in a variable, say total.
3. Traverse the array and for every ith index, print total – (mp[arr[i]] – 1) as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the number of``// required pairs for every array element``void` `countEqualElementPairs(``int` `arr[], ``int` `N)``{``    ``// Initialize a map``    ``unordered_map<``int``, ``int``> mp;` `    ``// Update the frequency``    ``// of every element``    ``for` `(``int` `i = 0; i < N; i++) {``        ``mp[arr[i]] += 1;``    ``}` `    ``// Stores the count of pairs``    ``int` `total = 0;` `    ``// Traverse the map``    ``for` `(``auto` `i : mp) {` `        ``// Count the number of ways to``        ``// select pairs consisting of``        ``// equal elements only``        ``total += (i.second * (i.second - 1)) / 2;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Print the count for``        ``// every array element``        ``cout << total - (mp[arr[i]] - 1)``             ``<< ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 1, 1, 2, 1, 2 };` `    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``countEqualElementPairs(arr, N);``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.Map;``import` `java.util.HashMap;` `class` `GFG``{``  ` `  ``// Function to count the number of``  ``// required pairs for every array element``  ``public` `static` `void` `countEqualElementPairs(``int` `arr[],``                                            ``int` `N)``  ``{``    ` `    ``// Initialize a map``    ``HashMap map = ``new` `HashMap<>();``    ` `    ``// Update the frequency``    ``// of every element``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ``Integer k = map.get(arr[i]);``      ``map.put(arr[i], (k == ``null``) ? ``1` `: k + ``1``);``    ``}``    ` `    ``// Stores the count of pairs``    ``int` `total = ``0``;` `    ``// Traverse the map``    ``for` `(Map.Entry e :``         ``map.entrySet())``    ``{``      ` `      ``// Count the number of ways to``      ``// select pairs consisting of``      ``// equal elements only``      ``total``        ``+= (e.getValue() * (e.getValue() - ``1``)) / ``2``;``    ``}` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Print the count for``      ``// every array element``      ``System.out.print(total - (map.get(arr[i]) - ``1``)``                       ``+ ``" "``);``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ` `    ``// Given array``    ``int` `arr[] = { ``1``, ``1``, ``2``, ``1``, ``2` `};` `    ``// Size of the array``    ``int` `N = ``5``;` `    ``countEqualElementPairs(arr, N);``  ``}``}` `// This code is contributed by adity7409.`

## Python3

 `# Python3 program for the above approach` `# Function to count the number of``# required pairs for every array element``def` `countEqualElementPairs(arr, N):``  ` `    ``# Initialize a map``    ``mp ``=` `{}` `    ``# Update the frequency``    ``# of every element``    ``for` `i ``in` `range``(N):``        ``if` `arr[i] ``in` `mp:``            ``mp[arr[i]] ``+``=` `1``        ``else``:``            ``mp[arr[i]] ``=` `1` `    ``# Stores the count of pairs``    ``total ``=` `0` `    ``# Traverse the map``    ``for` `key,value ``in` `mp.items():``      ` `        ``# Count the number of ways to``        ``# select pairs consisting of``        ``# equal elements only``        ``total ``+``=` `(value ``*` `(value ``-` `1``)) ``/` `2` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``      ` `        ``# Print the count for``        ``# every array element``        ``print``(``int``(total ``-` `(mp[arr[i]] ``-` `1``)),end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[``1``, ``1``, ``2``, ``1``, ``2``]` `    ``# Size of the array``    ``N ``=` `len``(arr)` `    ``countEqualElementPairs(arr, N)``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to count the number of``// required pairs for every array element``static` `void` `countEqualElementPairs(``int``[] arr, ``int` `N)``{` `    ``// Initialize a map``    ``Dictionary<``int``,``               ``int``> map = ``new` `Dictionary<``int``,``                                         ``int``>();` `    ``// Update the frequency``    ``// of every element``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(!map.ContainsKey(arr[i]))``            ``map[arr[i]] = 1;``        ``else``            ``map[arr[i]]++;``    ``}` `    ``// Stores the count of pairs``    ``int` `total = 0;` `    ``// Traverse the map``    ``foreach``(KeyValuePair<``int``, ``int``> e ``in` `map)``    ``{``        ` `        ``// Count the number of ways to``        ``// select pairs consisting of``        ``// equal elements only``        ``total += (e.Value * (e.Value - 1)) / 2;``    ``}` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Print the count for``        ``// every array element``        ``Console.Write(total - (map[arr[i]] - 1) + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `Main()``{``    ` `    ``// Given array``    ``int``[] arr = { 1, 1, 2, 1, 2 };` `    ``// Size of the array``    ``int` `N = 5;` `    ``countEqualElementPairs(arr, N);``}``}` `// This code is contributed by ukasp`

## Javascript

 ``
Output:
`2 2 3 2 3`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up