Session 1 - What to Expect & the Questions That Repeat

1. What to Expect, and the Questions That Repeat

Title

DSA Interview Prep · Session 1

A map of the interview itself, then the handful of patterns that most questions are wearing a costume over. Python throughout.

2. What you will be able to do

Objectives

Interview questions look infinite and are not. This first session builds the map: what a round actually contains, and which shapes keep coming back. By the end you can:

1. Describe the structure of a technical round and name what the interviewer is scoring besides a working answer.
2. Run the six-step loop - clarify, examples, brute force, optimize, code, test - on a problem you have never seen.

1. Read a problem's constraints and name the complexity you are being asked for before writing a line.
2. Recognize the eight patterns that cover most interview questions, and give the signature clue that triggers each one.
3. Recall the most frequently asked problems and say which pattern each belongs to rather than which solution you memorized.

3. What You Are Actually Walking Into

Section

Section 1

4. Estimate first: how big is the surface really?

Estimation

Before we look at any list. LeetCode alone has well over 3,000 problems, and companies pull from all of them.

5. The rounds, in the order you meet them

Concept

Almost every company runs some version of this ladder. The DSA content is concentrated in the middle two.

Recruiter screen

30 min, no code. Background and logistics.

Online assessment

60-90 min, auto-graded. Hidden tests, no human to talk to.

Technical phone screen

45-60 min, 1-2 problems, shared editor, human listening.

Onsite loop

3-5 rounds: DSA, sometimes system design, always behavioral.

The online assessment is scored only on passing tests - so speed and edge cases decide it. Every other round is scored by a person who is listening to your reasoning, which is a different game and the one we mostly train for.

6. What a 45-minute round is made of

Concept

A round is not 45 minutes of coding. Here is where the time actually goes in a round that goes well.

Notice that coding is under half of it. Candidates who spend minutes 3-12 silently typing are the ones who get 'weak communication' on the feedback form even when the code works.

7. Four scores, and only one of them is the answer

Intuition

Interview feedback forms at most large companies rate roughly four things separately. This is why a working solution can still fail a round.

Problem solving

Did you get to a reasonable approach, and how much help did it take?

Coding

Is it clean, correct, and does it compile in your head?

Communication

Could they follow your reasoning without asking?

Verification

Did you test it yourself, or wait to be told it was broken?

Two candidates can produce the same final code and get opposite decisions. The difference is almost always communication and verification - the two you can improve fastest, and the two we drill every session.

McDowell, Cracking the Coding Interview, 6th ed. Ch. VI — the same four axes, described from the interviewer's side

8. Two of these are true. One is folklore.

Two truths and a lie

Sort each claim. Commit before you scroll - the wrong one is wrong for a reason worth having.

9. Three families of question

Concept

Every DSA question you get will sit in one of three families, and the family tells you how to spend the first five minutes.

Most of a 2-3 month prep window should go to the middle family - it is the biggest, and it is the one that transfers to problems you have not seen.

10. Which family is each of these?

Sorting

Take thirty seconds per prompt. You are not solving them.

Valid parentheses is borderline - it needs a stack, but the stack is the first thing anyone thinks of. When a pattern is that obvious, the question has become an implementation question.

11. The problem statement is deliberately incomplete

Missing information

Interviewers under-specify on purpose. The unasked question is the trap.

Prompt: "Given an array of numbers, return the two that add up to a target."

12. Trap: starting to code because the silence felt bad

Trap

13. The six-step loop - run it on every problem

Pattern

This is the procedure. It does not change with the problem, and it is what we will rehearse until it is automatic.

1. Clarify. Restate the problem in your own words. Ask about input shape, duplicates, empties, and what to return when there is no answer.
2. Example. Write one small concrete input and its expected output by hand. This catches misunderstandings that words hide.
3. Brute force. State the obvious solution and its time and space cost out loud. Do not code it. You now have a floor and a working fallback.

1. Optimize. Name the wasted work in the brute force, then name the structure that removes it. This is where the pattern gets chosen, and said aloud.
2. Code. Write it while narrating what each block is for. Meaningful names, no clever one-liners.
3. Test. Dry-run your own code on the example from step 2, then on the edges: empty, one element, all-duplicates, no answer.

Steps 1-4 should take about a third of the round. If you have said nothing for two minutes at any point, you are off the loop.

14. Why bother stating a brute force you will not write?

Explain it to yourself

15. Check yourself: the first three minutes

Check

Answer before you look. This one is about method, not code.

16. Complexity: The Language of the Round

Section

Section 2

17. Before we build on it - what do you already have?

Warm-up

18. Big-O measures growth, not speed

Concept

Big-O answers exactly one question: when the input gets 10 times bigger, what happens to the work? It says nothing about milliseconds on your laptop.

O(f(n)) — The shape of the growth curve as n gets large, with constant factors and lower-order terms dropped - because those stop mattering exactly when n stops being small.

Read the bottom two rows again. The gap between n log n and n^2 is not a tuning problem - at a million elements it is 2 x 10^7 operations against 10^12, which at a realistic ten million operations per second is a couple of seconds against more than a day.

19. Watch the brute force die

Scale up

count_pairs compares every element with every later element. Step through what happens as the input grows - these counts are exact, not estimates.

The shape to remember: the input grew 10x, the work grew 100x. That squaring is what O(n^2) means, and it is why the constraint line in the problem statement is the most important line in it.

20. Decode it symbol by symbol

Notation

Candidates say 'oh of en log en' fluently and cannot say where the log came from. Read each piece.

If you can say where the log comes from, you can derive the complexity of a solution you have never analysed. If you cannot, you are reciting.

21. The constraints tell you the answer's shape

Concept

Every well-posed problem states a bound on n. That bound is the interviewer telling you which complexity they will accept.

Read the table right to left in the interview: you are given n up to 10^5, so you need at most n log n, so sorting is affordable but a nested loop is not. That reasoning, said out loud, is worth real points.

22. Pick the target, do not solve anything

Discrimination

For each constraint, choose the complexity you should be aiming for. No code.

23. Mark where the time actually goes

Cost model

The trap is not the loop you can see. Read this and find the expensive line.

This function is the single most common accidental quadratic in Python interviews, and it is invisible unless you cost the operations inside the loop rather than counting the loops.

24. Cost a function line by line

Worked example

Interviewers ask 'what is the complexity of what you just wrote?' every single round. Here is the procedure, on a function with two loops that are not nested and one that is.

def summarize(nums):
    total = 0
    for n in nums:            # A
        total += n
    nums_sorted = sorted(nums)  # B
    pairs = 0
    for i in range(len(nums)):  # C
        for j in range(i + 1, len(nums)):
            pairs += 1
    return total, nums_sorted[0], pairs

25. Trap: two loops means quadratic

Trap

for n in nums:
    total += n
for n in nums:
    biggest = max(biggest, n)

for i in range(len(nums)):
    for j in range(len(nums)):
        check(nums[i], nums[j])

26. Space complexity, the half nobody volunteers

Concept

Every complexity answer has two halves. Saying only the time half is a missed point in almost every round.

Say both halves without being asked: "O(n) time, O(n) extra space - and I can get space down to O(1) if I'm allowed to sort in place." That sentence is a trade-off, which is what the design half of the score is looking for.

27. Check yourself: cost this function

Check

Read it carefully. The answer is not the number of loops.

28. The Eight Patterns Behind Most Questions

Section

Section 3

29. The clue-to-pattern reflex

Concept

Interview problems announce themselves. This table is the reflex we are building - phrase on the left, structure on the right.

Saying "the word substring plus a constraint on characters makes me think sliding window" is not guessing. It is the reasoning interviewers most want to hear, because it is what transfers to the next problem.

30. Match the clue to the structure

Matching

No solving. Just pair each phrase with the structure it should trigger.

31. Pattern 1 - hash map: buy time with memory

Concept

The hash map is the most common single idea in interview questions. It turns "have I seen this?" from a scan into a lookup.

