Your concept feed

Let’s picture it

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

Swipe when you’re ready

One little change

Point to the middle one.

0 · Home

1 · Park

2 · Café

The park is second. In Python, its position is 1, because counting starts at 0.

Same idea. One more small step.

Now it has a name

That’s a list.

Home

Park

Café

A list keeps things in order. An index is just a position in that list.

Want to try a tiny question?

No pressure. Just try it.

Which place is at position 0?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

Nothing to learn first. Let’s replay this little example.

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

stops = ["home", "park", "cafe"]
assert stops[1] == "park"
assert len(stops) == 3

A small step before this topic

Let’s picture it

Now visit each stop.

Home

Park

Café

You don’t need three different instructions. “Visit the next place” works each time.

Swipe when you’re ready

One little change

One, then the next.

✓ Home

Park

Café

Finish home. Move to the park. Then do the same at the café.

Same idea. One more small step.

Now it has a name

That repeat is a loop.

✓ Home

✓ Park

✓ Café

One small action, repeated for each item. Three stops mean three visits.

Want to try a tiny question?

No pressure. Just try it.

Add one more stop. How many visits now?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

visited = []
for stop in ["home", "park", "cafe"]:
    visited.append(stop)
assert visited == ["home", "park", "cafe"]

A small step before this topic

Let’s picture it

What if it rains?

☔ Rain

☕ Café

Let’s choose the café on rainy days, and the park on sunny days.

Swipe when you’re ready

One little change

Today is sunny.

☀ Sun

🌳 Park

The rule stays the same. The weather changed, so we choose the other place.

Same idea. One more small step.

Now it has a name

That’s an if / else.

Raining?

Yes: café

No: park

A condition is a yes-or-no question. Its answer chooses which step happens next.

Want to try a tiny question?

No pressure. Just try it.

It’s raining. Where does our rule send us?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Now visit each stop.

Home

Park

Café

You don’t need three different instructions. “Visit the next place” works each time.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

raining = True
if raining:
    next_stop = "cafe"
else:
    next_stop = "park"
assert next_stop == "cafe"

A small step before this topic

Let’s picture it

Name a tiny job.

3

add one

4

Our job is “add one.” Give it 3, and it gives back 4.

Swipe when you’re ready

One little change

Try a new input.

8

add one

9

Give the same job 8. It gives back 9. We can reuse the instructions.

Same idea. One more small step.

Now it has a name

That job is a function.

input

function

answer

Input goes in. An answer comes back. In Python, return sends the answer back.

Want to try a tiny question?

No pressure. Just try it.

What does add-one return for 5?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

What if it rains?

☔ Rain

☕ Café

Let’s choose the café on rainy days, and the park on sunny days.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def add_one(number):
    return number + 1

assert add_one(3) == 4
assert add_one(8) == 9

A small step before this topic

Let’s picture it

Picture a pile of plates.

Pink · top

Blue · bottom

Blue goes down first. Pink goes on top.

Swipe when you’re ready

One little change

Take the top one.

Take pink

Blue stays

Pink comes off first, even though blue arrived first.

Same idea. One more small step.

Now it has a name

That’s a stack.

Newest call

Earlier call

Last in, first out. Paused function calls work this way too: finish the newest call, then return.

Want to try a tiny question?

No pressure. Just try it.

Add green on top. Which plate comes off next?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Name a tiny job.

3

add one

4

Our job is “add one.” Give it 3, and it gives back 4.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

plates = []
plates.append("blue")
plates.append("pink")
assert plates.pop() == "pink"
assert plates == ["blue"]

A small step before this topic

Let’s picture it

Now picture a line of people.

Ana

Bo

Ana arrives first. Bo waits behind her.

Swipe when you’re ready

One little change

Ana goes first.

Ana leaves

Bo

Cy joins

Bo moves to the front. New arrivals join the back.

Same idea. One more small step.

Now it has a name

That’s a queue.

front →

Bo

Cy

First in, first out. Unlike plates, we serve the oldest waiting item first.

Want to try a tiny question?

No pressure. Just try it.

Who goes before Cy?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Picture a pile of plates.

Pink · top

Blue · bottom

Blue goes down first. Pink goes on top.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

from collections import deque

line = deque(["Ana", "Bo"])
assert line.popleft() == "Ana"
assert list(line) == ["Bo"]

A small step before this topic

Let’s picture it

Have we visited the park?

Home ✓

Park ✓

Keep a little checklist of places we’ve seen.

Swipe when you’re ready

One little change

Write park again.

Home ✓

Park ✓

We still only need one check beside park. We’re remembering whether, not how many times.

Same idea. One more small step.

Now it has a name

That’s a set.

park in seen?

Yes

A set keeps distinct items. “Is park in here?” becomes a quick membership check.

Want to try a tiny question?

