Minimize Maximum Pair Sum in Array - Practice Coding Problems

Minimize Maximum Pair Sum in Array - Problem

Imagine you're organizing a dance competition where dancers need to be paired up optimally! 💃🕺

You have an array of nums with an even length n, and you need to pair up all elements into n/2 pairs. Each element must be used exactly once.

The pair sum of a pair (a, b) equals a + b. The maximum pair sum is the largest sum among all pairs.

For example, with pairs (1,5), (2,3), and (4,4):
• Pair sums: 1+5=6, 2+3=5, 4+4=8
• Maximum pair sum = max(6, 5, 8) = 8

Your goal is to minimize this maximum pair sum by choosing the optimal pairing strategy. Return the smallest possible maximum pair sum.

Input & Output

example_1.py — Basic Example

$ Input: [3,5,2,3]

› Output: 7

💡 Note: After sorting: [2,3,3,5]. Optimal pairs: (2,5) with sum 7, and (3,3) with sum 6. The maximum pair sum is 7.

example_2.py — All Same Elements

$ Input: [3,5,4,2,4,6]

› Output: 8

💡 Note: After sorting: [2,3,4,4,5,6]. Optimal pairs: (2,6)=8, (3,5)=8, (4,4)=8. All pairs have sum 8, so maximum is 8.

example_3.py — Minimum Case

$ Input: [1,2]

› Output: 3

💡 Note: Only one pair possible: (1,2) with sum 3. The maximum (and only) pair sum is 3.

Visualization

Tap to expand

Understanding the Visualization

Sort Elements

Arrange all elements in ascending order to identify extremes

Pair Extremes

Match smallest with largest to create balanced pairs

Continue Inward

Move pointers inward, continuing the pairing strategy

Find Maximum

Track the largest sum among all created pairs

Key Takeaway

🎯 Key Insight: Pairing extremes (smallest with largest) minimizes the maximum pair sum through greedy optimization.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array. Pairing takes O(n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (assuming in-place sorting)

✓ Linear Space

Constraints

n == nums.length
2 <= n <= 10⁵
n is even
1 <= nums[i] <= 10⁵

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal approach uses a greedy strategy: sort the array and pair the smallest element with the largest, second smallest with second largest, etc. This minimizes the maximum pair sum in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal Greedy)	O(n log n)	O(1)	Sort array and pair largest with smallest elements using two pointers
Brute Force (Try All Pairings)	O((n-1)!!)	O(n)	Generate all possible pairings and find the one with minimum maximum sum

Two Pointers (Optimal Greedy) — Algorithm Steps

Sort the array in ascending order
Initialize two pointers: left at start, right at end
Pair nums[left] with nums[right] and calculate their sum
Move left pointer right and right pointer left
Track the maximum sum among all pairs
Return the maximum sum after all pairs are formed

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort elements in ascending order

Initialize Pointers

Place left at start, right at end

Pair Optimally

Pair smallest with largest element

Track Maximum

Keep track of maximum pair sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int minimizeSum(int* nums, int n) {
    // Sort the array to enable greedy pairing
    qsort(nums, n, sizeof(int), compare);
    
    int maxPairSum = 0;
    int left = 0, right = n - 1;
    
    // Pair smallest with largest elements
    while (left < right) {
        int pairSum = nums[left] + nums[right];
        if (pairSum > maxPairSum) {
            maxPairSum = pairSum;
        }
        left++;
        right--;
    }
    
    return maxPairSum;
}

int main() {
    int nums[] = {3, 5, 2, 3};
    int n = 4;
    printf("%d\n", minimizeSum(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the array. Pairing takes O(n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (assuming in-place sorting)

✓ Linear Space

Constraints

n == nums.length
2 <= n <= 10⁵
n is even
1 <= nums[i] <= 10⁵

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal Greedy) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler