Set C — Repetition (Scenarios 11–15)

Thinking questions — answered.

1. WHILE with a sentinel (lesson §14): we don’t know the number of coins in advance — we know the stop sign. Condition: “the value just read is not 0”. This is the read → process → read-again shape; forgetting the second read is the classic infinite loop here.
2. Both start at 0 — sums and counts start empty. Starting count at 1 is the classic first-coin miscount.
3. Trace (coins 5,2,1,5,2,5 then 0):

Predicted: total 20, coins 6 — count the actual coins in that list: 5,2,1,5,2,5 is six coins summing to 20. (If your trace said 23, you added the sentinel — proof the table works.)

Suggested approach. Sentinel WHILE with two accumulators; read, check, process, read again. The “process then re-read” order keeps the sentinel out of the arithmetic.

Pseudocode.

total ← 0
count ← 0
READ coin
WHILE coin ≠ 0 DO
    total ← total + coin
    count ← count + 1
    READ coin                      (read again — moves toward the stop)
ENDWHILE
PRINT "Total: ", total, " Rs"
PRINT "Coins: ", count

Solution explanation. The sentinel pattern’s three beats: prime (read once before the loop, so the condition has something true to test), process (accumulate only when the value is real), advance (read again at the loop’s end). Every WHILE you write this year should make you ask the three questions from the set header — here they’re: repeats = accumulate+read; changes = coin (eventually 0); starts = both accumulators 0. The output after the loop, once — not inside.

C++ solution.

// s11_jar.cpp — Set C · Scenario 11
// Compile: g++ -std=c++17 -Wall -Wextra s11_jar.cpp -o s11

#include <iostream>

int main() {
    int total = 0;
    int count = 0;

    int coin = 0;
    std::cout << "Coin value (0 to finish): ";
    std::cin  >> coin;                       // prime the loop

    while (coin != 0) {                      // stop condition: sentinel seen
        total = total + coin;                // accumulator 1
        count = count + 1;                   // accumulator 2
        std::cout << "Coin value (0 to finish): ";
        std::cin  >> coin;                   // advance: read again
    }

    std::cout << "Total: " << total << " Rs\n";
    std::cout << "Coins: " << count << "\n";
    return 0;
}

Test cases.

Edge cases. Single coin then sentinel (the minimum legal jar — total 1, coins 1); many 2s (even/odd totals parity check); first value is the sentinel — excluded by assumptions, but notice: the loop body never runs, total stays 0, coins 0 — a graceful zero, worth knowing your code does that rather than crashing.

Thinking questions — answered.

1. Condition: minutes > 0 (keep going while minutes remain). For start 3 the body runs exactly 3 times — once per value 3, 2, 1. Counting the runs before coding is how you’ll know your loop isn’t off by one.
2. Starts at the given minutes; the update is minutes = minutes - 1 — a count-down accumulator. The loop must reach minutes = 0, where > 0 fails and the loop exits — that’s the stop you built in.
3. Trace:

Body ran 3 times ✓, alert printed once after. ✓

Suggested approach. WHILE with a counting-down variable; the alert prints after the loop — a one-time event, so it lives outside.

Pseudocode.

READ minutes
WHILE minutes > 0 DO
    PRINT minutes
    minutes ← minutes − 1
ENDWHILE
PRINT "STORM ALERT"

Solution explanation. Same skeleton as Scenario 11 — condition check, body, update — but the moving value is now one we own, not user input. The two classic errors are both visible in the trace: printing the 0 (put the alert’s print inside wrongly and you’d print 0 too — the condition stops at 0 before the body runs) and forgetting the update (missing minutes − 1 = infinite 3 3 3 …: the trace table shows a body that never changes the checked value — the lesson’s §14 red flag). The alert’s placement (inside vs after) is decided by meaning: it happens once, after all minutes — not once per minute.

C++ solution.

// s12_countdown.cpp — Set C · Scenario 12
// Compile: g++ -std=c++17 -Wall -Wextra s12_countdown.cpp -o s12

#include <iostream>