No pressure. Just try it.

Add park twice. How many copies in a set?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

seen = set()
seen.add("park")
seen.add("park")
assert "park" in seen
assert len(seen) == 1

A small step before this topic

Let’s picture it

Let’s remember a little more.

Park

5 minutes

The park is five minutes away. Write that beside its name.

Swipe when you’re ready

One little change

Look it up later.

“park”

notebook

5

Ask for “park.” The notebook gives you 5. No need to measure the walk again.

Same idea. One more small step.

Now it has a name

That’s a dictionary.

key: park

value: 5

A key finds a value. Here, the place name is the key and the time is the value.

Want to try a tiny question?

No pressure. Just try it.

We now write park: 6. What does park return?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Have we visited the park?

Home ✓

Park ✓

Keep a little checklist of places we’ve seen.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

minutes = {"park": 5, "cafe": 8}
assert minutes["park"] == 5
minutes["park"] = 6
assert minutes["park"] == 6

A small step before this topic

Let’s picture it

Draw our little walk.

Home

Park

Café

A dot for each place. A line where we can walk directly.

Swipe when you’re ready

One little change

Two short walks can join.

Home

Park

Café

Home to park, then park to café. We can reach the café without a direct road.

Same idea. One more small step.

Now it has a name

Dots and links have names.

node

edge

node

A dot is a node. A link is an edge. Together, they make a graph.

Want to try a tiny question?

No pressure. Just try it.

Must two places share a direct road to be reachable?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

neighbors = {"home": ["park"], "park": ["home", "cafe"], "cafe": ["park"]}
assert "park" in neighbors["home"]
assert "cafe" in neighbors["park"]

A small step before this topic

Let’s picture it

Where did we put the book?

Cup

Plate

Book

Pen

Try “second shelf, first box.” We need two positions, not just one.

Swipe when you’re ready

One little change

Pick a row, then a column.

0,0

0,1

1,0

1,1

Python calls the second row 1. The first column is 0. So the book is at [1][0].

Same idea. One more small step.

Now it has a name

That’s a two-dimensional table.

cupboard

row

column

Two labels find one cell. A third label could tell us which cupboard contains the table.

Want to try a tiny question?

No pressure. Just try it.

Two cupboards have the same shelves. What extra label helps?

You can also keep scrolling

1 / 4

Start small

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Let’s start with three stops.

🏠 Home

🌳 Park

☕ Café

Home. Then the park. Then the café. Just a few things in a row.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

shelves = [["cup", "plate"], ["book", "pen"]]
assert shelves[1][0] == "book"
assert shelves[0][1] == "plate"

A small step before this topic

Let’s picture it

Same door. One small difference.

You + key

Locked door

You have a key. Your friend doesn’t. The door is the same, but your next move isn’t.

Swipe when you’re ready

One little change

Remember the key.

at door

has key?

If we only write down “at the door,” we lose something important.

Same idea. One more small step.

Now it has a name

That little note is a state.

place

key: yes

A state remembers what we need to continue. Here: where we are, and whether we have the key.

Want to try a tiny question?

No pressure. Just try it.

Is “at the door” enough to decide if we can enter?

You can also keep scrolling

1 / 4

The foundations

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

What if it rains?

☔ Rain

☕ Café

Let’s choose the café on rainy days, and the park on sunny days.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def can_enter(cell, tokens_left):
    return cell == "." or tokens_left > 0

assert can_enter("#", 1)
assert not can_enter("#", 0)

A small step before this topic

Let’s picture it

How many little jobs?

Hi

Visit three places. Say hello once at each. That’s three hellos.

Swipe when you’re ready

One little change

Now try every pair.

3 people

× 3 greetings

= 9

Three people each greet all three people, including themselves for this toy count. That’s nine greetings.

Same idea. One more small step.

Now it has a name

Count how the work grows.

one pass: n

all pairs: n²

One pass grows with n. Trying every pair grows with n × n. Code length doesn’t tell us that.

Want to try a tiny question?

No pressure. Just try it.

With 4 items, how many ordered pairs, including self-pairs?

You can also keep scrolling

1 / 4

The foundations

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Same door. One small difference.

You + key

Locked door

You have a key. Your friend doesn’t. The door is the same, but your next move isn’t.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def predecessor_checks(n):
    return sum(i for i in range(n))

assert predecessor_checks(5) == 10
assert predecessor_checks(1000) == 499500

A small step before this topic

Let’s picture it

Find 8 in a sorted row.

2

4

6

8

10

Start with 2, 4, 6, 8, 10. Look at the middle: 6.

Swipe when you’re ready

One little change

Keep the side that can work.

2 ×

4 ×

6 ×

8

10

8 is bigger than 6. Everything on the left is too small, so we can leave it behind.

Same idea. One more small step.

Now it has a name

Keep one promise.

