Related Articles
Count of unique pairs (arr[i], arr[j]) such that i < j
• Difficulty Level : Medium
• Last Updated : 28 May, 2021

Given an array arr[], the task is to print the count of unique pairs (arr[i], arr[j]) such that i < j.

Examples:

Input: arr[] = {1, 2, 1, 4, 5, 2}
Output: 11
The possible pairs are (1, 2), (1, 1), (1, 4), (1, 5), (2, 1), (2, 4), (2, 5), (2, 2), (4, 5), (4, 2), (5, 2)

Input: arr[] = {1, 2, 3, 4}
Output:
The possible pairs are (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)

Naive approach: The easiest way is to iterate through every possible pair and if it satisfies the condition, then add it to a set. Then, we can return the size of the set as our answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``#include ``using` `namespace` `std;`` ` `// Function to return the count ``// of unique pairs in the array ``int` `getPairs(``int` `arr[], ``int` `n)``{``    ``// Set to store unique pairs ``    ``set> h;``    ``for``(``int` `i = 0; i < (n - 1); i++)``    ``{``        ``for` `(``int` `j = i + 1; j < n; j++)``        ``{``            ``// Create pair of (arr[i], arr[j]) ``            ``// and add it to the hashset ``            ``h.insert(make_pair(arr[i], arr[j])); ``        ``}``    ``}``    ` `    ``// Return the size of the HashSet ``    ``return` `h.size();``}``    ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 2, 4, 2, 5, 3, 5 };``    ``int`  `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``printf``(``"%d"``, getPairs(arr, n)) ;``    ``return` `0;``}`` ` `// This code is contributed by SHUBHAMSINGH10`

## Java

 `// Java implementation of the approach``import` `java.util.HashSet;``import` `javafx.util.Pair;` `class` `GFG {` `    ``// Function to return the count``    ``// of unique pairs in the array``    ``static` `int` `getPairs(``int` `arr[], ``int` `n)``    ``{` `        ``// HashSet to store unique pairs``        ``HashSet h = ``new` `HashSet();``        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``            ``for` `(``int` `j = i + ``1``; j < n; j++) {` `                ``// Create pair of (a[i], a[j])``                ``// and add it to the hashset``                ``Pair p``                    ``= ``new` `Pair<>(arr[i], arr[j]);``                ``h.add(p);``            ``}``        ``}` `        ``// Return the size of the HashSet``        ``return` `h.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.println(getPairs(arr, n));``    ``}``}`

