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.

5. Combinatoric Additions: Pascal's Triangle • Invariant Proof & Speed-Run

Theory Context•Math & Geometry

EasyLC 118

Pascal's Triangle (LeetCode 118)

Target Frequency:AmazonMetaNetflix

Build the top numRows rows of Pascal's triangle and hand them back.

Pascal's triangle's defining rule: every interior entry equals the two entries sitting directly above it, added together.

Worked Examples

Example 1

Input:numRows = 5

Output:[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

row 0

row 1

row 2

row 3

row 4

Explanation: Each row starts and ends with 1, and every inner number is the sum of the two numbers above it.

Example 2

Input:numRows = 1

Output:[[1]]

row 0

Explanation: Only the top row, [1].

⚖️Formal Constraints & Bounds

1 <= numRows <= 30

Deep-Dive & Conceptual Insights

Core Insight

Each interior cell at row r and column c is the sum of the cells directly above it: triangle[r-1][c-1] + triangle[r-1][c]. Outer borders are always 1.

Real-World Scenario & Production Applications

Binomial coefficient lookups in probability theory, polynomial expansion algorithms, dynamic programming combinatorics.

Worked on Paper

The Math, Step by Step

1. The numbers in the triangle

Number the rows from 0 at the top, and the places in a row from 0 on the left. Row $r$ has $r + 1$ numbers. Write $T(r, c)$ for the number in row $r$ at place $c$ . The code stores it in triangle[r][c].

These numbers are the binomial coefficients: $T(r, c) = \binom{r}{c}$ , the number of ways to choose $c$ items out of $r$ items. Part 3 shows why.

2. One entry from the row above

The problem's rule is that every inner entry is the sum of the two entries above it:

Place $c$ in row $r$	Value	In the code
$c = 0$ , the left end	1	`row = [1] * (r + 1)` sets it
$c = r$ , the right end	1	`row = [1] * (r + 1)` sets it
$0 < c < r$ , an inner place	$T(r - 1, c - 1) + T(r - 1, c)$	`row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]`

The two entries above place $c$ are place $c - 1$ and place $c$ of row $r - 1$ .

3. Why the entries are binomial coefficients

The binomial coefficients follow the same rule:

$\binom{r}{c} = \binom{r - 1}{c - 1} + \binom{r - 1}{c}$

To see why, choose $c$ items out of $r$ items, and look at the last item. Either the choice includes the last item. Then the other $c - 1$ items come from the first $r - 1$ items, which gives $\binom{r - 1}{c - 1}$ ways. Or the choice leaves the last item out. Then all $c$ items come from the first $r - 1$ items, which gives $\binom{r - 1}{c}$ ways. The two groups do not overlap, and together they hold every choice.

The ends match too: $\binom{r}{0} = \binom{r}{r} = 1$ , because there is one way to choose nothing and one way to choose everything. The triangle and the binomial coefficients start the same and grow by the same rule, so they are equal.

4. Rows 0 and 1, and why the code needs only additions

The inner loop is for c in range(1, r). For row 0 and row 1 this range is empty, so these rows stay all 1s: [1] and [1, 1]. From row 2 on, the loop fills places 1 to $r - 1$ and leaves both ends at 1.

The code never computes a factorial. Each entry takes one addition of two numbers from the row above, which the code has already built. For the largest input, numRows = 30, the largest entry is $\binom{29}{14} = 77558760$ , well inside a 32-bit integer.

5. Example 1 by hand

numRows = 5, so the code builds rows 0 to 4:

Row $r$	Inner entries computed	`row`
0	none	`[1]`
1	none	`[1, 1]`
2	$1 + 1 = 2$	`[1, 2, 1]`
3	$1 + 2 = 3$ , $2 + 1 = 3$	`[1, 3, 3, 1]`
4	$1 + 3 = 4$ , $3 + 3 = 6$ , $3 + 1 = 4$	`[1, 4, 6, 4, 1]`

The result is the expected output. Row 4 matches the formula: $\binom{4}{2} = \frac{4 \cdot 3}{2} = 6$ . Each row also adds up to $2^r$ : row 4 adds up to $1 + 4 + 6 + 4 + 1 = 16 = 2^4$ , the number of ways to choose any subset of 4 items.

6. Example 2 by hand

numRows = 1. The loop runs once, for row 0, which is [1]. The code returns [[1]], the expected output.

7. From the math to the code

Math	In `generate`
rows $0 \ldots \text{numRows} - 1$	`for r in range(numRows):`
$T(r, 0) = T(r, r) = 1$	`row = [1] * (r + 1)`
inner places $1 \ldots r - 1$	`for c in range(1, r):`
$T(r, c) = T(r - 1, c - 1) + T(r - 1, c)$	`row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]`

The triangle has $1 + 2 + \cdots + \text{numRows}$ entries, and each takes one addition. So the code takes $O(\text{numRows}^2)$ time and space.

Code Shape

Archetype Code Shape

Python

1	triangle = []
2	for r in range(numRows):
3	row = [1] * (r + 1)
4	for c in range(1, r):
5	row[c] = prev[c-1] + prev[c]
6	triangle.append(row)
7	return triangle

Conceptual Narrative

Pascal's Triangle generates binomial coefficients where each interior element is the sum of the two directly above it.

🧭 Conceptual Foundation & Pattern Intuition

Row $r$ in Pascal's Triangle represents the coefficients of the polynomial expansion $(x + y)^r$ . Each entry $C(r, c) = C(r-1, c-1) + C(r-1, c)$ , with boundary values $C(r, 0) = C(r, r) = 1$ . Generating the triangle iteratively constructs each row in $O(r)$ time from the preceding row.

🏟️ The Analogy: Water Cascading Down a Pyramid of Glasses

Imagine a pyramid of champagne glasses. Pouring into the top glass causes wine to overflow equally to the left and right glasses below. Each interior glass receives overflow from two glasses directly above it.

🔑 Why It Works

Padding boundaries with 1 and vectorizing pairwise additions builds each row in strictly linear time without factorial division.

Off-by-one on row indexing: numRows is 1-indexed (e.g. numRows = 5 returns 5 rows). Off-by-one loops that stop at numRows - 1 miss the final row.
Mutating previous row in-place: Reusing or mutating prev while generating curr corrupts subsequent column additions.
Factorial overflow in combinatoric formulas: Computing $n! / (k!(n-k)!)$ directly causes 64-bit integer overflow even for moderate $n$ ( $n > 20$ ). Addition-based DP avoids factorials entirely.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Generate first numRows of Pascal's triangle, binomial coefficient grid, combinatorial pyramid.

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Invariant: In row r, row[0] = row[r] = 1, and for all 1 <= j < r, row[j] = prev[j - 1] + prev[j].

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

Off-by-one row bounds: In row r (0-indexed), there are exactly r + 1 elements. The interior loop runs from j = 1 to r - 1.
Mutating the previous row in-place: Must construct a new list for each row to preserve previous rows in the output triangle.
Handling numRows = 0 or numRows = 1: Ensure base cases return empty list or [[1]] cleanly without indexing out of bounds.

The 60-Second Interview Pitch

Say this out loud before you type a single line

I initialize triangle = []. For each row index r from 0 to numRows - 1, I initialize a new row [1] * (r + 1). For every interior position j from 1 to r - 1, I set row[j] = triangle[r - 1][j - 1] + triangle[r - 1][j]. I append row to triangle and return it. Total elements computed is N(N + 1)/2, running in O(numRows²) time and O(numRows²) space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N^2)

