The deliberate progression

The original 25 modules and all 250 kata numbers are retained. Each module builds on state and control-flow decisions practiced earlier.

Module 01. Execution Grammar and State Mutation

Make loop order, branch selection, counters, streaks, boundaries, and commit points automatic.

Begin with execution, not pattern names. These scans teach you to distinguish the incoming value, the state update and the moment an answer becomes valid. Trace every assignment. A running total, a streak and a run encoder use the same loop driver but have different commit and reset rules.

Module 02. Hash Maps, Sets, and Frequency State

Use remembered information about the past to answer the current event in constant expected time.

The first module summarized a prefix with a few numbers. A map or set lets the prefix remember information by value: membership, frequency, identity relationships or a previous occurrence. Before every lookup, decide whether the current element belongs in the stored history yet. That timing separates a valid pair from using one index twice.

Module 03. Sorting and Ordered Scans

Turn global relationships into local comparisons by imposing useful order.

Sorting deliberately changes the order in which evidence arrives. Equal values become neighbors, intervals can be consumed from left to right, and a current frontier can summarize everything already settled. Identify what ordering buys before paying its cost. Keep the input-order tie policy separate from the sorted processing order.

Module 04. Two Pointers and In-Place Read/Write State

Use two coordinated frontiers and prove why each pointer movement is safe.

Two boundaries now cooperate within one structure. Sometimes they converge around candidates; sometimes one reads and another writes a compacted prefix. Do not treat these as one interchangeable template. Name the region each pointer owns and prove why moving it cannot destroy an answer or unread input.

Module 05. Sliding Windows

Make fixed windows, longest-valid windows, shortest-satisfying windows, and counting windows feel distinct.

A window is a contiguous region whose contents change at both ends. Fixed-width problems make removal predictable; variable-width problems require a validity condition and a repair loop. Practice ingest, repair and commit in that order, and explain when a counting problem commits several answers rather than just one.

Module 06. Prefix Sums, Prefix State, and Difference Arrays

Reason with array boundaries rather than repeatedly recomputing ranges.

Some interval questions can be answered without moving a window at all. Prefix summaries turn interval work into a difference or a relationship between two boundaries. The empty prefix is an actual state that often needs to be seeded. Difference arrays reverse the idea: record changes at boundaries and reconstruct their effect later.

Module 07. Stacks and Expression State

Use last-in-first-out state for nested structures, unresolved neighbours, and parsing contexts.

A stack records unfinished obligations in last-in, first-out order. Delimiters, operators, deferred strings and colliding objects all have different meanings, but each next event interacts with the most recent unresolved state. Write down what a pop completes before writing the pop itself.

Module 08. Monotonic Stacks and Monotonic Deques

Invert repeated future searches: let each incoming event resolve or dominate earlier pending candidates.

Monotonic structures keep only candidates that can still matter. A new value may resolve old candidates or dominate them permanently. Those are different reasons to remove an entry. Equality policy is especially important: repeated heights or minima must have a consistent owner, and window expiry is separate from value dominance.

Module 09. Queues, Heaps, and Streaming Frontiers

Choose FIFO for breadth/order and heaps for the next globally relevant candidate or a bounded winner pool.

Choose a frontier by the next event you need. Queues expose the oldest item, stacks the newest, and heaps the highest-priority candidate. Streaming top-k and medians retain summaries instead of the whole history. Distinguish strict per-operation cost from amortized cost across a sequence.

Module 10. Intervals and Sweep-Line Events

Represent durations through ordered boundaries and maintain only currently active state.

Translate intervals into ordered events. Endpoint conventions decide whether a departure and arrival at the same time overlap. Sweep-line state describes what is active between events, while interval merging summarizes completed coverage. Dynamic calendars expose an additional issue: sorted lookup may be fast even when insertion still shifts a list.

Module 11. Linked Lists and Pointer Mutation

Treat links as the structure; preserve unread nodes before changing pointers.

Linked structures make reference ownership visible. Before replacing a next pointer, preserve the node you still need to reach. Dummy nodes remove special cases at the head; fast/slow pointers compare traversal progress. Diagrams should name objects and arrows, because equal values do not imply equal node identity.

Module 12. Binary Search and Monotone Answer Spaces

Maintain a candidate interval and use one comparison or feasibility test to discard half safely.

Binary search is controlled elimination. Start from a candidate interval and a statement explaining what remains possible inside it. Exact lookup, lower bound, rotated lookup and answer-space search use related boundary mechanics but different predicates. The rotated-array lesson expands both successful branches in detail so the familiar updates retain a precise meaning.

Module 13. Matrix Traversal and Simulation

Coordinate row/column indices, shrinking boundaries, and old-versus-new state in two dimensions.

A matrix adds a coordinate system, not an excuse to abandon state definitions. Name row and column meanings, traversal direction, and whether an update reads original or already-modified cells. In-place transformations depend on preserving enough old information before it is overwritten.

