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

• Difficulty Level : Basic
• Last Updated : 16 Jun, 2022

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

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[0]);` `    ``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`

## Javascript

 ``

Output:

```10
12
11```

Time Complexity: O(N*N), as we are using nested loops for traversing N*N times. Where N is the number of elements in the array.

Auxiliary Space: O(N*N), as we are using extra space for the map. Where N is the number of elements in the array.

My Personal Notes arrow_drop_up
Related Articles