Maximum Product Difference Between Two Pairs

Maximum Product Difference Between Two Pairs - Problem

Array Sorting Easy

The product difference between two pairs (a, b) and (c, d) is defined as (a × b) - (c × d).

For example, the product difference between (5, 6) and (2, 7) is (5 × 6) - (2 × 7) = 30 - 14 = 16.

Given an integer array nums, your task is to choose four distinct indices w, x, y, z such that the product difference between pairs (nums[w], nums[x]) and (nums[y], nums[z]) is maximized.

Goal: Return the maximum possible product difference.

Key Insight: To maximize (a × b) - (c × d), we want to maximize a × b and minimize c × d. This means we need the two largest numbers for the first pair and the two smallest numbers for the second pair!

Input & Output

example_1.py — Basic Case

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

› Output: 34

💡 Note: We can choose indices 1,3,2,4 corresponding to values (6,7) and (2,4). The maximum product difference is (6×7) - (2×4) = 42 - 8 = 34.

example_2.py — Simple Case

$ Input: [4,2,5,9,7,3]

› Output: 64

💡 Note: The optimal choice is the two largest values (9,7) and two smallest values (2,3). Maximum difference = (9×7) - (2×3) = 63 - 6 = 57. Wait, let me recalculate: (9×7) - (2×3) = 63 - 6 = 57. Actually, we should check (9×7) - (2×3) = 63 - 6 = 57.

example_3.py — Minimum Case

$ Input: [1,2,3,4]

› Output: 6

💡 Note: With only 4 elements, we must use all of them. The maximum difference is (4×3) - (1×2) = 12 - 2 = 10. Actually: (4×3) - (1×2) = 12 - 2 = 10.

Constraints

4 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁴
Array contains at least 4 elements
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Analyze All Stocks

Sort all available stocks by performance (like sorting the array)

Pick Top Performers

Choose the 2 best stocks for your growth portfolio (largest elements)

Pick Conservative Options

Choose the 2 most stable/lowest-risk stocks for conservative portfolio (smallest elements)

Calculate Performance Gap

Subtract conservative portfolio returns from growth portfolio returns

Key Takeaway

🎯 Key Insight: Just like in investing, the maximum difference comes from pairing extremes - the highest performers together and the lowest performers together. No need to check every possible combination!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses sorting to easily identify the two largest and two smallest elements. After sorting, we calculate (max₁ × max₂) - (min₁ × min₂) directly. This approach has O(n log n) time complexity due to sorting, which is much better than the brute force O(n⁴) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n⁴)	O(1)	Check every possible combination of 4 distinct indices
Sorting + Two Pointers (Optimal)	O(n log n)	O(1) or O(n)	Sort array and pick the two largest and two smallest elements

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of 4 distinct indices (C(n,4))
For each combination of 4 indices, create all possible pairings
Calculate product difference for each pairing: (a×b) - (c×d)
Keep track of the maximum product difference
Return the maximum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible groups of 4 distinct indices

Try Pairings

For each group, try both ways to pair them

Calculate Difference

Compute (a×b) - (c×d) for each pairing

Track Maximum

Keep the largest difference found

Code -

solution.c — C

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

int maxProductDifference(int* nums, int n) {
    int maxDiff = INT_MIN;
    
    // Try all combinations of 4 distinct indices
    for (int w = 0; w < n; w++) {
        for (int x = w + 1; x < n; x++) {
            for (int y = 0; y < n; y++) {
                if (y == w || y == x) continue;
                for (int z = y + 1; z < n; z++) {
                    if (z == w || z == x) continue;
                    
                    // Try both possible pairings
                    int diff1 = (nums[w] * nums[x]) - (nums[y] * nums[z]);
                    int diff2 = (nums[y] * nums[z]) - (nums[w] * nums[x]);
                    
                    if (diff1 > maxDiff) maxDiff = diff1;
                    if (diff2 > maxDiff) maxDiff = diff2;
                }
            }
        }
    }
    
    return maxDiff;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", maxProductDifference(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We need to check C(n,4) = n!/(4!(n-4)!) combinations, which is roughly n⁴/24 for large n

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track indices and maximum difference

✓ Linear Space

42.0K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler