How do you solve Product of Array Except Self using the Prefix × Suffix in One Array (Optimal) approach?

When to use it: The intended answer — O(n) time, O(1) extra space, division-free. Define `answer[i]` as the product of all elements to the left of `i` times the product of all elements to the right. Build it in two passes: 1. **Left pass.** Maintain `prefix = 1`. For each `i` from left to right, set `answer[i] = prefix` (the product of everything strictly before `i`), then update `prefix *= nums[i]`. Crucially we write *before* multiplying, so `answer[i]` never includes `nums[i]`. 2. **Right pass.** Maintain `suffix = 1`. For each `i` from right to left, multiply `answer[i] *= suffix`, then update `suffix *= nums[i]`. Now `answer[i]` holds prefix×suffix — exactly the product of all-but-self. **Why zeros just work.** If `nums[k] = 0`, then for any `i ≠ k` either the prefix or suffix passes through index `k` and carries the zero, making `answer[i] = 0`. Only `answer[k]` skips its own zero and survives. No special-casing needed — the structure handles it. Time complexity: O(n). Space complexity: O(1).

Loading…

mediumArraysLC #238Frequently asked

Product of Array Except Self

Q: How do you solve Product of Array Except Self using the Division (Why It Fails) approach?

When to use it: Mention only to show you know why it's banned — then discard it. The tempting shortcut is `total = ∏ nums`, then `answer[i] = total / nums[i]`. It's O(n) and tiny — but it's disqualified for two reasons. First, the problem bans the division operator outright. Second, it breaks on zeros: if one element is 0 you'd divide by zero, and if two elements are 0 every answer should be 0 but the formula can't express that cleanly. **Takeaway.** Naming this and explaining *why* it's rejected demonstrates you understood the constraints, then pivots naturally to the prefix/suffix solution. Time complexity: O(n). Space complexity: O(1).

LCPractice

Arrays & Hashing · 5 of 83 · 8 min

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of `nums` except `nums[i]`.

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer. You must write an algorithm that runs in O(n) time and without using the division operation.

In plain English

For each position, multiply together every other element. Equivalently, multiply the running product of everything to its left by the running product of everything to its right — neither of which contains the element itself.

Examples

Example 1

Input: nums = [1, 2, 3, 4]
Output: [24, 12, 8, 6]
Note: answer[0]=2·3·4, answer[1]=1·3·4, answer[2]=1·2·4, answer[3]=1·2·3.

Example 2

Input: nums = [-1, 1, 0, -3, 3]
Output: [0, 0, 9, 0, 0]
Note: Only index 2 (the position of the single zero) gets a non-zero product; every other index multiplies by that zero.

Example 3

Input: nums = [2, 3]
Output: [3, 2]
Note: Each element's answer is just the other element.

Constraints

2 ≤ nums.length ≤ 10⁵
-30 ≤ nums[i] ≤ 30
The product of any prefix or suffix fits in a 32-bit integer
Follow-up: O(1) extra space (the output array does not count)

Clarifying questions4First question: Am I allowed to use division?Explore questions

Q1.Am I allowed to use division?
No — it's explicitly forbidden, and it would also break when any element is zero.
Q2.Can the array contain zeros?
Yes. The prefix/suffix approach handles zeros automatically: an index next to a zero still gets the correct product.
Q3.Does the output array count toward the space budget?
No — the follow-up explicitly excludes the output array, so we can store prefixes there and keep only a scalar for the suffix.
Q4.Could products overflow?
The problem guarantees every prefix/suffix fits in a 32-bit int, so standard int arithmetic is safe here.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

answer[i] = product of everything left of i × product of everything right of i. Compute prefix products in one left-to-right pass, then multiply by suffix products in a right-to-left pass, reusing the output array so it's O(1) extra space. Division is banned (and breaks on zeros), so the two-pass prefix/suffix trick is the intended answer. O(n) time.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can avoid division and still hit O(n) by precomputing left and right partial products, and whether you can squeeze extra space to O(1) using the output array.

Where candidates slip

Reaching for total-product ÷ nums[i] (fails on zeros and is explicitly forbidden), or using separate prefix and suffix arrays without collapsing them.

How to stand out

Derive the two-pass solution from the definition, handle the zero cases by construction (no special-casing needed), and note the output array doesn't count as extra space.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Division (Why It Fails)	`O(n)`	`O(1)`	Mention only to show you know why it's banned — then discard it.	Read
2	Prefix × Suffix in One Array (Optimal)Optimal	`O(n)`	`O(1)`	The intended answer — O(n) time, O(1) extra space, division-free.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.Explore the full tree

Why prefix × suffix

How to read it:Each answer cell is the left running product times the right running product.

Rendering diagram…

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Division (Why It Fails)

TimeO(n)SpaceO(1)

Mention only to show you know why it's banned — then discard it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The naive idea: compute the total product, then divide by each element.

2Hint 2Explore hint

What happens when an element is 0? And the problem forbids division anyway.

3Hint 3Explore hint

Use this to motivate a division-free O(n) method.

A · Core idea

The tempting shortcut is total = ∏ nums, then answer[i] = total / nums[i]. It's O(n) and tiny — but it's disqualified for two reasons. First, the problem bans the division operator outright. Second, it breaks on zeros: if one element is 0 you'd divide by zero, and if two elements are 0 every answer should be 0 but the formula can't express that cleanly.

Takeaway. Naming this and explaining why it's rejected demonstrates you understood the constraints, then pivots naturally to the prefix/suffix solution.

C · Code with teaching comments

Reference implementation preview// Rejected: division is forbidden AND undefined when nums[i] == 0. public int[] productExceptSelf(int[] nums) { int total = 1; for (int n : nums) total *= n; // breaks: total becomes 0 if any zero int[] res = new int[nums.length];Explore the full code

solution.javaJava

Division (Why It Fails) — reference

1 teaching note

1
// Rejected: division is forbidden AND undefined when nums[i] == 0.
2
public int[] productExceptSelf(int[] nums) {
3
    int total = 1;
4
    for (int n : nums) total *= n;       // breaks: total becomes 0 if any zero
5
    int[] res = new int[nums.length];
6
    // Division is banned and crashes on any zero element — why we don't ship this.
7
    for (int i = 0; i < nums.length; i++) res[i] = total / nums[i]; // div by zero
8
    return res;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The zero cases are the real lesson: when division is unsafe, replace 'undo a global aggregate' with 'build the aggregate from the sides'. That reframing is the prefix/suffix idea.

ComplexityO(n) time, O(1) space — Two linear passes, but it's invalid: division is disallowed and undefined for zeros.

E · Edge cases and pitfalls2Submitting division and getting rejected by the no-division rule.Explore edge cases

Pitfalls

Submitting division and getting rejected by the no-division rule.
Crashing or producing wrong output when the array contains one or more zeros.

03.2

Approach 2 of 2 · Optimal

Prefix × Suffix in One Array (Optimal)

TimeO(n)SpaceO(1)

The intended answer — O(n) time, O(1) extra space, division-free.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

answer[i] = (product of everything left of i) × (product of everything right of i). Can you precompute those?

2Hint 2Explore hint

Do a left-to-right pass writing the running prefix product into answer[i] (before multiplying in nums[i]).

3Hint 3Explore hint

Then a right-to-left pass: keep a running suffix product scalar and multiply it into answer[i] before folding nums[i] into the suffix.

A · Core idea

Define answer[i] as the product of all elements to the left of i times the product of all elements to the right. Build it in two passes:

1
Left pass. Maintain prefix = 1. For each i from left to right, set answer[i] = prefix (the product of everything strictly before i), then update prefix *= nums[i]. Crucially we write before multiplying, so answer[i] never includes nums[i].
2
Right pass. Maintain suffix = 1. For each i from right to left, multiply answer[i] *= suffix, then update suffix *= nums[i]. Now answer[i] holds prefix×suffix — exactly the product of all-but-self.

Why zeros just work. If nums[k] = 0, then for any i ≠ k either the prefix or suffix passes through index k and carries the zero, making answer[i] = 0. Only answer[k] skips its own zero and survives. No special-casing needed — the structure handles it.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 3, 4]

Array state

after left pass

res holds prefixes

[0]

[1]

[2]

[3]

Current pointerResolved stateNot processed

Final result[24, 12, 8, 6]

C · Code with teaching comments

solution.javaJava

Prefix × Suffix in One Array (Optimal) — optimal

4 teaching notes

1
public int[] productExceptSelf(int[] nums) {
2
    int n = nums.length;
3
    int[] res = new int[n];
4
    int prefix = 1;
5
    for (int i = 0; i < n; i++) {
6
        // Store product of everything strictly LEFT of i (before folding nums[i] in).
7
        res[i] = prefix;
8
        // Now extend the running prefix to include nums[i] for the next index.
9
        prefix *= nums[i];
10
    }
11
    int suffix = 1;
12
    for (int i = n - 1; i >= 0; i--) {
13
        // Multiply in product of everything RIGHT of i — completes prefix×suffix.
14
        res[i] *= suffix;
15
        // Extend the running suffix leftward for the next index.
16
        suffix *= nums[i];
17
    }
18
    return res;
19
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.19 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The output array doubles as scratch space for the prefix pass, so the only extra memory is the suffix scalar. This 'write the partial aggregate into the result, then fold in the other direction' is the reusable shape behind many prefix/suffix problems.

ComplexityO(n) time, O(1) space — Two linear passes = O(n). The output array holds prefixes (doesn't count), and the suffix is a single scalar → O(1) extra space.

E · Edge cases and pitfalls5nums = [0, 4, 0] — Two zeros → every answer is 0, including the zero positions (each has the other zero on one side).Explore edge cases

Edge cases handled

nums = [0, 4, 0]Two zeros → every answer is 0, including the zero positions (each has the other zero on one side).
nums = [-1, 1, 0, -3, 3]Single zero → only its index gets the product of the rest (9); all others are 0.

Pitfalls

Multiplying nums[i] into prefix BEFORE writing res[i] — then answer[i] wrongly includes itself.
Allocating separate prefix[] and suffix[] arrays — correct but misses the O(1)-space follow-up.
Initializing prefix/suffix to 0 instead of 1 — zeros out every product.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int[] productExceptSelf(int[] nums) { int n = nums.length; int[] res = new int[n]; int prefix = 1; for (int i = 0; i < n; i++) {Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Writing the cell after folding in nums[i]

If you multiply nums[i] into prefix before assigning res[i], the cell includes the element itself, which is exactly what 'except self' forbids.

Explore the code comparison

Don't write this

prefix *= nums[i];
res[i] = prefix; // now includes nums[i] — wrong

Write this instead

res[i] = prefix; // product of everything before i
prefix *= nums[i];

Two extra arrays when O(1) space is asked

Separate prefix[] and suffix[] arrays are O(n) extra space. Store prefixes in the output array and carry the suffix as a single scalar to meet the follow-up.

Explore the code comparison

Don't write this

prefix = [...]; suffix = [...]
res = [prefix[i] * suffix[i] for i in range(n)]

Write this instead

res = [1]*n
# left pass writes prefixes into res, right pass multiplies a scalar suffix

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Prefix × suffix products (no division)

Code pattern to memorize

res[i] = 1
prefix = 1
for i in range(n): res[i] = prefix; prefix *= nums[i]
suffix = 1
for i in range(n-1,-1,-1): res[i] *= suffix; suffix *= nums[i]

Rules to remember

1answer[i] = (product of all left of i) × (product of all right of i) — never includes nums[i].
2No division — it's banned and undefined when any element is 0.
3Write the prefix into res on the way right, then multiply by the running suffix on the way left.
4Reuse the output array for prefixes so the running suffix scalar is the only extra state → O(1) extra space.
5Seed both running products at 1 (multiplicative identity), and res[0]'s prefix is 1 (nothing to its left).

Use this pattern when

Each output depends on 'everything except me' aggregated multiplicatively or additively
Division is disallowed or unsafe (zeros, modular arithmetic)
You can precompute left/right partial aggregates in linear passes

Choose another pattern when

Division is allowed and no zeros → total product ÷ nums[i] is simpler
Need contiguous-subarray products → Maximum Product Subarray (DP), not prefix/suffix
Need sums not products of all-but-self → same prefix/suffix idea but additive

Interview takeaway

Prefix/suffix accumulation answers any 'combine everything except index i' question in O(n) without division. The same two-pass scaffold underlies trapping rain water and many range-aggregate problems.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternPrefix/suffix accumulation. Reach for it when each output combines 'everything except index i', especially when division is disallowed or unsafe. The two-pass scaffold reappears in Trapping Rain Water and range-aggregate problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Maximum Product Subarray
Coming soon
Contiguous products with sign flips — track running max and min (DP).
Range Sum Query — Immutable
Coming soon
Additive prefix sums answer range queries in O(1).
Trapping Rain Water
Uses left-max / right-max prefix-suffix arrays, same two-pass scaffold.

Same pattern

←

Group Anagrams

Continue · Next problem

Encode and Decode Strings

mediumArraysLC #238Frequently asked

Product of Array Except Self

LCPractice

Arrays & Hashing · 5 of 83 · 8 min

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of `nums` except `nums[i]`.

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer. You must write an algorithm that runs in O(n) time and without using the division operation.

In plain English

Examples

Example 1

Input: nums = [1, 2, 3, 4]
Output: [24, 12, 8, 6]
Note: answer[0]=2·3·4, answer[1]=1·3·4, answer[2]=1·2·4, answer[3]=1·2·3.

Example 2

Input: nums = [-1, 1, 0, -3, 3]
Output: [0, 0, 9, 0, 0]
Note: Only index 2 (the position of the single zero) gets a non-zero product; every other index multiplies by that zero.

Example 3

Input: nums = [2, 3]
Output: [3, 2]
Note: Each element's answer is just the other element.

Constraints

2 ≤ nums.length ≤ 10⁵
-30 ≤ nums[i] ≤ 30
The product of any prefix or suffix fits in a 32-bit integer
Follow-up: O(1) extra space (the output array does not count)

Clarifying questions4First question: Am I allowed to use division?Explore questions

Q1.Am I allowed to use division?
No — it's explicitly forbidden, and it would also break when any element is zero.
Q2.Can the array contain zeros?
Yes. The prefix/suffix approach handles zeros automatically: an index next to a zero still gets the correct product.
Q3.Does the output array count toward the space budget?
No — the follow-up explicitly excludes the output array, so we can store prefixes there and keep only a scalar for the suffix.
Q4.Could products overflow?
The problem guarantees every prefix/suffix fits in a 32-bit int, so standard int arithmetic is safe here.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can avoid division and still hit O(n) by precomputing left and right partial products, and whether you can squeeze extra space to O(1) using the output array.

Where candidates slip

Reaching for total-product ÷ nums[i] (fails on zeros and is explicitly forbidden), or using separate prefix and suffix arrays without collapsing them.

How to stand out

Derive the two-pass solution from the definition, handle the zero cases by construction (no special-casing needed), and note the output array doesn't count as extra space.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Division (Why It Fails)	`O(n)`	`O(1)`	Mention only to show you know why it's banned — then discard it.	Read
2	Prefix × Suffix in One Array (Optimal)Optimal	`O(n)`	`O(1)`	The intended answer — O(n) time, O(1) extra space, division-free.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.Explore the full tree

Why prefix × suffix

How to read it:Each answer cell is the left running product times the right running product.

Rendering diagram…

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Division (Why It Fails)

TimeO(n)SpaceO(1)

Mention only to show you know why it's banned — then discard it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The naive idea: compute the total product, then divide by each element.

2Hint 2Explore hint

What happens when an element is 0? And the problem forbids division anyway.

3Hint 3Explore hint

Use this to motivate a division-free O(n) method.

A · Core idea

Takeaway. Naming this and explaining why it's rejected demonstrates you understood the constraints, then pivots naturally to the prefix/suffix solution.

C · Code with teaching comments

solution.javaJava

Division (Why It Fails) — reference

1 teaching note

1
// Rejected: division is forbidden AND undefined when nums[i] == 0.
2
public int[] productExceptSelf(int[] nums) {
3
    int total = 1;
4
    for (int n : nums) total *= n;       // breaks: total becomes 0 if any zero
5
    int[] res = new int[nums.length];
6
    // Division is banned and crashes on any zero element — why we don't ship this.
7
    for (int i = 0; i < nums.length; i++) res[i] = total / nums[i]; // div by zero
8
    return res;
9
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.9 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The zero cases are the real lesson: when division is unsafe, replace 'undo a global aggregate' with 'build the aggregate from the sides'. That reframing is the prefix/suffix idea.

ComplexityO(n) time, O(1) space — Two linear passes, but it's invalid: division is disallowed and undefined for zeros.

E · Edge cases and pitfalls2Submitting division and getting rejected by the no-division rule.Explore edge cases

Pitfalls

Submitting division and getting rejected by the no-division rule.
Crashing or producing wrong output when the array contains one or more zeros.

03.2

Approach 2 of 2 · Optimal

Prefix × Suffix in One Array (Optimal)

TimeO(n)SpaceO(1)

The intended answer — O(n) time, O(1) extra space, division-free.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

answer[i] = (product of everything left of i) × (product of everything right of i). Can you precompute those?

2Hint 2Explore hint

Do a left-to-right pass writing the running prefix product into answer[i] (before multiplying in nums[i]).

3Hint 3Explore hint

Then a right-to-left pass: keep a running suffix product scalar and multiply it into answer[i] before folding nums[i] into the suffix.

A · Core idea

Define answer[i] as the product of all elements to the left of i times the product of all elements to the right. Build it in two passes:

1
Left pass. Maintain prefix = 1. For each i from left to right, set answer[i] = prefix (the product of everything strictly before i), then update prefix *= nums[i]. Crucially we write before multiplying, so answer[i] never includes nums[i].
2
Right pass. Maintain suffix = 1. For each i from right to left, multiply answer[i] *= suffix, then update suffix *= nums[i]. Now answer[i] holds prefix×suffix — exactly the product of all-but-self.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 3, 4]

Array state

after left pass

res holds prefixes

[0]

[1]

[2]

[3]

Current pointerResolved stateNot processed

Final result[24, 12, 8, 6]

C · Code with teaching comments

solution.javaJava

Prefix × Suffix in One Array (Optimal) — optimal

4 teaching notes

1
public int[] productExceptSelf(int[] nums) {
2
    int n = nums.length;
3
    int[] res = new int[n];
4
    int prefix = 1;
5
    for (int i = 0; i < n; i++) {
6
        // Store product of everything strictly LEFT of i (before folding nums[i] in).
7
        res[i] = prefix;
8
        // Now extend the running prefix to include nums[i] for the next index.
9
        prefix *= nums[i];
10
    }
11
    int suffix = 1;
12
    for (int i = n - 1; i >= 0; i--) {
13
        // Multiply in product of everything RIGHT of i — completes prefix×suffix.
14
        res[i] *= suffix;
15
        // Extend the running suffix leftward for the next index.
16
        suffix *= nums[i];
17
    }
18
    return res;
19
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.19 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n) time, O(1) space — Two linear passes = O(n). The output array holds prefixes (doesn't count), and the suffix is a single scalar → O(1) extra space.

E · Edge cases and pitfalls5nums = [0, 4, 0] — Two zeros → every answer is 0, including the zero positions (each has the other zero on one side).Explore edge cases

Edge cases handled

nums = [0, 4, 0]Two zeros → every answer is 0, including the zero positions (each has the other zero on one side).
nums = [-1, 1, 0, -3, 3]Single zero → only its index gets the product of the rest (9); all others are 0.

Pitfalls

Multiplying nums[i] into prefix BEFORE writing res[i] — then answer[i] wrongly includes itself.
Allocating separate prefix[] and suffix[] arrays — correct but misses the O(1)-space follow-up.
Initializing prefix/suffix to 0 instead of 1 — zeros out every product.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int[] productExceptSelf(int[] nums) { int n = nums.length; int[] res = new int[n]; int prefix = 1; for (int i = 0; i < n; i++) {Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Writing the cell after folding in nums[i]

If you multiply nums[i] into prefix before assigning res[i], the cell includes the element itself, which is exactly what 'except self' forbids.

Explore the code comparison

Don't write this

prefix *= nums[i];
res[i] = prefix; // now includes nums[i] — wrong

Write this instead

res[i] = prefix; // product of everything before i
prefix *= nums[i];

Two extra arrays when O(1) space is asked

Separate prefix[] and suffix[] arrays are O(n) extra space. Store prefixes in the output array and carry the suffix as a single scalar to meet the follow-up.

Explore the code comparison

Don't write this

prefix = [...]; suffix = [...]
res = [prefix[i] * suffix[i] for i in range(n)]

Write this instead

res = [1]*n
# left pass writes prefixes into res, right pass multiplies a scalar suffix

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Prefix × suffix products (no division)

Code pattern to memorize

res[i] = 1
prefix = 1
for i in range(n): res[i] = prefix; prefix *= nums[i]
suffix = 1
for i in range(n-1,-1,-1): res[i] *= suffix; suffix *= nums[i]

Rules to remember

1answer[i] = (product of all left of i) × (product of all right of i) — never includes nums[i].
2No division — it's banned and undefined when any element is 0.
3Write the prefix into res on the way right, then multiply by the running suffix on the way left.
4Reuse the output array for prefixes so the running suffix scalar is the only extra state → O(1) extra space.
5Seed both running products at 1 (multiplicative identity), and res[0]'s prefix is 1 (nothing to its left).

Use this pattern when

Each output depends on 'everything except me' aggregated multiplicatively or additively
Division is disallowed or unsafe (zeros, modular arithmetic)
You can precompute left/right partial aggregates in linear passes

Choose another pattern when

Division is allowed and no zeros → total product ÷ nums[i] is simpler
Need contiguous-subarray products → Maximum Product Subarray (DP), not prefix/suffix
Need sums not products of all-but-self → same prefix/suffix idea but additive

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Maximum Product Subarray
Coming soon
Contiguous products with sign flips — track running max and min (DP).
Range Sum Query — Immutable
Coming soon
Additive prefix sums answer range queries in O(1).
Trapping Rain Water
Uses left-max / right-max prefix-suffix arrays, same two-pass scaffold.

Same pattern

←

Group Anagrams

Continue · Next problem

Encode and Decode Strings