Skip to content
Related Articles

Related Articles

Maximum count of pairs which generate the same sum

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 01 Aug, 2022
Improve Article
Save Article

Given an array arr[], the task is to count the maximum count of pairs that give the same sum.

Examples: 

Input: arr[] = {1, 2, 3, 4} 
Output:
(1, 2) = 3 
(1, 3) = 4 
(1, 4), (2 + 3) = 5 
(2, 4) = 6 
(3, 4) = 7

Input: arr[] = {1, 8, 3, 11, 4, 9, 2, 7} 
Output:

Approach: 

  1. Create a map to store the frequency of the sum of each pair.
  2. Traverse the map and find the maximum frequency.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// count of pairs with equal sum
int maxCountSameSUM(int arr[], int n)
{
    // Create a map to store frequency
    unordered_map<int, int> M;
 
    // Store counts of sum of all pairs
    // in the map
    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++)
            M[(arr[i] + arr[j])]++;
 
    int max_count = 0;
 
    // Find maximum count
    for (auto ele : M)
        if (max_count < ele.second)
            max_count = ele.second;
 
    return max_count;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 8, 3, 11, 4, 9, 2, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxCountSameSUM(arr, n);
 
    return 0;
}

Java




// Java implementation of the approach
 
class GFG
{
     
// return the max
static int Max(int arr[])
{
    int max = arr[0];
    for(int i = 1; i < arr.length; i++)
        if(arr[i] > max)max = arr[i];
     
    return max;
}
     
// Function to return the maximum
// count of pairs with equal sum
static int maxCountSameSUM(int arr[], int n)
{
    int maxi = Max(arr);
     
    // Create a map to store frequency
    int[] M = new int[2 * maxi + 1];
     
     
    for(int i = 0; i < M.length; i++)M[i] = 0;
 
    // Store counts of sum of all
    // pairs in the map
    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++)
            M[(arr[i] + arr[j])] += 1;
 
    int max_count = 0;
 
    // Find maximum count
    for (int i = 0; i < 2 * maxi; i++)
        if (max_count < M[i])
            max_count = M[i];
 
    return max_count;
}
 
// Driver code
public static void main(String args[])
{
    int arr[] = { 1, 8, 3, 11, 4, 9, 2, 7 };
    int n = arr.length;
    System.out.print(maxCountSameSUM(arr, n));
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 implementation of the approach
from collections import defaultdict
 
# Function to return the maximum
# count of pairs with equal sum
def maxCountSameSUM(arr, n):
 
    # Create a map to store frequency
    M = defaultdict(lambda:0)
 
    # Store counts of sum of
    # all pairs in the map
    for i in range(0, n - 1):
        for j in range(i + 1, n):
            M[arr[i] + arr[j]] += 1
 
    max_count = 0
 
    # Find maximum count
    for ele in M:
        if max_count < M[ele]:
            max_count = M[ele]
 
    return max_count
 
# Driver code
if __name__ == "__main__":
 
    arr = [1, 8, 3, 11, 4, 9, 2, 7]
    n = len(arr)
    print(maxCountSameSUM(arr, n))
     
# This code is contributed
# by Rituraj Jain

C#




// C# implementation of the approach
using System.Linq;
using System;
 
class GFG
{
     
// Function to return the maximum
// count of pairs with equal sum
static int maxCountSameSUM(int []arr, int n)
{
    int maxi = arr.Max();
     
    // Create a map to store frequency
    int[] M = new int[2 * maxi + 1];
 
    // Store counts of sum of all
    // pairs in the map
    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++)
            M[(arr[i] + arr[j])] += 1;
 
    int max_count = 0;
 
    // Find maximum count
    for (int i = 0; i < 2 * maxi; i++)
        if (max_count < M[i])
            max_count = M[i];
 
    return max_count;
}
 
// Driver code
static void Main()
{
    int []arr = { 1, 8, 3, 11, 4, 9, 2, 7 };
    int n = arr.Length;
    Console.WriteLine(maxCountSameSUM(arr, n));
}
}
 
// This code is contributed by mits

PHP




<?php
// PHP implementation of the approach
 
// Function to return the maximum
// count of pairs with equal sum
function maxCountSameSUM($arr, $n)
{
    $maxi = max($arr);
     
    // Create a map to store frequency
    $M = array_fill(1, 2 * $maxi, 0);
 
    // Store counts of sum of all
    // pairs in the map
    for ($i = 0; $i < $n - 1; $i++)
        for ($j = $i + 1; $j < $n; $j++)
            $M[($arr[$i] + $arr[$j])] += 1;
 
    $max_count = 0;
 
    // Find maximum count
    for ($i = 0; $i < sizeof($M); $i++)
        if ($max_count < $M[$i])
            $max_count = $M[$i];
 
    return $max_count;
}
 
// Driver code
$arr = array( 1, 8, 3, 11, 4, 9, 2, 7 );
$n = sizeof($arr);
echo maxCountSameSUM($arr, $n);
 
// This code is contributed by Ryuga
?>

Javascript




<script>
 
// JavaScript implementation of the approach
 
// Function to return the maximum
// count of pairs with equal sum
function maxCountSameSUM(arr, n)
{
    // Create a map to store frequency
    var M = new Map();
 
    // Store counts of sum of all pairs
    // in the map
    for (var i = 0; i < n - 1; i++)
        for (var j = i + 1; j < n; j++)
        {
            if(M.has(arr[i] + arr[j]))
                M.set(arr[i] + arr[j], M.get(arr[i] + arr[j])+1)
            else   
                M.set(arr[i] + arr[j], 1);
        }
 
    var max_count = 0;
 
    // Find maximum count
    M.forEach((value, key) => {
         
        if (max_count < value)
            max_count = value;
    });
 
    return max_count;
}
 
// Driver code
var arr = [1, 8, 3, 11, 4, 9, 2, 7];
var n = arr.length;
document.write( maxCountSameSUM(arr, n));
 
</script>

Output

3

Time Complexity: O(n^2) as two loops are used to traverse the entire array.
Auxiliary Space: O(n), for storing counts of the sum of all pairs in the map


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!