8

10

If 8 is present, it stays in the part we keep. That repeating promise is called an invariant.

Want to try a tiny question?

No pressure. Just try it.

Would this left-or-right shortcut work on an unsorted row?

You can also keep scrolling

1 / 4

The foundations

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

How many little jobs?

Hi

Visit three places. Say hello once at each. That’s three hellos.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def lower_bound(values, target):
    lo, hi = 0, len(values)
    while lo < hi:
        mid = (lo + hi) // 2
        if values[mid] >= target:
            hi = mid
        else:
            lo = mid + 1
    return lo

assert lower_bound([2, 4, 4, 9], 4) == 1
assert lower_bound([2, 4, 4, 9], 10) == 4
assert lower_bound([], 3) == 0

A small step before this topic

Let’s picture it

Keep a small part of a row.

2

3

Our budget is 5. The values 2 and 3 fit together.

Swipe when you’re ready

One little change

One more makes it too much.

2 + 3 + 4 = 9

4 fits

Add 4: the sum is 9. Remove from the left until it fits again.

Same idea. One more small step.

Now it has a name

That moving part is a window.

left edge

kept values

right edge

With nonnegative values, adding cannot lower the sum. That predictable change tells us which boundary to move.

Want to try a tiny question?

No pressure. Just try it.

Could adding a negative number make a too-large sum fit?

You can also keep scrolling

1 / 4

The foundations

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Find 8 in a sorted row.

2

4

6

8

10

Start with 2, 4, 6, 8, 10. Look at the middle: 6.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def longest_within_limit(values, limit):
    left = total = best = 0
    for right, value in enumerate(values):
        total += value
        while total > limit:
            total -= values[left]
            left += 1
        best = max(best, right - left + 1)
    return best

assert longest_within_limit([2, 1, 3, 1], 4) == 2
assert longest_within_limit([0, 0], 0) == 2
assert longest_within_limit([], 5) == 0

A small step before this topic

Recursion

Let’s picture it

Open a box.

Big box

Small box

Empty

There’s a smaller box inside. We already know how to open a box.

Swipe when you’re ready

One little change

Do the same small job again.

Big box

Small box

Empty

Open the smaller box. Keep going until there isn’t another box inside.

Same idea. One more small step.

Now it has a name

That’s the idea of recursion.

smaller

stop

A function asks itself to handle a smaller case. The empty box is our stopping point: the base case.

Want to try a tiny question?

No pressure. Just try it.

What if every box contains another box forever?

You can also keep scrolling

1 / 4

Recursion

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Same door. One small difference.

You + key

Locked door

You have a key. Your friend doesn’t. The door is the same, but your next move isn’t.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def suffix_sum(values):
    def total(i):
        if i == len(values):
            return 0
        return values[i] + total(i + 1)
    return total(0)

assert suffix_sum([4, 2, 7]) == 13
assert suffix_sum([]) == 0

A small step before this topic

Recursion

Let’s picture it

A question can make two more.

ways(4)

ways(3)

ways(2)

Climb one or two stairs at a time. Four stairs can lead to a smaller question with three or two left.

Swipe when you’re ready

One little change

Look, the same question returns.

ways(3)

ways(2) again

ways(3) also asks for ways(2). We’ve reached that smaller question twice.

Same idea. One more small step.

Now it has a name

Notice the repeated work.

ways(2)

save answer

reuse

Draw the calls to spot repeated questions. Later, we’ll save their answers instead of solving them again.

Want to try a tiny question?

No pressure. Just try it.

Do two calls with the same input always need separate work here?

You can also keep scrolling

1 / 4

Recursion

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Open a box.

Big box

Small box

Empty

There’s a smaller box inside. We already know how to open a box.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def ways(remaining):
    if remaining == 0:
        return 1
    if remaining < 0:
        return 0
    return ways(remaining - 1) + ways(remaining - 2)

assert ways(4) == 5
assert ways(0) == 1

A small step before this topic

Trees

Let’s picture it

Count a tiny family of dots.

Parent

Child: 1

One parent has two children. Each child says, “There’s one of me.”

Swipe when you’re ready

One little change

Let the answers travel up.

Total: 3

1

The parent adds the two answers, then counts itself: 1 + 1 + 1.

Same idea. One more small step.

Now it has a name

That works for bigger trees too.

my answer

left answer

right answer

Ask each child about its little tree. Combine the answers. You don’t need to hold the whole tree in your head.

Want to try a tiny question?

No pressure. Just try it.

Do we also count the parent itself?

You can also keep scrolling

1 / 4

Trees

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Open a box.

Big box

Small box

Empty

There’s a smaller box inside. We already know how to open a box.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def height(node):
    if node is None:
        return 0
    _, left, right = node
    return 1 + max(height(left), height(right))

tree = (8, (3, None, None), (10, None, (12, None, None)))
assert height(tree) == 3
assert height(None) == 0

A small step before this topic

Trees

Let’s picture it

How far down is this dot?

Level 0

Level 1

Call the top dot level 0. Its children sit one level below.

Swipe when you’re ready

One little change

Send a little note downward.

My level: 1

Your level: 2

Tell each child: “Your level is my level plus one.”

Same idea. One more small step.

Now it has a name

Some answers need the parent’s help.

send level ↓

child

A child can count its descendants. But its distance from the top needs information from above.

Want to try a tiny question?

No pressure. Just try it.

Can a leaf tell its level just by seeing no children?

You can also keep scrolling

1 / 4

Trees

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Count a tiny family of dots.

Parent

Child: 1

One parent has two children. Each child says, “There’s one of me.”

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def has_sum(node, remaining):
    if node is None:
        return False
    value, left, right = node
    remaining -= value
    if left is None and right is None:
        return remaining == 0
    return has_sum(left, remaining) or has_sum(right, remaining)

tree = (8, (3, None, None), (10, None, None))
assert has_sum(tree, 11)
assert not has_sum(tree, 8)
assert not has_sum(None, 0)

A small step before this topic

Trees

Let’s picture it

Two trees can make different promises.

8

3

10

In a search tree, smaller keys go left and larger keys go right. We’ll use distinct keys here.

Swipe when you’re ready

One little change

A heap promises something else.

3

10

8

A min-heap keeps the smallest value at the top. Its left and right sides need not be sorted.

Same idea. One more small step.

Now it has a name

Choose the promise you need.

find a key

take smallest

Looking for an ordered key? Think search tree. Repeatedly taking the smallest? Think min-heap.

Want to try a tiny question?

No pressure. Just try it.

Does a min-heap promise its left side is smaller than its right?

You can also keep scrolling

1 / 4

Trees

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Find 8 in a sorted row.

2

4

6

8

10

Start with 2, 4, 6, 8, 10. Look at the middle: 6.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

from heapq import heappop, heappush

pending = []
for cost in [8, 2, 7, 1]:
    heappush(pending, cost)
assert pending[0] == 1
assert [heappop(pending) for _ in range(4)] == [1, 2, 7, 8]

A small step before this topic

Let’s picture it

Come back to our little map.

Home

Park

Café

Home, park, café. Each place is a dot; each allowed walk is a link.

Swipe when you’re ready

One little change

A dot can also mean a situation.

Park + key

Park, no key

“At park with a key” may allow a move that “at park without a key” cannot.

Same idea. One more small step.

Now it has a name

Choose dots that tell the whole story.

situation

legal move

new situation

A graph organizes possible moves. Sometimes places are enough. Sometimes a place plus a small extra fact is needed.

Want to try a tiny question?

No pressure. Just try it.

Must graph nodes always represent physical places?

You can also keep scrolling

1 / 4

Graphs

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Same door. One small difference.

You + key

Locked door

You have a key. Your friend doesn’t. The door is the same, but your next move isn’t.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def neighbors(row, col, rows, cols):
    for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
        nr, nc = row + dr, col + dc
        if 0 <= nr < rows and 0 <= nc < cols:
            yield nr, nc

assert set(neighbors(0, 0, 2, 3)) == {(1, 0), (0, 1)}

A small step before this topic

Let’s picture it

Try the nearest places first.

Home

1 road

2 roads

From home, find everything one road away before looking two roads away.

Swipe when you’re ready

One little change

Put new places at the back.

current layer

next layer

A queue keeps the earlier discoveries in front. That lets us finish one layer before the next.

Same idea. One more small step.

Now it has a name

That’s breadth-first search: BFS.

0 moves

1 move

2 moves

With equal-cost roads, the first layer reaching a place uses the fewest roads. Unequal costs need more care.

Want to try a tiny question?

No pressure. Just try it.

One road costs 100 minutes; two others cost 1 each. Fewest roads means fastest?

You can also keep scrolling

1 / 4

Graphs

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Come back to our little map.

Home

Park

Café

Home, park, café. Each place is a dot; each allowed walk is a link.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

from collections import deque

def distances(graph, start):
    distance = {start: 0}
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in graph.get(node, []):
            if neighbor not in distance:
                distance[neighbor] = distance[node] + 1
                queue.append(neighbor)
    return distance

graph = {"A": ["B", "C"], "B": ["D"], "C": ["D"], "D": []}
assert distances(graph, "A") == {"A": 0, "B": 1, "C": 1, "D": 2}

A small step before this topic

Let’s picture it

Follow one path for a while.

Home

Park

Café

Instead of finishing a whole layer, keep walking down one branch. This is depth-first search, or DFS.

Swipe when you’re ready

One little change

Remember where you’ve been.

Home ✓

Park ✓

Café ✓

For reachability, a seen set helps avoid walking around the same cycle forever.

Same idea. One more small step.

Now it has a name

But ask what “seen” means.

this attempt

undo mark

next attempt

For routes that cannot repeat a place, a place used in one attempt may be free in another. Clear path-only marks when returning.

Want to try a tiny question?

No pressure. Just try it.

Does “used in this path” always mean “forbidden in every path”?

You can also keep scrolling

1 / 4

Graphs

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Open a box.

Big box

Small box

Empty

There’s a smaller box inside. We already know how to open a box.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def reachable(graph, start):
    seen = {start}
    stack = [start]
    while stack:
        node = stack.pop()
        for neighbor in graph.get(node, []):
            if neighbor not in seen:
                seen.add(neighbor)
                stack.append(neighbor)
    return seen

graph = {"A": ["B"], "B": ["A", "C"], "C": []}
assert reachable(graph, "A") == {"A", "B", "C"}

A small step before this topic

Let’s picture it

Socks before shoes.

Socks

Shoes

Some jobs must wait for other jobs. Draw an arrow from the earlier job to the later one.

Swipe when you’re ready

One little change

Start with a ready job.

✓ Socks

Shoes ready

Do a job with nothing unfinished before it. Remove it from the waiting list and look for the next ready job.

Same idea. One more small step.

Now it has a name

That makes a dependency order.

A waits for B

B waits for A

Its name is topological order. A cycle means some jobs keep waiting on one another, so no such order exists.

Want to try a tiny question?

No pressure. Just try it.

A waits for B, and B waits for A. Can either start under these rules?

You can also keep scrolling

1 / 4

Graphs

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Come back to our little map.

Home

Park

Café

Home, park, café. Each place is a dot; each allowed walk is a link.

1 / 3

Python for Course Schedule II. The complete example includes small checks you can run; the full notes state its scope.

Show the complete Python solution

from collections import deque

def order_tasks(n, edges):
    graph = [[] for _ in range(n)]
    incoming = [0] * n
    for u, v in edges:
        graph[u].append(v)
        incoming[v] += 1
    ready = deque(i for i in range(n) if incoming[i] == 0)
    order = []
    while ready:
        u = ready.popleft()
        order.append(u)
        for v in graph[u]:
            incoming[v] -= 1
            if incoming[v] == 0:
                ready.append(v)
    return order if len(order) == n else None

assert order_tasks(3, [(0, 2), (1, 2)]) == [0, 1, 2]
assert order_tasks(2, [(0, 1), (1, 0)]) is None
assert order_tasks(0, []) == []

A small step before this topic

Backtracking

Let’s picture it

Try a snack combination.

Apple

Banana

Pear

Pick apple first. See what can go with it. We’re exploring, not committing forever.

Swipe when you’re ready

One little change

Put it back and try again.

Apple

Banana

Pear

After exploring the apple choices, undo that pick. Now start with banana.

Same idea. One more small step.

Now it has a name

That’s backtracking.

choose

explore

undo

Choose, explore, undo. Undoing keeps the next attempt from accidentally inheriting the last attempt’s choices.

Want to try a tiny question?

No pressure. Just try it.

Before a sibling attempt, what happens to path-only choices?

You can also keep scrolling

1 / 4

Backtracking

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

A question can make two more.

ways(4)

ways(3)

ways(2)

Climb one or two stairs at a time. Four stairs can lead to a smaller question with three or two left.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def subsets(values):
    answers, path = [], []
    def visit(i):
        if i == len(values):
            answers.append(path.copy())
            return
        visit(i + 1)               # Exclude this item.
        path.append(values[i])     # Include this item.
        visit(i + 1)
        path.pop()                 # Restore the caller's path.
    visit(0)
    return answers

assert subsets(["A", "B"]) == [[], ["B"], ["A"], ["A", "B"]]
assert subsets([]) == [[]]

A small step before this topic

Tries

Let’s picture it

Car and cat start the same way.

c

a

r / t

Write c, then a, just once. Split where the words become different.

Swipe when you’re ready

One little change

A prefix isn’t always a word.

c

a

r

t ✓

If we only stored cart, reaching c-a-r is not enough to say car was stored too.

Same idea. One more small step.

Now it has a name

Mark where each word ends.

car ✓

cart ✓

cat ✓

This shared-prefix tree is a trie. The word-end mark tells a whole word apart from just its beginning.

Want to try a tiny question?

No pressure. Just try it.

Only cart is stored. Does car count as a stored word?

You can also keep scrolling

1 / 4

Tries

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Count a tiny family of dots.

Parent

Child: 1

One parent has two children. Each child says, “There’s one of me.”

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def insert(root, word):
    node = root
    for char in word:
        node = node.setdefault(char, {})
    node[None] = True

def follow(root, text):
    node = root
    for char in text:
        if char not in node:
            return None
        node = node[char]
    return node

trie = {}
insert(trie, "cart")
assert follow(trie, "car") is not None
assert None not in follow(trie, "car")
insert(trie, "car")
assert None in follow(trie, "car")
assert follow(trie, "dog") is None

A small step before this topic

Thinking in DP

Let’s picture it

We’ve answered this before.

route A

3 stairs left

route B

Two routes leave us with three stairs left. We may climb one or two at a time.

Swipe when you’re ready

One little change

Save these three little routes.

1+1+1

1+2

2+1

The routes are 1+1+1, 1+2, and 2+1. Count them once; both arrivals can reuse the answer.

Same idea. One more small step.

Now it has a name

That sharing is the heart of DP.

same question

reuse answer

Dynamic programming saves answers to smaller questions. Share only when the remaining question really is the same.

Want to try a tiny question?

No pressure. Just try it.

One route has a key left and the other doesn’t. Always the same remaining question?

You can also keep scrolling

1 / 4

Thinking in DP

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Same door. One small difference.

You + key

Locked door

You have a key. Your friend doesn’t. The door is the same, but your next move isn’t.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

from functools import cache

def count_climbs(n):
    @cache
    def ways(r):
        if r == 0:
            return 1
        if r < 0:
            return 0
        return ways(r - 1) + ways(r - 2)
    return ways(n)

assert count_climbs(5) == 8
assert count_climbs(0) == 1

A small step before this topic

Thinking in DP

Let’s picture it

Two ways to fill a notebook.

asked?

solve once

save

One way: when a question appears, solve it if needed, then write down the answer.

Swipe when you’re ready

One little change

Or prepare the small answers first.

small

Fill answers in an order where each needed earlier answer is already available.

Same idea. One more small step.

Now it has a name

Same idea, different order.

on demand

in order

Saving answers on demand is memoization. Filling them in a planned order is tabulation.

Want to try a tiny question?

No pressure. Just try it.

When filling a table, should an answer be ready before another cell uses it?

You can also keep scrolling

1 / 4

Thinking in DP

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

We’ve answered this before.

route A

3 stairs left

route B

Two routes leave us with three stairs left. We may climb one or two at a time.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def count_climbs(n):
    table = [0] * (n + 1)
    table[0] = 1
    for height in range(1, n + 1):
        table[height] = table[height - 1]
        if height >= 2:
            table[height] += table[height - 2]
    return table[n]

assert [count_climbs(n) for n in range(6)] == [1, 1, 2, 3, 5, 8]

Let’s picture it

Pick snacks, but not neighbors.

4

5

4

The values are 4, 5, 4. Taking the middle snack blocks both neighbors.

Swipe when you’re ready

One little change

Taking less first can win.

4 ✓

5 ×

4 ✓

Take the first 4 and the last 4. Their total is 8, which beats 5.

Same idea. One more small step.

Now it has a name

Ask about the row from here.

take: i + 2

skip: i + 1

At position i, compare taking it and moving two places, or skipping it and moving one. One position names this smaller question.

Want to try a tiny question?

No pressure. Just try it.

After taking position i, where can we continue?

You can also keep scrolling

1 / 4

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

We’ve answered this before.

route A

3 stairs left

route B

Two routes leave us with three stairs left. We may climb one or two at a time.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

from functools import cache

def best_non_adjacent(values):
    @cache
    def best(i):
        if i >= len(values):
            return 0
        return max(best(i + 1), values[i] + best(i + 2))
    return best(0)

assert best_non_adjacent([4, 5, 4]) == 8
assert best_non_adjacent([-5, -1]) == 0
assert best_non_adjacent([]) == 0

Let’s picture it

Pick dots, but not parent and child.

5

4

The parent is worth 5. Each of its two children is worth 4.

Swipe when you’re ready

One little change

Skipping the parent can help.

skip 5

take 4

Take both children for 8. Taking the parent would block them and give only 5.

Same idea. One more small step.

Now it has a name

Keep two answers per little tree.

take root

skip root

Best if we take its root. Best if we skip its root. The parent uses whichever child choices its own decision allows.

Want to try a tiny question?

No pressure. Just try it.

If we take a parent, may we take its immediate child in this problem?

You can also keep scrolling

1 / 4

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Count a tiny family of dots.

Parent

Child: 1

One parent has two children. Each child says, “There’s one of me.”

1 / 3

Python for House Robber III. The complete example includes small checks you can run; the full notes state its scope.

Show the complete Python solution

def tree_pick(root):
    def solve(node):
        if node is None:
            return 0, 0
        value, left, right = node
        lt, ls = solve(left)
        rt, rs = solve(right)
        take = value + ls + rs
        skip = max(lt, ls) + max(rt, rs)
        return take, skip
    return max(solve(root))

