# Print all pairs in an unsorted array with equal sum

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2022

Given an unsorted array A[]. The task is to print all unique pairs in the unsorted array with equal sum.
Note: Print the result in the format as shown in the below examples.
Examples:

```Input: A[] = { 6, 4, 12, 10, 22, 54, 32, 42, 21, 11}
Output:
Pairs : ( 4, 12) ( 6, 10)  have sum : 16
Pairs : ( 10, 22) ( 21, 11)  have sum : 32
Pairs : ( 12, 21) ( 22, 11)  have sum : 33
Pairs : ( 22, 21) ( 32, 11)  have sum : 43
Pairs : ( 32, 21) ( 42, 11)  have sum : 53
Pairs : ( 12, 42) ( 22, 32)  have sum : 54
Pairs : ( 10, 54) ( 22, 42)  have sum : 64

Input:A[]= { 4, 23, 65, 67, 24, 12, 86}
Output:
Pairs : ( 4, 86) ( 23, 67) have sum : 90```

The idea is to use map in C++ STL for avoiding duplicate pairs of elements.

• Create a map with key as pair of integer and value as integer to store all unique pairs of elements and their corresponding sum.
• Traverse the array and generate all possible pairs and store the pairs and their corresponding sum on the first map.
• Create a second map with key as integer and value as a vector of pair to store a list of all pairs of elements with a corresponding sum.
• Finally, traverse the second map, and for a sum with more than one pair, print all pairs and then the corresponding sum in a format as shown in the above example.

Below is the implementation of the above approach:

## C++

 `// C++ program to print all pairs``// with equal sum` `#include ``using` `namespace` `std;` `// Function to print all pairs``// with equal sum``void` `pairWithEqualSum(``int` `A[], ``int` `n)``{` `    ``map<``int``, vector > > mp;` `    ``// Insert all unique pairs and their``    ``// corresponding sum in the map``    ``for` `(``int` `i = 0; i < n - 1; i++) {``        ``for` `(``int` `j = i + 1; j < n; j++) {``            ``pair<``int``, ``int``> p = make_pair(A[i], A[j]);` `            ``mp[A[i] + A[j]].push_back(p);``        ``}``    ``}` `    ``// Traverse the map mp, and for sum``    ``// with more than one pair, print all pairs``    ``// and the corresponding sum``    ``for` `(``auto` `itr = mp.begin(); itr != mp.end(); itr++) {``        ``if` `(itr->second.size() > 1) {``            ``cout << ``"Pairs : "``;` `            ``for` `(``int` `i = 0; i < itr->second.size(); i++) {``                ``cout << ``"( "` `<< itr->second[i].first << ``", "``                     ``<< itr->second[i].second << ``") "``;``            ``}` `            ``cout << ``" have sum : "` `<< itr->first << endl;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `A[]``        ``= { 6, 4, 12, 10, 22, 54, 32, 42, 21, 11, 8, 2 };` `    ``int` `n = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``pairWithEqualSum(A, n);` `    ``return` `0;``}`

## Java

 `// Java program to print all pairs``// with equal sum``import` `java.util.*;` `class` `GFG {``    ``static` `class` `pair {``        ``int` `first, second;``        ``public` `pair(``int` `first, ``int` `second)``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}``    ``}` `    ``// Function to print all pairs``    ``// with equal sum``    ``static` `void` `pairWithEqualSum(``int` `A[], ``int` `n)``    ``{` `        ``Map > mp = ``new` `HashMap<>();` `        ``// Insert all unique pairs and their``        ``// corresponding sum in the map``        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {``            ``for` `(``int` `j = i + ``1``; j < n; j++) {``                ``pair p = ``new` `pair(A[i], A[j]);``                ``Vector pp = ``new` `Vector();``                ``if` `(mp.containsKey(A[i] + A[j]))``                    ``pp.addAll(mp.get(A[i] + A[j]));``                ``pp.add(p);``                ``mp.put(A[i] + A[j], pp);``            ``}``        ``}` `        ``// Traverse the map mp, and for sum``        ``// with more than one pair, print all pairs``        ``// and the corresponding sum``        ``for` `(Map.Entry > itr :``             ``mp.entrySet()) {``            ``if` `(itr.getValue().size() > ``1``) {``                ``System.out.print(``"Pairs : "``);` `                ``for` `(``int` `i = ``0``; i < itr.getValue().size();``                     ``i++) {``                    ``System.out.print(``                        ``"( "` `+ itr.getValue().get(i).first``                        ``+ ``", "``                        ``+ itr.getValue().get(i).second``                        ``+ ``") "``);``                ``}` `                ``System.out.print(``                    ``" have sum : "` `+ itr.getKey() + ``"\n"``);``            ``}``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = { ``6``,  ``4``,  ``12``, ``10``, ``22``, ``54``,``                    ``32``, ``42``, ``21``, ``11``, ``8``,  ``2` `};` `        ``int` `n = A.length;` `        ``pairWithEqualSum(A, n);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python implementation of the``# approach` `# Function to print all pairs``# with equal sum`  `def` `pairWithEqualSum(A, n):``    ``mp ``=` `{}` `    ``# Insert all unique pairs and their``    ``# corresponding sum in the map` `    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i``+``1``, n):``            ``if` `A[i]``+``A[j] ``in` `mp:``                ``mp[A[i]``+``A[j]].append((A[i], A[j]))``            ``else``:``                ``mp[A[i]``+``A[j]] ``=` `[(A[i], A[j])]` `    ``# Traverse the map mp, and for sum``    ``# with more than one pair, print all pairs``    ``# and the corresponding sum` `    ``for` `itr ``in` `mp:``        ``if` `len``(mp[itr]) > ``1``:``            ``print``(``"Pairs : "``, end``=``"")``            ``for` `i ``in` `range``(``0``, ``len``(mp[itr])):``                ``print``(``"("``, mp[itr][i][``0``], ``","``,``                      ``mp[itr][i][``1``], ``")"``, end``=``" "``)` `            ``print``(``"have sum :"``, itr)`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `[``6``, ``4``, ``12``, ``10``, ``22``, ``54``,``         ``32``, ``42``, ``21``, ``11``, ``8``, ``2``]``    ``n ``=` `len``(A)` `    ``pairWithEqualSum(A, n)`

## C#

 `// C# program to print all pairs``// with equal sum``using` `System;``using` `System.Collections.Generic;` `class` `GFG {``    ``class` `pair {``        ``public` `int` `first, second;``        ``public` `pair(``int` `first, ``int` `second)``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}``    ``}` `    ``// Function to print all pairs``    ``// with equal sum``    ``static` `void` `pairWithEqualSum(``int``[] A, ``int` `n)``    ``{` `        ``Dictionary<``int``, List > mp``            ``= ``new` `Dictionary<``int``, List >();` `        ``// Insert all unique pairs and their``        ``// corresponding sum in the map``        ``for` `(``int` `i = 0; i < n - 1; i++) {``            ``for` `(``int` `j = i + 1; j < n; j++) {``                ``pair p = ``new` `pair(A[i], A[j]);``                ``List pp = ``new` `List();``                ``if` `(mp.ContainsKey(A[i] + A[j]))``                    ``pp = AddAll(mp[A[i] + A[j]]);``                ``pp.Add(p);``                ``if` `(mp.ContainsKey(A[i] + A[j]))``                    ``mp[A[i] + A[j]] = pp;``                ``else``                    ``mp.Add(A[i] + A[j], pp);``            ``}``        ``}` `        ``// Traverse the map mp, and for sum``        ``// with more than one pair, print all pairs``        ``// and the corresponding sum``        ``foreach``(KeyValuePair<``int``, List > itr ``in` `mp)``        ``{``            ``if` `(itr.Value.Count > 1) {``                ``Console.Write(``"Pairs : "``);` `                ``for` `(``int` `i = 0; i < itr.Value.Count; i++) {``                    ``Console.Write(``                        ``"( "` `+ itr.Value[i].first + ``", "``                        ``+ itr.Value[i].second + ``") "``);``                ``}` `                ``Console.Write(``" have sum : "` `+ itr.Key``                              ``+ ``"\n"``);``            ``}``        ``}``    ``}``    ``static` `List AddAll(List list)``    ``{``        ``List l = ``new` `List();``        ``foreach``(pair p ``in` `list) l.Add(p);``        ``return` `l;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] A = { 6,  4,  12, 10, 22, 54,``                    ``32, 42, 21, 11, 8,  2 };` `        ``int` `n = A.Length;` `        ``pairWithEqualSum(A, n);``    ``}``}` `// This code is contributed by Rajput-Ji`

Output

