Coin Change Total Number of Ways in DSA Typescript - Execution Trace

Concept Flow - Coin Change Total Number of Ways

Start with empty ways array

↓

Initialize ways[0

↓

For each coin

↓

For each amount from coin to target

↓

Update ways[amount

↓

Repeat for all coins

↓

Result: ways[target

We build an array where each index shows ways to make that amount. For each coin, we add ways to make amounts including that coin.

Execution Sample

DSA Typescript

const coins = [1, 2, 3];
const amount = 4;
const ways = Array(amount + 1).fill(0);
ways[0] = 1;
for (const coin of coins) {
  for (let i = coin; i <= amount; i++) {
    ways[i] += ways[i - coin];
  }
}

Calculate total ways to make amount 4 using coins 1, 2, and 3.

Execution Table

Step	Operation	Amount Index Updated	ways Array State	Explanation
0	Initialize ways	0	[1, 0, 0, 0, 0]	ways[0] = 1 means 1 way to make amount 0 (use no coins)
1	Use coin 1	1	[1, 1, 0, 0, 0]	ways[1] += ways[0] → 0 + 1 = 1
2	Use coin 1	2	[1, 1, 1, 0, 0]	ways[2] += ways[1] → 0 + 1 = 1
3	Use coin 1	3	[1, 1, 1, 1, 0]	ways[3] += ways[2] → 0 + 1 = 1
4	Use coin 1	4	[1, 1, 1, 1, 1]	ways[4] += ways[3] → 0 + 1 = 1
5	Use coin 2	2	[1, 1, 2, 1, 1]	ways[2] += ways[0] → 1 + 1 = 2
6	Use coin 2	3	[1, 1, 2, 2, 1]	ways[3] += ways[1] → 1 + 1 = 2
7	Use coin 2	4	[1, 1, 2, 2, 3]	ways[4] += ways[2] → 1 + 2 = 3
8	Use coin 3	3	[1, 1, 2, 3, 3]	ways[3] += ways[0] → 2 + 1 = 3
9	Use coin 3	4	[1, 1, 2, 3, 4]	ways[4] += ways[1] → 3 + 1 = 4
10	End	-	[1, 1, 2, 3, 4]	All coins processed, ways[4] = 4 total ways

💡 All coins processed, final ways array shows total ways to make each amount

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 8	Final
ways	[1,0,0,0,0]	[1,1,0,0,0]	[1,1,2,1,1]	[1,1,2,3,3]	[1,1,2,3,4]
coin	N/A	1	2	3	3
i (amount index)	N/A	1	2	3	4

Key Moments - 3 Insights

Why do we set ways[0] = 1 at the start?

ways[0] = 1 means there is exactly one way to make amount 0: by choosing no coins. This is the base case that allows building up solutions for larger amounts (see execution_table step 0).

Why do we add ways[i - coin] to ways[i] inside the loop?

Adding ways[i - coin] means we count all ways to make the smaller amount (i - coin) and then add the current coin to reach amount i. This accumulates all combinations including the current coin (see execution_table steps 1-9).

Why do we loop coins first, then amounts, not the other way?

Looping coins first ensures combinations are counted without duplicates. Each coin adds ways to amounts in order, so we don't count the same combination multiple times in different orders (see concept_flow).

Visual Quiz - 3 Questions

Look at the execution_table at step 7, what is the value of ways[4]?

A 1

B 2

C 3

D 4

💡 Hint

Check the 'ways Array State' column at step 7 in execution_table

At which step does ways[3] first become 3?

A Step 8

B Step 6

C Step 3

D Step 9

💡 Hint

Look at the 'ways Array State' column for ways[3] in execution_table rows

If we remove coin 1 from the coins array, how would ways[4] change after processing all coins?

A It would become 3

B It would become 1

C It would stay 4

D It would become 0

💡 Hint

Without coin 1, fewer combinations exist; check how coin 1 updates ways in execution_table steps 1-4

Concept Snapshot

Coin Change Total Number of Ways:
- Use a ways array of size amount+1
- Initialize ways[0] = 1 (base case)
- For each coin, update ways[i] += ways[i - coin] for i >= coin
- ways[amount] gives total combinations
- Order of loops avoids duplicates

Full Transcript

This visualization shows how to find the total number of ways to make a target amount using given coin denominations. We start with an array 'ways' where ways[0] = 1, meaning one way to make zero amount. For each coin, we update the ways array by adding ways to make smaller amounts. The execution table traces each update step by step, showing how the array changes. Key moments clarify why ways[0] is set to 1, why we add ways[i - coin], and why the coin loop comes first. The quiz tests understanding of array states at specific steps and effects of removing coins. The snapshot summarizes the approach in simple steps.