Muster: The 16-Week Curriculum

The standard interview-pattern taxonomy is organized around recurring patterns, not a pile of individual problems. A course that covers the recurring families cannot be “grind 90 problems”; it has to teach the pattern-recognition reflex. The structure below assumes about 12 to 15 hours per week. Less than that, stretch to 20 weeks; more (full-time), compress to 10. Python is the default working language because it gives the best signal-to-keystroke ratio under pressure, and heapq, collections, and bisect cover almost every pattern. The course works in any language if the learner commits to one and stays, but everything here is written in Python and assumes you have done the Week 0 refresher.

The five pedagogical principles

These principles are enforced by the tutor. See .tutor/tutor-core.md for the enforcement contract and tutor-reference.md for the learner-facing version.

  1. Pattern first, code second. Before opening the editor, name the pattern aloud and write the approach in plain English in a comment.
  2. The struggle floor: 25 minutes. No hints for the first 25 minutes of any new problem.
  3. Hints, not solutions. Six-rung hint ladder, one per ask, maximum six.
  4. Debrief every problem. Five-question debrief in the commit message before moving on.
  5. Spaced repetition. Every Friday, two prior-week problems re-solved cold, no notes.

The weekly cadence

A repeating five-day rhythm:

flowchart LR
    M["Mon: pattern intro<br/>write Pattern Card"] --> T["Tue-Thu: one problem/day<br/>floor, ladder, debrief"]
    T --> F["Fri: cold revisit x2<br/>weekly pattern debrief"]
    F --> W["Sat/Sun: optional<br/>stretch, mock, or rest"]
    W --> M2["next week"]

Notice: the cold revisit on Friday is not optional review; it is the beat that converts a solved problem into a recognized pattern. Skipped Fridays are why prep does not stick.

  • Monday (90 min). Pattern introduction. Read the week README, write the Pattern Card in your own words at .tutor/pattern-cards/<pattern-slug>.md.
  • Tuesday through Thursday (2 to 3 hours each). One problem per day at minimum, two on a light pattern. Pattern Card open, struggle floor enforced, debrief committed.
  • Friday (2 hours). Cold revisit of two prior-week problems plus the weekly pattern debrief, written from scratch with no peeking.
  • Saturday or Sunday (optional, 2 hours). Stretch problem, mock interview, or rest. Missed cold revisits are made up before starting the next week.

The five-question debrief (committed with every problem) 

1. What pattern did this turn out to be?
2. What was the trigger phrase or input shape that should have made me reach for it?
3. What was the time and space complexity, and what would dominate at scale?
4. What edge case would have broken my first attempt?
5. What would I do differently in three days when I see this cold?

How the patterns build

The weeks are ordered so each pattern leans on the ones before it. The dependencies are real, not decorative:

flowchart TD
    A["Arrays & Hashing"] --> B["Two Pointers"]
    B --> C["Sliding Window"]
    A --> D["Stacks"]
    A --> E["Binary Search"]
    B --> F["Linked List"]
    F --> G["Trees"]
    G --> H["Heap / Priority Queue"]
    G --> I["Backtracking"]
    I --> J["Tries & Intervals"]
    G --> K["Graphs"]
    K --> L["Advanced Graphs"]
    A --> M["1-D DP"]
    M --> N["2-D DP"]
    A --> O["Greedy / Bit / Math"]
    H --> P["Mock Marathon"]
    L --> P
    N --> P
    J --> P
    O --> P

Notice: trees feed heaps, backtracking, and graphs; backtracking feeds tries. When a later week feels hard, the gap is often in the week it points back to.

The 16 weeks at a glance

Week Pattern Canonical Deep-Dive Time Budget
0 Setup and Python refresher (n/a) 8 to 12 hours
1 Arrays and Hashing Two Sum 12 hours
2 Two Pointers 3Sum 12 hours
3 Sliding Window Minimum Window Substring 13 hours
4 Stacks Largest Rectangle in Histogram 12 hours
5 Binary Search Koko Eating Bananas 14 hours
6 Linked List Reorder List 13 hours
7 Trees Binary Tree Maximum Path Sum 14 hours
8 Heap and Priority Queue (plus consolidation) Find Median from Data Stream 15 hours
9 Backtracking N-Queens 13 hours
10 Tries and Intervals Word Search II 13 hours
11 Graphs Course Schedule 14 hours
12 Advanced Graphs Cheapest Flights Within K Stops 20 to 22 hours
13 1-D Dynamic Programming Coin Change 14 hours
14 2-D Dynamic Programming Edit Distance 15 hours
15 Greedy, Bit Manipulation, Math and Geometry (multiple) 22 to 26 hours
16 Mock Interview Marathon (cross-pattern) 18 hours

Per-week content (source of truth)

Each entry below is the canonical specification for that week. The week directory’s README.md expands this block into the same shape as week-01-arrays-and-hashing/README.md. Do not invent content; transcribe and expand from here.

Week 0: Setup and Python Refresher

Focus. Remove every excuse the next sixteen weeks could offer. Install Python and an AI coding tool, initialize the working area, and close the Python fluency gap with the refresher and its self-check. Perform the first tutor handshake.

No canonical problem. No practice set. Setup steps, the Python refresher, the self-check that gates Week 1, and a “verify the tutor is alive” check.

Week 1: Arrays and Hashing

Recognition cue. “I am checking membership, counting frequency, or asking ‘have I seen this before’” almost always means a hash map or hash set. The cue is also any time a nested loop is doing membership-style work.

Core concepts. Hash map vs hash set vs Counter. “Trade space for time” made explicit. One-pass vs two-pass. Sorted-string or frequency-tuple keys for grouping anagrams. Bucket sort by frequency for top-k. The prefix-sum / running-accumulation family: a prefix (and suffix) array answers range and product queries in O(n), and a running prefix sum plus a hash map of seen prefix sums answers “how many subarrays sum to k” even when the array has negatives, where a sliding window would not.

Python idioms refreshed this week. dict, set, dict.get(key, default), collections.Counter, collections.defaultdict, sorting with key=, tuples as dict keys, list/dict comprehensions.

Canonical deep-dive. Two Sum. Walk it three ways: brute force O(n^2), sort plus two-pointer O(n log n), hash map O(n). Make the cost of each method explicit.

Practice set.

  • Valid Anagram (https://leetcode.com/problems/valid-anagram/)
  • Contains Duplicate (https://leetcode.com/problems/contains-duplicate/)
  • Group Anagrams (https://leetcode.com/problems/group-anagrams/)
  • Top K Frequent Elements (https://leetcode.com/problems/top-k-frequent-elements/)
  • Product of Array Except Self (https://leetcode.com/problems/product-of-array-except-self/)
  • Longest Consecutive Sequence (https://leetcode.com/problems/longest-consecutive-sequence/)

Cold revisit. None.

Week 2: Two Pointers

Recognition cue. Sorted (or sortable) input, and the question is about pairs or triples that satisfy a relation. Or any “from both ends, walk toward the middle” structure.

Core concepts. Why sorting is often step one. The directional rule (which pointer to move and why). The “shorter side moves” intuition for Container With Most Water. Two pointers as a special case of sliding window. The fast/slow pointer variant that returns in Week 6.

Python idioms refreshed this week. Two-index while loops, arr.sort() vs sorted(arr), tuple unpacking, the a, b = b, a swap, skipping duplicates with index moves.

Canonical deep-dive. 3Sum. The full machinery: sort, fix one index, two-pointer the remainder, skip duplicates correctly at three levels.

Practice set.

  • Valid Palindrome (https://leetcode.com/problems/valid-palindrome/)
  • Container With Most Water (https://leetcode.com/problems/container-with-most-water/)
  • Trapping Rain Water (https://leetcode.com/problems/trapping-rain-water/)
  • Two Sum II (https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/)

Cold revisit. Two Sum, Valid Anagram.

Week 3: Sliding Window

Recognition cue. “Find the longest / shortest / best contiguous subarray or substring satisfying condition X.” Anything about contiguous ranges with a constraint.

Core concepts. Fixed window vs variable window. The expand-right / shrink-left rhythm. State maintained as the window moves (a Counter, a set, a running sum, a deque). The monotonic deque trick for window max. The “size 2 window” framing that turns Best Time to Buy/Sell into a sliding window problem.

Python idioms refreshed this week. collections.deque (append, appendleft, popleft), Counter as window state, dict membership checks, max/min over a running value.

Canonical deep-dive. Minimum Window Substring. The “have” vs “need” counter machinery is the lesson; walk it slowly.

Practice set.

  • Best Time to Buy and Sell Stock (https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)
  • Longest Substring Without Repeating Characters (https://leetcode.com/problems/longest-substring-without-repeating-characters/)
  • Longest Repeating Character Replacement (https://leetcode.com/problems/longest-repeating-character-replacement/)
  • Sliding Window Maximum (https://leetcode.com/problems/sliding-window-maximum/)

Cold revisit. Contains Duplicate, 3Sum.

Week 4: Stacks

Recognition cue. Anything LIFO. Anything matching pairs. Anything where the answer for an element depends on a future element. Monotonic stacks for any “next greater” variation.

Core concepts. Plain stack vs monotonic stack and the question “increasing or decreasing.” Storing indices vs values. The histogram trick where popping computes a rectangle bounded by the popped height.

Python idioms refreshed this week. list as a stack (append, pop), storing tuples or indices on the stack, the sentinel-value trick, enumerate.

Canonical deep-dive. Largest Rectangle in Histogram. The monotonic-stack pattern with sentinel-zero trick.

Practice set.

  • Valid Parentheses (https://leetcode.com/problems/valid-parentheses/)
  • Min Stack (https://leetcode.com/problems/min-stack/)
  • Daily Temperatures (https://leetcode.com/problems/daily-temperatures/)
  • Generate Parentheses (https://leetcode.com/problems/generate-parentheses/)

Cold revisit. Group Anagrams, Trapping Rain Water.

Recognition cue. Sorted input is the obvious one. The harder cue: the answer space itself can be ordered, even when the input is not (“binary search on the answer”). If you can write a feasible(x) predicate that is monotonic in x, you can binary search x.

Core concepts. bisect_left vs bisect_right. Boundary conditions and three templates. Rotated arrays and how to decide which half is sorted. Binary searching on a continuous answer space. The partition trick in Median of Two Sorted Arrays.

Python idioms refreshed this week. bisect.bisect_left / bisect_right, integer midpoint mid = (lo + hi) // 2, float('inf'), // floor division and its pitfalls.

Canonical deep-dive. Koko Eating Bananas. “Binary search on the answer” framing is the single most useful upgrade in this course.

Practice set.

  • Binary Search (https://leetcode.com/problems/binary-search/)
  • Search in Rotated Sorted Array (https://leetcode.com/problems/search-in-rotated-sorted-array/)
  • Find Minimum in Rotated Sorted Array (https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)
  • Median of Two Sorted Arrays (https://leetcode.com/problems/median-of-two-sorted-arrays/)

Cold revisit. Top K Frequent, Daily Temperatures.

Week 6: Linked List

Recognition cue. Pointer manipulation without index access. Cycle detection. In-place reordering. “The middle” or “the nth from the end.”

Core concepts. The dummy head. Fast/slow pointers (Floyd’s). In-place reversal as a primitive. Merging as a primitive. Why the heap-merge in Merge K Sorted Lists scales the linked-list and heap patterns together. The doubly-linked-list plus hash map primitive (a node carrying prev and next, spliced in O(1) and keyed by a dict) is the LRU-cache design.

Python idioms refreshed this week. Defining and reading a ListNode class, None checks, attribute reassignment (node.next = ...), the dummy-node idiom, multiple assignment for pointer moves.

Canonical deep-dive. Reorder List. Combines all three primitives in one problem.

Practice set.

  • Reverse Linked List (https://leetcode.com/problems/reverse-linked-list/)
  • Merge Two Sorted Lists (https://leetcode.com/problems/merge-two-sorted-lists/)
  • Linked List Cycle (https://leetcode.com/problems/linked-list-cycle/)
  • Merge K Sorted Lists (https://leetcode.com/problems/merge-k-sorted-lists/)
  • LRU Cache (hash map + doubly linked list; O(1) get/put) (https://leetcode.com/problems/lru-cache/)

Cold revisit. Min Stack, Search in Rotated Sorted Array.

Week 7: Trees

Recognition cue. Recursion fits naturally. “Path from root to leaf,” “level-by-level,” “lowest common ancestor,” “is this tree balanced/symmetric/valid BST.”

Core concepts. DFS vs BFS, and how to choose. The distinction between what a recursive function returns and what it records via closure or class state. Pre/in/post-order and what each is good for. Serialization with explicit nulls.

Python idioms refreshed this week. Recursion and the recursion limit, nested helper functions with nonlocal, collections.deque for BFS, TreeNode attribute access, Optional return types.

Canonical deep-dive. Binary Tree Maximum Path Sum. The return-vs-record split is fully exposed here.

Practice set.

  • Binary Tree Level Order Traversal (https://leetcode.com/problems/binary-tree-level-order-traversal/)
  • Maximum Depth of Binary Tree (https://leetcode.com/problems/maximum-depth-of-binary-tree/)
  • Lowest Common Ancestor of a Binary Tree (https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)
  • Serialize and Deserialize Binary Tree (https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)

Cold revisit. Valid Palindrome, Generate Parentheses.

Week 8: Heap and Priority Queue (plus consolidation)

Recognition cue. “Top k,” “kth largest/smallest,” “find median of a stream,” “merge k of anything sorted,” “always pop the best next thing.”

Core concepts. Three heap patterns: top-k with size-k heap, merging sorted streams, two-heaps for median. Python’s heapq quirks. Heap vs Quickselect tradeoff.

Python idioms refreshed this week. heapq.heappush / heappop / heapify, min-heap-only and the negation trick for a max-heap, tuples as heap entries (and the tie-breaker pitfall), heapq.heappushpop.

Canonical deep-dive. Find Median from Data Stream. The two-heap balancing trick.

Practice set.

  • Kth Largest Element in an Array (https://leetcode.com/problems/kth-largest-element-in-an-array/)
  • K Closest Points to Origin (https://leetcode.com/problems/k-closest-points-to-origin/)
  • Task Scheduler (https://leetcode.com/problems/task-scheduler/)
  • Merge K Sorted Lists (reprise; this time from the heap angle) (https://leetcode.com/problems/merge-k-sorted-lists/)

Consolidation block (Friday/weekend). Re-solve five problems cold from weeks 1 through 6, learner’s choice. Write a one-page midpoint reflection: which patterns are not sticking, what is going to change for weeks 9 through 16.

Cold revisit. Reorder List, learner’s choice of three more.

Week 9: Backtracking

Recognition cue. “Generate all subsets / permutations / combinations.” “Find every solution that satisfies X.” Placement problems like N-Queens.

Core concepts. The make-choice / recurse / undo-choice skeleton. The role of pruning. The path plus used template.

Python idioms refreshed this week. Recursion with a shared path list (append then pop to undo), copying with path[:] or list(path), set for used elements, why [[0]*c]*r aliasing bites and how to avoid it.

Canonical deep-dive. N-Queens. Diagonals-as-sets for O(1) conflict checks.

Practice set.

  • Subsets (https://leetcode.com/problems/subsets/)
  • Combination Sum (https://leetcode.com/problems/combination-sum/)
  • Permutations (https://leetcode.com/problems/permutations/)
  • Word Search (https://leetcode.com/problems/word-search/)

Cold revisit. Koko Eating Bananas, Maximum Depth of Binary Tree.

Week 10: Tries and Intervals (intentionally lighter)

Recognition cue (Tries). Many strings, prefix questions, wildcards, autocomplete, “all words on a board.” Recognition cue (Intervals). Each input is [start, end]; the question is merge, insert, count conflicts, or fit-into-rooms.

Core concepts (Tries). Node with children map plus end-of-word flag. Wildcard DFS. Trie as a pruning tool for grid searches. Core concepts (Intervals). Sort by start (occasionally by end). Extend-or-push sweep. Min-heap of end times for room-counting.

Python idioms refreshed this week. Nested dicts or defaultdict for trie nodes, a small node class, sorting intervals with key=lambda x: x[0], a min-heap of end times.

Canonical deep-dive. Word Search II. Fuses Tries with Backtracking from Week 9.

Practice set (Tries).

  • Implement Trie (Prefix Tree) (https://leetcode.com/problems/implement-trie-prefix-tree/)
  • Design Add and Search Words (https://leetcode.com/problems/design-add-and-search-words-data-structure/)

Practice set (Intervals).

  • Merge Intervals (https://leetcode.com/problems/merge-intervals/)
  • Insert Interval (https://leetcode.com/problems/insert-interval/)
  • Car Pooling (drills the interval sweep / min-heap of end times) (https://leetcode.com/problems/car-pooling/)

Cold revisit. Reorder List, three problems of learner’s choice from weeks 5 to 8.

Week 11: Graphs

Recognition cue. “Connections,” “reach,” “components,” “cycles,” grid-shaped problems that are actually graphs.

Core concepts. Adjacency list vs matrix vs implicit. DFS and BFS with mandatory visited tracking. Connected components. Cycle detection. Topological sort via DFS coloring AND Kahn’s. The “precompute neighbor patterns” trick for Word Ladder.

Python idioms refreshed this week. defaultdict(list) for adjacency, collections.deque for BFS, a visited set, grid neighbor generation with direction tuples, recursion for DFS.

Canonical deep-dive. Course Schedule. Implement both DFS-coloring and Kahn’s in the same file.

Practice set.

  • Number of Islands (https://leetcode.com/problems/number-of-islands/)
  • Clone Graph (https://leetcode.com/problems/clone-graph/)
  • Pacific Atlantic Water Flow (https://leetcode.com/problems/pacific-atlantic-water-flow/)
  • Word Ladder (https://leetcode.com/problems/word-ladder/)

Cold revisit. Binary Tree Maximum Path Sum, N-Queens.

Week 12: Advanced Graphs (the heaviest single week)

Recognition cue. Weighted edges. Shortest path on a non-uniform graph. Negative edges. All-pairs. Constraints like “at most k stops.”

Core concepts. The practiced core: Dijkstra with a heap (why non-negative weights matter), Bellman-Ford (the k-bounded relaxation, solved from memory), and Union-Find / Disjoint-Set Union (path compression plus union by rank), with Kruskal as the DSU-based MST alternative to Prim’s. State expansion (the node alone is not the state; (node, stops_used) is). Recognize-the-cue-only, not drilled from memory: Floyd-Warshall (all-pairs) and Hierholzer’s algorithm (Eulerian path).

Python idioms refreshed this week. heapq as a priority queue for Dijkstra, float('inf') for distances, tuples as (cost, node) heap entries, adjacency with weights, and a parent list for Union-Find with path compression.

Canonical deep-dive. Cheapest Flights Within K Stops. The right home to internalize state expansion.

Practice set.

  • Network Delay Time (https://leetcode.com/problems/network-delay-time/)
  • Min Cost to Connect All Points (https://leetcode.com/problems/min-cost-to-connect-all-points/)
  • Swim in Rising Water (https://leetcode.com/problems/swim-in-rising-water/)
  • Redundant Connection (Union-Find) (https://leetcode.com/problems/redundant-connection/)
  • Reconstruct Itinerary (Hierholzer’s; recognize the cue, not a from-memory drill) (https://leetcode.com/problems/reconstruct-itinerary/)

Cold revisit. Word Search II, Minimum Window Substring.

Week 13: 1-D Dynamic Programming

Recognition cue. Overlapping subproblems. Decisions at each position depend on prior decisions. “Number of ways,” “longest / shortest ending at i,” “minimum cost to reach state X.”

Core concepts. The five-step framework: state, transition, base case, order of computation, answer extraction. Top-down memoization vs bottom-up tabulation. Space optimization to rolling variables. O(n log n) LIS with bisect and a tails array. Unbounded vs 0/1 knapsack.

Python idioms refreshed this week. List initialization ([0]*n, [float('inf')]*n), functools.lru_cache for memoization, rolling-variable space optimization, bisect for the LIS tails array.

Canonical deep-dive. Coin Change. Unbounded-knapsack framing.

Practice set.

  • Climbing Stairs (https://leetcode.com/problems/climbing-stairs/)
  • House Robber (https://leetcode.com/problems/house-robber/)
  • Longest Increasing Subsequence (https://leetcode.com/problems/longest-increasing-subsequence/)
  • Word Break (https://leetcode.com/problems/word-break/)
  • Maximum Subarray (Kadane’s; the “best ending here” running DP) (https://leetcode.com/problems/maximum-subarray/)

Cold revisit. Course Schedule, Find Median from Data Stream.

Week 14: 2-D Dynamic Programming

Recognition cue. Two indices simultaneously: a grid, two strings, two endpoints, intervals on a sequence.

Core concepts. Defining dp[i][j] is 80% of the work. Match/mismatch transition in string DP. Interval DP (Burst Balloons) and why “what was burst last” reframes the problem. Regex DP and the dual case of *. Space-optimization to one or two rows.

Python idioms refreshed this week. 2-D list initialization done correctly ([[0]*cols for _ in range(rows)], never [[0]*cols]*rows), indexing dp[i][j], iterating two sequences with their indices.

Canonical deep-dive. Edit Distance. The canonical 2-D string DP.

Practice set.

  • Unique Paths (https://leetcode.com/problems/unique-paths/)
  • Longest Common Subsequence (https://leetcode.com/problems/longest-common-subsequence/)
  • Burst Balloons (https://leetcode.com/problems/burst-balloons/)
  • Regular Expression Matching (https://leetcode.com/problems/regular-expression-matching/)

Cold revisit. Merge Intervals, Coin Change.

Week 15: Greedy, Bit Manipulation, Math and Geometry

Focus. Three smaller patterns combined into one week. This is a deliberately large pool of 15 problems; the required core is about seven (Jump Game, Gas Station; Single Number, Number of 1 Bits, Counting Bits; Pow(x, n), Rotate Image) and the rest are optional stretch, recommended before the Week 16 marathon. Budget 22 to 26 hours, and treat the genuinely short bit and math problems with a relaxed 10 to 15 minute floor rather than the full 25.

Greedy. Recognition: “make the locally optimal move.” Always ask: can I prove this works?

  • Jump Game (https://leetcode.com/problems/jump-game/)
  • Jump Game II (https://leetcode.com/problems/jump-game-ii/)
  • Gas Station (https://leetcode.com/problems/gas-station/)
  • Partition Labels (https://leetcode.com/problems/partition-labels/)
  • Non-overlapping Intervals (https://leetcode.com/problems/non-overlapping-intervals/)

Bit Manipulation. Recognition: XOR cancels duplicates, n & (n-1) clears the lowest bit, powers of two are shifts.

  • Single Number (https://leetcode.com/problems/single-number/)
  • Number of 1 Bits (https://leetcode.com/problems/number-of-1-bits/)
  • Counting Bits (https://leetcode.com/problems/counting-bits/)
  • Reverse Bits (https://leetcode.com/problems/reverse-bits/)
  • Sum of Two Integers (https://leetcode.com/problems/sum-of-two-integers/)

Math and Geometry. Recognition: matrix rotations, spiral traversal, fast exponentiation, cycle detection.

  • Rotate Image (https://leetcode.com/problems/rotate-image/)
  • Spiral Matrix (https://leetcode.com/problems/spiral-matrix/)
  • Set Matrix Zeroes (https://leetcode.com/problems/set-matrix-zeroes/)
  • Happy Number (https://leetcode.com/problems/happy-number/)
  • Pow(x, n) (https://leetcode.com/problems/powx-n/)

Python idioms refreshed this week. Bit operators (^, &, |, <<, >>), n & (n - 1), masking to 32 bits, divmod, in-place matrix transforms.

Cold revisit. Edit Distance, Cheapest Flights Within K Stops.

Week 16: Mock Interview Marathon

Focus. Convert the patterns into interview performance.

Schedule.

  • Mon to Thu: four full 60-minute mock interviews, ideally with humans (a study partner, a peer mock platform, or a demanding-mentor agent in graduate mode). One problem per mock, randomly drawn from any prior week. Record if possible. Watch the recording.
  • Fri: Recognition speed drill. Twenty problem statements pulled from the prior weeks, three minutes per statement. Name the pattern, sketch the algorithm, give the complexity. No code.
  • Sat or Sun: Long-form retrospective. Personal “weak patterns” list. Post-course continuation plan.

Final deliverable. A RETROSPECTIVE.md in your work repo: personal weak-pattern list, strongest patterns, three problems you expect to see in real interviews and the playbook for each, and a 12-week post-course continuation plan.

How to start

Read getting-started.md at the repo root. Install Python and an AI coding tool, work the Python refresher, and pass the Week 0 self-check. The tutor runs its intake protocol on first interaction and writes your .tutor/session.json. Begin with Week 0.

Source

The pattern selection and canonical problems follow the widely used pattern-based interview taxonomy: the recurring families that show up across modern technical screens. The pedagogy (the struggle floor, the hint ladder, the debrief gate, the cold revisits, the Pattern Cards) is original to Muster and modeled on the Lernen course pedagogy.

Table of contents