int main() {
    int minutes = 0;
    std::cout << "Minutes until storm: ";
    std::cin  >> minutes;

    while (minutes > 0) {
        std::cout << minutes << "\n";
        minutes = minutes - 1;      // move toward the stop
    }

    std::cout << "STORM ALERT\n";
    return 0;
}

Test cases.

Edge cases. Start 1 (the minimum: exactly one number — a loop that runs “at least once but not twice” catches off-by-ones on both ends); start 2 (does it print 2 then 1, or skip 1?); start 120 (maximum — count the output lines: 120 numbers + 1 alert).

Thinking questions — answered.

1. FOR — the repetition count is known in advance: FOR student FROM 1 TO 8. The loop variable counts students, not marks; the marks arrive one per iteration.
2. Two accumulators: passed, failed — but they’re dependent: every student is one or the other, so failed = 8 − passed at the end. Tracking one accumulator is simpler and removes a whole class of drift bugs. (Tracking both is also acceptable — the design note is: notice the dependency, choose deliberately.)
3. 49 fails, 50 passes (>= 50). Trace for the given input:

Predicted: passed 4, failed 4. (The sample output above showed 5/3 for a different mark set — your trace is the truth for your input.)

Suggested approach. FOR loop over 8 students; one accumulator (passed); boundary test with >=; derive failed at the end.

Pseudocode.

passed ← 0
FOR student FROM 1 TO 8 DO
    READ mark
    IF mark >= 50 THEN
        passed ← passed + 1
    ENDIF
ENDFOR
PRINT "Passed: ", passed
PRINT "Failed: ", 8 − passed

Solution explanation. The counting-accumulator pattern: one variable incremented only when the body’s data meets a condition. The decision lives inside the loop but is a plain Scenario-7-style comparison — composition, not new machinery. The 8 − passed trick is worth naming: derive, don’t duplicate — one source of truth per fact. (Compare: if you tracked failed separately and forgot to increment it on one path, the two would disagree, and “passed + failed = 8” — your free invariant — would break silently.)

C++ solution.

// s13_passcount.cpp — Set C · Scenario 13
// Compile: g++ -std=c++17 -Wall -Wextra s13_passcount.cpp -o s13

#include <iostream>

int main() {
    int passed = 0;

    int student = 1;
    while (student <= 8) {              // FOR-student-from-1-to-8, C++-style
        int mark = 0;
        std::cout << "Mark " << student << ": ";
        std::cin  >> mark;

        if (mark >= 50) {               // boundary: 50 passes
            passed = passed + 1;
        }
        student = student + 1;          // advance (never forget!)
    }

    std::cout << "Passed: " << passed << "\n";
    std::cout << "Failed: " << 8 - passed << "\n";
    return 0;
}

Test cases.

Edge cases. All-exactly-50 (every mark sits on the boundary — tests >= vs >), all zeros, alternating pass/fail, and 100s (top edge). Notice the loop count edges matter too: eight prompts must appear — run it and count; the day you write 9 iterations by mistake is the day this habit pays.

Thinking questions — answered.

1. Inside: read saving, decide verdict, print the week’s line, update both accumulators. After: the two summary lines. The test is “does this action happen once per week (inside) or once for the whole report (after)?” — the same question as Scenario 12’s alert placement, now with three inside-items.
2. From the loop variable — the FOR’s counter is the week number (1–6). Printing it is why the loop variable exists; never hand-count.
3. Trace:

Final: total 530, on-target 4.

Suggested approach. FOR 1..6; two accumulators; decision inside (>= 100); SHORT amount derived as 100 - saving (only meaningful in that branch — another derive-don’t-duplicate); summary after.

Pseudocode.

total ← 0
onTarget ← 0
FOR week FROM 1 TO 6 DO
    READ saving
    total ← total + saving
    IF saving >= 100 THEN
        PRINT "Week ", week, ": OK (", saving, ")"
        onTarget ← onTarget + 1
    ELSE
        PRINT "Week ", week, ": SHORT by ", 100 − saving, " (", saving, ")"
    ENDIF
ENDFOR
PRINT "Total saved: ", total, " Rs"
PRINT "Weeks on target: ", onTarget

Solution explanation. This is Set C’s synthesis: FOR (known count)

• accumulators (two) + a decision per iteration + inside/after placement discipline. The trace table now has five columns and still catches the classics: forgetting total update (column freezes), boundary 100 (row 4 must say OK), and the SHORT arithmetic (40 = 100 − 60, printed from the derivation, never hand-typed). Note what the loop does NOT decide: nothing about earlier weeks is re-examined — each week is processed once, fully, and forgotten. That “process one item completely” mindset is what makes loops scale to 600 weeks or 6 million.

C++ solution.

// s14_savings.cpp — Set C · Scenario 14
// Compile: g++ -std=c++17 -Wall -Wextra s14_savings.cpp -o s14

#include <iostream>

int main() {
    int total = 0;
    int onTarget = 0;

    int week = 1;
    while (week <= 6) {
        int saving = 0;
        std::cout << "Week " << week << " saving: ";
        std::cin  >> saving;

        total = total + saving;

        if (saving >= 100) {
            std::cout << "Week " << week << ": OK (" << saving << ")\n";
            onTarget = onTarget + 1;
        } else {
            std::cout << "Week " << week << ": SHORT by "
                      << 100 - saving << " (" << saving << ")\n";
        }
        week = week + 1;
    }

    std::cout << "Total saved: " << total << " Rs\n";
    std::cout << "Weeks on target: " << onTarget << "\n";
    return 0;
}

Test cases.

Edge cases. Saving exactly 100 (boundary row), saving 0 (minimum — SHORT by 100), all-boundary and all-zero runs (accumulators at their extremes), 145 (does your “SHORT” arithmetic stay sane when the branch isn’t taken? It must never print for OK weeks).

Thinking questions — answered.

1. The counter is the multiplier: starts at 1, stops after 12 — both fixed by the requirement; only n comes from input. (A FOR 1..12.)
2. Before the loop: n (read once). Per iteration: multiplier (the counter itself — not a second variable!), product (n × multiplier, computed fresh each time).
3. Widest product: 144 (3 chars for n = 12). Padding to 2 breaks at 100+ for the product column — but for n ≤ 12 products reach 144, so the example’s 2-space alignment is only correct for products < 100… catch: for n = 12, 12 x 12 = 144 cannot fit the 2-char result column; the requirement says “like the example”, and the honest design is right-align to the widest for the chosen n, or accept the example’s minor raggedness at 12. Deciding this is the constraint analysis — document your choice in the write-up.
4. Trace (n = 7):

Suggested approach. FOR 1..12 over the multiplier; compute the product inside; print with the counter and the product; decide alignment by the constraint analysis in Q3 — simplest honest choice: print natural numbers with a single space, or right-align to 3 for guaranteed tidiness.

Pseudocode.

READ n
FOR multiplier FROM 1 TO 12 DO
    product ← n × multiplier
    PRINT n, " x ", multiplier, " = ", product
ENDFOR

Solution explanation. The table-generation pattern: the loop variable is one of the printed columns — no separate counter, no second loop. Note what the trace fixed before it became a bug: writing multiplier = multiplier + 1 and a FOR would double-advance (the FOR owns the counter); and the product is recomputed per iteration from the counter — never stored across iterations (it has no memory between rows). Compared with Set A’s straight-line scenarios, the only new skill is letting the loop variable do double duty as data — a small step in code, the normal way of thinking in every table/histogram/report task later (Unit 06, the Pattern & Table Studio, is exactly this scenario with shapes).

C++ solution.

// s15_table.cpp — Set C · Scenario 15
// Compile: g++ -std=c++17 -Wall -Wextra s15_table.cpp -o s15

#include <iostream>

int main() {
    int n = 0;
    std::cout << "Table of: ";
    std::cin  >> n;

    int multiplier = 1;
    while (multiplier <= 12) {
        int product = n * multiplier;     // fresh each row
        std::cout << n << " x " << multiplier << " = " << product << "\n";
        multiplier = multiplier + 1;
    }
    return 0;
}

Test cases.

Edge cases. n = 1 (every product equals the multiplier — a natural correctness check), n = 12 (the largest products, alignment stress), count the rows: exactly 12 — never 11 or 13.