Data Structures
& Algorithms.

F1 · Beginner · 30 min

How to measure an algorithm by how its cost grows, not how long it happens to run. O(1), O(log n), O(n), O(n log n), O(n²) — recognising these lets you predict whether code scales to a million items before you ever run it.

• Time vs space complexity
• Common growth classes
• Amortised analysis
• Best / average / worst case

Build itTake three solutions to the same problem and rank them by Big-O. Predict which wins at n = 1,000,000, then time them to check.

✓ CheckpointExplain why O(n) can beat O(log n) on real input, and what the notation deliberately hides.

F2 · Beginner · 30 min

The workhorse structure: contiguous memory, O(1) random access, O(n) insert/delete in the middle. Most interview problems start here — in-place manipulation, reversals, rotations, and the index arithmetic everything else builds on.

• Random access & traversal
• In-place edits
• String building
• Index math

Build itReverse an array in place with two pointers, then rotate it by k positions using no extra memory.

✓ CheckpointExplain why inserting at the front of an array is O(n) and why that cost is invisible until it is not.

F3 · Beginner · 45 min

Hash maps trade memory for O(1) average lookups. Frequency counts, de-duplication, and “have I seen this before?” checks become trivial. The single most useful trick for cutting an O(n²) brute force down to O(n).

• Hash maps & sets
• Frequency counting
• Collisions (basics)
• The two-sum pattern

Build itSolve two-sum in O(n) with a hash map, then find the first non-repeating character in a string.

✓ CheckpointExplain what a hash set buys over a sorted array, and the case where the array wins.

F4 · Intermediate · 45 min

Two indices walking through a sequence — from opposite ends or as a fast/slow pair — crack a huge class of array and string problems in O(n) time and O(1) space. The sliding window is the same idea aimed at subarrays and substrings.

• Opposite-end pointers
• Fast / slow pointers
• Fixed & variable windows
• In-place partitioning

Build itFind the longest substring without repeating characters using a sliding window backed by a set.

✓ CheckpointExplain how a sliding window turns an O(n²) scan into O(n), and what property the input must have.

F5 · Intermediate · 40 min

Number theory shows up constantly — primes, GCD, modular arithmetic. The Sieve of Eratosthenes finds every prime up to n by crossing out multiples, far faster than testing each number for primality.

• Primes & factorisation
• GCD / LCM
• Modular arithmetic
• The Sieve

Build itGenerate every prime under 1,000 with the Sieve, then work out why it runs in O(n log log n).

✓ CheckpointExplain why the sieve is faster than testing each number for primality, in terms of work reused.

F6 · Intermediate · 45 min

On sorted data, halve the search space every step — O(log n) instead of O(n). The pattern reaches far past arrays: any time the answer space is monotonic, you can “binary search on the answer.”

• Sorted-array search
• Lower / upper bound
• Search on the answer
• Off-by-one safety

Build itImplement binary search with zero off-by-one bugs, then reuse it to find a square root to six decimals.

✓ CheckpointWrite the binary search boundary condition from memory and say which off-by-one you get wrong most.

T1 · Beginner · 30 min

LIFO and FIFO — the two simplest abstract structures, yet they power undo systems, expression parsing, BFS, and scheduling. Half the battle is recognising that a problem is secretly a stack or queue problem.

• Stack (LIFO)
• Queue / deque (FIFO)
• Monotonic stack
• Matching & parsing

Build itValidate balanced brackets with a stack, then build a min-stack that returns its minimum in O(1).

✓ CheckpointExplain what a monotonic stack maintains, and how that turns “next greater element” into one pass.

T2 · Intermediate · 40 min

Nodes joined by pointers: O(1) insert/delete, but no random access. The classic playground for pointer manipulation — reversal, cycle detection, and merging two lists in order.

• Singly / doubly linked
• Pointer reversal
• Floyd cycle detection
• Dummy-head trick

Build itReverse a linked list iteratively, then detect a cycle with fast/slow pointers.

✓ CheckpointExplain why the fast/slow pointer finds a cycle, and why the meeting point is not the cycle start.

T3 · Intermediate · 50 min

A function that calls itself, peeling a problem down to a base case. Backtracking adds “try, recurse, undo” to explore every configuration — permutations, subsets, N-queens, Sudoku.

• Base case & recursion
• The call stack
• Backtracking template
• Pruning

Build itGenerate all subsets of a set, then all permutations. Add pruning to place 8 queens without conflicts.

✓ CheckpointExplain what backtracking undoes and why forgetting the undo poisons every later branch.

