Minimize the Maximum Difference of Pairs - Practice Coding Problems

Minimize the Maximum Difference of Pairs - Problem

Imagine you're a matchmaker trying to create the most harmonious pairs possible! 🎯

You have an array of integers nums and need to form exactly p pairs from these numbers. Your goal is to minimize the maximum difference among all pairs you create.

The Challenge: Each number can only be used once, and you want to make sure that even the "worst" pair (the one with the largest difference) is as good as possible.

For example, if nums = [10, 1, 2, 7, 1, 3] and p = 2, you could pair:

Option 1: (1,1) and (2,3) → differences: 0 and 1 → maximum = 1
Option 2: (1,2) and (3,7) → differences: 1 and 4 → maximum = 4

Clearly, Option 1 is better! Return the minimum possible maximum difference.

Note: If p = 0 (no pairs needed), return 0.

Input & Output

example_1.py — Basic Case

$ Input: nums = [10,1,2,7,1,3], p = 2

› Output: 1

💡 Note: The optimal pairing is (1,1) with difference 0 and (2,3) with difference 1. The maximum difference is 1, which is the minimum possible.

example_2.py — Single Pair

$ Input: nums = [4,2,1,2], p = 1

› Output: 0

💡 Note: We can pair the two 2's together, giving us a difference of 0, which is optimal.

example_3.py — No Pairs Needed

$ Input: nums = [1,2,3,4], p = 0

› Output: 0

💡 Note: No pairs are needed, so we return 0 by definition.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
0 ≤ p ≤ (nums.length)/2
Each index can appear in at most one pair

Visualization

Tap to expand

Understanding the Visualization

Line Up Dancers

Sort dancers by skill level so similar dancers are adjacent

Binary Search Strategy

Ask: 'Can we form enough pairs with max skill gap ≤ X?'

Greedy Pairing

Always pair adjacent dancers when possible - they have the smallest gaps

Find Sweet Spot

Binary search finds the minimum X where we can form enough pairs

Key Takeaway

🎯 Key Insight: Binary search on the answer + greedy validation creates an elegant O(n log n) solution that's both intuitive and optimal!

Asked in

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

The optimal solution uses binary search on the answer combined with a greedy validation. After sorting the array, we binary search on possible maximum differences (0 to max-min). For each candidate, we greedily pair adjacent elements if their difference is within the limit. This approach runs in O(n log n) time and O(1) space, making it highly efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(n log n)	O(1)	Binary search on the answer combined with greedy pairing validation
Brute Force (Try All Combinations)	O(n! / (n-2p)!)	O(p)	Generate all possible ways to choose p pairs and find the minimum maximum difference

Binary Search + Greedy (Optimal) — Algorithm Steps

Sort the array to enable greedy pairing
Binary search on possible maximum differences (0 to max_element - min_element)
For each candidate maximum difference, greedily check if p pairs can be formed
Greedy strategy: scan sorted array and pair adjacent elements if their difference ≤ candidate
If we can form ≥ p pairs, the candidate is valid; try smaller values
If we can't form p pairs, try larger values

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort to enable greedy pairing of adjacent elements

Binary Search Range

Search between 0 and max_element - min_element

Greedy Validation

For each candidate, greedily pair adjacent elements

Narrow Search

If valid, try smaller; if invalid, try larger

Code -

solution.c — C

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

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

int canFormPairs(int* nums, int n, int p, int maxDiff) {
    int pairs = 0;
    for (int i = 0; i < n - 1; ) {
        if (nums[i + 1] - nums[i] <= maxDiff) {
            pairs++;
            i += 2;
        } else {
            i++;
        }
    }
    return pairs >= p;
}

int minimizeMax(int* nums, int numsSize, int p) {
    if (p == 0) return 0;
    
    qsort(nums, numsSize, sizeof(int), compare);
    
    int left = 0, right = nums[numsSize - 1] - nums[0];
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canFormPairs(nums, numsSize, p, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log(max-min)) for binary search with O(n) validation each time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search bounds and counters

✓ Linear Space

67.0K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler