# Count of unique pairs (arr[i], arr[j]) such that i < j

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: 6
The possible pairs are (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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); ` `    ``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 `

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); ` ` `  `    ``// 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)); ` `    ``} ` `} `

## 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 */`

## Python

 `# Python 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) ` ` `  `# Prthe count of unique pairs  ` `print``(getPairs(a, n))  ` ` `  `# This code is contributed by SHUBHAMSINGH10 `

Output:

```14
```

Time Complexity: O(n)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.