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

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 */`
Output:
```14

```

Time Complexity: O(n)

My Personal Notes arrow_drop_up