Maximum Product of Two Elements in an Array

Maximum Product of Two Elements in an Array - Problem

Given an array of integers nums, your task is to find two different elements that will give you the maximum possible product when you subtract 1 from each and multiply them together.

More specifically, you need to choose two different indices i and j from the array and return the maximum value of (nums[i] - 1) * (nums[j] - 1).

Example: If you have the array [3, 4, 5, 2], you could pick indices 1 and 2 (values 4 and 5) to get (4-1) * (5-1) = 3 * 4 = 12, which happens to be the maximum possible product!

🎯 Goal: Find the pair of elements that maximizes the product after subtracting 1 from each.

Input & Output

example_1.py — Basic Case

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

› Output: 12

💡 Note: We can choose indices 1 and 2 (values 4 and 5). The product is (4-1)*(5-1) = 3*4 = 12, which is the maximum possible.

example_2.py — Larger Numbers

$ Input: [1,5,4,5]

› Output: 16

💡 Note: We can choose indices 1 and 3 (both values are 5). The product is (5-1)*(5-1) = 4*4 = 16.

example_3.py — Minimum Case

$ Input: [3,7]

› Output: 12

💡 Note: With only two elements, we must choose both. The product is (3-1)*(7-1) = 2*6 = 12.

Constraints

2 ≤ nums.length ≤ 500
1 ≤ nums[i] ≤ 10³
You must choose two different indices (i ≠ j)

Visualization

Tap to expand

Understanding the Visualization

Survey All Competitors

Look at each person's strength level in the array

Find the Champions

Identify the two strongest competitors

Calculate Prize Money

Multiply their adjusted strengths: (max-1) × (second_max-1)

Key Takeaway

🎯 Key Insight: Since we're multiplying positive numbers (after subtracting 1), the maximum product always comes from the two largest values in the array!

Asked in

a Amazon 45 ⊞ Microsoft 32 Apple 28 G Google 15

The optimal approach is to find the two largest elements in the array since multiplying the largest values (after subtracting 1) will always give the maximum product. This can be done by either sorting the array in O(n log n) time, or by making a single pass to find the two maximum values in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Two Largest Elements	O(n log n)	O(1)	Sort the array and pick the two largest elements
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs and find the maximum product

Sorting + Two Largest Elements — Algorithm Steps

Sort the array in ascending order
Take the two largest elements (last two in sorted array)
Calculate and return (largest - 1) * (second_largest - 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with unsorted array

Sort Array

Sort in ascending order

Pick Two Largest

Select last two elements

Code -

solution.c — C

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

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

int maxProduct(int* nums, int n) {
    qsort(nums, n, sizeof(int), compare);
    return (nums[n - 1] - 1) * (nums[n - 2] - 1);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maxProduct(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by the sorting step, finding max elements is O(1) after sorting

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space if we can modify input, O(n) if we need to preserve original

✓ Linear Space

67.2K Views

High Frequency

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

Sorting + Two Largest Elements — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler