Maximum Product Subarray - Practice Coding Problems

Maximum Product Subarray - Problem

Given an integer array nums, find the contiguous subarray (containing at least one element) that has the largest product, and return that product.

This is a twist on the classic Maximum Subarray problem! Unlike sum where we only worry about negative numbers, with products we need to consider both negative numbers (which can flip signs) and zeros (which reset everything).

Key Challenge: A negative number can turn a small product into a large one if multiplied by another negative number!

Example: In array [2,3,-2,4], the maximum product subarray is [2,3] with product 6, not the entire array which gives -48.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: The subarray [2,3] has the largest product 6. Even though the entire array multiplies to -48, we stop at [2,3] to get the maximum.

example_2.py — Single Element

$ Input: [-2]

› Output: -2

💡 Note: With only one element, the maximum product subarray is the element itself, which is -2.

example_3.py — Zero in Array

$ Input: [-2,0,-1]

› Output: 0

💡 Note: The result is 0 because we can choose the subarray [0] which gives product 0, better than any negative products from [-2] or [-1].

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-10 ≤ nums[i] ≤ 10
The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Track Best and Worst Streaks

Keep track of your current best and worst performing periods

Handle Negative Days

On negative days, your worst streak might become your best tomorrow

Reset on Zero

Market crashes (zeros) reset everything - start fresh

Update Maximum

Always remember your historical best performance

Key Takeaway

🎯 Key Insight: By tracking both best and worst streaks simultaneously, we can handle the sign-flipping nature of negative numbers and always capture the optimal subarray product.

Asked in

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

The optimal solution uses dynamic programming to track both minimum and maximum products ending at each position. This handles the key insight that negative numbers can flip small products into large ones. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check the product of every possible contiguous subarray
Dynamic Programming - Track Min/Max	O(n)	O(1)	Keep track of both minimum and maximum products ending at each position

Brute Force (Check All Subarrays) — Algorithm Steps

Use outer loop to pick starting index i
Use inner loop to pick ending index j (from i to n-1)
Calculate product of elements from i to j
Update maximum product if current product is larger
Return the maximum product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Check all subarrays starting from index 0

Move to index 1

Check all subarrays starting from index 1

Continue pattern

Repeat for all starting positions

Code -

solution.c — C

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

int maxProduct(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int maxProduct = nums[0];
    
    for (int i = 0; i < numsSize; i++) {
        int currentProduct = 1;
        for (int j = i; j < numsSize; j++) {
            currentProduct *= nums[j];
            if (currentProduct > maxProduct) {
                maxProduct = currentProduct;
            }
        }
    }
    
    return maxProduct;
}

int main() {
    int nums[] = {2, 3, -2, 4};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maxProduct(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate through all possible subarray combinations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

52.3K Views

High 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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler