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

The foundations

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

The foundations

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

The foundations

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

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

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

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

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

Visit the same three dots.

A

B

C

We can say the parent’s name first, then visit its children.

Swipe when you’re ready

One little change

Or wait until the children finish.

Finish last: A

First: B

Then: C

For a count, the parent needs the children’s answers first. So visit B, C, then finish A.

Same idea. One more small step.

Now it has a name

The timing has a name.

before

between

after

Parent first is preorder. Children first is postorder. Left, parent, right is inorder for a binary tree.

Want to try a tiny question?

No pressure. Just try it.

Which timing helps combine child answers?

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 traversal_orders(root):
    preorder, inorder, postorder = [], [], []
    def visit(node):
        if node is None:
            return
        value, left, right = node
        preorder.append(value)
        visit(left)
        inorder.append(value)
        visit(right)
        postorder.append(value)
    visit(root)
    return preorder, inorder, postorder

tree = (2, (1, None, None), (3, None, None))
assert traversal_orders(tree) == ([2, 1, 3], [1, 2, 3], [1, 3, 2])
assert traversal_orders(None) == ([], [], [])

A small step before this topic

Graphs

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

Graphs

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

Graphs

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

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

Backtracking

Let’s picture it

This bag is already too heavy.

limit: 5

packed: 6

The limit is 5 kg. We’ve packed 6 kg, and every remaining item has positive weight.

Swipe when you’re ready

One little change

More items cannot fix that.

6 kg

add more

still too heavy

We can stop exploring this branch. There’s no need to try every heavier version.

Same idea. One more small step.

Now it has a name

That early stop is pruning.

cannot work

safe to stop

Skip a branch when you can explain why it cannot work. “It looks unpromising” is not enough.

Want to try a tiny question?

No pressure. Just try it.

If later choices can subtract weight, is “already too heavy” enough to stop?

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.

Try a snack combination.

Apple

Banana

Pear

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

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 unique_subsets(values):
    values = sorted(values)
    answers, path = [], []
    def visit(start):
        answers.append(path.copy())
        for i in range(start, len(values)):
            if i > start and values[i] == values[i - 1]:
                continue
            path.append(values[i])
            visit(i + 1)
            path.pop()
    visit(0)
    return answers

assert unique_subsets([1, 1, 2]) == [[], [1], [1, 1], [1, 1, 2], [1, 2], [2]]

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

Let’s picture it

What could ca? mean?

ca?

car

cat

Let ? stand for one letter. Both car and cat could match.

Swipe when you’re ready

One little change

Try the allowed endings.

ca

r?

t?

At the wildcard, check each child. One failed ending doesn’t rule out the others.

Same idea. One more small step.

Now it has a name

Storage and search work together.

trie: choices

search: try them

The trie tells us which letters exist. The search tries the possibilities. These are two different jobs.

Want to try a tiny question?

No pressure. Just try it.

One wildcard child fails. Can another child still match?

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.

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

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

Show the Python example

def matches(node, pattern, i=0):
    if i == len(pattern):
        return None in node
    char = pattern[i]
    if char == ".":
        return any(matches(child, pattern, i + 1)
                   for key, child in node.items() if key is not None)
    return char in node and matches(node[char], pattern, i + 1)

trie = {"c": {"a": {"r": {None: True}, "t": {None: True}}}}
assert matches(trie, "ca.")
assert not matches(trie, "c.")
assert not matches(trie, "dog")

Let’s picture it

Type just ca.

ca

car

cat

Follow c, then a. All the matching words live below that shared beginning.

Swipe when you’re ready

One little change

Now collect the word endings.

car

cart

cat

Walk below ca and gather the marked words, such as car, cart, and cat.

Same idea. One more small step.

Now it has a name

Finding and listing are different jobs.

find prefix

collect words

Finding ca can be quick. Listing a million completions still means producing a million outputs.

Want to try a tiny question?

No pressure. Just try it.

Does a short prefix guarantee a tiny amount of total work?

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.

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

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

Show the Python example

def autocomplete(root, prefix):
    node = root
    for char in prefix:
        if char not in node:
            return []
        node = node[char]
    answers, path = [], list(prefix)
    def collect(current):
        if None in current:
            answers.append("".join(path))
        for char in sorted(key for key in current if key is not None):
            path.append(char)
            collect(current[char])
            path.pop()
    collect(node)
    return answers

trie = {"c": {"a": {"r": {None: True, "t": {None: True}}, "t": {None: True}}}}
assert autocomplete(trie, "ca") == ["car", "cart", "cat"]
assert autocomplete(trie, "cart") == ["cart"]
assert autocomplete(trie, "dog") == []

Let’s picture it

Find CAT on a letter board.

C

A

R

T

Move between neighboring cells. The letters on your path build a word.

Swipe when you’re ready

One little change

Let a trie guide each move.

C

CA

CAT ✓

After C, only follow a neighbor if its letter continues a stored prefix.

Same idea. One more small step.

Now it has a name

Remember this path’s cells.

mark

explore

unmark

We move on the board and through the trie together. If reuse is forbidden, mark a cell, explore, then unmark it.

Want to try a tiny question?

No pressure. Just try it.

Should one failed path permanently block its cells for every other attempt?

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.

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.

1 / 3

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

Show the complete Python solution

def find_words(board, words):
    if not board or not board[0]:
        return []
    root = {}
    for word in words:
        node = root
        for char in word:
            node = node.setdefault(char, {})
        node[None] = word
    rows, cols = len(board), len(board[0])
    found, used = set(), set()
    def visit(r, c, node):
        if not (0 <= r < rows and 0 <= c < cols) or (r, c) in used:
            return
        char = board[r][c]
        if char not in node:
            return
        child = node[char]
        if None in child:
            found.add(child[None])
        used.add((r, c))
        for dr, dc in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
            visit(r + dr, c + dc, child)
        used.remove((r, c))
    for r in range(rows):
        for c in range(cols):
            visit(r, c, root)
    return sorted(found)

board = [["c", "a"], ["r", "t"]]
assert find_words(board, ["cat", "car", "cr", "catr", "caca"]) == ["cat", "catr", "cr"]
assert find_words([["a"]], ["a", "aa", "a"]) == ["a"]