Teaching-mechanic library

state_containers · cs · transformer.trace

Concept: Variables & assignment

Player does: Predict each container's value after the instructions run

Breaks: x = x + 1 is an impossible equation

In code, = is assignment, not algebraic equality, so x = x + 1 replaces x's stored value with one more than itself.

branch_doors · cs · transformer.trace

Concept: Conditionals

Player does: Predict which door the branching world opens for the current state

Breaks: Both branches of an if run

An if statement runs exactly one of its branches, chosen by whether the condition is true or false.

automation_track · cs · builder.program

Concept: Loops

Player does: Configure a repeating action instead of stepping manually

Breaks: A loop checks its condition only once

A loop re-checks its condition every iteration, which is what lets it keep running or stop.

reusable_machines · cs · builder.program

Concept: Functions

Player does: Define a machine once and call it at several stations

Breaks: Functions run when they're defined

A function's body runs only when it is called, not at the moment it is defined.

nested_rooms · cs · transformer.trace

Concept: Recursion

Player does: Each room holds a smaller copy; predict the result as base cases return

Breaks: Recursion never stops

Recursion terminates once it reaches a base case, which stops the chain of smaller calls from growing further.

indexed_inventory · cs · transformer.trace

Concept: Arrays & indexing

Player does: Fetch items by slot from a zero-indexed inventory

Breaks: Indexes count from 1 in every language

Many languages index arrays starting at 0, so the first element sits at index 0, not 1.

pointer_chain · cs · linker.chain

Concept: Linked lists

Player does: Relink next-pointers to insert a node

Breaks: You can jump straight to the 5th node

A linked list has no direct index access; reaching the 5th node means following the chain of pointers from the head.

tower_access · cs · sequencer.linear

Concept: Stacks

Player does: Predict the pop order after pushes and pops

Breaks: First in, first out

A stack is last in, first out: the most recently pushed item is the one that pops first.

processing_line · cs · sequencer.linear

Concept: Queues

Player does: Predict the service order at the processing line

Breaks: The newest arrival is served first

A queue is first in, first out, so the earliest arrival is served before newer ones.

branch_explorer · cs · sequencer.linear

Concept: Tree traversal

Player does: Order the rooms visited in pre-, in-, or post-order

Breaks: In-order means top to bottom

In-order traversal visits left subtree, node, then right subtree, which is not the same as visiting top to bottom.

half_split_hunt · cs · mapper.search

Concept: Binary search

Player does: Find the hidden number within ⌈log₂ n⌉ probes

Breaks: Binary search works on unsorted data

Binary search relies on the data being sorted so each probe can eliminate half the remaining range.

ordering_conveyor · cs · transformer.trace

Concept: Sorting algorithms

Player does: Predict the conveyor after pass k of bubble or insertion sort

Breaks: Every sort does the same work

Different sorting algorithms compare and move elements in different patterns, so their intermediate states differ.

network_explorer · cs · sequencer.linear

Concept: BFS vs DFS

Player does: Predict the visit order as BFS spreads and DFS dives

Breaks: BFS and DFS visit in the same order

BFS explores level by level with a queue while DFS dives deep with a stack, so they visit nodes in different orders.

weighted_path_planner · cs · linker.path

Concept: Shortest paths (Dijkstra)

Player does: Find the cheapest route across weighted bridges

Breaks: Fewest edges means cheapest

The shortest path minimizes total edge weight, which can require more edges than the fewest-edge route.

bucket_router · cs · transformer.function_machine

Concept: Hashing

Player does: Predict each key's bucket from h(k) = k mod m; spot collisions

Breaks: Hashing sorts the keys

A hash function maps keys to buckets for fast lookup; it does not order the keys.

memory_warehouse · cs · transformer.trace

Concept: Caching & locality

Player does: Predict hits and misses as requests arrive

Breaks: Every memory access costs the same

A cache hit is far cheaper than a miss, so locality of access strongly affects real performance.

race_switches · cs · truth_finder.predict_reveal

Concept: Race conditions

Player does: Predict the final counter when two agents interleave

Breaks: Two increments always add 2

Without synchronization, interleaved increments can overwrite each other, so two increments may add less than 2.

deadlock_locks · cs · linker.network

Concept: Deadlock

Player does: Find the cycle in the wait-for graph and break it

Breaks: Deadlock needs a bug in a single thread

Deadlock arises from a cycle of threads each waiting on a resource the other holds, not from a bug in one thread alone.

state_world · cs · linker.network

Concept: Finite state machines

Player does: Draw the transitions so the world accepts the input

Breaks: A state machine remembers its whole history

A finite state machine's next move depends only on its current state and input, not its full history.

big_o_race · cs · sequencer.rank

Concept: Complexity

Player does: Rank runners by growth rate as n explodes

Breaks: An O(n²) algorithm is always slower

Big-O describes growth as input size gets large; an O(n²) algorithm can still be faster than a worse-growth one on small inputs.

code_golem · cs · builder.program

Concept: Algorithms

Player does: Program the golem to build the staircase

Breaks: Computers do what you meant

A computer executes exactly what an algorithm specifies, not what its author intended.

cipher_door · cs · transformer.encode

Concept: Binary, hex, encodings

Player does: Translate the carving from binary or hex to unlock the door

Breaks: Hex digits only go 0–9

Hexadecimal digits run 0 through F, using A–F to represent values ten through fifteen.

bug_hunter · cs · truth_finder.error_hunt

Concept: Debugging

Player does: Strike the scroll line that causes the bug

Breaks: The bug is on the line where the error shows

A bug's root cause often sits earlier in the code than the line where the error finally surfaces.

osi_elevator · cs · sequencer.linear

Concept: Network layers

Player does: Ride a packet down and up the protocol stack

Breaks: Layers can be skipped

Each OSI layer depends on the one below it, so data must pass through every layer in order, never skipping one.