Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Number of unique pairs in an array

  • Difficulty Level : Basic
  • Last Updated : 30 Jun, 2021

Given an array of N elements, the task is to find all the unique pairs that can be formed using the elements of a given array. 
Examples: 

Input: arr[] = {1, 1, 2} 
Output: 4 
(1, 1), (1, 2), (2, 1), (2, 2) are the only possible pairs.

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, 2, 3} 
Output: 9 



Naive approach: The simple solution is to iterate through every possible pair and add them to a set and then find out the size of the set.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the number
// of unique pairs in the array
int countUnique(int arr[], int n)
{
 
    // Set to store unique pairs
    set<pair<int, int> > s;
 
    // Make all possible pairs
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            s.insert(make_pair(arr[i], arr[j]));
 
    // Return the size of the set
    return s.size();
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 4, 2, 5, 3, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << countUnique(arr, n);
    return 0;
}
Java



// Java implementation of the approach
import java.awt.Point;
import java.util.*;
 
class GFG
{
 
// Function to return the number
// of unique pairs in the array
static int countUnique(int arr[], int n)
{
 
    // Set to store unique pairs
    Set<Point> s = new HashSet<>();
 
    // Make all possible pairs
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            s.add(new Point(arr[i], arr[j]));
 
    // Return the size of the set
    return s.size();
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 2, 4, 2, 5, 3, 5 };
    int n = arr.length;
 
    System.out.print(countUnique(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
 
# Function to return the number
# of unique pairs in the array
def countUnique(arr, n):
    # Set to store unique pairs
    s = set()
 
    # Make all possible pairs
    for i in range(n):
        for j in range(n):
            s.add((arr[i], arr[j]))
 
    # Return the size of the set
    return len(s)
 
 
# Driver code
 
arr = [ 1, 2, 2, 4, 2, 5, 3, 5 ]
n = len(arr)
print(countUnique(arr, n))
 
# This code is contributed by ankush_953
C#



// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
     
public class store : IComparer<KeyValuePair<int, int>>
{
    public int Compare(KeyValuePair<int, int> x,
                       KeyValuePair<int, int> y)
    {
        if (x.Key != y.Key)
        {
            return x.Key.CompareTo(y.Key);   
        }
        else
        {
            return x.Value.CompareTo(y.Value);   
        }
    }
}
     
// Function to return the number
// of unique pairs in the array
static int countUnique(int []arr, int n)
{
     
    // Set to store unique pairs
    SortedSet<KeyValuePair<int,
                           int>> s = new  SortedSet<KeyValuePair<int,
                                                                 int>>(new store());
   
    // Make all possible pairs
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            s.Add(new KeyValuePair<int, int>(arr[i], arr[j]));
   
    // Return the size of the set
    return s.Count;
}
 
// Driver code   
public static void Main(string []arg)
{
    int []arr = { 1, 2, 2, 4, 2, 5, 3, 5 };
    int n = arr.Length;
     
    Console.Write(countUnique(arr, n));
}
}
 
// This code is contributed by rutvik_56
Javascript



<script>
 
    // JavaScript implementation of the approach
 
    // Function to return the number
    // of unique pairs in the array
    function countUnique(arr,n)
    {
 
        // Set to store unique pairs
        let s = new Set();
 
        // Make all possible pairs
        for (let i = 0; i < n; i++)
            for (let j = 0; j < n; j++)
                s.add((arr[i], arr[j]));
 
        // Return the size of the set
        return 5*s.size;
    }
 
    // Driver code
    let arr = [ 1, 2, 2, 4, 2, 5, 3, 5 ];
    let n = arr.length;
 
    document.write(countUnique(arr, n));
     
</script>
Output: 
25
 
Time Complexity: Time complexity of the above implementation is O(n2 Log n). We can optimize it to O(n2) using unordered_set with user defined hash function.
Efficient approach: First find out the number of unique elements in an array. Let the number of unique elements be x. Then, the number of unique pairs would be x2. This is because each unique element can form a pair with every other unique element including itself.
Below is the implementation of the above approach: 
C++



// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the number
// of unique pairs in the array
int countUnique(int arr[], int n)
{
 
    unordered_set<int> s;
    for (int i = 0; i < n; i++)
        s.insert(arr[i]);
 
    int count = pow(s.size(), 2);
 
    return count;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 4, 2, 5, 3, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << countUnique(arr, n);
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
    // Function to return the number
    // of unique pairs in the array
    static int countUnique(int arr[], int n)
    {
 
        HashSet<Integer> s = new HashSet<>();
        for (int i = 0; i < n; i++)
        {
            s.add(arr[i]);
        }
        int count = (int) Math.pow(s.size(), 2);
 
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = {1, 2, 2, 4, 2, 5, 3, 5};
        int n = arr.length;
        System.out.println(countUnique(arr, n));
    }
}
 
/* This code has been contributed
by PrinciRaj1992*/
Python3



# Python3 implementation of the approach
 
# Function to return the number
# of unique pairs in the array
def countUnique(arr, n):
     
    s = set()
    for i in range(n):
        s.add(arr[i])
 
    count = pow(len(s), 2)
 
    return count
 
# Driver code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 2, 4, 2, 5, 3, 5 ]
    n = len(arr)
 
    print(countUnique(arr, n))
     
# This code is contributed by Ryuga
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Function to return the number
    // of unique pairs in the array
    static int countUnique(int []arr, int n)
    {
 
        HashSet<int> s = new HashSet<int>();
        for (int i = 0; i < n; i++)
        {
            s.Add(arr[i]);
        }
        int count = (int) Math.Pow(s.Count, 2);
 
        return count;
    }
 
    // Driver code
    static void Main()
    {
        int []arr = {1, 2, 2, 4, 2, 5, 3, 5};
        int n = arr.Length;
        Console.WriteLine(countUnique(arr, n));
    }
}
 
// This code has been contributed by mits
Javascript



<script>
 
// JavaScript Program to implement
// the above approach
 
 
    // Function to return the number
    // of unique pairs in the array
    function countUnique(arr, n){
 
        let s = new Set();
        for (let i = 0; i < n; i++)
        {
            s.add(arr[i]);
        }
        let count = Math.pow(s.size, 2);
 
        return count;
    }
// Driver Code
 
    let arr = [ 1, 2, 2, 4, 2, 5, 3, 5 ];
    let n = arr.length;
 
     document.write(countUnique(arr, n));
 
</script>
Output: 
25
 
Time Complexity: O(n) 



My Personal Notes
arrow_drop_up
Next

Count all distinct pairs with difference equal to k
Recommended Articles
Page :
Find Unique pair in an array with pairs of numbers
03, Oct 17
Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]
12, Feb 21
Minimum sum of all differences between unique pairs in the Array
06, Aug 21
Find the GCD of LCM of all unique pairs in an Array
14, May 20
Count of unique pairs (arr[i], arr[j]) such that i < j
04, Feb 19
Find all unique pairs of maximum and second maximum elements over all sub-arrays in O(NlogN)
12, Aug 19
Max count of unique ratio/fraction pairs in given arrays
12, Jun 20
Maximizing Unique Pairs from two arrays
16, Jun 17
Number of pairs such that path between pairs has the two vertices A and B
10, Apr 20
Given an array of pairs, find all symmetric pairs in it
17, Sep 15
Find the maximum cost of an array of pairs choosing at most K pairs
23, Apr 19
Check if an array of pairs can be sorted by swapping pairs with different first elements
29, Apr 21
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Minimize sum of absolute difference between all pairs of array elements by decrementing and incrementing pairs by 1
30, Jul 21
Number of distinct ways to represent a number as sum of K unique primes
07, May 20
Divide the array into minimum number of sub-arrays having unique elements
21, Oct 19
Find next greater number formed with exactly two unique digits for each Array element
16, Nov 21
Maximum number of unique values in the array after performing given operations
10, Apr 20
Maximum possible sum of a window in an array such that elements of same window in other array are unique
04, Aug 17
Find Sum of all unique sub-array sum for a given array.
18, May 18
Maximize count of unique array elements by incrementing array elements by K
13, Jan 21
Ways to form n/2 pairs such that difference of pairs is minimum
20, Nov 18
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Shivam_72
@Shivam_72
Vote for difficulty
Current difficulty :
Basic





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