assert tree_pick((5, (4, None, None), (4, None, None))) == 8
assert tree_pick((-5, None, None)) == 0
assert tree_pick(None) == 0

A familiar idea

How far is everyone from each home?

A

B

C

Three homes form A–B–C. From A, distances total 0+1+2 = 3. From B, they total 1+0+1 = 2.

Swipe when you’re ready

One new wrinkle

Move the measuring point one edge.

2 closer

1 farther

Move from A to B. B and C become one step closer. Only A becomes one step farther.

Same idea. One more small step.

Try a tiny example

Update instead of starting over.

3

− 2 + 1

2

The total changes from 3 to 3 − 2 + 1 = 2. A whole side of the tree moves together.

Same idea. One more small step.

Notice what matters

Count both sides using subtree size.

closer: size[v]

farther: n − size[v]

For parent u and child v, size[v] nodes get closer; n − size[v] get farther. answer[v] = answer[u] + n − 2×size[v].

Same idea. One more small step.

Make it reusable

Two passes are enough.

gather upward

reuse downward

First gather subtree sizes and the root’s total. Then pass the updated answer from each parent to its children. That’s rerooting DP.

Want to try a tiny question?

No pressure. Just try it.

Why does the simple two-side update depend on the input being a tree?

You can also keep scrolling

1 / 6

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Pick dots, but not parent and child.

5

4

The parent is worth 5. Each of its two children is worth 4.

1 / 3

Python for Sum of Distances in Tree. The complete example includes small checks you can run; the full notes state its scope.

Show the complete Python solution

def distance_sums(n, edges):
    if n == 0:
        return []
    graph = [[] for _ in range(n)]
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)
    parent = [-1] * n
    order = [0]
    for u in order:
        for v in graph[u]:
            if v != parent[u]:
                parent[v] = u
                order.append(v)
    size, subtotal = [1] * n, [0] * n
    for u in reversed(order[1:]):
        p = parent[u]
        size[p] += size[u]
        subtotal[p] += subtotal[u] + size[u]
    answer = [0] * n
    answer[0] = subtotal[0]
    for u in order[1:]:
        p = parent[u]
        answer[u] = answer[p] + n - 2 * size[u]
    return answer

assert distance_sums(3, [(0,1), (1,2)]) == [3,2,3]
assert distance_sums(4, [(0,1), (0,2), (0,3)]) == [3,5,5,5]
assert distance_sums(1, []) == [0]

Let’s picture it

Make 3 using coins 1 and 2.

1 + 2

2 + 1

We could use 1 then 2, or 2 then 1.

Swipe when you’re ready

One little change

What are we counting?

orders: 2

combination: 1

Those are two orders, but the same combination of coins. The question decides whether to count them separately.

Same idea. One more small step.

Now it has a name

Same ingredients, different tasks.

fewest?

orders?

combinations?

Fewest coins, number of orders, and number of combinations are different questions. Decide which answer one cell is storing.

Want to try a tiny question?

No pressure. Just try it.

If order doesn’t matter, are 1+2 and 2+1 two combinations?

You can also keep scrolling

1 / 4

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Pick snacks, but not neighbors.

4

5

4

The values are 4, 5, 4. Taking the middle snack blocks both neighbors.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def minimum_coins(coins, target):
    dp = [0] + [float("inf")] * target
    for amount in range(1, target + 1):
        for coin in coins:
            if coin <= amount:
                dp[amount] = min(dp[amount], 1 + dp[amount - coin])
    return -1 if dp[target] == float("inf") else dp[target]

assert minimum_coins([1, 3, 4], 6) == 2
assert minimum_coins([2], 3) == -1
assert minimum_coins([2], 0) == 0

Let’s picture it

Keep some numbers in order.

3 ×

1 ✓

2 ✓

From 3, 1, 2, we can keep 1 then 2. We are allowed to skip 3.

Swipe when you’re ready

One little change

Ask what can end here.

1

2

For the 2, an earlier smaller number such as 1 can extend into a longer increasing sequence.

Same idea. One more small step.

Now it has a name

Gaps are allowed.

keep order

allow gaps

A subsequence preserves order without needing neighboring positions. That’s different from one continuous window.

Want to try a tiny question?

No pressure. Just try it.

Can we reorder 3, 1, 2 into 1, 2, 3 as a subsequence?

You can also keep scrolling

1 / 4

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Pick snacks, but not neighbors.

4

5

4

The values are 4, 5, 4. Taking the middle snack blocks both neighbors.

1 / 3

No need to read the code yet. It’s here when you want to connect the picture to Python.

Show the Python example

def lis_length(values):
    dp = [1] * len(values)
    for i in range(len(values)):
        for j in range(i):
            if values[j] < values[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp, default=0)

