loading…
If you like solving puzzles under time pressure and want to walk into a coding interview with the patterns already in your hands, this path is for you.
Prepares for coding interviews: data structures, algorithms and problem patterns. Python is the fastest language to write in an interview, and most companies allow it.
Take the lessons top to bottom. Each one opens with code you run, and ends with graded exercises that check your answer.
16 lessons every path shares. Skip the ones you already know.
Write your first Python program and print to the screen.
Numbers, strings, booleans — the building blocks.
Arithmetic, powers, the math module — Python as a calculator.
Slicing, methods, and f-strings — text manipulation done right.
Make decisions and repeat yourself — but only on purpose.
Loop until a condition fails. Bail out or skip with break/continue.
Collections of things, and how to walk through them.
Carve up lists and strings with [start:stop:step].
Two more collections: tuples are fixed, sets are unique.
Key → value pairs. The most important data structure in Python.
Empty things are False. `is` vs `==`. The infamous None.
The Pythonic ways to iterate — count, pair, sequence.
Bundle up logic so you can reuse it.
Lists of dicts, dicts of lists — modelling real-world data.
Filter and transform in one line — the Pythonic way.
Catch what could go wrong, recover gracefully.
31 lessons specific to this role.
Functions that call themselves — and how to stay sane doing it.
The language interviewers speak. Constant, log, linear, quadratic — and why it matters at scale.
In-place vs copy, indexing tricks, and the array patterns interviewers love.
Two indices walking through the data. Turns many O(n²) problems into O(n).
A moving frame over the array. Fixed or variable size. Solves 80% of 'longest / shortest / sum-K' questions.
dict + set take you from O(n²) to O(n). The Two-Sum trick, in-depth.
The classic search. Plus the trickier variant — binary-searching on the answer.
Balanced brackets, next-greater-element, monotonic stacks. When you need to remember the recent past.
FIFO structures. The one your interviewer expects when they say 'level-order' or 'shortest path in a grid'.
Base case, recursive case, and the call stack. Recursion is what all of DP, backtracking, and tree traversal is built on.
Comparison sorts, key functions, stability. Also — the two you'll be asked to code from scratch.
Preorder, inorder, postorder, and level-order — how each traversal reveals a different view of the same tree.
Binary search tree in Python: implement the BST invariant, insert and search in log time, and inorder traversal.
The three ways to store a graph in memory and how the choice shapes every algorithm you run on it.
Breadth-first search with a queue and a visited set, and why it gives you the shortest path when every edge costs 1.
Depth-first search recursively and iteratively, plus the two classic use cases: connected components and cycle detection.
Kahn's algorithm and DFS-based toposort — turning a directed acyclic graph into a valid linear schedule.
The mental shift from raw recursion to DP: overlapping subproblems, optimal substructure, memoization vs tabulation.
Classic 1D DP where each state picks between take-and-skip or skip. Ends with O(1) space via rolling variables.
Bottom-up DP for min coins to make an amount. Introduces the unbounded knapsack pattern and sentinel base cases.
LIS two ways: the honest O(n²) DP that teaches the state, and the O(n log n) patience-sorting variant that keeps the smallest tails.
Levenshtein distance via 2D DP: minimum insert/delete/substitute operations to turn one string into another. The template for pairwise string DP.
Use heapq to pull min/max in log n. Top-K, streaming medians, Dijkstra — all sit on this one primitive.
Store a dictionary as a tree of characters. Prefix lookup is O(k) in the query length, independent of vocabulary size.
Disjoint Set Union with path compression and union by rank. Powers Kruskal's MST, cycle detection, and dynamic connectivity queries.
Python LRU cache tutorial: build the hash map plus doubly-linked list behind functools.lru_cache with O(1) operations.
Three ways to grab the k largest or smallest items — heapq.nlargest, sorting, and quickselect. Each wins under different k, n, and streaming conditions.
The choose/recurse/unchoose template that powers permutations, subsets, and N-Queens.
When taking the best local choice actually produces the best global answer, with three worked patterns.
Bitwise operators, arbitrary-precision Python ints, and the four tricks worth memorising.
From O(n*m) scans to rolling hashes, plus when Python's built-ins already win.
Finishing this path gives you the Python part of the job, with graded exercises and projects you can show. It is not, by itself, a qualification for the role.