All 29 levels

The full DSA syllabus in the order we recommend. Each level explains the ideas, gives a tested template in Python and C++, lists the mistakes people make, and links practice problems from easy to hard.

World 1: Foundations

Meadow, 6 levels

How to reason about cost, plus the three structures every other topic is built on: arrays, strings and hash maps.

  1. Level 1

    Complexity Analysis (Big-O)

    Learn to predict how fast code runs and how much memory it needs before you write it — the skill that decides which algorithm to pick.

    6 concepts, 4 challengesAbout 3 h
  2. Level 2

    Math for DSA

    GCD, primes, modular arithmetic and fast exponentiation — the small toolkit that appears in placement tests and contest problems again and again.

    6 concepts, 6 challengesAbout 4 h
  3. Level 3

    Arrays

    The most important data structure in interviews: constant-time indexing, in-place tricks, matrices and Kadane's algorithm.

    6 concepts, 7 challengesAbout 5 h
  4. Level 4

    Strings

    Character arrays with their own traps: immutability, counting, palindromes and efficient pattern matching.

    6 concepts, 8 challengesAbout 5 h
  5. Level 5

    Hash Maps & Sets

    Constant-time lookup is the single most useful optimisation in DSA. Learn how hash tables work and the patterns that use them.

    6 concepts, 8 challengesAbout 4 h
  6. Level 6

    Recursion

    Solve a problem by solving smaller copies of it. Recursion is the gateway to trees, backtracking, divide-and-conquer and DP.

    6 concepts, 6 challengesAbout 5 h

World 2: Core Patterns

Lagoon, 6 levels

Reusable techniques — two pointers, windows, prefix sums, binary search — that turn O(n²) brute force into O(n) or O(n log n).

  1. Level 7

    Two Pointers

    Walk two indices through an array to eliminate whole groups of candidates at once, turning O(n²) pair searches into O(n).

    6 concepts, 7 challengesAbout 4 h
  2. Level 8

    Sliding Window

    Maintain a moving range over an array or string and update its state incrementally instead of recomputing every subarray.

    6 concepts, 8 challengesAbout 5 h
  3. Level 9

    Prefix Sums & Difference Arrays

    Precompute running totals once to answer any range-sum query in O(1), and count subarrays with a target sum using a hash map.

    6 concepts, 7 challengesAbout 3 h
  4. Level 10

    Binary Search

    Halve the search space every step. Beyond sorted arrays, binary search finds the answer to any problem with a monotonic yes/no condition.

    6 concepts, 8 challengesAbout 5 h
  5. Level 11

    Sorting Algorithms

    How merge sort, quicksort, heap sort and counting sort work, when each is the right tool, and how sorting unlocks other techniques.

    6 concepts, 6 challengesAbout 5 h
  6. Level 12

    Intervals & Sweep Line

    Merge, insert and schedule ranges. Almost every interval problem starts by sorting and then sweeps once.

    6 concepts, 7 challengesAbout 3 h

World 3: Linear Structures

Lavender, 3 levels

Linked lists, stacks and queues: pointer manipulation and the monotonic tricks behind many "next greater" problems.

  1. Level 13

    Linked Lists

    Nodes joined by pointers. Linked-list problems are really exercises in careful pointer rewiring — dummy heads, reversal and fast/slow pointers.

    6 concepts, 9 challengesAbout 5 h
  2. Level 14

    Stacks & Monotonic Stacks

    Last in, first out. Stacks match brackets, evaluate expressions and — as monotonic stacks — find the next greater element in linear time.

    6 concepts, 8 challengesAbout 4 h
  3. Level 15

    Queues, Deques & Monotonic Queues

    First in, first out. Queues power BFS and scheduling; double-ended queues solve sliding-window maximum in linear time.

    6 concepts, 7 challengesAbout 3 h

World 4: Trees & Heaps

Pinewood, 4 levels

Hierarchical data: traversals, binary search trees, priority queues and prefix trees.

  1. Level 16

    Binary Trees

    Traversals, depth, diameter and lowest common ancestors. Tree problems are recursion problems: decide what each subtree returns.

    6 concepts, 10 challengesAbout 6 h
  2. Level 17

    Binary Search Trees

    Trees that keep data sorted: left is smaller, right is larger. Search, insert and delete follow one root-to-leaf path.

    6 concepts, 8 challengesAbout 4 h
  3. Level 18

    Heaps & Priority Queues

    Always know the smallest (or largest) item in O(1) and remove it in O(log n). The tool for top-k, merging and scheduling problems.

    6 concepts, 8 challengesAbout 4 h
  4. Level 19

    Tries (Prefix Trees)

    A tree of characters where shared prefixes share nodes. Ideal for autocomplete, dictionaries and prefix queries.

    6 concepts, 7 challengesAbout 3 h

World 5: Graphs

Crystal, 4 levels

Model anything with nodes and edges: traversal, dependency ordering, connectivity and shortest paths.

  1. Level 20

    Graph Traversal: BFS & DFS

    Represent networks as adjacency lists and explore them with breadth-first and depth-first search — including grids, which are graphs in disguise.

    6 concepts, 9 challengesAbout 6 h
  2. Level 21

    Topological Sort

    Order tasks so every dependency comes first. Topological sorting also detects impossible (cyclic) dependency graphs.

    6 concepts, 7 challengesAbout 3 h
  3. Level 22

    Union-Find (Disjoint Set Union)

    Merge groups and ask "are these two connected?" in near-constant time. The engine behind Kruskal's MST and dynamic connectivity.

    6 concepts, 6 challengesAbout 3 h
  4. Level 23

    Shortest Paths & Minimum Spanning Trees

    Dijkstra, Bellman-Ford, Floyd-Warshall and Prim/Kruskal — choosing the right algorithm based on edge weights and what you need to connect.

    6 concepts, 7 challengesAbout 6 h

World 6: Mastery

Ember Peak, 6 levels

Search and optimisation: backtracking, greedy proofs, dynamic programming, bit tricks and range-query trees.

  1. Level 24

    Backtracking

    Build solutions one choice at a time and undo choices that lead nowhere. The systematic way to generate subsets, permutations and puzzle solutions.

    6 concepts, 10 challengesAbout 6 h
  2. Level 25

    Greedy Algorithms

    Make the locally best choice and never look back. Fast and simple — when you can prove it works.

    6 concepts, 8 challengesAbout 4 h
  3. Level 26

    Dynamic Programming I (1D)

    Solve each subproblem once and reuse the answer. Learn to define states and recurrences on one-dimensional problems.

    6 concepts, 9 challengesAbout 8 h
  4. Level 27

    Dynamic Programming II (2D, Knapsack, Strings)

    Grid paths, knapsack, longest common subsequence and edit distance — DP where the state needs two indices.

    6 concepts, 11 challengesAbout 8 h
  5. Level 28

    Bit Manipulation

    Work directly with binary: XOR tricks, counting bits, masks and subset enumeration — tiny code, big speedups.

    6 concepts, 8 challengesAbout 3 h
  6. Level 29

    Range Queries: Fenwick & Segment Trees

    When the array keeps changing, prefix sums break. Fenwick and segment trees answer range queries and updates in O(log n).

    6 concepts, 7 challengesAbout 6 h