Module 14. Grid DFS, BFS, and Multi-Source Search

Treat cells as graph nodes, directions as edges, and marking time as part of correctness.

Grid traversal is graph traversal with implicit neighbors. Model allowed directions explicitly, then choose DFS for region consumption or BFS for shortest unit-cost distance. Multi-source BFS begins with an entire initial frontier. Mark at discovery to prevent duplicate work; reserve path-local visitation for later backtracking problems.

Module 15. Recursion and Divide-and-Conquer

Define what one call returns, identify the base case, and combine smaller solved instances.

Recursion replaces a loop driver with a call contract. A child call should return a complete, named result; the parent combines it once. Practice descent and unwinding before branching into many choices. Divide-and-conquer adds a proof that smaller solved pieces can be combined without losing order or duplicating work.

Module 16. Backtracking and Combinatorial Search

Represent a partial candidate, enumerate legal choices, restore shared state, and prune impossible branches.

Backtracking explores alternative histories. Unlike permanent graph visitation, a chosen value or reserved cell belongs to one path and must be restored before its sibling starts. Use choose, explore, undo as an ownership protocol. Pruning is justified only when the rejected prefix cannot lead to a valid completed answer.

Module 17. Binary Trees: Recursive DFS and Structural Contracts

Make each recursive call promise one precise fact about its subtree and combine answers bottom-up.

A tree makes recursive subproblems structural: the left and right child subtrees are already disjoint. Traversal order depends on when the parent acts. Summary problems require a stronger call contract. Height is an upward contribution; diameter is a completed path, so a single variable cannot serve both meanings.

Module 18. Tree BFS, Binary Search Trees, and Tries

Use level frontiers, ordering invariants, and prefix trees for hierarchical search.

Different tree tasks exploit different structure. BFS groups by depth, BST search carries value-order constraints, and a trie consumes a character prefix along edges. Do not assume a generic binary tree is sorted. Wildcard trie search reconnects hierarchical lookup with the branching discipline from backtracking.

Module 19. Graph Traversal and Connected Components

Identify nodes/edges explicitly, select DFS or BFS, and mark discovery at the correct time.

Make vertices, edges, direction and identity explicit before traversing a graph. Discovery must happen when work is scheduled. Reachability uses permanent visitation; path enumeration may revisit a shared descendant through another route. BFS shortest-hop reasoning depends on every edge having the same cost.

Module 20. Directed Graphs, Cycles, and Topological Order

Model prerequisite relationships and distinguish nodes currently on the DFS path from fully finished nodes.

Directed dependencies require a distinction between active recursion and completed work. Topological order turns a DAG into a valid computation schedule. Once that schedule is known, ancestor sets, path values and downstream effects become dynamic programs over vertices. Shared dependencies require set union rather than blindly adding counts.

Module 21. Union-Find, Weighted Graphs, and Minimum Spanning Trees

Maintain dynamic components and use priority frontiers for weighted shortest paths or minimum connection cost.

Connectivity, minimum connection cost and shortest travel cost are different questions. DSU summarizes which components are joined. Kruskal and Prim choose safe connection edges; Dijkstra prioritizes accumulated path length. Edge-budgeted flights need another state axis, while zero/one weights permit a cheaper deque frontier.

Module 22. Greedy Algorithms and Kadane-Style State

Recognize when one compact frontier or a locally safe choice summarizes all useful history.

A greedy rule needs an exchange or dominance argument, not just a plausible choice. Earliest finishing intervals leave room for later choices; a failed gas-station prefix rules out several starts at once. Some one-pass recurrences also prepare the next chapter: distinguish the best answer ending here from the best answer anywhere.

Module 23. Dynamic Programming I: One-Dimensional State

Define one subproblem precisely, derive its recurrence, set base cases, and choose a valid computation order.

Define one subproblem before optimizing its storage. Prefix length, exact amount and endpoint index describe different states and lead to different recurrences. Base cases are part of the model, especially the empty prefix. Only compress a table after you can identify which previous answers every update must still read.

Module 24. Dynamic Programming II: Grids, Knapsack, and Strings

Give every DP axis a precise meaning and derive transitions from neighbouring or smaller states.

Every DP axis needs a sentence. Grid coordinates, item/capacity pairs, two prefix lengths and interval endpoints encode different dependency graphs. Loop order is a topological order of those states. In one-dimensional knapsack compression, reversing capacity order is what preserves the previous item layer.

Module 25. Bit Manipulation, Mathematics, and Designed Data Structures

Use algebraic identities and maintain multi-operation invariants in stateful classes.

Finish with algebraic summaries and persistent multi-operation state. XOR cancels paired information; Euclid preserves a mathematical identity. RandomizedSet, LRU and TimeMap combine structures whose invariants must agree after every operation. The final timestamp search returns to the half-open boundary discipline developed earlier.