# The whole pattern, in three lines
seen = {}                 # value -> where I saw it
for i, n in enumerate(nums):
    if n in seen:         # O(1) average, not a scan
        return seen[n], i
    seen[n] = i

The cost is O(n) extra space. That is the trade you should say out loud: "I'll spend O(n) memory to drop the time from quadratic to linear."

Python Wiki - TimeComplexity (per-operation costs for list, dict, set) dict — average-case O(1) get and set

32. Predict the output before you read the code twice

Prediction

Commit to an answer. This is the shape of a dozen real questions.

def first_repeat(nums):
    seen = set()
    for n in nums:
        if n in seen:
            return n
        seen.add(n)
    return None

print(first_repeat([5, 3, 9, 3, 5]))

"First duplicate" is ambiguous: first by second occurrence (what this code does) or first by first occurrence (which would be 5). Ask. This is a real clarifying question, not a pedantic one.

33. The most-asked question there is: Two Sum

Worked example

Given nums and a target, return the indices of the two numbers that add to the target. This is the single most commonly assigned interview problem, and its one-pass solution is the template for a dozen others.

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

The move worth stealing: store what you have seen keyed by what a future element would need. That single idea also solves subarray-sum-equals-k, pairs-with-difference-k, and contains-duplicate-within-distance-k.

34. Trap: sorting first when the question wants indices

Trap

nums.sort()          # destroys the original positions
lo, hi = 0, len(nums) - 1
# ... two-pointer scan finds the values 11 and 15

35. Pattern 2 - two pointers: walk from both ends

Concept

When the data is sorted, or the answer depends on a pair, two indices moving toward each other replace a nested loop with a single pass.

lo, hi = 0, len(a) - 1
while lo < hi:
    total = a[lo] + a[hi]
    if total == target:
        return lo, hi
    if total < target:
        lo += 1          # need more: only the left end can grow
    else:
        hi -= 1          # need less: only the right end can shrink

The reason it is O(n) and not O(n^2): each pointer only ever moves in one direction, so together they take at most n steps in total.

36. What stays true the whole time?

Invariant

Step through a palindrome check on "Race car!" and watch for the thing that never changes. The cleaned string is racecar.

The invariant: everything outside lo and hi has already been verified to match. When the pointers meet, 'outside' is the whole string, so the answer is True. That sentence is the proof of correctness, and being able to state it is what separates a memorized loop from an understood one.

37. Valid palindrome, two pointers

Worked example

Given a string, ignore case and non-alphanumeric characters, and decide whether it reads the same forwards and backwards.

def is_palindrome(s):
    t = [c.lower() for c in s if c.isalnum()]
    lo, hi = 0, len(t) - 1
    while lo < hi:
        if t[lo] != t[hi]:
            return False
        lo += 1
        hi -= 1
    return True

Cost: O(n) time, and O(n) space because of the cleaned list. If asked for O(1) space, skip non-alphanumeric characters in place with two while loops inside the main one - a natural follow-up, so have the answer ready.

38. Pattern 3 - a window you resize, not rebuild

Intuition

The words substring, subarray, and consecutive all mean the same thing structurally: a contiguous stretch with two ends.

The naive solution rebuilds every stretch from scratch: n starting points times n lengths, and O(n) work to evaluate each - cubic, or quadratic if you are careful. The window keeps one stretch and edits its ends.

Mental image: you are not printing a new photo each time, you are dragging the edges of a crop box. Everything already inside the box stays valid.

39. Two flavours of window

Concept

Which one you need is decided by a single question: is the window's size given to you, or is it whatever the constraint allows?

# fixed size k: one in, one out
window = sum(nums[:k])
best = window
for i in range(k, len(nums)):
    window += nums[i] - nums[i - k]
    best = max(best, window)

# variable size: grow always, shrink while the rule is broken
start = 0
for end in range(len(nums)):
    add(nums[end])
    while broken():
        remove(nums[start])
        start += 1

Both are O(n) because every index enters the window once and leaves at most once - the inner while does not make it quadratic, and being able to say why is a frequent follow-up question.

40. The line that makes it a window

Fill the middle

Everything here is standard except one line. Fill it in - this is the line that decides whether the window is correct.

41. Longest substring without repeating characters

Worked example

A top-five most-asked question, and the cleanest example of a variable window. Input: "abcabcbb".

def longest_unique(s):
    last = {}
    start = 0
    best = 0
    for i, ch in enumerate(s):
        if ch in last and last[ch] >= start:
            start = last[ch] + 1
        last[ch] = i
        best = max(best, i - start + 1)
    return best

Cost: O(n) time - each index is visited once - and O(min(n, alphabet)) space for the map. Say the alphabet bound; it is the kind of precision that reads as experience.

42. Trap: recomputing the window instead of updating it

Trap

best = 0
for i in range(len(nums) - k + 1):
    best = max(best, sum(nums[i:i + k]))

window = sum(nums[:k])
best = window
for i in range(k, len(nums)):
    window += nums[i] - nums[i - k]
    best = max(best, window)

43. Pattern 4 - binary search: throw away half, every time

Concept

Any time the data is sorted, or the answer is monotonic ("if 7 works then 8 works"), you can halve the space instead of scanning it.

def bsearch(a, x):
    lo, hi = 0, len(a) - 1
    while lo <= hi:               # inclusive range [lo, hi]
        mid = (lo + hi) // 2
        if a[mid] == x:
            return mid
        if a[mid] < x:
            lo = mid + 1          # x must be to the right
        else:
            hi = mid - 1          # x must be to the left
    return -1

The version worth memorizing is not this one but its cousin: the smallest index where a condition first becomes true. Most real binary-search interview questions - rotated array, first bad version, minimum capacity - are that boundary search wearing a costume.

44. This binary search hangs. Find the line.

Error analysis

It compiles, it passes the happy path, and on some inputs it never returns. Read it as if reviewing a colleague's pull request.

The rule that prevents every version of this bug: each iteration must make the range strictly smaller. Before you write the loop, say which of lo/hi is inclusive - most binary-search bugs are convention drift, not logic errors.

45. Now write it with the scaffolding removed

Faded example

The boundary search - find the first index where the condition holds. Fill the three blanks.

46. Pattern 5 - stack: the most recent unfinished thing

Concept

A stack is the right structure whenever the thing you need next is the thing you saw most recently: nesting, matching, undo, and 'next greater element'.

def valid(s):
    pairs = {')': '(', ']': '[', '}': '{'}
    stack = []
    for ch in s:
        if ch in '([{':
            stack.append(ch)
        else:
            if not stack or stack.pop() != pairs[ch]:
                return False
    return not stack

Two edge cases carry the whole question, and both are on line 8 and line 10: a closer arriving when the stack is empty ("())"), and leftovers on the stack at the end ("(("). Candidates who only check the middle case get one of the hidden tests wrong.

47. Commit: which of these are valid?

Prediction

Four inputs to the bracket checker above. Decide all four before revealing.

48. Monotonic stack: Daily Temperatures

Worked example

Given daily temperatures, return for each day how many days until a warmer one. This is the standard 'next greater element' question, and it is the one that separates candidates who know a stack from candidates who know when.

def daily(temps):
    out = [0] * len(temps)
    stack = []                       # indices, temperatures decreasing
    for i, t in enumerate(temps):
        while stack and temps[stack[-1]] < t:
            j = stack.pop()
            out[j] = i - j
        stack.append(i)
    return out

Why it is O(n) despite the inner while: every index is pushed once and popped at most once, so the total number of pops across the whole run is at most n. That amortized argument is the follow-up question, every time.

49. Pattern 6 - BFS and DFS are the same code with one line changed

Concept

Every tree question and every grid question is one of these two walks. The only structural difference is which end of the pending collection you take from.

from collections import deque

def bfs(start, neighbors):
    seen = {start}
    q = deque([start])
    while q:
        node = q.popleft()        # FIFO -> level by level
        for nxt in neighbors(node):
            if nxt not in seen:
                seen.add(nxt)
                q.append(nxt)

def dfs(node, neighbors, seen):
    seen.add(node)
    for nxt in neighbors(node):   # LIFO via the call stack
        if nxt not in seen:
            dfs(nxt, neighbors, seen)

The seen set is not optional and is not an optimization - without it a graph with any cycle loops forever. Forgetting it on a grid problem, where every cell has a path back, is the most common graph mistake in interviews.

50. BFS or DFS? Fill in the table.

Trade off

Complete the blanks from what you just read. Both are correct answers to different questions.

The one that decides real rounds: "shortest" or "fewest" plus "unweighted" means BFS. If edges have weights, neither is right and the answer is Dijkstra - a good sentence to have ready.

51. Number of Islands - a grid is just a graph

Worked example

Given a grid of "1" (land) and "0" (water), count the connected regions of land. Grids show up constantly, and the trick is seeing that a cell's neighbours are its four adjacent cells.

def num_islands(grid):
    rows, cols = len(grid), len(grid[0])
    count = 0

    def sink(r, c):
        if r < 0 or c < 0 or r >= rows or c >= cols or grid[r][c] != '1':
            return
        grid[r][c] = '0'                 # mark visited by sinking it
        sink(r + 1, c); sink(r - 1, c)
        sink(r, c + 1); sink(r, c - 1)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1               # a new island starts here
                sink(r, c)
    return count

Mention the recursion depth unprompted: on a 1000x1000 all-land grid, recursive DFS can exceed Python's stack limit, and the fix is an explicit stack or BFS. Naming a failure mode of your own solution scores well.

52. Order the moves for any grid problem

Ranking

These five steps solve nearly every grid question. Put them in the order you would actually perform them.

53. Pattern 7 - DP is just refusing to solve the same thing twice

Intuition

Dynamic programming has a fearsome name and a small idea: some recursive problems ask the same sub-question over and over, so you write the answer down the first time.

Naive fib(40) makes about 205 million calls, and roughly 15 million of them are recomputing fib(5) alone. Storing each answer once turns an exponential tree into a linear walk - the algorithm did not get cleverer, it just stopped forgetting.

Two questions identify a DP problem: is the answer built from answers to smaller versions of the same problem, and do those smaller versions repeat? If yes to both, write the recurrence before any code.

54. Two ways to write the same DP

Concept

Top-down memoization and bottom-up tabulation compute identical values. Write whichever makes the recurrence obvious - then say the other exists.

from functools import cache

@cache                              # top-down: recursion + a memo
def climb(n):
    if n <= 2:
        return n
    return climb(n - 1) + climb(n - 2)

def climb_iter(n):                  # bottom-up: no recursion at all
    a, b = 1, 1
    for _ in range(n - 1):
        a, b = b, a + b
    return b

In an interview, write the memoized version first - it is closer to the recurrence you just said aloud, so it is easier to justify - then offer the iterative rewrite as the optimization. That sequence is itself a signal.

55. Climbing Stairs, and the recurrence behind it

Worked example

You can climb 1 or 2 steps at a time. How many distinct ways to reach step n? This is the DP everyone is asked first, and its recurrence is the one to be able to derive cold.

def climb(n):
    a, b = 1, 1        # a = ways(n-2), b = ways(n-1)
    for _ in range(n - 1):
        a, b = b, a + b
    return b

Cost: O(n) time and O(1) space because only two values are kept. House Robber, Min Cost Climbing Stairs, and Decode Ways are all this same loop with a different line inside.

56. Given the recurrence, name the problem

Reverse engineer

Interviewers often hand you a recurrence and ask what it computes. Work backwards from this one.

57. Pattern 8 - heap: when you want the top K, not the order

Concept

Sorting to answer "the k largest" costs O(n log n). A heap of size k costs O(n log k), and when k is small that is effectively linear.

import heapq
from collections import Counter

def top_k(nums, k):
    counts = Counter(nums)                 # O(n)
    return [n for n, _ in heapq.nlargest(
        k, counts.items(), key=lambda p: p[1])]

print(top_k([1, 1, 1, 2, 2, 3], 2))        # -> [1, 2]

Two Python facts worth knowing cold: heapq is a min-heap, so push negated values for a max-heap; and Counter(nums).most_common(k) exists, but interviewers usually want to hear the heap or bucket reasoning behind it.

Python 3 documentation - heapq heapq.nlargest — the size-k heap used here

58. The whole toolkit on one card - fill the blanks

Comparison

Complete this from memory. This card is the thing to be able to reproduce before your first real interview.

59. Every option is plausible. Knock them out.

Elimination

Prompt: "Given an unsorted array of up to 100,000 integers, return the length of the longest run of consecutive integers - for example [100, 4, 200, 1, 3, 2] gives 4, for 1,2,3,4."

60. The Questions That Keep Coming Back

Section

Section 4

61. The short list, part one

Concept

These are the problems that appear again and again across company question banks and every widely used study list. Learn them as instances of patterns, in the third column - that is the part that transfers.

NeetCode - pattern-grouped practice list — a widely used pattern-grouped list, if you want a practice order

62. The short list, part two

Concept

Twenty problems, eight patterns. Working these until the pattern is instant - not the code - is most of what a 2-3 month runway is for.

63. Name the pattern, do not solve it

Pattern

Four prompts you have not seen in this deck. Thirty seconds each, pattern only.

• "Given a string, return the length of the shortest substring containing every character of another string."
• "Given an array where every element appears twice except one, find the one."
• "Given a rotated sorted array, find the minimum element."
• "Given prices and a fee per trade, maximize profit over the whole series."

64. How the same question gets disguised

Concept

Interviewers know the famous problems are famous. The defence is to change the story, not the structure - which is precisely why pattern recognition beats memorization.

When a prompt has an unusual story, strip the nouns: what is the input shape, what is the output, and what would the brute force be? The pattern usually appears the moment the story is gone.

65. Strip the story yourself

Real world

Prompt: "Our logging service receives a stream of request IDs. Report the first ID that we have already handled, so we can drop the retry."

66. Break this plausible claim

Counterexample

A confident-sounding statement. It is false. Find the case that kills it.

Claim: "If the array is sorted, two pointers always beat a hash map, so you should never hash a sorted array."

67. Will it pass? Commit before you compute.

Hypothesis

An online assessment gives you n up to 200,000 and a 2-second limit. Your candidate solution sorts the array, then for each element does a binary search.

68. Merge Intervals - the sort-then-sweep shape

Worked example

Given a list of intervals, merge all the overlapping ones. It is the canonical member of a whole family: insert interval, meeting rooms, non-overlapping intervals.

def merge(intervals):
    intervals.sort(key=lambda p: p[0])
    out = []
    for start, end in intervals:
        if out and start <= out[-1][1]:
            out[-1][1] = max(out[-1][1], end)
        else:
            out.append([start, end])
    return out

Cost: O(n log n), dominated entirely by the sort. When a solution's cost is all sorting, say so - it tells the interviewer you know the sweep itself is linear.

69. Check yourself: pick the pattern

Check

A prompt you have not seen. Pattern only - do not solve it.

70. Teach it to someone a year behind you

Explain it

71. Answer, and rate how sure you are

Commit first

Rate your confidence honestly. Confident-and-wrong is the state worth finding now rather than in a real round.

72. Saying It Out Loud, and Testing It Yourself

Section

Section 5

73. The narration script

Concept

Communication is scored separately, and it is the easiest score to raise. These are sentences to have ready - they work on any problem.

• "Let me restate the problem to make sure I have it: ..."
• "Two clarifying questions before I start: can the input be empty, and can values repeat?"
• "The brute force is X, which is O(n squared). Let me look for the waste."
• "The repeated work here is Y, and a hash map removes it - so I'll trade O(n) space for O(n) time."

• "I'm going to call this variable last_seen because it holds ..."
• "That's the main loop. Let me trace it on the example we wrote at the start."
• "Edge cases I want to check: empty input, one element, all duplicates."
• "Final cost: O(n) time, O(n) space. If space were tight I'd sort instead and trade to O(n log n) time, O(1) space."

Notice how many of these state a trade-off. That is the sentence type that separates a mid-level from a junior read, and it costs nothing to add.

74. Plan in English before you plan in Python

Step zero

Prompt: "Given a list of words, group together the ones that are anagrams of each other."

75. Test your own code, before they ask you to

Pattern

Verification is a separate score. This checklist is what to run at minute 35, out loud, without being prompted.

1. Dry-run the example from step 2. Walk the actual values through the actual lines, saying each variable's value. Do not re-read the code - execute it.
2. Empty input. Does nums = [] crash on nums[0] or on len(nums) - 1?
3. One element. Two-pointer and window loops often never execute here.
4. All identical values. The classic breaker for dedup and window logic.

1. No valid answer exists. What do you return - -1, None, an empty list? Whatever you clarified at minute 3.
2. The boundary of the constraint. k = n, k = 0, target smaller than every element.
3. Off-by-one on every range. Is the last index reachable? Is range(n) or range(n + 1) correct here?

Say what you are testing as you test it: "empty input - line 3 would index into an empty list, so I need a guard." Finding your own bug scores higher than never having one, because it is evidence of a habit.

76. The output is wrong. Diagnose it.

Anomaly

This function is supposed to remove every even number. It does not, and it raises no error - the worst kind of bug.

def remove_evens(nums):
    for n in nums:
        if n % 2 == 0:
            nums.remove(n)
    return nums

print(remove_evens([1, 2, 4, 5]))   # -> [1, 4, 5]

77. Same problem, one tool removed

Constraint

You have solved 'find the first repeated value' with a hash set: O(n) time, O(n) space.

78. Trap: "I think that's it" without a dry run

Trap

79. Check yourself: which case breaks it?

Check

A fixed-size window that looks correct. One of these inputs makes it silently wrong - no exception, just a wrong number.

def max_sum_k(nums, k):
    window = sum(nums[:k])
    best = window
    for i in range(k, len(nums)):
        window += nums[i] - nums[i - k]
        best = max(best, window)
    return best

80. Your Runway: Ten Weeks From Here

Section

Section 6

81. A 10-week plan for a 2-3 month window

Concept

You said interviews start in two to three months and that you want the solution to click on unseen problems. That means pattern reps, spaced out - not a race through a problem list.

Two rules that matter more than the schedule: always talk while you solve, even alone; and redo a problem you got wrong three days later rather than moving on. Volume without recall is the most common way a 10-week plan produces no improvement.

82. How to practise a problem so it transfers

Concept

The difference between 400 problems and 120 problems is much smaller than the difference between these two habits.

Your one-line log for Two Sum: "unsorted + indices wanted -> hash map of value to index, one pass, O(n)/O(n)." Twenty of those lines is the revision sheet you read the morning of an interview.

83. Draw the map before you close the deck

Connect it up

Do this on paper too. Reproducing it from memory tomorrow is the actual homework.

The arrows are the part that matters. Interviewers rarely ask "do you know BFS" - they ask "why did you choose that over the alternative", and the arrows are where those answers live.

84. Where is your weakest link right now?

Exit ticket

85. What you now have

Recap

You have the map. Sessions from here are reps on it - narrated, timed, and with the weak patterns first.

• A round is 45 minutes with under half spent coding, scored on four axes: problem solving, coding, communication, and verification.
• The six-step loop: clarify, example, brute force with a cost, optimize, code while narrating, test yourself.
• Constraints name the complexity: n up to 10^5 means O(n log n) or better; n up to 20 means exponential is expected.

• Eight patterns carry most questions: hash map, two pointers, sliding window, binary search, stack, BFS/DFS, heap, dynamic programming.
• Twenty problems worth knowing as instances of those patterns - not as memorized code.
• A 10-week plan with a narration habit and spaced redos built into it.