Coding Interview Foundations

A live technical screen is rarely about trick questions — it's a 60–90 minute conversation about how you think, held over a shared editor, covering a well-known core: data structures, algorithms, Big-O, recursion, trees and graphs, hash tables, object-oriented design and a dash of concurrency. This track covers exactly that core. Every module pairs a plain-English explanation with a live interactive lab— step a binary search, watch a race condition lose updates, collide hash keys — plus a “say it out loud” box with the sentences that demonstrate understanding to another engineer.

1. 🗺️

   Module 1

   The problem-solving method

   Clarify, work an example by hand, name the brute force, then earn the optimization — the loop that turns a blank editor into a conversation.

   🎛 Two-sum: brute force vs hash map

   →
2. ⏱️

   Module 2

   Big-O notation

   What O(n), O(n log n) and O(n²) actually promise, the ~10⁸ ops/second budget, and how to read a required complexity straight off the input size.

   🎛 Growth-rate explorer

   →
3. 🧱

   Module 3

   Arrays, linked lists, stacks & queues

   The four workhorses: contiguous vs linked memory, O(1) ends vs O(n) middles, and the one-line use case that picks each structure.

   🎛 Stack vs queue simulator

   →
4. #️⃣

   Module 4

   Hash tables

   Key → hash → bucket: how average O(1) lookup works, what collisions and load factor do to it, and why hash maps answer half of all interview problems.

   🎛 Bucket & collision lab

   →
5. 🪆

   Module 5

   Recursion & memoization

   Base case, recursive case, the call stack — and the overlapping-subproblems smell that says memoize, collapsing O(2ⁿ) into O(n).

   🎛 Call-count comparator

   →
6. 🔍

   Module 6

   Searching & sorting

   Binary search stepped probe by probe, the sorting landscape from quicksort to counting sort, and 'sort first' as an optimization move.

   🎛 Binary-search stepper

   →
7. 🌳

   Module 7

   Trees & traversals

   Pre/in/post-order and level-order on the same tree, BST invariants, and the recursive shape that solves most tree questions in ten lines.

   🎛 Traversal visualizer

   →
8. 🕸️

   Module 8

   Graphs: BFS & DFS

   Adjacency lists, the visited set, queue-vs-stack as the only difference between BFS and DFS, and when each one is the right call.

   🎛 BFS/DFS animator

   →
9. 🧩

   Module 9

   OOP & design patterns

   Encapsulation, composition over inheritance, SOLID in one breath each — and the six patterns (strategy, factory, observer, decorator, adapter, singleton) that cover most design questions.

   🎛 Scenario → pattern quiz

   →
10. 🧵

    Module 10

    Concurrency

    Threads vs processes, race conditions you can reproduce, locks and deadlock, and the vocabulary — atomic, mutex, thread-safe — used correctly.

    🎛 Race-condition simulator

    →