The code looks harmless. Each block below runs on its own, and the output under it is what Python 3.13 printed.

defaults = {"theme": "dark", "tags": ["new"]}
user_a = defaults.copy()
user_a["tags"].append("beta")

print("1. shallow copy, then append")
print("   defaults:", defaults)
print("   user_a  :", user_a)
print("   same inner list?", user_a["tags"] is defaults["tags"])

1. shallow copy, then append
   defaults: {'theme': 'dark', 'tags': ['new', 'beta']}
   user_a  : {'theme': 'dark', 'tags': ['new', 'beta']}
   same inner list? True

.copy() made a new dict, so user_a is not defaults. But the new dict holds the same list object under "tags". You copied the outer box and kept pointing at the same contents. That is what "shallow" means. The rest of the interview answer is where it bites.

When you explain it out loud, draw it: two dict boxes, each with an arrow labelled tags going to the same list box. The drawing usually answers the follow-up questions. The is check in the code is the same picture in text. It asks whether two names point at one object, not whether the contents look equal.

The same thing happens with the other usual ways to copy. list(x), x[:] and x.copy() all build a new outer list and share the inner ones:

nested = [["a"], ["b"]]
clones = [list(nested), nested[:], nested.copy()]
print("inner lists shared with the original:", [c[0] is nested[0] for c in clones])

inner lists shared with the original: [True, True, True]

The bug is not specific to .copy(): it appears wherever you wanted an independent copy and wrote the cheap one.

Schoolabe's Python interview questions page lists "What is the difference between shallow copy and deep copy in Python?" in its sample of the question bank. It describes the category as "copying vs references" gotchas that interviewers probe with short follow-ups. Interviewers rarely stop at a definition; they show five lines and ask what prints.

Follow-ups worth rehearsing

The fix everyone knows is copy.deepcopy, which walks the structure and copies everything it finds:

import copy

defaults = {"theme": "dark", "tags": ["new"]}
user_b = copy.deepcopy(defaults)
user_b["tags"].append("beta")

print("2. deepcopy, then append")
print("   defaults:", defaults)
print("   user_b  :", user_b)

2. deepcopy, then append
   defaults: {'theme': 'dark', 'tags': ['new']}
   user_b  : {'theme': 'dark', 'tags': ['new', 'beta']}

Then there is the trap inside the trap: a shallow copy is not always broken. If you replace a value instead of mutating it, the copy is fine.

defaults = {"theme": "dark", "tags": ["new"]}
user_c = defaults.copy()
user_c["theme"] = "light"
user_c["tags"] = user_c["tags"] + ["beta"]

print("3. shallow copy, but rebind instead of mutate")
print("   defaults:", defaults)
print("   user_c  :", user_c)

3. shallow copy, but rebind instead of mutate
   defaults: {'theme': 'dark', 'tags': ['new']}
   user_c  : {'theme': 'light', 'tags': ['new', 'beta']}

The + builds a brand new list and assigns it to the key in the copy only. append changes the list both dicts share. A small difference in how you write the line decides whether the bug exists, and that is the cause behind advice like "just always use deepcopy".

The list-of-lists cousin needs no call to copy at all:

grid = [[0] * 3] * 3
grid[0][0] = 9
print("repeated rows ->", grid)

grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 9
print("comprehension   ->", grid)

repeated rows -> [[9, 0, 0], [9, 0, 0], [9, 0, 0]]
comprehension   -> [[9, 0, 0], [0, 0, 0], [0, 0, 0]]

Multiplying a list repeats the reference, not the row. Three rows, one list. The comprehension fixes it because [0] * 3 is evaluated again for every row, so each row is a fresh list. If someone answers the grid question correctly but can't say why the comprehension works, keep asking; that is the part that matters. I think this is the better thing to ask in a mock interview, because it tells you more about whether someone understands references than the shallow versus deep definition does. You see it in grid and DP problems, where people build a table of zeros.

Is deepcopy just the answer, then?

Not by reflex. It copes with cycles, which surprised me: a list that contains itself deep-copies fine, and the last line of the next block checks it. So correctness isn't the objection. Cost is.

import copy
import time

rows = [list(range(100)) for _ in range(2000)]
times = []
for _ in range(10):
    start = time.perf_counter()
    copy.deepcopy(rows)
    times.append((time.perf_counter() - start) * 1000)
print(f"deepcopy of 2,000 lists of 100 ints: {min(times):.0f} to {max(times):.0f} ms over 10 runs")

loop = [1]
loop.append(loop)
clone = copy.deepcopy(loop)
print("self-referencing list deep-copied fine:", clone[1] is clone and clone is not loop)

deepcopy of 2,000 lists of 100 ints: 26 to 35 ms over 10 runs
self-referencing list deep-copied fine: True

(Your timings will differ.)

That timing is from one machine, so run it yourself. The deepcopy figure held steady across my runs at roughly 25 to 35 ms. I won't quote a ratio against a shallow copy, because a shallow copy of that list is so quick that the timer mostly measures noise.

For a settings object copied once per signup, who cares. Inside a loop that runs a million times, you will care a great deal. The cheaper habit is to not share mutable things in the first place: build new lists with + or a comprehension, or store tags as a tuple so append isn't even possible. Then the shallow copy is safe and you never need the slow one.

My tests only used lists, dicts and ints. Objects with custom __copy__ or __deepcopy__ methods, or ones holding file handles or locks, behave differently, and I didn't try any of them. If an interviewer pushes in that direction, say you would check the class before assuming.

Write down what you think prints before you run it.

Written by the Schoolabe team, who build schoolabe.com. Its homepage says tutorials, quizzes and practice are free, and that lessons and practice problems run in the browser.

In this post we'll use a small but real dataset, Palmer Penguins, and go through a beginner's workflow: load, inspect, clean, filter, create columns, group, and summarise. Every snippet below runs as written, and the outputs shown are the actual outputs.

The dataset

Palmer Penguins has measurements for 344 penguins of three species (Adelie, Chinstrap, Gentoo) from three islands in the Palmer Archipelago, Antarctica. The data was collected by Dr. Kristen Gorman and the Palmer Station LTER, and it's released under CC0. It's small enough to understand completely and messy enough to be realistic.

You'll need Python 3 and pandas (pip install pandas). We'll read the CSV straight from a public URL.

Step 1: Load and take a first look

import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
df = pd.read_csv(url)

print(df.shape)
print(df.head())

(344, 7)
  species     island  bill_length_mm  ...  flipper_length_mm  body_mass_g     sex
0  Adelie  Torgersen            39.1  ...              181.0       3750.0    MALE
1  Adelie  Torgersen            39.5  ...              186.0       3800.0  FEMALE
2  Adelie  Torgersen            40.3  ...              195.0       3250.0  FEMALE
3  Adelie  Torgersen             NaN  ...                NaN          NaN     NaN
4  Adelie  Torgersen            36.7  ...              193.0       3450.0  FEMALE

344 rows, 7 columns, and on row 3 we already have a fully missing record. Notice that flipper_length_mm and body_mass_g came in as floats (181.0). That's because pandas can't store NaN in a standard integer column, so a single missing value turns the whole column into floats.

Step 2: Understand the columns

df.info()

RangeIndex: 344 entries, 0 to 343
Data columns (total 7 columns):
 #   Column             Non-Null Count  Dtype
---  ------             --------------  -----
 0   species            344 non-null    str
 1   island             344 non-null    str
 2   bill_length_mm     342 non-null    float64
 3   bill_depth_mm      342 non-null    float64
 4   flipper_length_mm  342 non-null    float64
 5   body_mass_g        342 non-null    float64
 6   sex                333 non-null    str

(On pandas 2.x, the text columns show up as object instead of str. Both mean the same thing here.)

info() is the first thing to run on any new dataset. It tells you the column types and how many non-null values each column has. We can already see that the four measurements are missing 2 values each, and sex is missing 11.

Then get a quick numeric summary:

print(df.describe().round(1))

       bill_length_mm  bill_depth_mm  flipper_length_mm  body_mass_g
count           342.0          342.0              342.0        342.0
mean             43.9           17.2              200.9       4201.8
std               5.5            2.0               14.1        802.0
min              32.1           13.1              172.0       2700.0
...
max              59.6           21.5              231.0       6300.0

A body mass between 2.7 kg and 6.3 kg looks plausible for these species. Checking that the min and max make sense is a quick way to catch data-entry errors.

Step 3: Find the missing values

print(df.isna().sum())

species               0
island                0
bill_length_mm        2
bill_depth_mm         2
flipper_length_mm     2
body_mass_g           2
sex                  11

To see the actual rows:

print(df[df.isna().any(axis=1)])

This shows 11 rows. Two of them (rows 3 and 339) have no measurements at all. The other nine have measurements but no sex.

What you do with missing data depends on your question. If you're studying body mass, rows with a recorded mass are still useful even when sex is unknown. So we drop rows only when the measurements are missing:

measurements = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
clean = df.dropna(subset=measurements).copy()
print(clean.shape)   # (342, 7)

Two habits worth building early:

• Use subset= so you don't throw away rows you could have kept. A plain df.dropna() would drop all 11.
• Use .copy() when you plan to add columns to a filtered DataFrame. It avoids the SettingWithCopyWarning you'd otherwise see on older pandas versions, and it makes clear that clean is a separate table.

Step 4: Count categories

print(df["species"].value_counts())

species
Adelie       152
Gentoo       124
Chinstrap     68

Which species lives on which island? pd.crosstab gives you a frequency table in one line:

print(pd.crosstab(df["species"], df["island"]))

island     Biscoe  Dream  Torgersen
species
Adelie         44     56         52
Chinstrap       0     68          0
Gentoo        124      0          0

In this sample, Adelie penguins appear on all three islands, while Chinstrap appear only on Dream and Gentoo only on Biscoe. A table like this is useful later on, because a "difference between islands" could really be a difference between species.

Step 5: Filter rows

Boolean filtering is the pandas skill you'll use most. Wrap each condition in parentheses and combine them with & (and) or | (or). Don't use the Python keywords and/or here.

heavy_gentoo = clean[(clean["species"] == "Gentoo") & (clean["body_mass_g"] > 5500)]
print(len(heavy_gentoo))                                     # 28
print(heavy_gentoo[["island", "sex", "body_mass_g"]].head())

     island   sex  body_mass_g
221  Biscoe  MALE       5700.0
223  Biscoe  MALE       5700.0
231  Biscoe  MALE       5550.0
233  Biscoe  MALE       5850.0
235  Biscoe  MALE       5850.0

query() does the same thing with a syntax that's often easier to read:

print(clean.query("island == 'Dream' and bill_length_mm > 50").shape)   # (30, 7)

Step 6: Create new columns

Arithmetic on columns works on the whole column at once, so no loop is needed:

clean["body_mass_kg"] = clean["body_mass_g"] / 1000
clean["bill_ratio"] = (clean["bill_length_mm"] / clean["bill_depth_mm"]).round(2)

print(clean[["species", "body_mass_kg", "bill_ratio"]].head(3))

  species  body_mass_kg  bill_ratio
0  Adelie          3.75        2.09
1  Adelie          3.80        2.27
2  Adelie          3.25        2.24

Step 7: Group and summarise

This is where pandas really helps. The question "What's the average body mass of each species?" becomes:

print(clean.groupby("species")["body_mass_g"].mean().round(0))

species
Adelie       3701.0
Chinstrap    3733.0
Gentoo       5076.0

For several statistics at once, use named aggregation. It gives you clean column names, which helps when you export the result:

summary = (
    clean.groupby("species")
         .agg(count=("body_mass_g", "size"),
              avg_mass_g=("body_mass_g", "mean"),
              avg_flipper_mm=("flipper_length_mm", "mean"),
              avg_bill_ratio=("bill_ratio", "mean"))
         .round(1)
         .sort_values("avg_mass_g", ascending=False)
)
print(summary)

           count  avg_mass_g  avg_flipper_mm  avg_bill_ratio
species
Gentoo       123      5076.0           217.2             3.2
Chinstrap     68      3733.1           195.8             2.7
Adelie       151      3700.7           190.0             2.1

In this data, Gentoo penguins are clearly the heaviest and have the longest flippers. Their bills are also long relative to their depth, which is why their bill ratio is the highest.

Step 8: Two dimensions with a pivot table

Average body mass by species and sex. Here we drop rows where sex is missing, because they can't go in either column:

by_sex = (
    clean.dropna(subset=["sex"])
         .pivot_table(index="species", columns="sex",
                      values="body_mass_g", aggfunc="mean")
         .round(0)
)
print(by_sex)

sex        FEMALE    MALE
species
Adelie     3369.0  4043.0
Chinstrap  3527.0  3939.0
Gentoo     4680.0  5485.0

In every species in this sample, males are heavier on average. You worked that out yourself from raw data in about 30 lines of code.

Step 9: Save your work

summary.to_csv("penguin_summary.csv")

Cheat sheet

Try it in the browser

If you'd rather not set anything up locally, our Data Analysis Lab has notebook-style pages for NumPy, Pandas and Matplotlib that run in the browser, using the same Palmer Penguins data. The mean body mass by species exercise is a good way to check that Step 7 stuck.

Your next challenge: find the island with the highest average flipper length for Adelie penguins only (they're the one species found on all three islands), and check whether the sex split looks similar on each island.

— Schoolabe team

So the useful skill is a method you can run without thinking, plus a way to check yourself on practice problems. I wrote a small Python checker for the second part.

Schoolabe's GATE memory management chapter uses this reference string with 3 frames as its worked example:

1 2 3 4 1 2 5 1 2

It says to count FIFO carefully with a queue, and it doesn't print the answer. Here are the three policies, then the numbers. The code blocks in this post are one file, in order; paste them together and it runs.

import random
from collections import OrderedDict, deque

def fifo(refs, frames):
    q, mem, faults, trace = deque(), set(), 0, []
    for p in refs:
        if p in mem:
            trace.append("hit")
        else:
            faults += 1
            if len(mem) == frames:
                mem.remove(q.popleft())
            q.append(p)
            mem.add(p)
            trace.append("F")
    return faults, trace

def lru(refs, frames):
    mem, faults, trace = OrderedDict(), 0, []
    for p in refs:
        if p in mem:
            mem.move_to_end(p)
            trace.append("hit")
        else:
            faults += 1
            if len(mem) == frames:
                mem.popitem(last=False)
            mem[p] = True
            trace.append("F")
    return faults, trace

def opt(refs, frames):
    mem, faults, trace = [], 0, []
    for i, p in enumerate(refs):
        if p in mem:
            trace.append("hit")
            continue
        faults += 1
        trace.append("F")
        if len(mem) < frames:
            mem.append(p)
            continue
        rest = refs[i + 1:]
        # evict the page whose next use is furthest away (or never)
        victim = max(mem, key=lambda x: rest.index(x) if x in rest else float("inf"))
        mem.remove(victim)
        mem.append(p)
    return faults, trace

lesson = [1, 2, 3, 4, 1, 2, 5, 1, 2]
print("Lesson string with 3 frames:", lesson)
for name, policy in (("FIFO", fifo), ("LRU", lru), ("OPT", opt)):
    n, t = policy(lesson, 3)
    print(f"  {name}: {n} faults   {' '.join(t)}")
print("FIFO on the same string with 4 frames:", fifo(lesson, 4)[0], "faults")

Lesson string with 3 frames: [1, 2, 3, 4, 1, 2, 5, 1, 2]
  FIFO: 7 faults   F F F F F F F hit hit
  LRU: 7 faults   F F F F F F F hit hit
  OPT: 5 faults   F F F F hit hit F hit hit
FIFO on the same string with 4 frames: 7 faults

Check the FIFO row by hand. Pages 1, 2, 3 fill the frames. Page 4 evicts 1, so the next 1 faults and evicts 2, so the next 2 faults and evicts 3. Page 5 evicts 4. Then 1 and 2 are both still in memory and hit. Seven faults.

For the hand trace I write the full frame contents under every reference, not just F or hit. For FIFO I underline the oldest page, and for LRU I rewrite the frames in recency order each time. It is slower, but when you go wrong you can see where.

LRU also gets seven here, so LRU does not always beat FIFO on a given string. Optimal gets five, and that is your floor. It needs the future, so no real system can do it. The chapter calls it the offline lower bound, and if your hand trace beats it, you have miscounted.

The anomaly

The chapter says FIFO can show Belady's anomaly, where more frames give more faults, and calls it a favourite trap. The lesson string above doesn't show it: FIFO with 4 frames also gives 7. The textbook string is the same one extended by three pages, 1 2 3 4 1 2 5 1 2 3 4 5.

belady = [1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5]
print("Classic string:", belady)
for name, policy in (("FIFO", fifo), ("LRU", lru)):
    for frames in (3, 4):
        print(f"  {name}, {frames} frames: {policy(belady, frames)[0]} faults")

Classic string: [1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5]
  FIFO, 3 frames: 9 faults
  FIFO, 4 frames: 10 faults
  LRU, 3 frames: 10 faults
  LRU, 4 frames: 8 faults

FIFO goes from 9 faults to 10 when it gets a fourth frame. The anomaly was described by Belady, Nelson and Shedler in "An anomaly in space-time characteristics of certain programs running in a paging machine", Communications of the ACM 12(6), June 1969, pp. 349-353 (doi 10.1145/363011.363155).

LRU on the same string drops from 10 to 8, as you would expect. The reason is the stack property: the pages LRU holds with k frames are always a subset of what it holds with k+1 frames. FIFO keeps pages by arrival order, not by use, so it has no such property.

How common is this? I guessed "not very" and wanted a number, so I drew random strings of 12 references over pages 1 to 5, with a fixed seed so you can reproduce it, and compared 3 frames against 4.

random.seed(2026)
trials, bad_fifo, bad_lru = 1_000_000, 0, 0
for _ in range(trials):
    refs = [random.randint(1, 5) for _ in range(12)]
    if fifo(refs, 4)[0] > fifo(refs, 3)[0]:
        bad_fifo += 1
    if lru(refs, 4)[0] > lru(refs, 3)[0]:
        bad_lru += 1
print(f"{trials:,} random strings, 12 refs over pages 1-5, 3 frames vs 4:")
print(f"  FIFO faulted more with 4 frames: {bad_fifo}")
print(f"  LRU faulted more with 4 frames:  {bad_lru}")

1,000,000 random strings, 12 refs over pages 1-5, 3 frames vs 4:
  FIFO faulted more with 4 frames: 1
  LRU faulted more with 4 frames:  0

One hit in a million. A first attempt with 100,000 strings found none, so I'd have written "never" if I'd stopped there. A single hit can't pin down a rate, though, so I also counted exhaustively with a small C program: of all 5^12 = 244,140,625 strings of 12 references over five pages, FIFO faults more with 4 frames than with 3 in exactly 120 of them. That is about 1 in 2 million. It also explains why the textbook string looks hand-built. Someone had to go looking for it.

Don't hunt for the anomaly in the trace. Look at the wording: of these three policies only FIFO can fault more with more frames, so a question asking which one can has its answer before you count anything. If the policy is LRU or Optimal, the anomaly can't be the point.

The checker is also good for something duller. Take any previous-year question with a string and a frame count, run all three policies, and compare with your hand trace. Schoolabe's GATE hub says its previous-year questions show questions and options only for now, and tells you to cross-check the official IIT answer key yourself. That is fair advice for any source, this one included.

CLOCK, the chapter's fourth policy, is not covered here.

Written by the Schoolabe team, who build schoolabe.com. The GATE CS section lists free subject tutorials, topic quizzes and previous-year papers.

A better approach: learn a small set of patterns well enough that you recognise them in problems you've never seen. This post gives you a 30-day plan built that way, with a working Python template for each core pattern.

Thirty days won't make you an expert. But it can take you from "I don't know where to start" to "I can usually tell what kind of problem this is."

Before Day 1: are you ready for DSA?

DSA assumes you can already write loops, conditionals and functions comfortably. If a palindrome check or "second largest element" still feels slow, spend a week or two on basic logic first. Our logic building track covers conditions, loops, recursion, arrays and strings in that order, and it's a reasonable warm-up.

Pick one language for the whole month. The examples below use Python because it keeps templates short.

How to spend each day

Aim for about 2 hours:

• 20 min: learn or revise the pattern (read, or trace it by hand on paper).
• 80 min: solve 2–3 problems that use it. Give yourself about 25 minutes per problem before you look at a hint.
• 20 min: write a short note for each problem: what the pattern was, and what clue in the question should have pointed you to it.

That last step matters most: you're learning the clues, not collecting solutions.

Week 1 (Days 1–7): Arrays, strings and hashing

Days 1–2: Array basics, reversing, rotating, and stating the time complexity of everything you write. Days 3–4: Strings: counting characters, anagrams, palindromes. Days 5–6: Hash maps and sets: the "have I seen this before?" pattern. Day 7: Revise and solve 3 mixed problems without notes.

Pattern: hash map lookup. The clue is "find a pair or duplicate," where the brute-force answer is two nested loops.

def two_sum(nums, target):
    seen = {}                      # value -> index
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

assert two_sum([2, 7, 11, 15], 9) == [0, 1]

One pass, O(n) time, O(n) extra space. Say that trade-off out loud in an interview.

Week 2 (Days 8–14): Two pointers, sliding window, prefix sums, binary search

Days 8–9: Two pointers on sorted arrays. Days 10–11: Sliding window (fixed and variable size). Day 12: Prefix sums. Day 13: Binary search, including "binary search on the answer." Day 14: Revision plus one timed set: 3 problems in 75 minutes.

Pattern: two pointers. The clue is a sorted array, or "pairs, triplets, or in-place partitioning."

def pair_with_sum_sorted(nums, target):
    lo, hi = 0, len(nums) - 1
    while lo < hi:
        s = nums[lo] + nums[hi]
        if s == target:
            return (lo, hi)
        if s < target:
            lo += 1
        else:
            hi -= 1
    return None

assert pair_with_sum_sorted([1, 3, 4, 6, 9], 10) == (0, 4)

Pattern: variable sliding window. The clue is "longest/shortest contiguous subarray or substring such that…"

def longest_unique_substring(s):
    last = {}          # char -> last index seen
    start = best = 0
    for i, ch in enumerate(s):
        if ch in last and last[ch] >= start:
            start = last[ch] + 1     # shrink window past the repeat
        last[ch] = i
        best = max(best, i - start + 1)
    return best

assert longest_unique_substring("abcabcbb") == 3

Pattern: prefix sum + hash map. The clue is "count subarrays whose sum equals k." Unlike a sliding window, it also works with negative numbers.

def count_subarrays_with_sum(nums, k):
    count, running = 0, 0
    freq = {0: 1}                  # prefix sum -> how many times seen
    for x in nums:
        running += x
        count += freq.get(running - k, 0)
        freq[running] = freq.get(running, 0) + 1
    return count

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

Pattern: binary search. Write one version you trust and reuse it every time:

def lower_bound(nums, target):
    """First index i with nums[i] >= target."""
    lo, hi = 0, len(nums)
    while lo < hi:
        mid = (lo + hi) // 2
        if nums[mid] < target:
            lo = mid + 1
        else:
            hi = mid
    return lo

assert lower_bound([1, 2, 4, 4, 7], 4) == 2

Week 3 (Days 15–21): Linked lists, stacks, queues, recursion, trees

Days 15–16: Linked lists: reversal, fast/slow pointers (finding the middle, detecting a cycle). Day 17: Stacks: valid parentheses, monotonic stack ("next greater element"). Day 18: Recursion and backtracking basics (subsets, permutations). Days 19–20: Binary trees: DFS (pre/in/post-order) and level-order BFS. Day 21: Revision.

If pointers feel abstract, watch them move: our DSA visualizers let you step through arrays, linked lists, stacks/queues and sorting in the browser. Use them alongside problems, not instead of them.

Pattern: monotonic stack. The clue is "next greater/smaller element" or "how many days until…"

def next_greater(nums):
    res = [-1] * len(nums)
    stack = []                     # indices with no answer yet
    for i, x in enumerate(nums):
        while stack and nums[stack[-1]] < x:
            res[stack.pop()] = x
        stack.append(i)
    return res

assert next_greater([2, 1, 3, 2, 5]) == [3, 3, 5, 5, -1]

Week 4 (Days 22–30): Graphs, heaps, intro to DP, mocks

Days 22–23: Graphs: adjacency lists, BFS, DFS, counting connected components. Day 24: Heaps: top-k elements, merging sorted lists (heapq in Python, priority_queue in C++). Days 25–27: Dynamic programming basics: climbing stairs, house robber, coin change, longest common subsequence. Days 28–29: Two full mock rounds: 2 problems, 60 minutes, talk out loud as you go. Day 30: Go back through your notes and redo every problem you marked "needed a hint."

Pattern: BFS for shortest path in an unweighted graph or grid. The clue is "minimum number of steps/moves."

from collections import deque

def shortest_path_grid(grid):
    """Steps from top-left to bottom-right; 0 = open, 1 = wall."""
    n, m = len(grid), len(grid[0])
    if grid[0][0] or grid[n-1][m-1]:
        return -1
    q = deque([(0, 0, 0)])
    seen = {(0, 0)}
    while q:
        r, c, d = q.popleft()
        if (r, c) == (n - 1, m - 1):
            return d
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < n and 0 <= nc < m and not grid[nr][nc] and (nr, nc) not in seen:
                seen.add((nr, nc))
                q.append((nr, nc, d + 1))
    return -1

assert shortest_path_grid([[0, 0, 0],
                           [1, 1, 0],
                           [0, 0, 0]]) == 4

Pattern: 1-D dynamic programming. The clue is "number of ways" or "min/max cost," where each answer builds on smaller answers.

def coin_change(coins, amount):
    INF = float("inf")
    dp = [0] + [INF] * amount      # dp[a] = fewest coins to make a
    for a in range(1, amount + 1):
        for c in coins:
            if c <= a:
                dp[a] = min(dp[a], dp[a - c] + 1)
    return dp[amount] if dp[amount] != INF else -1

assert coin_change([1, 2, 5], 11) == 3

For DP, write the recurrence in words first, then code it.

A quick "which pattern?" cheat sheet

Mistakes to avoid

• Watching solutions instead of struggling. Twenty-five honest minutes teach you more than a ten-minute video.
• Skipping complexity analysis. State it before the interviewer asks.
• Never practising under time pressure. Do one timed set a week from Week 2.

Save the templates above in one file, run it (every assert should pass silently), and add to it as you learn new patterns. By Day 30 it's your revision sheet.

All the best for placements!

— Schoolabe team