2025 AP CSA FRQ 3: Round Solution + Rubric

May 2026 exam uses a NEW point structure — tap for details

This page shows the original 2025 FRQ 3, which the College Board scored on a 9-point rubric. The May 2026 exam uses a NEW point distribution and structure — the patterns and traps on this page still apply, but expect different point values and formats on test day.

FRQ 1: 7 points (2 parts: Part A 4pts + Part B 3pts) — Methods & Control Structures

FRQ 2: 7 points (single part) — Class Design

FRQ 3: 5 points (single part) — Data Analysis with ArrayList

FRQ 4: 6 points (single part) — 2D Array

Total Section II: 25 points = 45% of exam score. Only Question 1 has two parts on the 2026 exam; Questions 2, 3, and 4 each have a single part.

Sources: Official College Board CED, Exam Overview (page 145) · Skylight Publishing CED Sample FR Solutions (page 161 reference)

2025 AP CSA FRQ 3: Round — Complete Solution & Rubric

Step-by-step solution to 2025 AP CSA FRQ 3 (Round) with the official 9-point rubric, common mistakes that cost points, and a built-in 22-minute practice timer. Written by an AP Computer Science teacher whose students earn 5s at more than 2x the national rate.

By Tanner Crow | AP CSA Teacher · 11+ years · 1,800+ verified tutoring hours (5.0 rating) | Last reviewed: April 2026
Year: 2025 Question: 3 of 4 Points: 9 Topics: ArrayList, Traversal Difficulty: Medium
Recommended pace: 22:00 per FRQ 22:00

The Official 2025 FRQ 3 Question

The complete prompt is in the PDF below. Use the recap above the editor to keep the key requirements in mind while you write your response.

The PDF cannot be embedded on this device.

Open Prompt PDF in New Tab
Open PDF in New Tab (Page 13) Jump to Code Editor ↓

Write Your Part A Response: Round (constructor)

Read the prompt above and write your responses in the editors below — Part A in the first, Part B in the second. The real AP exam in Bluebook gives you the prompt and separate response areas per part with no requirement summary or hints. Practice like that here. When you’re done with both parts, click Reveal Solution & Scoring Rubric below to compare your code against the official rubric.

Round (constructor).java Tab indents | Enter auto-indents | Brackets auto-close
Drag bottom-right corner to resize editor ⇲

Write Your Part B Response: buildMatches

buildMatches.java Tab indents | Enter auto-indents | Brackets auto-close
Drag bottom-right corner to resize editor ⇲
↑ Jump to PDF Prompt Open PDF in New Tab

Ready to self-grade? Compare your code against the official 9-point rubric below. AP FRQs are graded by trained human readers, so we don’t auto-score — you’ll learn more by checking your work against the rubric criteria yourself.

What the Prompt Was Asking

Before reading the solution, check whether your response covered each of these requirements:

Write: public Round(String[] names) — Part A; public ArrayList buildMatches() — Part B

Required behavior:

  • Part A: initialize the instance variable competitorList (drop the type declaration!), then loop through names array, building Competitor(name, rank) objects with ranks starting at 1 and adding each to competitorList.
  • Part B: declare AND initialize a local ArrayList with new. Use a two-pointer pattern — low index from the start, high index from the end of competitorList — building Match objects from both ends and adding them to the local list.
  • Part B even/odd handling: for an even-sized list, low starts at 0. For an odd-sized list, low starts at 1 (skip the top seed who gets a bye). Loop until low and high meet, then return the local matches list.

Sample Solution & Rubric

Verified solution coming soon. See the official College Board scoring guidelines for the complete solution and 9-point rubric. The prompt, common mistakes, and key insight on this page are still accurate — only the worked sample solution and per-point rubric breakdown are pending verification.
// Verified solution coming soon
//
// While we finalize this solution against the official
// 2025 College Board scoring guidelines, please refer to
// the primary source (linked above) for the complete worked
// solution and rubric breakdown.
//
// In the meantime, the prompt, common mistakes, sample
// solutions from past students, and the key insight below
// will help you understand what the question is testing
// and how to avoid the most common point losses.
//
// Last updated: April 27, 2026

Official 9-Point Scoring Rubric for Round

Pts Criterion
? Verified rubric coming soon. See official College Board scoring guidelines for the complete 9-point rubric breakdown for this FRQ.

Common Mistakes That Cost Points on FRQ 3

Mistake 1: Redeclaring competitorList as a local variable inside the constructor. Sample 3C in the official commentary lost Point 4 because writing ArrayList competitorList = new ArrayList<>(); shadows the instance variable. The constructor must INITIALIZE the existing instance variable. Drop the type from the left side: competitorList = new ArrayList();. The instance variable is provided by the class declaration; the constructor populates it, not redeclares it.
Mistake 2: Using i instead of i + 1 for the rank parameter. Sample 3B in the official commentary lost Point 2 because the response wrote new Competitor(names[i], i) instead of new Competitor(names[i], i + 1). The prompt explicitly says ranks start at 1, but the for loop variable i starts at 0. Either use i + 1 in the constructor call, or maintain a separate int rank = 1; counter that increments each iteration.
Mistake 3: Adding two competitors directly to the list without constructing a Match object. Sample 3A in the official commentary lost Point 8 because the response wrote games.add(competitorList.get(i), competitorList.get(...)) instead of games.add(new Match(competitorList.get(i), competitorList.get(...))). Match is an object — you must construct it with new Match(...) first, THEN add that single constructed Match object to the list.
Mistake 4: Off-by-one in the loop bound — using < where the correct bound needs <=. Sample 3A in the official commentary lost Point 9 because the loop terminated one iteration early, omitting the final pair of competitors. The two-pointer pattern needs to run until the indices meet, which requires either <= as the upper bound or a + 1 adjustment (canonical solution uses i < competitorList.size() / 2 + 1 for the odd case). Always trace your loop with size = 5 and size = 4 to verify the count.
Mistake 5: Including the first competitor (index 0) in the odd-size case. Sample 3B in the official commentary lost Point 9 because the loop started at index 0 in BOTH the even and odd cases. The prompt's bracket logic gives the top-seeded competitor a bye in odd-sized brackets — they don't play this round. So the odd case must start at index 1, leaving competitor 0 unmatched. Use either an if/else block or set low = 1 when competitorList.size() % 2 == 1.
Key Insight: The Round problem teaches the two-pointer pattern for pairing from both ends of a list — a recurring AP CSA pattern that shows up in tournament brackets, palindrome checks, and any 'match opposites' algorithm. The structure is always the same: maintain a low index counting up from the start and a high index counting down from the end, then loop while low < high (or low <= high depending on whether you want to include the middle pair). Adding a Match object inside that loop is straightforward; the failures happen at the BOUNDS — students either skip the middle pair (< when it should be <=) or include too many pairs (continuing past the meeting point). A second equally important insight specific to Class Writing FRQs: when the prompt provides instance variables, your constructor INITIALIZES them, not REDECLARES them. Writing ArrayList competitorList = ... inside the constructor creates a new local variable that shadows the instance variable, leaving the instance variable null forever. Drop the type declaration: just write competitorList = .... Variable shadowing through accidental re-declaration is one of the most-tested distinctions in AP CSA grading.

FAQs About 2025 AP CSA FRQ 3

What does 2025 AP CSA FRQ 3 Round test?

Round tests writing a constructor that converts a String[] into an ArrayList of Competitor objects with rank tracking, plus a buildMatches method that pairs competitors from both ends of the list with even/odd handling. The hardest single point is Point 9: the correct number of matches must be produced, with the first competitor skipped in the odd case. Sample 3A in the Chief Reader commentary lost this point for using < instead of <= in the loop bound.

How many points is FRQ 3 worth?

9 points, awarded across the rubric criteria. FRQ 3 makes up about 11% of the AP CSA exam score.

What is the most common mistake on 2025 FRQ 3 Round?

Redeclaring competitorList as a local variable inside the constructor. Sample 3C in the Chief Reader commentary lost Point 4 because writing ArrayList competitorList = new ArrayList<>(); creates a new local variable that shadows the instance variable provided in the class. The correct pattern drops the type declaration: competitorList = new ArrayList();. The constructor's job is to INITIALIZE the existing instance variable, not to declare a new one.

How long should I spend on FRQ 3?

Aim for 22 minutes per FRQ. The AP CSA free-response section is 90 minutes for 4 questions, so 22 minutes per question leaves a 2-minute buffer to review.

Is Round still relevant for the 2026 AP CSA exam?

Yes. The current AP CSA 4-unit curriculum still tests ArrayList traversal and modification, so Round is excellent practice for the 2026 exam format.

Where can I find the official scoring guidelines?

College Board publishes the official scoring guidelines as a PDF on AP Central. The rubric on this page mirrors those criteria. You can download the official scoring guidelines here.

Related AP CSA FRQs to Practice Next

If you found Round useful, work through these next to lock in the same Java concepts:

Why 2025 FRQ 3 Still Matters for the 2026 AP CSA Exam

The 2026 AP CSA curriculum reorganized the topic list into 4 units, but the FRQ types stayed the same. 2025 FRQ 3 (Round) tests ArrayList traversal and modification, which is still a core part of the exam. Practicing this question prepares you for the Bluebook digital test format and builds the muscle memory you need for the exam on Friday, May 15, 2026.

← Previous FRQ 2025 FRQ Index Next FRQ →
Every AP CSA FRQ since 2004 • Practice by topic instead of year • AP CSA exam prep hub

Get in Touch

Whether you're a student, parent, or teacher — I'd love to hear from you.

Just want free AP CS resources?

Enter your email below and check the subscribe box — no message needed. Students get daily practice questions and study tips. Teachers get curriculum resources and teaching strategies.

Typically responds within 24 hours
✓

Message Sent!

Thanks for reaching out. I'll get back to you within 24 hours.

🏫 Welcome, fellow educator!

I offer curriculum resources, practice materials, and study guides designed for AP CS teachers. Let me know what you're looking for — whether it's classroom materials, a guest speaker, or Teachers Pay Teachers resources.

✉

Email

tanner@apcsexamprep.com

📚

Courses

AP CSA, CSP, & Cybersecurity

⏱

Response Time

Within 24 hours

Prefer email? Reach me directly at tanner@apcsexamprep.com