What is the pricing and subscription model for Hi👋SpeedAlgo?

The entire core curriculum of 13 patterns and 225 practice problems is 100% free to access with no credit card required. New accounts get 40 free coins once, the daily claim adds +20 coins once a day, and inviting a friend earns you +25 coins when they complete their first practice step. These are the only ways to earn coins. Each AI coach question costs 1-5 coins, priced by the server according to its size. AI coaching is free with your own Google Gemini, OpenAI or OpenRouter API key (BYOK). Coins also unlock extras for 24 hours: a Recall hint level (1 coin), a Solve solution reveal (2), a LeetCode problem card's solutions (1) and a pattern's extra canonical problems (1). Nothing on the site is sold for money: coins can only be earned, never bought.

What is the refund and cancellation policy?

Hi👋SpeedAlgo sells nothing for money: there are no subscriptions, renewals or charges, so there is nothing to cancel or refund. Nothing on the site is sold for money: coins can only be earned, never bought.

Who creates and maintains the curriculum?

Hi👋SpeedAlgo is developed and maintained by Hi👋WebEnterprise (https://hiwebenterprise.com), an engineering organization focused on developer education, deliberate practice methodologies, and cognitive ergonomics for technical interviews.

How does Hi👋SpeedAlgo prepare candidates for senior and staff SWE interviews?

Rather than rote LeetCode grinding, Hi👋SpeedAlgo uses deliberate practice for each pattern: learn the loop invariant, Big-O proof and edge cases from a side-by-side template and a step-by-step debugger, rebuild the template from memory, then solve a new problem on your own against a graded test suite.

20. Product of Array Except Self • Invariant Proof & Speed-Run

Theory Context•Two Pointers & Sliding Window

MediumLC 238

Product of Array Except Self (LeetCode 238)

Target Frequency:AmazonMetaGoogleApple

You have an integer array nums. Build an output array answer where each answer[i] holds the product of every element of nums other than nums[i] itself.

Every prefix or suffix product you'll ever need to compute is guaranteed to fit inside a 32-bit integer.

Solve it in O(n) time, and without dividing.

Worked Examples

Example 1

Input:nums = [1,2,3,4]

Output:[24,12,8,6]

Explanation: For index 0: 234 = 24; index 1: 134 = 12; index 2: 124 = 8; index 3: 123 = 6.

Example 2

Input:nums = [-1,1,0,-3,3]

Output:[0,0,9,0,0]

Explanation: Index 2 has product (-1)1(-3)*3 = 9. All other indices include the factor 0, resulting in 0.

⚖️Formal Constraints & Bounds

2 <= nums.length <= 10⁵
-30 <= nums[i] <= 30
The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.

Deep-Dive & Conceptual Insights

Core Insight

Everything except nums[i] is everything left of i times everything right of i. A left pass stores the left product in res[i] and a right pass multiplies in the right product, so no division is ever needed.

Real-World Scenario & Production Applications

Bayesian probability updates (independent evidence combination), graphics rendering light transport equations, and zero-safe arithmetic pipeline processing.

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Left Pass

Walk left to right and store in res[i] the product of everything strictly left of i. Write res[i] first, then fold nums[i] into prefix.

Mathematical Recurrence / Code Invariant

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

Step-by-Step Execution Trace Table

Index	`nums[i]`	Prefix Product Pass	Suffix Multiplier	Final `res[i]`
0	1	1	24	24
1	2	1	12	12
2	3	2	4	8
3	4	6	1	6

Worked on Paper

The Math, Step by Step

1. The number the code builds for each index

For each index $i$ , the answer is the product of every element except nums[i]. Split those elements into two groups: the elements to the left of $i$ and the elements to the right of $i$ .

$L[i] = \text{nums}[0] \cdot \text{nums}[1] \cdots \text{nums}[i - 1] \qquad R[i] = \text{nums}[i + 1] \cdots \text{nums}[n - 1]$

$L[i]$ is the prefix product before $i$ , and $R[i]$ is the suffix product after $i$ . Every element except nums[i] is in exactly one of the two groups, so

$\text{answer}[i] = L[i] \cdot R[i]$

2. Each product from the one before it

A product with no factors is $1$ , called the empty product. So $L[0] = 1$ , because nothing is to the left of index 0. $R[n - 1] = 1$ , because nothing is to the right of the last index. Every other value takes one multiplication:

$L[i + 1] = L[i] \cdot \text{nums}[i] \qquad R[i - 1] = R[i] \cdot \text{nums}[i]$

So one pass from left to right builds every $L[i]$ , and one pass from right to left builds every $R[i]$ .

3. Why no division is needed, and why zeros are safe

A shorter idea is "the product of all elements, divided by nums[i]". It fails when nums[i] is 0, because you cannot divide by 0. The problem also forbids division.

$L[i] \cdot R[i]$ only multiplies. A zero in nums is multiplied into every $L$ to its right and every $R$ to its left. It is never a factor of its own index's answer. So Example 2, which has a zero, needs no special case.

4. Write first, then multiply

In the left pass, the code writes res[i] = prefix before it runs prefix *= nums[i]. At that moment prefix is still $L[i]$ , the product of the elements before $i$ . If the two lines were swapped, res[i] would get $L[i] \cdot \text{nums}[i]$ and include nums[i] itself. The right pass uses the same order: res[i] *= suffix runs before suffix *= nums[i].

The right pass also uses *=, not =. res[i] already holds $L[i]$ from the left pass. Multiplying keeps it, so res[i] becomes $L[i] \cdot R[i]$ .

5. Example 1 by hand

nums = [1,2,3,4].

$i$	`nums[i]`	$L[i]$	$R[i]$	$L[i] \cdot R[i]$
0	1	$1$ (empty)	$2 \cdot 3 \cdot 4 = 24$	$24$
1	2	$1$	$3 \cdot 4 = 12$	$12$
2	3	$1 \cdot 2 = 2$	$4$	$8$
3	4	$1 \cdot 2 \cdot 3 = 6$	$1$ (empty)	$6$

After the left pass, res = [1, 1, 2, 6], the $L$ column. The right pass multiplies each entry by the $R$ column, [24, 12, 4, 1]. The result [24, 12, 8, 6] is the expected output.

6. Example 2 by hand

nums = [-1,1,0,-3,3].

$i$	`nums[i]`	$L[i]$	$R[i]$	$L[i] \cdot R[i]$
0	$-1$	$1$ (empty)	$1 \cdot 0 \cdot (-3) \cdot 3 = 0$	$0$
1	$1$	$-1$	$0 \cdot (-3) \cdot 3 = 0$	$0$
2	$0$	$(-1) \cdot 1 = -1$	$(-3) \cdot 3 = -9$	$9$
3	$-3$	$(-1) \cdot 1 \cdot 0 = 0$	$3$	$0$
4	$3$	$0$	$1$ (empty)	$0$

Only index 2 has the zero outside both groups. Its answer is $(-1) \cdot (-9) = 9$ . Every other index has the zero in $L$ or in $R$ , so its answer is $0$ . The result [0, 0, 9, 0, 0] is the expected output.

7. From the formulas to the code

Formula	In `productExceptSelf`
$L[0] = 1$	`prefix = 1`
`res[i]` gets $L[i]$	`res[i] = prefix`
$L[i + 1] = L[i] \cdot \text{nums}[i]$	`prefix *= nums[i]`
$R[n - 1] = 1$	`suffix = 1`
`res[i]` becomes $L[i] \cdot R[i]$	`res[i] *= suffix`
$R[i - 1] = R[i] \cdot \text{nums}[i]$	`suffix *= nums[i]`

Each pass takes $O(n)$ time. Besides the output array res, the code keeps only prefix and suffix, so it uses $O(1)$ extra space.

Code Shape

Archetype Code Shape

Python

1	res = [1] * n
2	prefix = 1
3	for i in range(n):
4	res[i] = prefix
5	prefix *= nums[i]
6	suffix = 1
7	for i in range(n - 1, -1, -1):
8	res[i] *= suffix
9	suffix *= nums[i]
10	return res

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

The obvious shortcut — multiply everything, then divide by nums[i] — is banned, and for good reason: any zero in the array breaks division entirely. The prefix/suffix trick sidesteps division altogether.

👥 The Analogy: Everyone Except You, From Two Directions

"The product of everyone except me" is really just "everyone standing to my left, multiplied by everyone standing to my right." So make two separate passes: walking left to right, hand each person the running product of everyone before them. Then walk right to left, multiplying each person's number by the running product of everyone after them. By the time both passes are done, every person is holding exactly "the product of everyone except themselves" — built entirely from multiplication, no division anywhere.

🔑 The Key Idea in the Code

Each index only ever needs its own left-total and right-total — never the array's overall total — which is exactly what makes skipping division possible.

Folding too early: prefix *= nums[i] before res[i] = prefix (or suffix *= nums[i] before res[i] *= suffix) multiplies nums[i] into its own answer. On [1,2,3,4] the left pass alone already stores [1,2,6,24] instead of [1,1,2,6].
Overwriting in the second pass: res[i] = suffix instead of res[i] *= suffix throws away the left product the first pass stored.
Wrong start value: prefix and suffix start at 1, the empty product. Starting at 0 makes every answer 0.
Dividing a total product: total // nums[i] is not allowed here, and it breaks as soon as nums contains a zero. Without division, one zero leaves a single non-zero answer and two zeros make every answer 0, with no special case.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

The statement asks, for every index, for "the product of every element of nums other than nums[i]": each answer needs everything on its left and everything on its right. "Without dividing" rules out total // nums[i], and "O(n) time" rules out multiplying the other N - 1 numbers again for every index.

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Invariant: when res[i] = prefix runs, prefix is the product of nums[0..i-1]; when res[i] *= suffix runs, suffix is the product of nums[i+1..n-1]. Neither ever contains nums[i], so after both passes res[i] is the product of all the other numbers.

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

Keeping two extra arrays: a full left array and a full right array also work, but they cost O(N) extra space. The follow-up asks for O(1) extra besides the output, so store the left products in res itself and carry the right side as the single number suffix.

The 60-Second Interview Pitch

Say this out loud before you type a single line

"I'll use a Prefix-Suffix Scan. Each answer is the product of everything left of i times everything right of i, and each side is a running product I can carry in one sweep. In the first pass, left to right, I write res[i] = prefix and only then fold nums[i] into prefix, so prefix only ever holds the numbers before i. In the second pass, right to left, I multiply res[i] by suffix and then fold nums[i] into suffix. I never divide, so zeros need no special case: one zero leaves a single non-zero answer, and two zeros make every answer zero. Two linear passes give O(N) time, and besides the output array I keep only prefix and suffix, so O(1) extra space."

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N)

Look at the code: res = [1] * n writes N slots. for i in range(n) runs N times and does one write (res[i] = prefix) and one multiplication (prefix *= nums[i]). for i in range(n - 1, -1, -1) runs N times and does two multiplications (res[i] *= suffix, suffix *= nums[i]). No loop is nested inside another, so the total is N + 2N + 2N = 5N constant-time steps.

SPACE COMPLEXITY

O(1) extra, output not counted

Look at the allocations: res is the answer the problem asks for (N integers, output, not counted). Besides it the code keeps n, prefix, suffix and i: four integers, whatever N is. There is no recursion, so the call stack stays constant.

Formal Recurrence Relation

T(N) = N (fill res) + 2N (left pass) + 2N (right pass) = 5N = O(N)

Derivation Progression

Fill res

res = [1] * n -> N writes

Every slot starts at 1, the empty product.

Left pass

for i in range(n): 1 write + 1 multiply -> 2N

res[i] = prefix stores the product of nums[0..i-1]; prefix *= nums[i] then extends it by one element. Each iteration is constant work.

Right pass

for i in range(n - 1, -1, -1): 2 multiplies -> 2N

res[i] *= suffix multiplies in the product of nums[i+1..n-1]; suffix *= nums[i] then extends it by one element.

Total

N + 2N + 2N = 5N = O(N)

The passes run one after the other, never nested, so their costs add up instead of multiplying.

Variable Definitions

$N$

len(nums), the number of elements (the code's n)

Memory Architecture & Bounds

🟣 Call Stack

O(1): no recursion

🔵 Auxiliary Heap

O(1): the integers n, prefix, suffix and i

🟢 Output Space

O(N): res, the answer itself, not counted as extra space

Boundary Best / Worst Cases

Best Case

$O(N)$ : both passes always visit every index

Average Case

$O(N)$

Worst Case

$O(N)$ : zeros or negative numbers change no step

Pointer Invariant Transition Progression

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

Triggers: "the product of every element other than nums[i]", "without dividing", "O(n) time". Each answer needs everything on its left and everything on its right: a Prefix-Suffix Scan, one pass from each end.

CONSTRAINTS & BOUNDS

$2 \le N \le 10^5$ and $-30 \le nums[i] \le 30$ . Multiplying the other $N - 1$ numbers again for every index is up to $10^{10}$ multiplications; two passes are $2 \times 10^5$ . Every prefix and suffix product is guaranteed to fit in 32 bits. The two passes read the array front to back, then back to front, so they stream well and stay cache-friendly; the only stored array is res, the output.

FAANG PRODUCTION TRAPS & EDGE CASES

At scale the risk is the size of the numbers, not the loop. This problem guarantees every prefix and suffix product fits in 32 bits; outside that guarantee, a running product of many values overflows a fixed-width integer, so production code checks the range or uses a wider type.

Theory Context•Two Pointers & Sliding Window

MediumLC 238

Product of Array Except Self (LeetCode 238)

Target Frequency:AmazonMetaGoogleApple

You have an integer array nums. Build an output array answer where each answer[i] holds the product of every element of nums other than nums[i] itself.

Every prefix or suffix product you'll ever need to compute is guaranteed to fit inside a 32-bit integer.

Solve it in O(n) time, and without dividing.

Worked Examples

Example 1

Input:nums = [1,2,3,4]

Output:[24,12,8,6]

Explanation: For index 0: 234 = 24; index 1: 134 = 12; index 2: 124 = 8; index 3: 123 = 6.

Example 2

Input:nums = [-1,1,0,-3,3]

Output:[0,0,9,0,0]

Explanation: Index 2 has product (-1)1(-3)*3 = 9. All other indices include the factor 0, resulting in 0.

⚖️Formal Constraints & Bounds

2 <= nums.length <= 10⁵
-30 <= nums[i] <= 30
The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.

Deep-Dive & Conceptual Insights

Core Insight

Real-World Scenario & Production Applications

Bayesian probability updates (independent evidence combination), graphics rendering light transport equations, and zero-safe arithmetic pipeline processing.

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Left Pass

Walk left to right and store in res[i] the product of everything strictly left of i. Write res[i] first, then fold nums[i] into prefix.

Mathematical Recurrence / Code Invariant

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

Step-by-Step Execution Trace Table

Index	`nums[i]`	Prefix Product Pass	Suffix Multiplier	Final `res[i]`
0	1	1	24	24
1	2	1	12	12
2	3	2	4	8
3	4	6	1	6

Worked on Paper

The Math, Step by Step

1. The number the code builds for each index

For each index $i$ , the answer is the product of every element except nums[i]. Split those elements into two groups: the elements to the left of $i$ and the elements to the right of $i$ .

$L[i] = \text{nums}[0] \cdot \text{nums}[1] \cdots \text{nums}[i - 1] \qquad R[i] = \text{nums}[i + 1] \cdots \text{nums}[n - 1]$

$L[i]$ is the prefix product before $i$ , and $R[i]$ is the suffix product after $i$ . Every element except nums[i] is in exactly one of the two groups, so

$\text{answer}[i] = L[i] \cdot R[i]$

2. Each product from the one before it

$L[i + 1] = L[i] \cdot \text{nums}[i] \qquad R[i - 1] = R[i] \cdot \text{nums}[i]$

So one pass from left to right builds every $L[i]$ , and one pass from right to left builds every $R[i]$ .

3. Why no division is needed, and why zeros are safe

A shorter idea is "the product of all elements, divided by nums[i]". It fails when nums[i] is 0, because you cannot divide by 0. The problem also forbids division.

4. Write first, then multiply

The right pass also uses *=, not =. res[i] already holds $L[i]$ from the left pass. Multiplying keeps it, so res[i] becomes $L[i] \cdot R[i]$ .

5. Example 1 by hand

nums = [1,2,3,4].

$i$	`nums[i]`	$L[i]$	$R[i]$	$L[i] \cdot R[i]$
0	1	$1$ (empty)	$2 \cdot 3 \cdot 4 = 24$	$24$
1	2	$1$	$3 \cdot 4 = 12$	$12$
2	3	$1 \cdot 2 = 2$	$4$	$8$
3	4	$1 \cdot 2 \cdot 3 = 6$	$1$ (empty)	$6$

After the left pass, res = [1, 1, 2, 6], the $L$ column. The right pass multiplies each entry by the $R$ column, [24, 12, 4, 1]. The result [24, 12, 8, 6] is the expected output.

6. Example 2 by hand

nums = [-1,1,0,-3,3].

$i$	`nums[i]`	$L[i]$	$R[i]$	$L[i] \cdot R[i]$
0	$-1$	$1$ (empty)	$1 \cdot 0 \cdot (-3) \cdot 3 = 0$	$0$
1	$1$	$-1$	$0 \cdot (-3) \cdot 3 = 0$	$0$
2	$0$	$(-1) \cdot 1 = -1$	$(-3) \cdot 3 = -9$	$9$
3	$-3$	$(-1) \cdot 1 \cdot 0 = 0$	$3$	$0$
4	$3$	$0$	$1$ (empty)	$0$

7. From the formulas to the code

Formula	In `productExceptSelf`
$L[0] = 1$	`prefix = 1`
`res[i]` gets $L[i]$	`res[i] = prefix`
$L[i + 1] = L[i] \cdot \text{nums}[i]$	`prefix *= nums[i]`
$R[n - 1] = 1$	`suffix = 1`
`res[i]` becomes $L[i] \cdot R[i]$	`res[i] *= suffix`
$R[i - 1] = R[i] \cdot \text{nums}[i]$	`suffix *= nums[i]`

Each pass takes $O(n)$ time. Besides the output array res, the code keeps only prefix and suffix, so it uses $O(1)$ extra space.

Code Shape

Archetype Code Shape

Python

1	res = [1] * n
2	prefix = 1
3	for i in range(n):
4	res[i] = prefix
5	prefix *= nums[i]
6	suffix = 1
7	for i in range(n - 1, -1, -1):
8	res[i] *= suffix
9	suffix *= nums[i]
10	return res

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

👥 The Analogy: Everyone Except You, From Two Directions

🔑 The Key Idea in the Code

Each index only ever needs its own left-total and right-total — never the array's overall total — which is exactly what makes skipping division possible.

Folding too early: prefix *= nums[i] before res[i] = prefix (or suffix *= nums[i] before res[i] *= suffix) multiplies nums[i] into its own answer. On [1,2,3,4] the left pass alone already stores [1,2,6,24] instead of [1,1,2,6].
Overwriting in the second pass: res[i] = suffix instead of res[i] *= suffix throws away the left product the first pass stored.
Wrong start value: prefix and suffix start at 1, the empty product. Starting at 0 makes every answer 0.
Dividing a total product: total // nums[i] is not allowed here, and it breaks as soon as nums contains a zero. Without division, one zero leaves a single non-zero answer and two zeros make every answer 0, with no special case.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

Keeping two extra arrays: a full left array and a full right array also work, but they cost O(N) extra space. The follow-up asks for O(1) extra besides the output, so store the left products in res itself and carry the right side as the single number suffix.

The 60-Second Interview Pitch

Say this out loud before you type a single line

"I'll use a Prefix-Suffix Scan. Each answer is the product of everything left of i times everything right of i, and each side is a running product I can carry in one sweep. In the first pass, left to right, I write res[i] = prefix and only then fold nums[i] into prefix, so prefix only ever holds the numbers before i. In the second pass, right to left, I multiply res[i] by suffix and then fold nums[i] into suffix. I never divide, so zeros need no special case: one zero leaves a single non-zero answer, and two zeros make every answer zero. Two linear passes give O(N) time, and besides the output array I keep only prefix and suffix, so O(1) extra space."

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N)

SPACE COMPLEXITY

O(1) extra, output not counted

Formal Recurrence Relation

T(N) = N (fill res) + 2N (left pass) + 2N (right pass) = 5N = O(N)

Derivation Progression

Fill res

res = [1] * n -> N writes

Every slot starts at 1, the empty product.

Left pass

for i in range(n): 1 write + 1 multiply -> 2N

res[i] = prefix stores the product of nums[0..i-1]; prefix *= nums[i] then extends it by one element. Each iteration is constant work.

Right pass

for i in range(n - 1, -1, -1): 2 multiplies -> 2N

res[i] *= suffix multiplies in the product of nums[i+1..n-1]; suffix *= nums[i] then extends it by one element.

Total

N + 2N + 2N = 5N = O(N)

The passes run one after the other, never nested, so their costs add up instead of multiplying.

Variable Definitions

$N$

len(nums), the number of elements (the code's n)

Memory Architecture & Bounds

🟣 Call Stack

O(1): no recursion

🔵 Auxiliary Heap

O(1): the integers n, prefix, suffix and i

🟢 Output Space

O(N): res, the answer itself, not counted as extra space

Boundary Best / Worst Cases

Best Case

$O(N)$ : both passes always visit every index

Average Case

$O(N)$

Worst Case

$O(N)$ : zeros or negative numbers change no step

Pointer Invariant Transition Progression

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

CONSTRAINTS & BOUNDS

FAANG PRODUCTION TRAPS & EDGE CASES

Index

nums[i]

Prefix Product Pass

Suffix Multiplier

Final res[i]

i

nums[i]

L[i]

R[i]

L[i] \cdot R[i]

1

(empty)

2 \cdot 3 \cdot 4 = 24

24

1

3 \cdot 4 = 12

12

1 \cdot 2 = 2

4

8

1 \cdot 2 \cdot 3 = 6

1

(empty)

6

i

nums[i]

L[i]

R[i]

L[i] \cdot R[i]

-1

1

(empty)

1 \cdot 0 \cdot (-3) \cdot 3 = 0

0

1

-1

0 \cdot (-3) \cdot 3 = 0

0

0

(-1) \cdot 1 = -1

(-3) \cdot 3 = -9

9

-3

(-1) \cdot 1 \cdot 0 = 0

3

0

3

0

1

(empty)

0

Formula

In productExceptSelf

L[0] = 1

prefix = 1

res[i] gets

L[i]

res[i] = prefix

L[i + 1] = L[i] \cdot \text{nums}[i]

prefix *= nums[i]

R[n - 1] = 1

suffix = 1

res[i] becomes

L[i] \cdot R[i]

res[i] *= suffix

R[i - 1] = R[i] \cdot \text{nums}[i]

suffix *= nums[i]

🧭 Conceptual Foundation & Pattern Intuition

👥 The Analogy: Everyone Except You, From Two Directions

🔑 The Key Idea in the Code

Each index only ever needs its own left-total and right-total — never the array's overall total — which is exactly what makes skipping division possible.

Index

nums[i]

Prefix Product Pass

Suffix Multiplier

Final res[i]

i

nums[i]

L[i]

R[i]

L[i] \cdot R[i]

1

(empty)

2 \cdot 3 \cdot 4 = 24

24

1

3 \cdot 4 = 12

12

1 \cdot 2 = 2

4

8

1 \cdot 2 \cdot 3 = 6

1

(empty)

6

i

nums[i]

L[i]

R[i]

L[i] \cdot R[i]

-1

1

(empty)

1 \cdot 0 \cdot (-3) \cdot 3 = 0

0

1

-1

0 \cdot (-3) \cdot 3 = 0

0

0

(-1) \cdot 1 = -1

(-3) \cdot 3 = -9

9

-3

(-1) \cdot 1 \cdot 0 = 0

3

0

3

0

1

(empty)

0

Formula

In productExceptSelf

L[0] = 1

prefix = 1

res[i] gets

L[i]

res[i] = prefix

L[i + 1] = L[i] \cdot \text{nums}[i]

prefix *= nums[i]

R[n - 1] = 1

suffix = 1

res[i] becomes

L[i] \cdot R[i]

res[i] *= suffix

R[i - 1] = R[i] \cdot \text{nums}[i]

suffix *= nums[i]