Skip to content
Related Articles

Related Articles

Improve Article

Count of index pairs with equal elements in an array

  • Difficulty Level : Easy
  • Last Updated : 15 Sep, 2021

Given an array of n elements. The task is to count the total number of indices (i, j) such that arr[i] = arr[j] and i < j
Examples : 
 

Input : arr[] = {1, 1, 2}
Output : 1
As arr[0] = arr[1], the pair of indices is (0, 1)

Input : arr[] = {1, 1, 1}
Output : 3
As arr[0] = arr[1], the pair of indices is (0, 1), 
(0, 2) and (1, 2)

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

 

Method 1 (Brute Force): 
For each index i, find element after it with same value as arr[i]. Below is the implementation of this approach: 
 

C++




// C++ program to count of pairs with equal
// elements in an array.
#include<bits/stdc++.h>
using namespace std;
 
// Return the number of pairs with equal
// values.
int countPairs(int arr[], int n)
{
    int ans = 0;
 
    // for each index i and j
    for (int i = 0; i < n; i++)
        for (int j = i+1; j < n; j++)
 
            // finding the index with same
            // value but different index.
            if (arr[i] == arr[j])
                ans++;
    return ans;
}
 
// Driven Program
int main()
{
    int arr[] = { 1, 1, 2 };
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << countPairs(arr, n) << endl;
    return 0;
}
Java



// Java program to count of pairs with equal
// elements in an array.
class GFG {
         
    // Return the number of pairs with equal
    // values.
    static int countPairs(int arr[], int n)
    {
        int ans = 0;
     
        // for each index i and j
        for (int i = 0; i < n; i++)
            for (int j = i+1; j < n; j++)
     
                // finding the index with same
                // value but different index.
                if (arr[i] == arr[j])
                    ans++;
        return ans;
    }
     
    //driver code
    public static void main (String[] args)
    {
        int arr[] = { 1, 1, 2 };
        int n = arr.length;
         
        System.out.println(countPairs(arr, n));
    }
}
 
// This code is contributed by Anant Agarwal.
Python3



# Python3 program to
# count of pairs with equal
# elements in an array.
 
# Return the number of
# pairs with equal values.
def countPairs(arr, n):
 
    ans = 0
 
    # for each index i and j
    for i in range(0 , n):
        for j in range(i + 1, n):
 
            # finding the index
            # with same value but
            # different index.
            if (arr[i] == arr[j]):
                ans += 1
    return ans
 
# Driven Code
arr = [1, 1, 2 ]
n = len(arr)
print(countPairs(arr, n))
 
# This code is contributed
# by Smitha
C#



// C# program to count of pairs with equal
// elements in an array.
using System;
 
class GFG {
         
    // Return the number of pairs with equal
    // values.
    static int countPairs(int []arr, int n)
    {
        int ans = 0;
     
        // for each index i and j
        for (int i = 0; i < n; i++)
            for (int j = i+1; j < n; j++)
     
                // finding the index with same
                // value but different index.
                if (arr[i] == arr[j])
                    ans++;
        return ans;
    }
     
    // Driver code
    public static void Main ()
    {
        int []arr = { 1, 1, 2 };
        int n = arr.Length;
         
        Console.WriteLine(countPairs(arr, n));
    }
}
 
// This code is contributed by anuj_67.
PHP



<?php
// PHP program to count of
// pairs with equal elements
// in an array.
 
// Return the number of pairs
// with equal values.
function countPairs( $arr, $n)
{
    $ans = 0;
 
    // for each index i and j
    for ( $i = 0; $i < $n; $i++)
        for ( $j = $i + 1; $j < $n; $j++)
 
            // finding the index with same
            // value but different index.
            if ($arr[$i] == $arr[$j])
                $ans++;
    return $ans;
}
 
// Driven Code
$arr = array( 1, 1, 2 );
$n = count($arr);
echo countPairs($arr, $n) ;
 
// This code is contributed by anuj_67.
?>
Javascript



<script>
// Javascript program to count of pairs with equal
// elements in an array.
 
    // Return the number of pairs with equal
    // values.
    function countPairs(arr, n)
    {
        let ans = 0;
       
        // for each index i and j
        for (let i = 0; i < n; i++)
            for (let j = i+1; j < n; j++)
       
                // finding the index with same
                // value but different index.
                if (arr[i] == arr[j])
                    ans++;
        return ans;
    }
      
// Driver code   
 
    let arr = [ 1, 1, 2 ];
    let n = arr.length;
           
    document.write(countPairs(arr, n));
     
    // This code is contributed by susmitakundugoaldanga.
</script>
Output : 
1
Time Complexity : O(n2)
Method 2 (Efficient approach): 
The idea is to count the frequency of each number and then find the number of pairs with equal elements. Suppose, a number x appears k times at index i1, i2,….,ik. Then pick any two indexes ix and iy which will be counted as 1 pair. Similarly, iy and ix can also be pair. So, choose nC2 is the number of pairs such that arr[i] = arr[j] = x.
Below is the implementation of this approach: 
 


C++



// C++ program to count of index pairs with
// equal elements in an array.
#include<bits/stdc++.h>
using namespace std;
 
// Return the number of pairs with equal
// values.
int countPairs(int arr[], int n)
{
    unordered_map<int, int> mp;
 
    // Finding frequency of each number.
    for (int i = 0; i < n; i++)
        mp[arr[i]]++;
 
    // Calculating pairs of each value.
    int ans = 0;
    for (auto it=mp.begin(); it!=mp.end(); it++)
    {
        int count = it->second;
        ans += (count * (count - 1))/2;
    }
 
    return ans;
}
 