```Pairs : ( 6, 4) ( 8, 2)  have sum : 10
Pairs : ( 4, 8) ( 10, 2)  have sum : 12
Pairs : ( 6, 8) ( 4, 10) ( 12, 2)  have sum : 14
Pairs : ( 6, 10) ( 4, 12)  have sum : 16
Pairs : ( 6, 12) ( 10, 8)  have sum : 18
Pairs : ( 12, 11) ( 21, 2)  have sum : 23
Pairs : ( 10, 22) ( 21, 11)  have sum : 32
Pairs : ( 12, 21) ( 22, 11)  have sum : 33
Pairs : ( 12, 22) ( 32, 2)  have sum : 34
Pairs : ( 22, 21) ( 32, 11)  have sum : 43
Pairs : ( 12, 32) ( 42, 2)  have sum : 44
Pairs : ( 32, 21) ( 42, 11)  have sum : 53
Pairs : ( 12, 42) ( 22, 32)  have sum : 54
Pairs : ( 10, 54) ( 22, 42)  have sum : 64```

Another implementation of the same above approach using one Single map.

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.HashMap;``import` `java.util.Map;` `class` `GFG{``    ` `// Function to find pairs``public` `void` `findPairs(``int` `arr[]){``    ` `    ``Map map = ``new` `HashMap();` `    ``int` `sum = ``0``, element = ``0``;``    ` `    ``// Iterate from 0 to arr.length``    ``for``(``int` `i = ``0``; i < arr.length; i++)``    ``{``        ` `      ``// Iterate from i+1 to arr.length``      ``for``(``int` `j = i + ``1``; j < arr.length; j++)``      ``{``          ``sum = arr[i] + arr[j];` `          ``// If sum is found in map``          ``if``(map.get(sum) != ``null``)``          ``{` `            ``// To find the first array``            ``// element whose of the sum pair``            ``element = map.get(sum);` `            ``// Print the output``            ``System.out.println(``"Pairs:("` `+ arr[i] +``                             ``","` `+ arr[j] + ``") ("` `+``                                    ``element + ``","` `+``                                  ``(sum - element) +``                              ``") have sum:"` `+ sum);``          ``}``          ``else``          ``{``            ``// Else put map[sum] = arr[i]``            ``map.put(sum, arr[i]);``          ``}``      ``}``    ``}``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = {``6``, ``4``, ``12``, ``10``, ``22``, ``54``,``                 ``32``, ``42``, ``21``, ``11``, ``8``, ``2``};` `    ``GFG obj = ``new` `GFG();` `    ``// Function Call``    ``obj.findPairs(arr);``  ``}``}`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `// Function to find pairs``static` `void` `findPairs(``int``[] arr){``      ` `    ``Dictionary<``int``,``int``> map = ``new` `Dictionary<``int``,``int``>();``  ` `    ``int` `sum = 0, element = 0;``      ` `    ``// Iterate from 0 to arr.length``    ``for``(``int` `i = 0; i < arr.Length; i++)``    ``{``          ` `      ``// Iterate from i+1 to arr.length``      ``for``(``int` `j = i + 1; j < arr.Length; j++)``      ``{``          ``sum = arr[i] + arr[j];``  ` `          ``// If sum is found in map``          ``if``(map.ContainsKey(sum))``          ``{``  ` `            ``// To find the first array``            ``// element whose of the sum pair``            ``element = map[sum];``  ` `            ``// Print the output``            ``Console.WriteLine(``"Pairs:("` `+ arr[i] +``                             ``","` `+ arr[j] + ``") ("` `+``                                    ``element + ``","` `+``                                  ``(sum - element) +``                              ``") have sum:"` `+ sum);``          ``}``          ``else``          ``{``            ``// Else put map[sum] = arr[i]``            ``map[sum] = arr[i];``          ``}``      ``}``    ``}``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = {6, 4, 12, 10, 22, 54,``                 ``32, 42, 21, 11, 8, 2};``  ` `        ``// Function Call``        ``findPairs(arr);``    ``}``}` `// This code is contributed by sanjoy_62.`

Output

```Pairs:(4,12) (6,10)  have sum:16
Pairs:(4,10) (6,8)  have sum:14
Pairs:(12,2) (6,8)  have sum:14
Pairs:(10,8) (6,12)  have sum:18
Pairs:(10,2) (4,8)  have sum:12
Pairs:(22,32) (12,42)  have sum:54
Pairs:(22,42) (10,54)  have sum:64
Pairs:(22,11) (12,21)  have sum:33
Pairs:(32,11) (22,21)  have sum:43
Pairs:(32,2) (12,22)  have sum:34
Pairs:(42,11) (32,21)  have sum:53
Pairs:(42,2) (12,32)  have sum:44
Pairs:(21,11) (10,22)  have sum:32
Pairs:(21,2) (12,11)  have sum:23
Pairs:(8,2) (6,4)  have sum:10```

Time Complexity: O(n2logn), as nested loops are used
Auxiliary Space: O(n), as extra space of size n is used to create a Hashmap

My Personal Notes arrow_drop_up