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)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :