AlgoMRI

1. Module 1

   Phase 0.1 — Physical Logic: The Light Switch Brain

   Phase 0 · The Engine Room — binary, bitwise operations, and stack vs heap memory.

2. Module 2

   Phase 0.2 — Language Constructs: The Sticky Note Stack

   Phase 0 · The Engine Room — variables, the call stack, scope, and pass-by-value vs reference.

3. Module 3

   Phase 0.3 — Unmasking Built-ins: The Peek Under the Hood

   Phase 0 · The Engine Room — dynamic arrays, hash maps, and string immutability.

4. Module 4

   Phase 1.1 — Variables & Memory: The Labeled Box Rule

   Phase 1 · Code as Instructions — variables are containers, not values.

5. Module 5

   Phase 1.2 — Conditionals & Decisions: The Fork in the Trail Rule

   Phase 1 · Code as Instructions — code skips entire branches.

6. Module 6

   Phase 1.3 — Loops & Repetition: The Song on Repeat Rule

   Phase 1 · Code as Instructions — one instruction, many executions.

7. Module 7

   Phase 1.4 — Arrays as Lockers: The Numbered Locker Row

   Phase 1 · Code as Instructions — one name, many values.

8. Module 8

   Phase 1.5 — Functions as Recipes: The Recipe Card Rule

   Phase 1 · Code as Instructions — write once, use anywhere.

9. Module 9

   Phase 2.1 — Linear Search: The Dark Library Rule

   Phase 2 · Code as Recipes — one item at a time.

10. Module 10

    Phase 2.2 — Simple Sorting: The Card Sorting Rule

    Phase 2 · Code as Recipes — compare and swap repeatedly.

11. Module 11

    Phase 2.3 — Stacks (LIFO): The Cafeteria Tray Rule

    Phase 2 · Code as Recipes — last in, first out.

12. Module 12

    Phase 2.4 — Queues (FIFO): The Coffee Shop Line Rule

    Phase 2 · Code as Recipes — first in, first out.

13. Module 13

    Phase 2.5 — Recursion: The Mirror Tunnel Rule

    Phase 2 · Code as Recipes — a function that calls itself.

14. Module 14

    Phase 3.1 — Linked Lists: The Treasure Hunt Rule

    Phase 3 · Code as Data — follow the pointers.

15. Module 15

    Phase 3.2 — Binary Search: The Dictionary Lookup Rule

    Phase 3 · Code as Data — cut the search space in half.

16. Module 16

    Phase 3.3 — Trees & Hierarchies: The Family Tree Rule

    Phase 3 · Code as Data — parent-child relationships.

17. Module 17

    Phase 3.4 — Hash Tables: The Hotel Front Desk Rule

    Phase 3 · Code as Data — direct key-to-location mapping.

18. Module 18

    Phase 3.5 — Pointers & References: The Library Call Slip Rule

    Phase 3 · Code as Data — address, not copy.

19. Module 19

    Phase 4.1 — Big O Analysis: The Coin Counting Rule

    Phase 4 · Code as Optimization — growth rate, not runtime.

20. Module 20

    Phase 4.2 — Divide & Conquer Sorting: The Exam Grading Rule

    Phase 4 · Code as Optimization — split, solve, merge.

21. Module 21

    Phase 4.3 — Graph Traversal (BFS/DFS): The Cave Explorer Rule

    Phase 4 · Code as Optimization — wide vs deep exploration.

22. Module 22

    Phase 4.4 — Dynamic Programming: The Notebook Rule

    Phase 4 · Code as Optimization — cache results, never recompute.

23. Module 23

    Phase 4.5 — Greedy Algorithms: The Making Change Rule

    Phase 4 · Code as Optimization — local optimum → global optimum.

24. Module 24

    Phase 5.1 — Space-Time Tradeoffs: The Kitchen Prep Rule

    Phase 5 · Code as Trade-offs — memory for speed is a bet.

25. Module 25

    Phase 5.2 — Balanced Trees: The Mobile Rule

    Phase 5 · Code as Trade-offs — self-balancing for guaranteed O(log n).

26. Module 26

    Phase 5.3 — Tries (Prefix Trees): The Phone Directory Rule

    Phase 5 · Code as Trade-offs — share prefixes, answer prefix queries.

27. Module 27

    Phase 5.4 — Advanced DP Patterns: The Traveler's Backpack Rule

    Phase 5 · Code as Trade-offs — 5 patterns solve 80% of DP.

28. Module 28

    Phase 5.5 — NP-Completeness: The Road Trip Rule

    Phase 5 · Code as Trade-offs — easy to verify, hard to solve.

29. Module 29

    Phase 6.1 — P vs NP: The Sudoku Rule

    Phase 6 · Code as Theory — the million-dollar question of CS.

30. Module 30

    Phase 6.2 — Approximation Algorithms: The Box Packing Rule

    Phase 6 · Code as Theory — good enough with a guarantee.

31. Module 31

    Phase 6.3 — Amortized Analysis: The Dynamic Array Rule

    Phase 6 · Code as Theory — average cost over many operations.

32. Module 32

    Phase 6.4 — Segment & Fenwick Trees: The Hotel Occupancy Rule

    Phase 6 · Code as Theory — O(log n) range queries.

33. Module 33

    Phase 6.5 — Formal Verification: The Mathematical Proof Rule

    Phase 6 · Code as Theory — prove correctness for all inputs.

We keep expanding this course — new modules are added regularly, and 1-year access covers everything published during that time.