# Print all the sum pairs which occur maximum number of times

Given an array arr[] of N distinct integers. The task is to find the sum of two array integers a[i] + a[j] which occurs maximum number of times. In the case of multiple answers, print all of them.

Examples:

Input: arr[] = {1, 8, 3, 11, 4, 9, 2, 7}
Output:
10
12
11
The sum 10, 12 and 11 occur 3 times
7 + 4 = 11, 8 + 3 = 11, 9 + 2 = 11
1 + 9 = 10, 8 + 2 = 10, 7 + 3 = 10
1 + 11 = 12, 8 + 4 = 12, 9 + 3 = 12

Input: arr[] = {3, 1, 7, 11, 9, 2, 12}
Output:
12
14
10
13

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

Approach: The following steps can be followed to solve the problem:

• Iterate over every pair of elements.
• Use a hash-table to count the number of times every sum pair occurs.
• At the end iterate over the hash-table and find the sum pair which occurs the maximum number of times.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the sum pairs ` `// that occur the most ` `void` `findSumPairs(``int` `a[], ``int` `n) ` `{ ` `    ``// Hash-table ` `    ``unordered_map<``int``, ``int``> mpp; ` `    ``for` `(``int` `i = 0; i < n - 1; i++) { ` `        ``for` `(``int` `j = i + 1; j < n; j++) { ` ` `  `            ``// Keep a count of sum pairs ` `            ``mpp[a[i] + a[j]]++; ` `        ``} ` `    ``} ` ` `  `    ``// Variables to store ` `    ``// maximum occurrence ` `    ``int` `occur = 0; ` ` `  `    ``// Iterate in the hash table ` `    ``for` `(``auto` `it : mpp) { ` `        ``if` `(it.second > occur) { ` `            ``occur = it.second; ` `        ``} ` `    ``} ` ` `  `    ``// Print all sum pair which occur ` `    ``// maximum number of times ` `    ``for` `(``auto` `it : mpp) { ` `        ``if` `(it.second == occur) ` `            ``cout << it.first << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[] = { 1, 8, 3, 11, 4, 9, 2, 7 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `    ``findSumPairs(a, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to find the sum pairs ` `// that occur the most ` `static` `void` `findSumPairs(``int` `a[], ``int` `n) ` `{ ` `    ``// Hash-table ` `    ``Map mpp = ``new` `HashMap<>(); ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++)  ` `    ``{ ` `        ``for` `(``int` `j = i + ``1``; j < n; j++)  ` `        ``{ ` ` `  `            ``// Keep a count of sum pairs ` `            ``mpp.put(a[i] + a[j],mpp.get(a[i] + a[j])==``null``?``1``:mpp.get(a[i] + a[j])+``1``); ` `        ``} ` `    ``} ` ` `  `    ``// Variables to store ` `    ``// maximum occurrence ` `    ``int` `occur = ``0``; ` ` `  `    ``// Iterate in the hash table ` `    ``for` `(Map.Entry entry : mpp.entrySet()) ` `    ``{ ` `        ``if` `(entry.getValue() > occur) ` `        ``{ ` `            ``occur = entry.getValue(); ` `        ``} ` `    ``} ` ` `  `    ``// Print all sum pair which occur ` `    ``// maximum number of times ` `    ``for` `(Map.Entry entry : mpp.entrySet()) ` `    ``{ ` `        ``if` `(entry.getValue() == occur) ` `            ``System.out.println(entry.getKey()); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[])  ` `{ ` `    ``int` `a[] = { ``1``, ``8``, ``3``, ``11``, ``4``, ``9``, ``2``, ``7` `}; ` `    ``int` `n = a.length; ` `    ``findSumPairs(a, n); ` `} ` `} ` ` `  `/* This code is contributed by PrinciRaj1992 */`

## Python3

 `# Python 3 implementation of the approach ` ` `  `# Function to find the sum pairs ` `# that occur the most ` `def` `findSumPairs(a, n): ` `     `  `    ``# Hash-table ` `    ``mpp ``=` `{i:``0` `for` `i ``in` `range``(``21``)} ` `    ``for` `i ``in` `range``(n ``-` `1``): ` `        ``for` `j ``in` `range``(i ``+` `1``, n, ``1``): ` `             `  `            ``# Keep a count of sum pairs ` `            ``mpp[a[i] ``+` `a[j]] ``+``=` `1` ` `  `    ``# Variables to store ` `    ``# maximum occurrence ` `    ``occur ``=` `0` ` `  `    ``# Iterate in the hash table ` `    ``for` `key, value ``in` `mpp.items(): ` `        ``if` `(value > occur): ` `            ``occur ``=` `value ` ` `  `    ``# Print all sum pair which occur ` `    ``# maximum number of times ` `    ``for` `key, value ``in` `mpp.items(): ` `        ``if` `(value ``=``=` `occur): ` `            ``print``(key) ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``a ``=` `[``1``, ``8``, ``3``, ``11``, ``4``, ``9``, ``2``, ``7``] ` `    ``n ``=` `len``(a) ` `    ``findSumPairs(a, n) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of above approach ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `class` `GFG  ` `{ ` ` `  `// Function to find the sum pairs ` `// that occur the most ` `static` `void` `findSumPairs(``int` `[]a, ``int` `n) ` `{ ` `    ``// Hash-table ` `    ``Dictionary<``int``,``int``> mpp = ``new` `Dictionary<``int``,``int``>(); ` `    ``for` `(``int` `i = 0; i < n - 1; i++)  ` `    ``{ ` `        ``for` `(``int` `j = i + 1; j < n; j++)  ` `        ``{ ` ` `  `            ``// Keep a count of sum pairs ` `            ``if``(mpp.ContainsKey(a[i] + a[j])) ` `            ``{ ` `                ``var` `val = mpp[a[i] + a[j]]; ` `                ``mpp.Remove(a[i] + a[j]); ` `                ``mpp.Add(a[i] + a[j], val + 1);  ` `            ``} ` `            ``else` `            ``{ ` `                ``mpp.Add(a[i] + a[j], 1); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Variables to store ` `    ``// maximum occurrence ` `    ``int` `occur = 0; ` ` `  `    ``// Iterate in the hash table ` `    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mpp) ` `    ``{ ` `        ``if` `(entry.Value > occur) ` `        ``{ ` `            ``occur = entry.Value; ` `        ``} ` `    ``} ` ` `  `    ``// Print all sum pair which occur ` `    ``// maximum number of times ` `    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mpp) ` `    ``{ ` `        ``if` `(entry.Value == occur) ` `            ``Console.WriteLine(entry.Key); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args)  ` `{ ` `    ``int` `[]a = { 1, 8, 3, 11, 4, 9, 2, 7 }; ` `    ``int` `n = a.Length; ` `    ``findSumPairs(a, n); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```10
12
11
```

My Personal Notes arrow_drop_up Striver(underscore)79 at Codechef and codeforces D

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.