2024 AP CSA FRQ 3: WordChecker Solution + Rubric

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

This page shows the original 2024 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)

2024 AP CSA FRQ 3: WordChecker — Complete Solution & Rubric

Step-by-step solution to 2024 AP CSA FRQ 3 (WordChecker) 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: 2024 Question: 3 of 4 Points: 9 Topics: ArrayList, Traversal Difficulty: Medium
Recommended pace: 22:00 per FRQ 22:00

The Official 2024 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: isWordChain

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.

isWordChain.java Tab indents | Enter auto-indents | Brackets auto-close
Drag bottom-right corner to resize editor ⇲

Write Your Part B Response: createList

createList.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 boolean isWordChain() — Part A; public ArrayList createList(String target) — Part B

Required behavior:

  • Part A isWordChain: loop from index 1 to wordList.size() - 1 (you need pairs, so start at 1). For each pair, check if the current word CONTAINS the previous word using indexOf(previous) != -1. Return false on first invalid pair, true after all pairs pass.
  • Part B createList: declare AND construct a new ArrayList with new ArrayList(). Loop through wordList. For each word, check if it starts with target — best done with indexOf(target) == 0 (no length guard needed).
  • Part B return logic: when a word starts with target, create a NEW string with target removed from the front using current.substring(target.length()), add the new string to your result list. Don't modify wordList. Return only the constructed list of revised strings.

How to Write the WordChecker Methods Step-by-Step

// Sample solution adapted from official scoring guidelines
// 2024 AP CSA FRQ 3: WordChecker (worth 9 points)

public boolean isWordChain() {
    for (int i = 0; i < wordList.size() - 1; i++) {
        String current = wordList.get(i);
        String next = wordList.get(i + 1);
        // The next word must contain the current word as a substring
        if (next.indexOf(current) == -1) {
            return false;
        }
    }
    return true;
}

public ArrayList createList(String target) {
    ArrayList result = new ArrayList();
    for (int i = 0; i < wordList.size(); i++) {
        String word = wordList.get(i);
        if (word.indexOf(target) != -1) {
            result.add(word);
        }
    }
    return result;
}

Official 9-Point Scoring Rubric for WordChecker

Pts Criterion
+1 Loops through pairs of consecutive words (index 0 to size-2)
+1 Calls wordList.get(i) to access elements
+1 Uses indexOf to test if next word contains current word
+1 Returns false on first failure, true if loop completes (algorithm, Part A)
+1 Initializes a new local ArrayList to hold results
+1 Loops through every word in wordList
+1 Tests whether each word contains target as a substring
+1 Adds qualifying words to the result list using .add
+1 Returns the result list (instance variable left unchanged, algorithm)

Common Mistakes That Cost Points on FRQ 3

Mistake 1: Calling substring without guarding against a word shorter than target. Sample 3A in the official commentary lost Point 6 because substring(0, target.length()) throws IndexOutOfBoundsException when a wordList element is shorter than target. The simplest fix is to use indexOf(target) == 0 — this works for ANY length without a guard. If you must use substring, write: current.length() >= target.length() && current.substring(0, target.length()).equals(target).
Mistake 2: Using array syntax (square brackets) instead of ArrayList syntax (.get and .size()). Sample 3B in the official commentary lost Points 1 and 5 because it wrote wordList[x] instead of wordList.get(x). Even though there's a 'no penalty' rule for [] vs () confusion in some cases, this rubric explicitly assesses ArrayList access in Points 1 and 5 — so the standard penalty exception does NOT apply. ArrayList is NOT an array; it requires .get(i) and .size() (with parentheses), not [i] and .length.
Mistake 3: Off-by-one in the loop bound — using < wordList.size() - 1 when comparing pairs. Sample 3C in the official commentary lost Point 1 because the loop condition i < wordList.size() - 1 means i never reaches the last index, skipping the final pair. The correct bound for accessing pairs (i, i-1) starting at i=1 is i < wordList.size(). The pattern: when you need indices [1, size-1], use i = 1 with i < size, NOT size - 1.
Mistake 4: Returning the assigned boolean instead of returning false on first failure. Sample 3B in the official commentary lost Point 3 because 'the boolean ans is assigned its value based on only the last iteration of the loop before it is returned.' This anti-pattern (track in a variable, return at end) gets overwritten by every iteration and ends up reflecting only the last pair. The correct pattern: return false IMMEDIATELY on first invalid pair, return true after the loop completes.
Mistake 5: Constructing the substring with the wrong starting index. Sample 3C in the official commentary lost Point 7 because the substring parameter was target.length() + 1 instead of target.length(). substring(target.length()) returns everything from index target.length() to the end — exactly the part AFTER target. Adding +1 skips the first character of the remainder. This is the same off-by-one pattern that appeared on 2025 Q2 SignedText (substring(s+1) vs substring(s)).
Key Insight: WordChecker teaches two recurring AP CSA ArrayList patterns: (1) the ADJACENT-PAIR traversal (loop from i=1, compare element i with element i-1), and (2) the FILTER-AND-TRANSFORM pattern where you build a NEW ArrayList from elements of an original (without modifying the original). The exam-day trap that costs the most points is Part B Point 6: substring is unsafe when the source string might be shorter than the substring bounds. The simplest defense is to use indexOf(target) == 0 — it returns -1 (or a non-zero value) gracefully for any short string, no exception, no guard needed. Reach for indexOf BEFORE substring whenever you're checking 'starts with' or 'contains.' A second insight specific to ArrayList access: the rubric explicitly assesses .get(i) usage in Points 1 and 5, which means [] vs () confusion (normally a no-penalty error) DOES cost points here. Sample 3B lost Points 1 and 5 by writing wordList[x] instead of wordList.get(x). On any FRQ involving ArrayList, internalize the syntax: .get(i), .set(i, val), .add(val), .add(i, val), .remove(i), .size() — all with parentheses, none with square brackets.

FAQs About 2024 AP CSA FRQ 3

What does 2024 AP CSA FRQ 3 WordChecker test?

WordChecker tests two ArrayList methods: isWordChain checks whether each element contains the previous element (using indexOf), and createList builds a NEW ArrayList containing modified copies of words that start with a target string (the original wordList must NOT be modified). The hardest single point is Point 6: the substring call must be guarded against words shorter than target — Sample 3A lost this point for an unguarded substring that throws IndexOutOfBoundsException.

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 2024 FRQ 3 WordChecker?

Calling substring without guarding against a word shorter than target. Sample 3A in the official commentary lost Point 6 because substring(0, target.length()) throws IndexOutOfBoundsException when an element is shorter than target. The fix is to use indexOf(target) == 0 (works for any length) instead of substring-and-equals, OR add an explicit length check: current.length() >= target.length() && current.substring(0, target.length()).equals(target).

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 WordChecker still relevant for the 2026 AP CSA exam?

Yes. The current AP CSA 4-unit curriculum still tests ArrayList traversal and modification, so WordChecker 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 WordChecker useful, work through these next to lock in the same Java concepts:

Why 2024 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. 2024 FRQ 3 (WordChecker) 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 2024 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

[email protected]

📚

Courses

AP CSA, CSP, & Cybersecurity

⏱

Response Time

Within 24 hours

Prefer email? Reach me directly at [email protected]