Base CS from zero
Control flow: multiple-choice review
Crux Multiple-choice synthesis across the control-flow unit: the program counter, conditional jumps and flags, fall-through, backward jumps, and why loops repeat or run forever.
Your altitude — climbing toward senior
ZeroJuniorMiddleSenior
You are at middle altitude — in the skySix questions that cut across the whole unit. None asks for a definition. Each asks you to reason about what the program counter does next — which is the single question every branch and every loop reduces to.
Goal
Confirm you can connect the four lessons into one model: the program counter drives flow, a compare sets flags, a conditional jump reads one flag bit, a backward jump repeats the body, and an if/else is just two destinations for the PC.
Quiz
Completed
Two running machines hold identical instruction bytes at identical addresses, yet they execute completely different sequences of instructions. How is that possible?
Heads-up The bytes are fixed and inert; the flow is dynamic. The PC decides which byte is fetched next, so the same program can run different flows depending on which jumps are taken.
Heads-up The CPU never sees source code — only bytes in memory. Both machines run the same bytes; the difference is which addresses the PC visits.
Heads-up General-purpose registers hold data being computed. Only the program counter holds the address of the next instruction to fetch.
Quiz
Completed
A CMP R0, R1 executes, then a JNE (jump if not equal) is reached. Which single piece of state does the JNE actually inspect to decide jump-or-fall-through?
Heads-up The conditional jump does no arithmetic. The comparison already happened in CMP; the flag is its residue. JNE only reads a flag bit.
Heads-up By the time JNE runs it inspects the flags register, not the operands. CMP recorded the relationship into the Z flag; the operand values are not re-read.
Heads-up The PC holds the address to fetch, not a comparison result. The decision comes from a flag (here Z) that CMP set.
Quiz
Completed
An if/else compiles to: CMP; conditional-jump-to-ELSE; if-true block; unconditional JUMP to END; ELSE: if-false block; END. Why is the unconditional JUMP after the if-true block necessary?
Heads-up Fall-through is mechanical: the PC keeps advancing into the next bytes in memory, which are the else block. Without the skip, the if-true path also executes the else block.
Heads-up An unconditional JUMP here targets END, the instruction after the else block — not address 0. Its job is to skip the else block, not restart.
Heads-up The else block is reached only via the conditional jump when the condition is false. The trailing JUMP exists to skip the else block on the true path, not to re-test anything.
Quiz
Completed
At the machine level, what is the only structural difference between a compiled while loop and a compiled for loop?
Heads-up General-purpose CPUs have no dedicated loop counter in the fetch-decode-execute cycle. Both loops use an ordinary register decremented or incremented by a normal instruction.
Heads-up Both test at the top, so the body can run zero times. Testing at the bottom (body runs at least once) is a do-while, not a for loop.
Heads-up There is no FOR opcode. for is syntactic sugar that compiles to the same backward-jump structure as while.
Quiz
Completed
A countdown loop decrements a counter and should exit when it hits 0, but it never exits and pins the CPU at 100%. Which explanation is consistent with how the machine actually runs the loop?
Heads-up The CPU counts nothing. It re-tests the condition each pass and makes one binary jump/fall-through decision; iteration count is an emergent property of the condition changing, not something the CPU tracks.
Heads-up Instructions never move. The bytes stay at fixed addresses; only the PC is rewound by the backward jump, so the same fixed bytes re-execute.
Heads-up An infinite loop is the CPU doing exactly what the program says. It cannot tell a deliberate while(true) from a bug; only the OS or an interrupt stops it.
Quiz
Completed
In sumPositives over [3, -1, 4], the inner if skips the negative element. When nums[i] is non-positive, what does the machine do, and does the loop end early?
Heads-up The while test checks i against the array length, not the sign of the element. A negative value only skips the inner if body; the loop keeps going.
Heads-up i++ is outside the if block and always runs. Skipping it would re-test the same element and loop forever — but that is not what the code does.
Heads-up A conditional jump picks exactly one path from a single flag bit. The negative element takes the skip path only.
Recap
The whole unit is one through-line: the program counter decides what runs next, and only a jump can change it. A compare sets a flag; a conditional jump reads that one flag and either jumps or falls through; an if/else is two PC destinations with a skip-JUMP guarding the boundary; a loop is a backward jump whose conditional test at the top decides whether to fall into the body again; and a loop runs forever when the tested value never changes. Every branch and loop you will ever read reduces to one question: where does the PC point next, and why.