Answering a "What Is Printed?" Question

This section works through one exam-style Java question in three steps and then uses Code Coach to check the answer.

How the Exam Asks About Code

The AP Computer Science A Exam has a multiple-choice section of 42 questions, each with four choices. Several sample questions in the College Board's course description begin with the words "Consider the following code segment." The question shows a few lines of Java and then asks, "What is printed as a result of executing this code segment?", followed by four possible answers. The course description names five computational thinking practices and gives each one an approximate weighting for the multiple-choice section. Practice 3, Analyze Code, has the highest weighting of the five, so reading code is a large part of what that section asks. Part B of this course's final exam uses the same format. Figure 1 shows the worked item below laid out the way it appears on paper.

1int score = 17;
2int bonus = score % 5;
3if (score + bonus > 20)
4{
5    System.out.println("high");
6}
7else
8{
9    System.out.println("low");
10}
11System.out.println(score + bonus);

The item asks what is printed, and its four choices are (A) `high` then `19`, (B) `low` then `19`, (C) `low` then `17`, and (D) `high` then `22`. A student who reads the choices first can pick one that looks right without checking it, so the routine below starts with the code.

Tracing the Code in a Table

Step 1 is a trace table, drawn on scratch paper, with one column for each variable and one column for output, which is the layout the course description suggests for tracing code, plus a column for the line number. The student fills one row for each line that runs, in the order the lines run, and leaves out the lines that are skipped.

Line   score   bonus   Output
1      17
2      17      2
3      17      2
9      17      2       low
11     17      2       19

Line 1 stores 17 in `score`, and line 2 stores 2 in `bonus`, because 17 divided by 5 is 3 with a remainder of 2, and the remainder operator keeps only the remainder. Storing the 2 is not output, because the 2 stays inside the program. Output is only what a print statement shows on the screen, so the Output column stays empty until a print statement runs.

Following the Condition and Checking Each Choice

Step 2 follows the path that the code takes, which depends on the condition on line 3, `score + bonus > 20`. The condition is the true-or-false expression in the parentheses after `if`. With the values in the table, the condition becomes 19 > 20, which is false. When the condition is false, the `else` block runs and the `if` block is skipped, so line 9 prints `low` and line 5 never runs. The print statements inside the braces are not the condition, because they are the code that the condition chooses between. The last line runs either way, because it sits after both blocks, so line 11 prints `19`.

Step 3 checks each choice against the table, starting with choices A and D, which print `high` and would need the condition to be true. Choice C prints 17, the value of `score` alone, which is the result of forgetting to add `bonus`. Choice D also adds 5, the number being divided by, instead of the remainder. Only choice B matches every row of the table, so B is the answer. Each wrong choice matches a real mistake, and checking all four choices can catch a mistake in the student's own table.

Code Coach as a Check After the Prediction

On the bench, Ask Code Coach opens only after a student checks an answer, so the student predicts first. A student who predicted B can then ask Code Coach what line 3 does. On October 19, 2026, that question was sent to Code Coach five times, with the code sent as numbered lines, the way the bench shows it. All five explanations were about line 3, the condition, and one of them said:

Line 3 checks if the sum of `score` and `bonus` is greater than 20.
- `score` is 17 (from line 1).
- `bonus` is `score % 5`, which is 17 % 5 = 2 (from line 2).
So, it checks if 17 + 2 > 20, which is false.

This explanation agrees with the trace table, because a false condition sends the code to the `else` block. Code Coach's explanation is still not a test, because it is generated text and not the program's real output. Agreeing with a table-mate is not a test either, because neither student has compared the prediction with what the program actually printed. The test is running the real code, with the prediction as the expected output, and comparing the two. Real Java printed `low` and then `19`, which matches choice B and agrees with Code Coach's explanation. On the exam there is no Code Coach and no Run button, so the trace table is the test that a student can run on paper.

Summary

A "What is printed?" question is answered in three steps: trace the code in a table, follow the condition to the block that runs, and check every choice against the table. A stored value is not output until a print statement shows it. Code Coach explained line 3 correctly in all five saved runs, but only running the real code and comparing it with the prediction is a test.

Sources: College Board, AP Computer Science A Course and Exam Description (2025); Oracle, The if-then and if-then-else Statements (n.d.); Oracle, Assignment, Arithmetic, and Unary Operators (n.d.); Code Coach README and captures, mistral-small-2603 (2026); class site source code, coach.tsx (2026); course passages for Oct 26, Nov 3 and Nov 4 (2026).