Start at Lesson 1 and move forward. Each lesson is broken into micro‑presentations (short, clear screens — one concept at a time). This makes daily training realistic even with school and distractions.

1. Learn: read the micro‑presentations (short + focused)
2. (Paid) Drill: take the quiz and record your score
3. Prove: pass the belt exam to rank up

Iaido rule: no wasted motion. In algorithms, wasted steps become wasted hours at scale.

AI is commoditizing basic coding. The advantage shifts to teens who can design correct solutions, analyze efficiency, choose the right data structures, and defend their reasoning under pressure.

Algorithms are a durable foundation behind software engineering interviews, competitive problem solving, and real system performance. Your teen isn’t just learning “how to code” — they’re learning how to think like a computer scientist.

Disclaimer: This course builds skills and discipline. It does not guarantee jobs or outcomes.

Train like Iaido: calm, precise, and efficient. AI can generate answers — your job is to choose the right one, prove it, and make it scale.

• You vs AI: don’t trust “looks correct” — verify correctness
• Speed with precision: learn patterns that cut runtime
• Edge cases: handle the weird inputs that break weak code
• Belts: show real proof, not just “watched content”

If you like brain‑combat, send this course to a friend who loves puzzles and “hard mode” thinking.

• Time and space complexity (what scales, what breaks)
• Recursion and problem decomposition
• Core data structures: arrays, linked lists, stacks, queues, trees, heaps, graphs
• Hashing and fast lookup strategies
• Algorithm paradigms: divide & conquer, greedy, dynamic programming, backtracking
• How to verify correctness and handle edge cases

• Short training slides (micro‑presentations; one idea per screen)
• (Paid) Auto‑graded drills/quizzes with retries
• (Paid) Belt exams to prove progress
• Moodle tracking: scores, completion, progress history
• No technical Q&A required — progress is designed to be independent

This is a dojo: train → drill → test → rank up.

Lesson ranges refer to the course training forms.

• White Belt (Lessons 1–4) — Sheath & Stance
  Algorithm mindset, memory basics, ADT thinking, and complexity fundamentals.
• Yellow Belt (Lessons 5–6) — The First Draw: Recursion Control
  Recursion tracing and recurrence relations for measuring cost.
• Orange Belt (Lessons 7–10) — Clean Cuts: Arrays & Strings
  Arrays, searching, array techniques, and string problem patterns.
• Green Belt (Lessons 11–15) — Structured Steel: Matrices to Queues
  Matrices, sparse structures, linked lists, stacks, and queues.
• Blue Belt (Lessons 16–18) — Tree Line: Fast Structure
  Trees, binary search trees, and balanced tree thinking.
• Brown Belt (Lessons 19–22) — Speed & Reach
  Heaps/priority queues, hashing, graphs, and divide & conquer.
• Black Belt (Lessons 23–26) — One Cut: Strategy Mastery
  Greedy algorithms, dynamic programming, backtracking, and strategy selection.
  Black Belt Test: comprehensive final exam.

Belts are proof. Parents get visibility. Teens get momentum.

Free (Guest Training)

• Access the free lesson content (training slides / micro‑presentations)
• See the curriculum + belt map
• Preview the dojo structure

Dojo Membership (Paid)

• Full access to all drills, quizzes, and belt tests
• Belt tracking and certificates
• Parent visibility of progress and scores inside Moodle

Founders / Inauguration Price: $5 per course for 30 days (about the price of a coffee). This is the launch price while the dojo is expanding — as more belts, exams, and courses are added, the price will rise.

1. The Iaido Mindset — why algorithms beat raw code at scale.
2. Memory Basics — stack vs heap and performance implications.
3. ADT Thinking — choose the right structure for the job.
4. Complexity — time/space as your stopwatch.
5. Recursion — tracing, stack behavior, and safe patterns.
6. Recurrence Relations — measuring recursive cost.
7. Arrays — indexing, resizing, and tradeoffs.
8. Searching — linear vs binary and correctness.
9. Array Techniques — merge, reverse, shifts, set operations.
10. Strings — validation, comparison, and common patterns.
11. Matrices — specialized representations for efficiency.
12. Sparse Structures — compact storage for mostly-empty data.
13. Linked Lists — dynamic structures and traversal patterns.
14. Stacks — parsing and expression evaluation patterns.
15. Queues — circular, priority, and scheduling logic.
16. Trees — traversal, building, and height reasoning.
17. Binary Search Trees — ordered storage operations.
18. Balanced Trees — keeping performance stable.
19. Heaps — priority queues and heapsort thinking.
20. Hashing — fast lookup and collision reality.
21. Graphs — BFS/DFS and reachability tools.
22. Divide & Conquer — split, solve, combine.
23. Greedy — when the clean cut works (and when it fails).
24. Dynamic Programming — win by remembering.
25. Backtracking — disciplined search and pruning.
26. Strategy Selection — choose the right approach under pressure.

Disclaimer: This course provides education and training and cannot guarantee a specific job outcome.

Belts are proof of skill. Your teen earns belts through drills and belt tests.

Passing score: 80%
Retries: Unlimited
Score policy: Best score counts (highest score recorded; retakes cannot lower record)

Eligibility: completing the required drills unlocks the belt test.

Optional anti‑spam cooldown (recommended): add a cooldown after failed attempts to reduce rapid guessing and encourage real review.

Integrity Rules — “You vs AI”

• No AI tools during belt tests. No chatbots, no code generators, no “explain this and give the answer.”
• No outside help during belt tests (friends, tutors, siblings).
• Parent presence encouraged during belt tests (nearby / same room).

Notes Policy

• Drills: open‑notes allowed.
• Belt tests: closed‑notes or one‑page notes (dojo admin choice).

Disclaimer: Belts and certificates verify training progress and do not guarantee job outcomes.