T4 · Intermediate · 50 min

Ordering data unlocks binary search, two-pointer sweeps, and greedy methods. Merge sort guarantees O(n log n) with a stable divide-and-conquer; quicksort is usually faster in practice with in-place partitioning.

• Divide & conquer
• Merge sort (stable)
• Quicksort & pivots
• When to sort first

Build itImplement merge sort, then quicksort, and compare how each behaves on already-sorted and reversed input.

✓ CheckpointExplain what stability means in a sort and give a case where losing it produces a wrong answer.

T5 · Intermediate · 50 min

Hierarchical nodes with children. Binary search trees keep data ordered for O(log n) search and insert; traversals — in-order, pre-order, post-order — visit every node in a meaningful sequence.

• Binary trees
• BST invariant
• DFS traversals
• Balanced trees (AVL / RB) intuition

Build itDo an in-order traversal of a BST (it yields sorted order), then check whether an arbitrary tree is a valid BST.

✓ CheckpointExplain why an unbalanced BST degenerates to a list, and what input causes it.

T6 · Intermediate · 45 min

A binary heap gives O(log n) insert and O(1) peek of the smallest (or largest) element — the engine behind priority queues, “top-k” problems, and Dijkstra’s frontier.

• Min / max heap
• Heapify in O(n)
• Top-k pattern
• Priority queue uses

Build itFind the k largest values in a stream using a min-heap of size k, and explain why it is O(n log k).

✓ CheckpointExplain why a heap gives you the minimum in O(1) but the sorted order still costs O(n log n).

P1 · Intermediate · 40 min

Vertices and edges model networks, maps, dependencies, and state spaces. Representation matters: an adjacency list for sparse graphs, a matrix for dense ones — the choice changes the cost of every traversal.

• Adjacency list vs matrix
• Directed / weighted edges
• Degree & connectivity
• Modelling problems as graphs

Build itBuild an adjacency list from an edge list, then count the connected components.

✓ CheckpointExplain when an adjacency matrix beats a list, in terms of density rather than preference.

P2 · Intermediate · 45 min

Breadth-first search explores level by level with a queue — giving the shortest path in unweighted graphs and powering flood fill, maze solving, and “nearest” queries.

• Queue-based BFS
• Shortest path (unweighted)
• Flood fill
• Multi-source BFS

Build itFind the shortest path through a grid maze with BFS, then flood-fill a region of connected cells.

✓ CheckpointExplain why BFS finds the shortest path on an unweighted graph and DFS does not.

P3 · Intermediate · 45 min

Depth-first search dives down each branch with recursion or a stack. It detects cycles, finds components, and — on a DAG — produces a topological order for scheduling dependencies.

• Recursive / iterative DFS
• Cycle detection
• Topological sort
• Connected components

Build itTopologically sort a build-dependency graph, and detect when a cycle makes ordering impossible.

✓ CheckpointExplain what a topological order guarantees and what its existence tells you about the graph.

P4 · Advanced · 55 min

When edges carry weights, BFS is not enough. Dijkstra greedily expands the cheapest frontier with a heap; it is the backbone of routing, networks, and every “least-cost” problem.

• Weighted edges
• Dijkstra + heap
• Edge relaxation
• Negative edges (Bellman-Ford)

Build itRun Dijkstra on a weighted road network to find the cheapest route, using a priority queue for the frontier.

✓ CheckpointExplain why Dijkstra breaks on negative edges, and which algorithm you reach for instead.

P5 · Advanced · 50 min

A* speeds up shortest-path search by adding a heuristic — an estimate of the distance still to go — so it aims toward the goal instead of expanding evenly. With an admissible heuristic it stays optimal.

• Heuristics & admissibility
• f = g + h
• A* vs Dijkstra
• Greedy best-first

Build itPathfind across a terrain grid with A* and a Manhattan heuristic, then compare how many nodes it expands versus Dijkstra.

✓ CheckpointExplain what makes an A* heuristic admissible, and what an inadmissible one costs you.

P6 · Advanced · 60 min

DP solves a problem by caching its overlapping subproblems — top-down with memoisation or bottom-up with a table. Once you spot the recurrence, exponential brute force collapses to polynomial time.

• Overlapping subproblems
• Memoisation vs tabulation
• State & transitions
• Classic DPs (knapsack, LCS, edit distance)

Build itSolve climbing-stairs with memoisation, re-derive it bottom-up, then move on to the 0/1 knapsack.

✓ CheckpointState the DP state for a problem you solved, and say why that state is sufficient.