Look at the execution steps: Row i has i elements. Row i is constructed by adding adjacent pairs from row i-1: row[j] = prev[j-1] + prev[j]. Total elements generated is 1 + 2 + ... + N = N * (N + 1) / 2 = O(N^2).

SPACE COMPLEXITY

O(N^2) Auxiliary

Look at memory allocations: Call stack uses O(1) Iterative. Output 2D list stores N * (N + 1) / 2 integers total O(N^2) space.

Formal Recurrence Relation

T(N) = ∑_{i=1}^N i = (N(N+1) / 2) = O(N^2)

Derivation Progression

Row Dimension

i elements in row i

Rows grow by 1 element per level.

Adjacent Element Addition

row[j] = prev[j-1] + prev[j]

Each triangle cell computed in O(1) addition.

Total Triangle Entries

(N(N+1) / 2) = O(N^2)

Linear in size of triangle output.

Variable Definitions

$N$

Total number of rows in Pascal's triangle

Memory Architecture & Bounds

🟣 Call Stack

O(1) Iterative

🔵 Auxiliary Heap

O(1) Current row buffer (output list excluded)

🟢 Output Space

O(N^2) 2D Pascal triangle array

Boundary Best / Worst Cases

Best Case

$O(N^2)$

Average Case

$O(N^2)$

Worst Case

$O(N^2)$

Recurrence Tree Topology

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

Keyword trigger: "numRows", every entry equals the sum of the two entries just above it. Combinatorial trigger: Pascal's Identity $\binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k}$ . A Senior SWE recognizes 2D coordinate DP generation where each layer builds strictly upon the previous array.

CONSTRAINTS & BOUNDS

$1 \le numRows \le 30$ . Total generated numbers: $\sum_{i=1}^{30} i = \frac{30 \times 31}{2} = 465$ integers. Runtime and memory footprint are negligible ( $O(N^2)$ with $N \le 30$ ).

FAANG PRODUCTION TRAPS & EDGE CASES

$numRows = 1$ returning [[1]]. Index out of bounds on interior pointers if not bounding $c \in [1, r-1]$ .

Theory Context•Math & Geometry

EasyLC 118

Pascal's Triangle (LeetCode 118)

Target Frequency:AmazonMetaNetflix

Build the top numRows rows of Pascal's triangle and hand them back.

Pascal's triangle's defining rule: every interior entry equals the two entries sitting directly above it, added together.

Worked Examples

Example 1

Input:numRows = 5

Output:[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

row 0

row 1

row 2

row 3

row 4

Explanation: Each row starts and ends with 1, and every inner number is the sum of the two numbers above it.

Example 2

Input:numRows = 1

Output:[[1]]

row 0

Explanation: Only the top row, [1].

⚖️Formal Constraints & Bounds

1 <= numRows <= 30

Deep-Dive & Conceptual Insights

Core Insight

Each interior cell at row r and column c is the sum of the cells directly above it: triangle[r-1][c-1] + triangle[r-1][c]. Outer borders are always 1.

Real-World Scenario & Production Applications

Binomial coefficient lookups in probability theory, polynomial expansion algorithms, dynamic programming combinatorics.

Worked on Paper

The Math, Step by Step

1. The numbers in the triangle

These numbers are the binomial coefficients: $T(r, c) = \binom{r}{c}$ , the number of ways to choose $c$ items out of $r$ items. Part 3 shows why.

2. One entry from the row above

The problem's rule is that every inner entry is the sum of the two entries above it:

Place $c$ in row $r$	Value	In the code
$c = 0$ , the left end	1	`row = [1] * (r + 1)` sets it
$c = r$ , the right end	1	`row = [1] * (r + 1)` sets it
$0 < c < r$ , an inner place	$T(r - 1, c - 1) + T(r - 1, c)$	`row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]`

The two entries above place $c$ are place $c - 1$ and place $c$ of row $r - 1$ .

3. Why the entries are binomial coefficients

The binomial coefficients follow the same rule:

$\binom{r}{c} = \binom{r - 1}{c - 1} + \binom{r - 1}{c}$

4. Rows 0 and 1, and why the code needs only additions

5. Example 1 by hand

numRows = 5, so the code builds rows 0 to 4:

Row $r$	Inner entries computed	`row`
0	none	`[1]`
1	none	`[1, 1]`
2	$1 + 1 = 2$	`[1, 2, 1]`
3	$1 + 2 = 3$ , $2 + 1 = 3$	`[1, 3, 3, 1]`
4	$1 + 3 = 4$ , $3 + 3 = 6$ , $3 + 1 = 4$	`[1, 4, 6, 4, 1]`

6. Example 2 by hand

numRows = 1. The loop runs once, for row 0, which is [1]. The code returns [[1]], the expected output.

7. From the math to the code

Math	In `generate`
rows $0 \ldots \text{numRows} - 1$	`for r in range(numRows):`
$T(r, 0) = T(r, r) = 1$	`row = [1] * (r + 1)`
inner places $1 \ldots r - 1$	`for c in range(1, r):`
$T(r, c) = T(r - 1, c - 1) + T(r - 1, c)$	`row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]`

The triangle has $1 + 2 + \cdots + \text{numRows}$ entries, and each takes one addition. So the code takes $O(\text{numRows}^2)$ time and space.

Code Shape

Archetype Code Shape

Python

1	triangle = []
2	for r in range(numRows):
3	row = [1] * (r + 1)
4	for c in range(1, r):
5	row[c] = prev[c-1] + prev[c]
6	triangle.append(row)
7	return triangle

Conceptual Narrative

Pascal's Triangle generates binomial coefficients where each interior element is the sum of the two directly above it.

🧭 Conceptual Foundation & Pattern Intuition

🏟️ The Analogy: Water Cascading Down a Pyramid of Glasses

🔑 Why It Works

Padding boundaries with 1 and vectorizing pairwise additions builds each row in strictly linear time without factorial division.

Off-by-one on row indexing: numRows is 1-indexed (e.g. numRows = 5 returns 5 rows). Off-by-one loops that stop at numRows - 1 miss the final row.
Mutating previous row in-place: Reusing or mutating prev while generating curr corrupts subsequent column additions.
Factorial overflow in combinatoric formulas: Computing $n! / (k!(n-k)!)$ directly causes 64-bit integer overflow even for moderate $n$ ( $n > 20$ ). Addition-based DP avoids factorials entirely.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Generate first numRows of Pascal's triangle, binomial coefficient grid, combinatorial pyramid.

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Invariant: In row r, row[0] = row[r] = 1, and for all 1 <= j < r, row[j] = prev[j - 1] + prev[j].

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

Off-by-one row bounds: In row r (0-indexed), there are exactly r + 1 elements. The interior loop runs from j = 1 to r - 1.
Mutating the previous row in-place: Must construct a new list for each row to preserve previous rows in the output triangle.
Handling numRows = 0 or numRows = 1: Ensure base cases return empty list or [[1]] cleanly without indexing out of bounds.

The 60-Second Interview Pitch

Say this out loud before you type a single line

I initialize triangle = []. For each row index r from 0 to numRows - 1, I initialize a new row [1] * (r + 1). For every interior position j from 1 to r - 1, I set row[j] = triangle[r - 1][j - 1] + triangle[r - 1][j]. I append row to triangle and return it. Total elements computed is N(N + 1)/2, running in O(numRows²) time and O(numRows²) space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(N^2)

SPACE COMPLEXITY

O(N^2) Auxiliary

Look at memory allocations: Call stack uses O(1) Iterative. Output 2D list stores N * (N + 1) / 2 integers total O(N^2) space.

Formal Recurrence Relation

T(N) = ∑_{i=1}^N i = (N(N+1) / 2) = O(N^2)

Derivation Progression

Row Dimension

i elements in row i

Rows grow by 1 element per level.

Adjacent Element Addition

row[j] = prev[j-1] + prev[j]

Each triangle cell computed in O(1) addition.

Total Triangle Entries

(N(N+1) / 2) = O(N^2)

Linear in size of triangle output.

Variable Definitions

$N$

Total number of rows in Pascal's triangle

Memory Architecture & Bounds

🟣 Call Stack

O(1) Iterative

🔵 Auxiliary Heap

O(1) Current row buffer (output list excluded)

🟢 Output Space

O(N^2) 2D Pascal triangle array

Boundary Best / Worst Cases

Best Case

$O(N^2)$

Average Case

$O(N^2)$

Worst Case

$O(N^2)$

Recurrence Tree Topology

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

CONSTRAINTS & BOUNDS

$1 \le numRows \le 30$ . Total generated numbers: $\sum_{i=1}^{30} i = \frac{30 \times 31}{2} = 465$ integers. Runtime and memory footprint are negligible ( $O(N^2)$ with $N \le 30$ ).

FAANG PRODUCTION TRAPS & EDGE CASES

$numRows = 1$ returning [[1]]. Index out of bounds on interior pointers if not bounding $c \in [1, r-1]$ .

c

Value

In the code

c = 0

, the left end

row = [1] * (r + 1) sets it

c = r

, the right end

row = [1] * (r + 1) sets it

0 < c < r

, an inner place

T(r - 1, c - 1) + T(r - 1, c)

row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]