// Driven Program
int main()
{
    int arr[] = {1, 1, 2};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << countPairs(arr, n) << endl;
    return 0;
}
Java



// Java program to count of index pairs with
// equal elements in an array.
import java.util.*;
 
class GFG {
 
    public static int countPairs(int arr[], int n)
    {
        //A method to return number of pairs with
        // equal values
         
        HashMap<Integer,Integer> hm = new HashMap<>();
         
        // Finding frequency of each number.
        for(int i = 0; i < n; i++)
        {
        if(hm.containsKey(arr[i]))
            hm.put(arr[i],hm.get(arr[i]) + 1);
        else
            hm.put(arr[i], 1);
        }
        int ans=0;
         
        // Calculating count of pairs with equal values
        for(Map.Entry<Integer,Integer> it : hm.entrySet())
        {
            int count = it.getValue();
            ans += (count * (count - 1)) / 2;
        }
        return ans;
    }
     
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = new int[]{1, 2, 3, 1};
        System.out.println(countPairs(arr,arr.length));
    }
}
 
// This Code is Contributed
// by Adarsh_Verma
Python3



# Python3 program to count of index pairs
# with equal elements in an array.
import math as mt
 
# Return the number of pairs with
# equal values.
def countPairs(arr, n):
 
    mp = dict()
 
    # Finding frequency of each number.
    for i in range(n):
        if arr[i] in mp.keys():
            mp[arr[i]] += 1
        else:
            mp[arr[i]] = 1
             
    # Calculating pairs of each value.
    ans = 0
    for it in mp:
        count = mp[it]
        ans += (count * (count - 1)) // 2
    return ans
 
# Driver Code
arr = [1, 1, 2]
n = len(arr)
print(countPairs(arr, n))
 
# This code is contributed by mohit kumar 29
C#



// C# program to count of index pairs with
// equal elements in an array.
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // Return the number of pairs with
    // equal values.
    public static int countPairs(int []arr, int n)
    {
        // A method to return number of pairs
        // with equal values
        Dictionary<int,
                   int> hm = new Dictionary<int,
                                            int>();
         
        // Finding frequency of each number.
        for(int i = 0; i < n; i++)
        {
            if(hm.ContainsKey(arr[i]))
            {
                int a = hm[arr[i]];
                hm.Remove(arr[i]);
                hm.Add(arr[i], a + 1);
            }
            else
                hm.Add(arr[i], 1);
        }
        int ans = 0;
         
        // Calculating count of pairs with
        // equal values
        foreach(var it in hm)
        {
            int count = it.Value;
            ans += (count * (count - 1)) / 2;
        }
        return ans;
    }
     
    // Driver code
    public static void Main()
    {
        int []arr = new int[]{1, 2, 3, 1};
        Console.WriteLine(countPairs(arr,arr.Length));
    }
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
// Javascript program to count of index pairs with
// equal elements in an array.
     
    function countPairs(arr,n)
    {
        //A method to return number of pairs with
        // equal values
          
        let hm = new Map();
          
        // Finding frequency of each number.
        for(let i = 0; i < n; i++)
        {
        if(hm.has(arr[i]))
            hm.set(arr[i],hm.get(arr[i]) + 1);
        else
            hm.set(arr[i], 1);
        }
        let ans=0;
          
        // Calculating count of pairs with equal values
        for(let [key, value] of hm.entries())
        {
            let count = value;
            ans += (count * (count - 1)) / 2;
        }
        return ans;
    }
     
    // Driver code
    let arr=[1, 2, 3, 1];
    document.write(countPairs(arr,arr.length));
 
 
 
// This code is contributed by patel2127
</script>
Output : 
 
1
Time Complexity : O(n)
Source: 
http://stackoverflow.com/questions/26772364/efficient-algorithm-for-counting-number-of-pairs-of-identical-elements-in-an-arr#comment42124861_26772516
This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
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
Next

Count equal element pairs in the given array
Recommended Articles
Page :
Minimum index i such that all the elements from index i to given index are equal
11, Feb 19
Count of index pairs with equal elements in an array | Set 2
13, Aug 20
Minimize count of array elements to be removed such that at least K elements are equal to their index values
20, Sep 21
Count of pairs having each element equal to index of the other from an Array
30, Jul 20
Rearrange array such that even index elements are smaller and odd index elements are greater
08, Oct 17
Check if every index i has an index j such that sum of elements in both directions are equal
04, Oct 18
Number of permutations such that sum of elements at odd index and even index are equal
02, Jul 18
Queries to calculate sum of array elements present at every Yth index starting from the index X
13, Jan 21
Queries for number of distinct elements from a given index till last index in an array
17, Jun 19
Minimum count of indices to be skipped for every index of Array to keep sum till that index at most T
24, Jun 21
Number of ways to select equal sized subarrays from two arrays having atleast K equal pairs of elements
06, May 20
Count pairs in an array such that both elements has equal set bits
16, Nov 18
Count pairs of equal array elements remaining after every removal
22, Dec 20
Count pairs of equal elements possible by excluding each array element once
23, Feb 21
Count pairs in an array having sum of elements with their respective sum of digits equal
10, Aug 21
Index of the elements which are equal to the sum of all succeeding elements
01, Oct 19
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Count of index pairs in array whose range product is a positive integer
26, May 20
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Count of Array elements greater than or equal to twice the Median of K trailing Array elements
05, Aug 20
Minimize remaining array sizes by removing equal pairs of first array elements
22, Jan 21
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Construct original array starting with K from an array of XOR of all elements except elements at same index
15, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox