Largest pair sum in an array

Given an unsorted array arr[] of distinct integers, find the largest pair sum in it. If there are less than 2 elements, then we need to return -1.

Input : arr[] = [12, 34, 10, 6, 40]
Output : 74
Explanation : The two largest elements are 40 and 34. Their sum is 74.
Input : arr[] = [10, 10, 10]
Output : 20
Explanation : Any two 10's give the maximum sum.
Input arr[] = [10]
Output : -1
Explanation : At least two elements are required to form a pair.

Try It Yourself

Table of Content

[Naive Approach] Using Nested Loops - O(n^2) Time and O(1) Space
[Expected Approach] Largest two Elements - O(n) Time and O(1) Space

[Naive Approach] Using Nested Loops - O(n²) Time and O(1) Space

The idea is to use two nested loops to iterate over all possible pairs of integers in the array, compute their sum and keep track of the maximum sum encountered so far.

C++

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int pairsum(vector<int> &arr)
{
    int maxSum = INT_MIN;
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int sum = arr[i] + arr[j];
            if (sum > maxSum) {
                maxSum = sum;
            }
        }
    }
    return (maxSum == INT_MIN)? -1 :  maxSum;
}

int main()
{
    vector<int> arr = { 12, 34, 10, 6, 40 };
    cout << "Max Pair Sum is "
        << pairsum(arr);
    return 0;
}

#include <stdio.h>
#include <limits.h>

int pairsum(int arr[], int n) {
    int maxSum = INT_MIN;
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int sum = arr[i] + arr[j];
            if (sum > maxSum) {
                maxSum = sum;
            }
        }
    }
    return (maxSum == INT_MIN) ? -1 : maxSum;
}

int main() {
    int arr[] = {12, 34, 10, 6, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Max Pair Sum is %d\n", pairsum(arr, n));
    return 0;
}

Java

class GFG {

    static int pairsum(int[] arr) {
        int maxSum = Integer.MIN_VALUE;
        int n = arr.length;

        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                int sum = arr[i] + arr[j];
                if (sum > maxSum) {
                    maxSum = sum;
                }
            }
        }

        return (maxSum == Integer.MIN_VALUE) ? -1 : maxSum;
    }

    public static void main(String[] args) {
        int[] arr = { 12, 34, 10, 6, 40 };
        System.out.println("Max Pair Sum is " + pairsum(arr));
    }
}

Python

def pairsum(arr):
    maxSum = float('-inf')
    n = len(arr)
    for i in range(n - 1):
        for j in range(i + 1, n):
            sum = arr[i] + arr[j]
            if sum > maxSum:
                maxSum = sum
    return -1 if maxSum == float('-inf') else maxSum

if __name__ == "__main__":
    arr = [12, 34, 10, 6, 40]
    print("Max Pair Sum is ", pairsum(arr))

using System;

class GFG
{
    static int pairsum(int[] arr)
    {
        int maxSum = int.MinValue;
        int n = arr.Length;

        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                int sum = arr[i] + arr[j];
                if (sum > maxSum)
                {
                    maxSum = sum;
                }
            }
        }

        return (maxSum == int.MinValue) ? -1 : maxSum;
    }

    static void Main()
    {
        int[] arr = { 12, 34, 10, 6, 40 };
        Console.WriteLine("Max Pair Sum is " + pairsum(arr));
    }
}

JavaScript

function pairsum(arr) {
    let maxSum = Number.NEGATIVE_INFINITY;
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = i + 1; j < n; j++) {
            let sum = arr[i] + arr[j];
            if (sum > maxSum) {
                maxSum = sum;
            }
        }
    }
    return (maxSum === Number.NEGATIVE_INFINITY) ? -1 : maxSum;
}

// Custom Input
let arr = [12, 34, 10, 6, 40];
console.log("Max Pair Sum is ", pairsum(arr));

Output

Max Pair Sum is 74

[Expected Approach] Largest two Elements - O(n) Time and O(1) Space

The largest pair sum in an array is always formed by the largest and second-largest elements. Instead of checking all possible pairs, we traverse the array once and keep track of these two values. Whenever a larger element is found, we update the largest and second-largest accordingly. Finally, their sum gives the required maximum pair sum.

C++

#include <iostream>
#include <vector>
using namespace std;

int pairsum(vector<int>& arr)
{
    int n = arr.size();
    if (n < 2) return -1; 
  
    // Initialize first and second largest element
    int first, second;
    if (arr[0] > arr[1]) {
        first = arr[0];
        second = arr[1];
    }
    else {
        first = arr[1];
        second = arr[0];
    }

    // Traverse remaining array and find first and second
    // largest elements in overall array
    for (int i = 2; i < n; i++) {

        // If current element is greater than first
        if (arr[i] > first) {
            second = first;
            first = arr[i];
        }
        // If element is between first and second
        else if (arr[i] > second)
            second = arr[i];
    }
    return (first + second);
}

int main()
{
    vector<int> arr = { 12, 34, 10, 6, 40 };
    cout << "Max Pair Sum is "
         << pairsum(arr);
    return 0;
}

#include <stdio.h>
#include <limits.h>

int pairsum(int arr[], int n) {
    if (n < 2) return -1;

    // Initialize first and second largest element
    int first, second;
    if (arr[0] > arr[1]) {
        first = arr[0];
        second = arr[1];
    } else {
        first = arr[1];
        second = arr[0];
    }

    // Traverse remaining array and find first and second
    // largest elements in overall array
    for (int i = 2; i < n; i++) {
      
        // If current element is greater than first
        if (arr[i] > first) {
            second = first;
            first = arr[i];
        } else if (arr[i] > second) {
            // If element is between first and second
            second = arr[i];
        }
    }
    return (first + second);
}

int main() {
    int arr[] = {12, 34, 10, 6, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Max Pair Sum is %d\n", pairsum(arr, n));
    return 0;
}