r

Inner entries computed

row

none

[1]

none

[1, 1]

1 + 1 = 2

[1, 2, 1]

1 + 2 = 3

2 + 1 = 3

[1, 3, 3, 1]

1 + 3 = 4

3 + 3 = 6

3 + 1 = 4

[1, 4, 6, 4, 1]

Math

In generate

rows

0 \ldots \text{numRows} - 1

for r in range(numRows):

T(r, 0) = T(r, r) = 1

row = [1] * (r + 1)

inner places

1 \ldots r - 1

for c in range(1, r):

T(r, c) = T(r - 1, c - 1) + T(r - 1, c)

row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]

Pascal's Triangle generates binomial coefficients where each interior element is the sum of the two directly above it.

🧭 Conceptual Foundation & Pattern Intuition

🏟️ The Analogy: Water Cascading Down a Pyramid of Glasses

🔑 Why It Works

Padding boundaries with 1 and vectorizing pairwise additions builds each row in strictly linear time without factorial division.

c

Value

In the code

c = 0

, the left end

row = [1] * (r + 1) sets it

c = r

, the right end

row = [1] * (r + 1) sets it

0 < c < r

, an inner place

T(r - 1, c - 1) + T(r - 1, c)

row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]

r

Inner entries computed

row

none

[1]

none

[1, 1]

1 + 1 = 2

[1, 2, 1]

1 + 2 = 3

2 + 1 = 3

[1, 3, 3, 1]

1 + 3 = 4

3 + 3 = 6

3 + 1 = 4

[1, 4, 6, 4, 1]

Math

In generate

rows

0 \ldots \text{numRows} - 1

for r in range(numRows):

T(r, 0) = T(r, r) = 1

row = [1] * (r + 1)

inner places

1 \ldots r - 1

for c in range(1, r):

T(r, c) = T(r - 1, c - 1) + T(r - 1, c)

row[c] = triangle[r - 1][c - 1] + triangle[r - 1][c]