Product of Array Except Self: Prefix and Suffix, Explained

The Problem

You are given an array of integers. Return a new array of the same length where position i holds the product of every element except the one at i. The usual rules: do not use division, and aim for O(n) time.

Example 1

Input: nums = [1, 2, 3, 4]
Output: [24, 12, 8, 6]
Why: position 0 is 2 × 3 × 4 = 24, position 1 is 1 × 3 × 4 = 12, and so on.

Example 2

Input: nums = [-1, 1, 0, -3, 3]
Output: [0, 0, 9, 0, 0]
Why: every product that includes the 0 is 0. Only position 2, which skips the 0, is non-zero: -1 × 1 × -3 × 3 = 9.

Assumptions to confirm

• Can the array contain zeros or negative numbers? (Assume yes.)
• Will the products fit in a normal integer? (Usually guaranteed; ask, because it changes the types you pick.)
• Does the output array count as extra space? (By convention, no.)

Start With the Brute Force

The direct answer loops over every position and multiplies all the other elements: O(n²) time and O(1) extra space. Say it, then name the repeated work: the products of long stretches of the array are computed again for almost every position.

Many candidates then suggest multiplying everything once and dividing by each element. Mention it, but explain why it is ruled out: division is usually forbidden, and it breaks when the array contains a zero.

The Optimal Approach: Prefix and Suffix Products

Solution in Python and TypeScript

Both versions reuse the output array for the left products, so the only extra memory is two numbers.

Python

def product_except_self(nums: list[int]) -> list[int]:
    n = len(nums)
    result = [1] * n
    prefix = 1
    for i in range(n):  # result[i] = product of everything left of i
        result[i] = prefix
        prefix *= nums[i]
    suffix = 1
    for i in range(n - 1, -1, -1):  # multiply in everything right of i
        result[i] *= suffix
        suffix *= nums[i]
    return result

TypeScript

function productExceptSelf(nums: number[]): number[] {
  const n = nums.length;
  const result = new Array<number>(n).fill(1);
  let prefix = 1;
  for (let i = 0; i < n; i++) { // result[i] = product of everything left of i
    result[i] = prefix;
    prefix *= nums[i];
  }
  let suffix = 1;
  for (let i = n - 1; i >= 0; i--) { // multiply in everything right of i
    result[i] *= suffix;
    suffix *= nums[i];
  }
  return result;
}

The order inside each loop is the whole trick: store first, multiply second. If you multiplied first, each position would include its own value.

Time and Space Complexity

How to Talk Through Product of Array Except Self in an Interview

1. Clarify: "Can there be zeros or negatives? Is division allowed? Does the output count towards space?"
2. Brute force: "For each position I could multiply all the others. That is quadratic."
3. Optimise: "Each answer is the product to the left times the product to the right. I can build both with running products in two passes, and store the left side directly in the output."
4. Code: narrate why each loop stores before it multiplies.
5. Test: [1, 2, 3, 4], then an array with one zero, then two zeros. State O(n) time and O(1) extra space.

Edge Cases and Common Follow-Ups

Practise Product of Array Except Self in a Mock Coding Round

Reading a solution is not the same as producing one with someone listening. The gap shows up as long silences, a jump straight to code without a brute force, or a bug you only spot after the interviewer asks you to test. The fix is to rehearse problems like Product of Array Except Self out loud, under time pressure, while explaining each decision.

MockIF runs mock coding interviews with a voice AI interviewer in a real in-browser editor, in Python and TypeScript. It runs your code against tests, asks you to explain your approach, adds follow-up questions the way a real interviewer would, and then scores your answer and gives specific feedback. Each session costs 2 credits. It is free to start with 5 credits, then monthly or 3-monthly plans, or one-off credit packs (see pricing).

Frequently Asked Questions