Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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<Integer, Integer> 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<Integer, Integer> 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




<script>
 
// Javascript program for the above approach
 
// Function to count the number of
// required pairs for every array element
function countEqualElementPairs(arr, N)
{
     
    // Initialize a map
    var mp = new Map();
 
    // Update the frequency
    // of every element
    for(var i = 0; i < N; i++)
    {
        if (mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i]) + 1);
        }
        else
        {
            mp.set(arr[i], 1);
        }
    }
 
    // Stores the count of pairs
    var total = 0;
 
    // Traverse the map
    mp.forEach((value, key) => {
         
        // Count the number of ways to
        // select pairs consisting of
        // equal elements only
        total += (value * (value - 1)) / 2;
    });
 
    // Traverse the array
    for(var i = 0; i < N; i++)
    {
         
        // Print the count for
        // every array element
        document.write(total -
                      (mp.get(arr[i]) - 1) + " ");
    }
}
 
// Driver code
 
// Given array
var arr = [ 1, 1, 2, 1, 2 ];
 
// Size of the array
var N = arr.length;
countEqualElementPairs(arr, N);
 
// This code is contributed by rutvik_56
 
</script>
Output: 
2 2 3 2 3

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!