assert lis_length([1, 9, 2, 3]) == 3
assert lis_length([2, 2, 2]) == 1
assert lis_length([]) == 0

A familiar idea

A word ending is a possible jump.

car

ca

rs

Split cars using dictionary words car, ca, and rs. The longest first match is car.

Swipe when you’re ready

One new wrinkle

The longest match gets stuck.

car | s ×

ca | rs ✓

car leaves s, which is not a word. ca leaves rs, which is. We must consider more than one ending.

Same idea. One more small step.

Try a tiny example

Ask whether a suffix can finish.

position i

remaining string

yes or no

Let can[i] mean the string from position i onward can be split. The empty suffix can finish.

Same idea. One more small step.

Notice what matters

A trie offers candidate endings.

trie match

word end

can[next]?

Walk forward through the trie. At each complete word, check whether the suffix after it can finish.

Same idea. One more small step.

Make it reusable

Trie plus one-position DP.

0

2

4

The trie discovers legal jumps. DP combines them into a complete route through string boundaries.

Want to try a tiny question?

No pressure. Just try it.

Why is the longest dictionary match not automatically best?

You can also keep scrolling

1 / 6

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

Car and cat start the same way.

c

a

r / t

Write c, then a, just once. Split where the words become different.

1 / 3

Python for Word Break. The complete example includes small checks you can run; the full notes state its scope.

Show the complete Python solution

def build_trie(words):
    root = {}
    for word in set(words):
        if not word:
            raise ValueError("Dictionary words must be nonempty")
        node = root
        for letter in word:
            node = node.setdefault(letter, {})
        node[None] = True
    return root

def can_segment(s, words):
    root = build_trie(words)
    can = [False] * (len(s) + 1)
    can[-1] = True
    for i in range(len(s) - 1, -1, -1):
        node = root
        for j in range(i, len(s)):
            if s[j] not in node:
                break
            node = node[s[j]]
            if None in node and can[j + 1]:
                can[i] = True
                break
    return can[0]

assert can_segment("cars", ["car", "ca", "rs"])
assert not can_segment("cars", ["car"])
assert can_segment("aaaa", ["a", "aa"])
assert can_segment("", ["a"])

A familiar idea

Keep the same word-boundary idea.

a | a | a | a

aa | aa

For aaaa with words a and aa, many sentences work. Now we need all of them, not just yes or no.

Swipe when you’re ready

One new wrinkle

First mark which suffixes can finish.

suffix possible?

keep or prune

Reuse Word Break’s yes/no DP. It tells us which candidate endings would lead into a dead end.

Same idea. One more small step.

Try a tiny example

Then walk every surviving branch.

choose

explore

undo

Choose a word, append it, explore the rest, then undo. The trie supplies word endings along the way.

Same idea. One more small step.

Notice what matters

Reuse impossibility, not one favorite sentence.

a | a

aa

same suffix

Two different prefixes can reach the same suffix. Both must be retained when the output asks for every sentence.

Same idea. One more small step.

Make it reusable

Trie, DP, and backtracking cooperate.

trie

DP

backtracking

The first generates choices, the second removes dead ends, and the third emits answers. Many valid outputs still take time to write.

Want to try a tiny question?

No pressure. Just try it.

Can memoization make printing exponentially many sentences take linear time?

You can also keep scrolling

1 / 6

1D dynamic programming

One small step at a time.

This idea builds on these smaller ones. Pick any to revisit it here.

A word ending is a possible jump.

car

ca

rs

Split cars using dictionary words car, ca, and rs. The longest first match is car.

1 / 5

Python for Word Break II. The complete example includes small checks you can run; the full notes state its scope.

Show the complete Python solution

def build_trie(words):
    root = {}
    for word in set(words):
        if not word:
            raise ValueError("Dictionary words must be nonempty")
        node = root
        for letter in word:
            node = node.setdefault(letter, {})
        node[None] = True
    return root

def all_sentences(s, words):
    if not s:
        return []
    root = build_trie(words)
    n = len(s)
    can = [False] * (n + 1)
    can[n] = True
    following = [[] for _ in range(n)]
    for i in range(n - 1, -1, -1):
        node = root
        for j in range(i, n):
            if s[j] not in node:
                break
            node = node[s[j]]
            if None in node and can[j + 1]:
                following[i].append(j + 1)
                can[i] = True
    answer, path = [], []

    def emit(i):
        if i == n:
            answer.append(" ".join(path))
            return
        for end in following[i]:
            path.append(s[i:end])
            emit(end)
            path.pop()

    emit(0)
    return answer

assert sorted(all_sentences("cars", ["car", "ca", "rs"])) == ["ca rs"]
assert len(all_sentences("aaaa", ["a", "aa"])) == 5
assert all_sentences("cars", ["car"]) == []
assert all_sentences("a", ["a", "a"]) == ["a"]