Maximum Product of Three Numbers - Practice Coding Problems

Maximum Product of Three Numbers - Problem

Given an integer array nums, you need to find three numbers whose product is the maximum possible and return this maximum product.

The array can contain both positive and negative integers, which makes this problem more interesting than it first appears! Consider that the product of two negative numbers is positive, so the maximum product might not always come from the three largest numbers.

Example: In array [1, 2, 3, 4], the maximum product is 2 × 3 × 4 = 24. But in array [-4, -3, -2, -1, 60], the maximum product is (-4) × (-3) × 60 = 720!

Your task is to efficiently find and return the maximum possible product of any three numbers from the array.

Input & Output

example_1.py — Basic Positive Numbers

$ Input: [1, 2, 3]

› Output: 6

💡 Note: The array has exactly three numbers, so we multiply all of them: 1 × 2 × 3 = 6.

example_2.py — Mixed Positive Numbers

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

› Output: 24

💡 Note: The maximum product comes from the three largest numbers: 2 × 3 × 4 = 24. Using 1 would give a smaller product.

example_3.py — Negative Numbers Present

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

› Output: 24

💡 Note: Two negative numbers multiply to make a positive: (-2) × (-3) × 4 = 6 × 4 = 24. This is better than (-1) × (-2) × (-3) = -6.

Visualization

Tap to expand

Understanding the Visualization

Sort the Portfolio

Arrange all investments from worst to best performance

Identify Key Players

Focus on the 2 worst performers and 3 best performers

Strategy 1: Play It Safe

Choose the 3 best performing investments

Strategy 2: Risk Mitigation

Use 2 worst performers (they cancel out) + 1 best performer

Choose the Winner

Compare both strategies and pick the one with maximum return

Key Takeaway

🎯 Key Insight: The maximum product of three numbers comes from either the three largest values OR two smallest values (if negative) times the largest value. Sorting helps us quickly identify these candidates!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by the sorting step, comparison is O(1)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations (assuming in-place sort)

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 10⁴
-1000 ≤ nums[i] ≤ 1000
The array will always have at least 3 elements

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 Apple 28

The optimal approach sorts the array and compares two scenarios: the product of the three largest numbers versus the product of the two smallest numbers times the largest number. This handles negative numbers correctly since two negatives make a positive. Time complexity: O(n log n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Analysis (Optimal)	O(n log n)	O(1)	Sort array and compare the two possible maximum scenarios
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible combination of three numbers

Sorting + Analysis (Optimal) — Algorithm Steps

Sort the array in ascending order
Calculate product of three largest numbers (last three elements)
Calculate product of two smallest numbers with the largest number
Return the maximum of these two products

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Arrange elements from smallest to largest

Identify Candidates

Mark the two smallest and three largest elements

Scenario 1

Calculate product of three largest numbers

Scenario 2

Calculate product of two smallest × largest

Compare

Return the maximum of the two scenarios

Code -

solution.c — C

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

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

int maximumProduct(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Two possible scenarios for maximum product:
    // 1. Three largest numbers
    int scenario1 = nums[numsSize-1] * nums[numsSize-2] * nums[numsSize-3];
    
    // 2. Two smallest (possibly large negative) * largest
    int scenario2 = nums[0] * nums[1] * nums[numsSize-1];
    
    return scenario1 > scenario2 ? scenario1 : scenario2;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by the sorting step, comparison is O(1)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations (assuming in-place sort)

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 10⁴
-1000 ≤ nums[i] ≤ 1000
The array will always have at least 3 elements

35.0K Views

Medium-High Frequency

~15 min Avg. Time

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

Sorting + Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler