2024 AP CSA FRQ 2: Scoreboard Solution + Rubric

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

This page shows the original 2024 FRQ 2, 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 2: Scoreboard — Complete Solution & Rubric

Step-by-step solution to 2024 AP CSA FRQ 2 (Scoreboard) 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: 2 of 4 Points: 9 Topics: Class Writing, Constructors Difficulty: Medium
Recommended pace: 22:00 per FRQ 22:00

The Official 2024 FRQ 2 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 7) Jump to Code Editor ↓

Write Your Scoreboard Class Response

Read the prompt above and write your response in the editor. The real AP exam in Bluebook gives you the prompt and a blank editor — no requirement summary, no hints. Practice like that here. When you’re done, click Reveal Solution & Scoring Rubric below to compare your code against the official rubric.

Scoreboard.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 class Scoreboard with constructor Scoreboard(String, String), method public void recordPlay(int) and method public String getScore()

Required behavior:

  • Class skeleton: public class Scoreboard, private instance variables for two team names (String), two scores (int), and an active-team indicator (int or boolean). Constructor initializes all of them — names from parameters, scores to 0, active team to a starting value.
  • recordPlay(int points): if points == 0, switch the active team to the other team. If points > 0, add points to the ACTIVE team's score variable. Don't switch teams on positive points; don't add points on zero.
  • getScore(): build and RETURN (don't print!) a String in the form 'score1-score2-activeTeamName'. Two literal hyphens between the three parts. Must be a return statement, not System.out.println.

How to Write the Scoreboard Class Step-by-Step

// Sample solution adapted from official scoring guidelines
// 2024 AP CSA FRQ 2: Scoreboard (class-write, worth 9 points)

public class Scoreboard {
    private String team1;
    private String team2;
    private int score1;
    private int score2;
    private String activeTeam;

    public Scoreboard(String name1, String name2) {
        team1 = name1;
        team2 = name2;
        score1 = 0;
        score2 = 0;
        activeTeam = team1;
    }

    public void recordPlay(int points) {
        if (activeTeam.equals(team1)) {
            if (points > 0) {
                score1 += points;
            } else {
                activeTeam = team2;
            }
        } else {
            if (points > 0) {
                score2 += points;
            } else {
                activeTeam = team1;
            }
        }
    }

    public String getScore() {
        return score1 + "-" + score2 + "-" + activeTeam;
    }
}

Official 9-Point Scoring Rubric for Scoreboard

Pts Criterion
+1 Class header public class Scoreboard (no parens)
+1 Private instance variables for both team names, both scores, and active team
+1 Constructor Scoreboard(String, String) stores team names
+1 Constructor initializes both scores to 0 and active team to team 1
+1 Method recordPlay(int points) branches on which team is active using .equals
+1 When points > 0, adds points to the active team's score
+1 When points == 0, switches the active team to the other team
+1 Method getScore() uses String concatenation
+1 Returns String formatted as score1-score2-activeTeamName

Common Mistakes That Cost Points on FRQ 2

Mistake 1: Constructor has a void return type. Sample 2A and 2B in the official commentary both lost Point 3 because their constructor headers were public void Scoreboard(...) instead of public Scoreboard(...). Constructors never have a return type, not even void. The class name alone is the constructor header pattern: public ClassName(parameters).
Mistake 2: Wrong return type on a method header. Sample 2B lost Point 4 because the getScore method had void return type instead of String. Sample 2C lost Point 4 because recordPlay had an incorrect return type. The two methods have specific return types: recordPlay is void (it modifies state), getScore returns String (it builds and returns a value). Mismatch on either loses Point 4.
Mistake 3: Printing the result instead of returning it. Sample 2A lost Point 9 because getScore prints the specified string to output rather than returning it. Sample 2B also printed instead of returning. The rubric explicitly states: 'build and return the specified string.' System.out.println is not a return — and ironically the rubric notes that the standard penalty for extraneous output is NOT applied here, so the only consequence is losing Point 9 directly.
Mistake 4: No active-team tracking variable. Sample 2B lost Point 7 and Point 8 because there was no active team designation — no instance variable to track which team is currently scoring. Without that variable, recordPlay can't decide which team's score to update, and getScore can't decide which name to append. The active team must be a separate instance variable (boolean isTeam1Active or int whoseTurn) that persists between method calls.
Mistake 5: Class header includes parentheses (record-style syntax). Sample 2C in the official commentary lost Point 1 because the class header contained parentheses, similar to Java record syntax. The class header is just public class Scoreboard. Parameters belong on the CONSTRUCTOR header, not the class header. Same mistake appeared on 2025 Q2 SignedText (Sample 2C) — students collapse class and constructor into a single line.
Key Insight: The Scoreboard problem teaches the full Class Writing FRQ pattern: class header without parentheses, private instance variables (including a state-tracker like 'active team'), constructor that initializes EVERY instance variable, methods with correct return types, and explicit return statements (not print) for accessor methods. The rubric awards 4 of 9 points for the SKELETON alone (Points 1-4: class header, private vars, constructor header + initialization, method headers). Students who write the skeleton first — public class X { private ... ; public X(...) { ... } public void recordX(...) { } public String getX() { } } — secure those structural points before touching the logic. A second insight: this problem requires a STATE VARIABLE that changes across method calls (the active team indicator). Class Writing FRQs with 'switch between modes' or 'track current state' behavior all need this pattern — declare an instance variable, initialize it in the constructor, mutate it in the methods that change state, read it in the methods that depend on state. Sample 2B lost 5 points across 7, 8, and 9 by omitting this single variable. The Scoreboard pattern (state instance variable + condition-driven mutation) recurs in 2018 CodeWordChecker, 2021 CombinedTable, and 2023 Sign.

FAQs About 2024 AP CSA FRQ 2

What does 2024 AP CSA FRQ 2 Scoreboard test?

Scoreboard tests writing a complete class with private String instance variables for team names, an int instance variable to track the active team, score variables, a constructor that initializes them all, a recordPlay method that adds points or switches teams based on a zero check, and a getScore method that returns a hyphenated String including both scores and the active team name. The hardest single point is Point 9: getScore must RETURN the formatted String — printing it loses the point.

How many points is FRQ 2 worth?

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

What is the most common mistake on 2024 FRQ 2 Scoreboard?

The constructor having a void return type. Sample 2A and Sample 2B in the official commentary both lost Point 3 because they wrote public void Scoreboard(String t1, String t2) instead of public Scoreboard(String t1, String t2). Constructors don't have return types — not even void. Adding void converts a constructor into a method that happens to share the class name, which the rubric explicitly rejects.

How long should I spend on FRQ 2?

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

Yes. The current AP CSA 4-unit curriculum still tests complete class writing with constructors and instance variables, so Scoreboard 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 Scoreboard useful, work through these next to lock in the same Java concepts:

Why 2024 FRQ 2 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 2 (Scoreboard) tests complete class writing with constructors and instance variables, 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]