## Python3

 `# Python3 implementation of the approach`` ` `# Function to return the count``# of unique pairs in the array``def` `getPairs(arr, n) :``     ` `    ``# Set to store unique pairs``    ``h ``=` `set``()``    ``for` `i ``in` `range``(n ``-` `1``) :``        ``for` `j ``in` `range``(i ``+` `1``, n) :``            ` `            ``# Create pair of (a[i], a[j])``            ``# and add it to the hashset``            ``h.add((arr[i], arr[j]));``             ` `    ``# Return the size of the HashSet``    ``return` `len``(h);`` ` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:``      ` `    ``arr ``=` `[ ``1``, ``2``, ``2``, ``4``, ``2``, ``5``, ``3``, ``5` `]``    ``n ``=` `len``(arr)``     ` `    ``print``(getPairs(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 count``// of unique pairs in the array``static` `int` `getPairs(``int` `[]arr, ``int` `n)``{``    ` `    ``// HashSet to store unique pairs``    ``HashSet> h = ``new` `HashSet>();``                                              ` `    ``for``(``int` `i = 0; i < n - 1; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``            ` `            ``// Create pair of (a[i], a[j])``            ``// and add it to the hashset``            ``Tuple<``int``,``                  ``int``> p = ``new` `Tuple<``int``,``                                     ``int``>(arr[i],``                                          ``arr[j]);``            ``h.Add(p);``        ``}``    ``}` `    ``// Return the size of the HashSet``    ``return` `h.Count;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 2, 2, 4, 2, 5, 3, 5 };``    ``int` `n = arr.Length;``    ` `    ``Console.WriteLine(getPairs(arr, n));``}``}` `// This code is contributed by Amit Katiyar`
Output:
`14`

Time Complexity: O(n2

Note: Please use an offline IDE to compile the above code. Online compilers might not support JavaFX.

Efficient Approach: Every element arr[i] can form a pair with the element arr[j] if i < j. But (arr[i], arr[j]) should be unique therefore for every unique arr[i], possible pairs will be equal to the number of distinct numbers in the sub-array arr[i + 1], arr[i + 2], …, arr[n – 1]. So for every arr[i], we will find the unique elements from right to left. For this task, it is easy to keep track of the elements visited by using a Hash Tablle. In this way, we will have unique arr[i] for every unique arr[j]. Now, we will sum these values for every unique arr[i] which is the desired count of pairs.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include``using` `namespace` `std;` `// Function to return the count``// of unique pairs in the array``int` `getPairs(``int` `a[], ``int` `n)``{``    ``set<``int``> visited1;` `    ``// un[i] stores number of unique elements``    ``// from un[i + 1] to un[n - 1]``    ``int` `un[n] ;` `    ``// Last element will have no unique elements``    ``// after it``    ``un[n - 1] = 0;` `    ``// To count unique elements after every a[i]``    ``int` `count = 0;``     ``// auto pos = s.find(3);` `     ``// prints the set elements``     ``// cout << "The set elements after 3 are: ";``     ``// for (auto it = pos; it != s.end(); it++)``    ``// cout << *it << " "``    ``for` `(``int` `i = n - 1; i > 0; i--)``    ``{` `        ``// If current element has already been used``        ``// i.e. not unique``        ``auto` `pos = visited1.find(a[i]);``        ``if` `(pos != visited1.end())``            ``un[i - 1] = count;``        ``else``            ``un[i - 1] = ++count;` `        ``// Set to true if a[i] is visited``        ``visited1.insert(a[i]);``    ``}` `    ``set<``int``>visited2;` `    ``// To know which a[i] is already visited``    ``int` `answer = 0;``    ``for` `(``int` `i = 0; i < n - 1; i++)``    ``{` `        ``// If visited, then the pair would``        ``// not be unique``        ``auto` `pos = visited2.find(a[i]);``        ``if` `(pos != visited2.end())``            ``continue``;` `        ``// Calculating total unqiue pairs``        ``answer += un[i];` `        ``// Set to true if a[i] is visited``        ``visited2.insert(a[i]);``    ``}``    ``return` `answer;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 1, 2, 2, 4, 2, 5, 3, 5 };``    ``int` `n = ``sizeof``(a)/``sizeof``(a[0]);` `    ``// Print the count of unique pairs``    ``cout<<(getPairs(a, n));``}` `// This code is contributed by Rajput-Ji`

## Java

 `// Java implementation of the approach``import` `java.util.HashSet;` `public` `class` `GFG {` `    ``// Function to return the count``    ``// of unique pairs in the array``    ``static` `int` `getPairs(``int` `a[], ``int` `n)``    ``{``        ``HashSet visited1 = ``new` `HashSet();` `        ``// un[i] stores number of unique elements``        ``// from un[i + 1] to un[n - 1]``        ``int` `un[] = ``new` `int``[n];` `        ``// Last element will have no unique elements``        ``// after it``        ``un[n - ``1``] = ``0``;` `        ``// To count unique elements after every a[i]``        ``int` `count = ``0``;``        ``for` `(``int` `i = n - ``1``; i > ``0``; i--) {` `            ``// If current element has already been used``            ``// i.e. not unique``            ``if` `(visited1.contains(a[i]))``                ``un[i - ``1``] = count;``            ``else``                ``un[i - ``1``] = ++count;` `            ``// Set to true if a[i] is visited``            ``visited1.add(a[i]);``        ``}` `        ``HashSet visited2 = ``new` `HashSet();` `        ``// To know which a[i] is already visited``        ``int` `answer = ``0``;``        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {` `            ``// If visited, then the pair would``            ``// not be unique``            ``if` `(visited2.contains(a[i]))``                ``continue``;` `            ``// Calculating total unqiue pairs``            ``answer += un[i];` `            ``// Set to true if a[i] is visited``            ``visited2.add(a[i]);``        ``}``        ``return` `answer;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a[] = { ``1``, ``2``, ``2``, ``4``, ``2``, ``5``, ``3``, ``5` `};``        ``int` `n = a.length;` `        ``// Print the count of unique pairs``        ``System.out.println(getPairs(a, n));``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Function to return the count``# of unique pairs in the array``def` `getPairs(a, n):``    ` `    ``visited1 ``=` `set``()``    ` `    ``# un[i] stores number of unique elements``    ``# from un[i + 1] to un[n - 1]``    ``un ``=` `[``0``] ``*` `n``    ` `    ``# Last element will have no unique elements``    ``# after it``    ``un[n ``-` `1``] ``=` `0``    ` `    ``# To count unique elements after every a[i]``    ``count ``=` `0``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):``        ` `        ``# If current element has already been used``        ``# i.e. not unique``        ``if` `(a[i] ``in` `visited1):``            ``un[i ``-` `1``] ``=` `count``        ``else``:``            ``count ``+``=` `1``            ``un[i ``-` `1``] ``=` `count``        ` `        ``# Set to true if a[i] is visited``        ``visited1.add(a[i])``    ` `    ``visited2 ``=` `set``()``    ` `    ``# To know which a[i] is already visited``    ``answer ``=` `0``    ``for` `i ``in` `range``(n ``-` `1``):``        ` `        ``# If visited, then the pair would``        ``# not be unique``        ``if` `(a[i] ``in` `visited2):``            ``continue``            ` `        ``# Calculating total unqiue pairs``        ``answer ``+``=` `un[i]``        ` `        ``# Set to true if a[i] is visited``        ``visited2.add(a[i])``    ` `    ``return` `answer` `# Driver code` `a ``=` `[``1``, ``2``, ``2``, ``4``, ``2``, ``5``, ``3``, ``5``]``n ``=` `len``(a)` `# Print the count of unique pairs``print``(getPairs(a, n))` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `    ``// Function to return the count``    ``// of unique pairs in the array``    ``static` `int` `getPairs(``int` `[]a, ``int` `n)``    ``{``        ``HashSet<``int``> visited1 = ``new` `HashSet<``int``>();` `        ``// un[i] stores number of unique elements``        ``// from un[i + 1] to un[n - 1]``        ``int` `[]un = ``new` `int``[n];` `        ``// Last element will have no unique elements``        ``// after it``        ``un[n - 1] = 0;` `        ``// To count unique elements after every a[i]``        ``int` `count = 0;``        ``for` `(``int` `i = n - 1; i > 0; i--)``        ``{` `            ``// If current element has already been used``            ``// i.e. not unique``            ``if` `(visited1.Contains(a[i]))``                ``un[i - 1] = count;``            ``else``                ``un[i - 1] = ++count;` `            ``// Set to true if a[i] is visited``            ``visited1.Add(a[i]);``        ``}` `        ``HashSet<``int``> visited2 = ``new` `HashSet<``int``>();` `        ``// To know which a[i] is already visited``        ``int` `answer = 0;``        ``for` `(``int` `i = 0; i < n - 1; i++)``        ``{` `            ``// If visited, then the pair would``            ``// not be unique``            ``if` `(visited2.Contains(a[i]))``                ``continue``;` `            ``// Calculating total unqiue pairs``            ``answer += un[i];` `            ``// Set to true if a[i] is visited``            ``visited2.Add(a[i]);``        ``}``        ``return` `answer;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]a = { 1, 2, 2, 4, 2, 5, 3, 5 };``        ``int` `n = a.Length;` `        ``// Print the count of unique pairs``        ``Console.WriteLine(getPairs(a, n));``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``
Output:
`14`

Time Complexity: O(n)

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up