Multiple-Choice Questions (MCQ)

Overview

The AP CSA multiple-choice section gives you 42 questions in 90 minutes and counts for 55% of your AP Computer Science A exam score. Every question has 4 answer choices, the exam is fully digital, and you get the Java Quick Reference, a sheet listing the Java library methods that may appear on the exam. The other 45% comes from four free-response questions in Section II.

This section is mostly a code-reading test. The heaviest emphasis falls on analyzing code (37-53% of questions), which means roughly half the section asks you to trace existing code and predict what it does. Another big chunk (22-38%) tests whether you can develop code, like completing a partially written method or picking the code segment that solves a problem. If you can trace loops, predict output, and spot common Java bugs in answer choices, you're set up to do well here.

AP CSA MCQ Format: What to Expect

Section I is 42 discrete and set-based multiple-choice questions in 90 minutes, worth 55% of your exam score. That works out to a little over 2 minutes per question.

All four units of the course show up, but not equally:

Read that table carefully. Data Collections (arrays, ArrayLists, 2D arrays) plus Selection and Iteration (conditionals and loops) together make up more than half the section. Class Creation is the smallest slice. So if you're prioritizing review time, loops and data structures should get the most reps. One more thing worth knowing: inheritance and polymorphism are no longer part of the course, so you won't see them tested.

The section also spreads across five computational thinking practices, with Analyze Code (37-53%) and Develop Code (22-38%) carrying most of the weight. Document Code lands at 10-15%, while Design Code and Use Computers Responsibly each sit at 2-10%.

About that Java Quick Reference: it handles method signatures so you don't have to. If you blank on whether it's substring(int, int) or something else, check the sheet. Think about what you need ("get part of a string", "find the size of a list"), then look it up instead of guessing from memory.

How to Approach the AP CSA Multiple-Choice Section

Treat the section as 42 small code-reading tasks. For each one, identify what's being asked, trace only the code that matters, and use the answer choices to check for common Java errors.

Step 1: Categorize before you compute

When you see a code segment (and you'll see lots of them), resist the urge to start crunching values immediately. First figure out what kind of question it is. Output question? Trace line by line. "What is the value of x" question? Update x at every assignment and ignore everything else. Loop question? Check the starting value, the stopping condition, and the update step before you calculate anything. This 5-second categorization shapes your whole approach.

Step 2: Trace on paper, not in your head

Nested loops and changing variables are genuinely hard to track mentally. Write a quick table with variable names as columns and update the values as you go. For string questions, write the string out with the index under each character. This feels slow, but it prevents a small slip from poisoning the entire question.

Step 3: Eliminate before you solve

You can often knock out 2-3 of the 4 choices without fully solving the problem. Eliminate impossible states first. An array index below 0 or at array.length or beyond would throw an ArrayIndexOutOfBoundsException, not produce output. A "random" value outside the possible range can't happen. Then type-check: if a method returns an int, eliminate any choice with a decimal. If a method is void, eliminate any choice that suggests it returns a value.

Step 4: Manage the clock with a checkpoint

Aim to be at question 20 by the 40-minute mark. That builds a small buffer, because the middle of the section is where the nested loops, multi-class scenarios, and "what does this convoluted code output" questions tend to live. If you're at question 15 at 40 minutes, pick up the pace. If any single question eats more than 3 minutes, mark it and move on. Every question is worth the same, so don't let one tough trace cost you three easy points. Around question 30, fatigue is real. If the code segments start blurring together, take a five-second reset, then re-read the question fresh.

Worked Examples: Two Classic AP CSA MCQ Traps

These two questions come from the official sample set, and they show exactly how wrong answers get built.

Integer division and casting. Consider this code segment:

</>Java
double q = 15.0;
int r = 2;
double x = (int) (q / r);
double y = q / r;
System.out.println(x + " " + y);

Trace it carefully. q / r is 15.0 / 2, which is 7.5 (double division, because q is a double). For x, the cast (int) truncates 7.5 down to 7, and storing 7 in a double makes it 7.0. For y, no cast happens, so y is 7.5. The output is 7.0 7.5. Notice the answer choices: every combination of 7.0 and 7.5 appears. Each wrong choice represents one specific mistake, like forgetting the cast truncates, or applying truncation to both variables. That's how this section works. The wrong answers aren't random; they're the answers you'd get by making one predictable error.

Watch where the cast sits, too. (int)(15.0 / 2) is 7, but (int)15.0 / 2 casts first and then divides, giving 7.5 when the other operand is a double. Parentheses change everything.

Substring indices. Consider this code segment:

</>Java
String str1 = "LMNOP";
String str2 = str1.substring(3);
str2 += str1.substring(2, 3);

Write the string with indices: L=0, M=1, N=2, O=3, P=4. substring(3) starts at index 3 and runs to the end, so str2 is "OP". substring(2, 3) includes index 2 but excludes index 3, so it's just "N". After concatenation, str2 is "OPN". The rule to burn in: substring(a, b) includes the character at index a, excludes the character at index b, and always has length b - a. Wrong answers on substring questions usually show the right letters pulled from the wrong positions, which is exactly why the write-out-the-indices habit pays off.

Recurring Question Patterns

The same handful of patterns shows up year after year, because the same Java bugs trip people up year after year.

2D arrays and row-major order. Expect questions on accessing an element, counting elements that meet a condition, or processing a row or column. The classic trap answer swaps rows and columns. In array[i][j], i is the row and j is the column. Math coordinates put the horizontal value first, but Java 2D arrays put the row first, and the test knows you might mix those up. Double-check every 2D access. (This skill also drives an entire free-response question, covered in the FRQ 4 2D Array guide.)

Array vs. ArrayList syntax. There's reliably at least one question that hinges on keeping these straight. Arrays use .length with no parentheses and square brackets for access. ArrayLists use .size(), .get(), and .set(). A choice that calls .length() on an array or uses brackets on an ArrayList is wrong on syntax alone, which makes it a free elimination.

"Which code segment will..." questions. When 3-4 options look frustratingly similar, expect this lineup: one has a subtle syntax error (like = instead of ==), one has reversed logic, one is off by one, and one is correct. Start with the syntax error, since it's usually the fastest to spot.

Enhanced for loop limits. The for-each loop can't modify the array structure, can't access indices, and can't traverse two collections at once. When a question uses an enhanced for loop, first check whether any answer choice quietly assumes one of those impossible abilities.

Short-circuit evaluation. In (x != 0 && y / x > 2), if x is 0, the second part never evaluates, so no divide-by-zero error occurs. Questions often include "runtime error" as a tempting choice exactly when short-circuiting prevents one.

Method calls on objects. Constructor and object questions test whether you match the constructor's signature. If a class has only a constructor taking (String, int), then new Date("September", "5th") fails (wrong types), new Date() fails (no such constructor), and accessing private instance variables from another class fails. Only the call that matches the declared signature works.

Common Mistakes

• Computing before reading the question. You waste time tracing the whole segment when the question only asks about one variable. Fix: identify the question type first, then trace only what matters.
• Trusting mental math on nested loops. Tracking two loop variables and an accumulator in your head invites errors. Fix: jot a quick variable table and update it line by line.
• Forgetting that integer division truncates. 7 / 2 is 3, not 3.5 and not 4, and (int)(7.9) is 7. Fix: any time you see division, check the operand types before computing.
• Swapping rows and columns in 2D arrays. Treating i as the horizontal coordinate flips your answer. Fix: say "row, then column" to yourself on every array[i][j] access.
• Burning 5 minutes on one brutal question. Each question is worth the same, and the later ones still need your attention. Fix: at the 3-minute mark, mark it, move on, and come back with leftover time.
• Reviewing practice questions by only checking the answer key. Knowing you missed #14 doesn't prevent the same miss next time. Fix: for every wrong answer, name the Java rule you misapplied or the edge case you skipped.

Practice and Next Steps

The fastest way to improve at the AP CSA MCQ is high-volume tracing practice with honest review. Work through guided MCQ practice questions and, for every miss, write down which trap got you (off-by-one, truncation, swapped indices). You'll start recognizing the wrong-answer patterns before you even finish tracing.

Once your accuracy is solid, simulate the real thing with a full-length AP CSA practice exam at exam pace, and pull real questions from past AP CSA exams to see how the patterns repeat. Since this section is 55% of your score, plug your practice results into the AP CSA score calculator to see where you stand. And don't neglect the other 45%: the strategy guides for FRQ 1 Methods and Control Structures and FRQ 3 Data Analysis with ArrayList cover the writing side of the same skills you're tracing here.