Maximum Product Subarray in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Maximum Product Subarray Calculation

What is the output of the following TypeScript code that finds the maximum product of a contiguous subarray?

DSA Typescript

function maxProduct(nums: number[]): number {
  let maxProd = nums[0];
  let minProd = nums[0];
  let result = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] < 0) {
      [maxProd, minProd] = [minProd, maxProd];
    }
    maxProd = Math.max(nums[i], maxProd * nums[i]);
    minProd = Math.min(nums[i], minProd * nums[i]);
    result = Math.max(result, maxProd);
  }
  return result;
}

console.log(maxProduct([2, 3, -2, 4]));

A 8

B 4

C -2

D 6

💡 Hint

Think about how negative numbers affect the product and how swapping max and min helps.

The maximum product subarray is [2, 3] with product 6. The negative number -2 resets the product, so the max product remains 6.

❓ Predict Output

intermediate

Result of Maximum Product Subarray with Negative Numbers

What will be printed after running this TypeScript code?

DSA Typescript

function maxProduct(nums: number[]): number {
  let maxProd = nums[0];
  let minProd = nums[0];
  let result = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] < 0) {
      [maxProd, minProd] = [minProd, maxProd];
    }
    maxProd = Math.max(nums[i], maxProd * nums[i]);
    minProd = Math.min(nums[i], minProd * nums[i]);
    result = Math.max(result, maxProd);
  }
  return result;
}

console.log(maxProduct([-2, 0, -1]));

A -1

B 0

C -2

D 1

💡 Hint

Zero resets the product, so consider subarrays around zero.

The maximum product subarray is [0] with product 0. Negative numbers alone produce smaller products.

🔧 Debug

advanced

Identify the Error in Maximum Product Subarray Implementation

This TypeScript function aims to find the maximum product subarray but produces wrong results. What is the error?

DSA Typescript

function maxProduct(nums: number[]): number {
  let maxProd = 1;
  let minProd = 1;
  let result = Number.MIN_SAFE_INTEGER;
  for (let num of nums) {
    let tempMax = maxProd * num;
    maxProd = Math.max(tempMax, minProd * num, num);
    minProd = Math.min(tempMax, minProd * num, num);
    result = Math.max(result, maxProd);
  }
  return result;
}

console.log(maxProduct([2, 3, -2, 4]));

A Swapping maxProd and minProd when num is negative is missing, causing wrong min/max tracking.

B Using Number.MIN_SAFE_INTEGER for result causes overflow errors.

C The for loop should use index-based iteration instead of for-of.

D Initializing maxProd and minProd to 1 causes incorrect results for arrays starting with negative or zero values.

💡 Hint

Handling negative numbers requires swapping max and min products.

Without swapping maxProd and minProd when num is negative, the algorithm fails to track correct max/min products.

🚀 Application

advanced

Maximum Product Subarray in a Circular Array

Given a circular array (the end connects to the start), which approach correctly finds the maximum product subarray?

A Double the array and find the max product subarray in the doubled array using the standard method.

B Use Kadane's algorithm directly on the circular array without modifications.

C Calculate max product subarray normally, then calculate max product subarray excluding the minimum product subarray, and take the max of both.

D Sort the array and multiply the largest elements to get the maximum product.

💡 Hint

Think about how circular subarrays can wrap around and how to handle that.

The maximum product subarray in a circular array can be the max of normal max product or the product that wraps around, which is total product divided by minimum product subarray.

🧠 Conceptual

expert

Why Track Both Maximum and Minimum Products in Maximum Product Subarray?

Why does the algorithm for maximum product subarray keep track of both maximum and minimum products at each step?

A Because a negative number can turn a minimum product into a maximum product when multiplied, so tracking both helps handle negatives correctly.

B Because the minimum product is needed to calculate the average product of the subarray.

C Because the minimum product is used to reset the maximum product when zero is encountered.

D Because tracking minimum product helps in sorting the array for faster computation.

💡 Hint

Consider how multiplying by a negative number affects product signs.

Multiplying a negative number by the current minimum product (which may be negative) can produce a new maximum product, so both must be tracked.

Practice

1. What does the "Maximum Product Subarray" problem ask you to find in an array of integers?

easy

A. The subarray with the largest sum of its elements

B. The contiguous subarray with the largest product of its elements

C. The longest subarray with all positive numbers

D. The subarray with the smallest product of its elements

Solution

1. Step 1: Understand the problem statement

   The problem asks for a contiguous part of the array where the product of all numbers is as large as possible.

2. Step 2: Differentiate from similar problems

   This is different from finding the largest sum or smallest product; it specifically focuses on the product of elements in a continuous segment.

3. Final Answer:

   The contiguous subarray with the largest product of its elements -> Option B

4. Quick Check:

   Maximum product subarray means largest product segment [OK]

Hint: Look for continuous elements with max product, not sum [OK]

Common Mistakes:

• Confusing product with sum
• Ignoring that subarray must be contiguous
• Thinking about longest subarray instead of max product

2. Which of the following TypeScript function signatures correctly represents a function to find the maximum product subarray?

easy

A. function maxProduct(nums: number[]): number

B. function maxProduct(nums: string): number

C. function maxProduct(nums: number): number[]

D. function maxProduct(nums: number[]): string

Solution

1. Step 1: Check input parameter type

   The input should be an array of numbers, so nums: number[] is correct.

2. Step 2: Check return type

   The function returns the maximum product value, which is a number, not an array or string.

3. Final Answer:

   function maxProduct(nums: number[]): number -> Option A

4. Quick Check:

   Input array, output number matches signature [OK]

Hint: Input is number array, output is single number [OK]

Common Mistakes:

• Using string type for input or output
• Returning array instead of number
• Incorrect parameter types

3. What is the output of the following TypeScript code?

function maxProduct(nums: number[]): number {
  let maxProd = nums[0];
  let minProd = nums[0];
  let result = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] < 0) {
      [maxProd, minProd] = [minProd, maxProd];
    }
    maxProd = Math.max(nums[i], maxProd * nums[i]);
    minProd = Math.min(nums[i], minProd * nums[i]);
    result = Math.max(result, maxProd);
  }
  return result;
}

console.log(maxProduct([2, 3, -2, 4]));

medium

A. 6

B. 4

C. -2

D. 24

Solution

1. Step 1: Initialize variables and start loop

   maxProd, minProd, and result start at 2. Loop from index 1 to 3.

2. Step 2: Iterate and update maxProd, minProd, and result

   At i=1 (3): maxProd = max(3, 2*3)=6, minProd = min(3, 2*3)=3, result=6.
   At i=2 (-2): nums[i]<0, swap maxProd and minProd: maxProd=3, minProd=6.
   maxProd = max(-2, 3*(-2)) = max(-2, -6) = -2.
   minProd = min(-2, 6*(-2)) = min(-2, -12) = -12.
   result = max(6, -2) = 6.
   At i=3 (4): maxProd = max(4, -2*4) = max(4, -8) = 4.
   minProd = min(4, -12*4) = min(4, -48) = -48.
   result = max(6, 4) = 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Max product subarray is [2,3] = 6 [OK]

Hint: Track max and min products, swap on negative [OK]

Common Mistakes:

• Not swapping max and min on negative number
• Only tracking max product, ignoring min product
• Confusing max product with sum

4. Identify the bug in this TypeScript function for maximum product subarray:

function maxProduct(nums: number[]): number {
  let maxProd = 1;
  let minProd = 1;
  let result = Number.MIN_VALUE;
  for (let num of nums) {
    if (num < 0) {
      let temp = maxProd;
      maxProd = minProd;
      minProd = temp;
    }
    maxProd = Math.max(num, maxProd * num);
    minProd = Math.min(num, minProd * num);
    result = Math.max(result, maxProd);
  }
  return result;
}

medium

A. Initializing maxProd and minProd to 0 instead of 1

B. Not swapping maxProd and minProd when num is positive

C. Using a for loop instead of forEach

D. Using Number.MIN_VALUE instead of Number.NEGATIVE_INFINITY for result

Solution

1. Step 1: Understand Number.MIN_VALUE usage

   Number.MIN_VALUE is the smallest positive number close to zero, not the most negative number.

2. Step 2: Correct initialization for result

   To track maximum product correctly, result should start at Number.NEGATIVE_INFINITY to handle negative products properly.

3. Final Answer:

   Using Number.MIN_VALUE instead of Number.NEGATIVE_INFINITY for result -> Option D

4. Quick Check:

   Use Number.NEGATIVE_INFINITY for max tracking [OK]

Hint: Use Number.NEGATIVE_INFINITY for max initial value [OK]

Common Mistakes:

• Confusing Number.MIN_VALUE with negative infinity
• Not swapping max and min on negative number
• Wrong initial values for maxProd and minProd

5. Given the array [-1, -3, -10, 0, 60], what is the maximum product subarray and its product?

hard

A. Subarray: [-1, -3, -10], Product: -30

B. Subarray: [-3, -10, 0], Product: 0

C. Subarray: [60], Product: 60

D. Subarray: [-10, 0, 60], Product: 0

Solution

1. Step 1: Analyze subarrays and their products

   Check products of contiguous subarrays:
   [-1] = -1
   [-1, -3] = 3
   [-1, -3, -10] = -30
   [-3] = -3
   [-3, -10] = 30
   [-10] = -10
   [0] = 0
   [60] = 60

2. Step 2: Identify maximum product

   The largest product found is 60 from subarray [60].

3. Final Answer:

   Subarray: [60], Product: 60 -> Option C

4. Quick Check:

   Max product is 60 from single element [60] [OK]

Hint: Check single elements and negative pairs carefully [OK]

Common Mistakes:

• Assuming negative product is maximum
• Ignoring single element subarrays
• Confusing zero product with max product