How to Solve AP CSA Free Response Questions: A Step-by-Step Strategy

By Tanner Crow — AP Computer Science Teacher & Tutor • 1,845+ Hours Tutored • 451 Five-Star Reviews

What the AP CSA FRQ Section Looks Like

The AP CSA exam dedicates the entire second section to four free-response questions. You get 90 minutes total, which works out to roughly 22 minutes per question. Each FRQ is scored on a rubric worth 9 points. The four question types you will encounter map to the 2025–2026 curriculum units:

Each question may have two or three parts labeled (a), (b), and sometimes (c). Parts are scored independently. A wrong answer in part (a) does not prevent you from earning full credit in part (b) if you use your part (a) method correctly in part (b), even if that method was incorrect.

Before You Read the Options: Predict First

This principle is not just for multiple-choice questions. It applies to free-response problems too. Before you write a single line of Java, you should already have a mental model of what a correct solution looks like. This is called answer prediction, and it is one of the most powerful habits you can build.

The same logic applies when reviewing answer choices on the multiple-choice section. Students who formulate their own answer before reading options are far less likely to be swayed by a convincing but wrong distractor. On the FRQ side, students who sketch a pseudocode plan before writing Java write cleaner, more complete solutions.

The 5-Step FRQ Framework

Full Worked Example: Applying the Framework

Let us apply all five steps to a representative FRQ prompt. This is an original practice problem modeled on the FRQ 3 (Array / ArrayList) style.

Step 1 — Read Actively

Underline: return type int (part a), void (part b), parameter threshold, parameter cutoff, "strictly greater than," "strictly less than," instance variable scores is an ArrayList.

Step 2 — Identify the Pattern

FRQ 3 / ArrayList. Part (a) is a counting pattern — traverse and accumulate. Part (b) is a removal pattern — traverse backwards or use an iterator to safely remove during traversal.

Step 3 — Predict the Plan

Part (a): Initialize a counter to 0. Loop through scores. If current score > threshold, increment counter. Return counter.

Part (b): Loop from the last index down to 0. If current score < cutoff, call scores.remove(i).

Step 4 — Write the Java

public int countAbove(int threshold) {
    int count = 0;                           // accumulator
    for (int score : scores) {              // for-each is safe here (no removal)
        if (score > threshold) {
            count++;
        }
    }
    return count;
}

public void removeBelow(int cutoff) {
    for (int i = scores.size() - 1; i >= 0; i--) {  // backwards traversal
        if (scores.get(i) < cutoff) {
            scores.remove(i);                          // index-based remove
        }
    }
}

Step 5 — Verify

Trace with scores = [85, 42, 91, 60, 38], threshold = 70, cutoff = 50:

How Rubric Points Are Awarded

The College Board rubric for FRQ 3 typically awards one point each for: correct loop structure, correct ArrayList access inside the loop, correct conditional, correct accumulator or modification, and correct return value. For a removal question, an additional point is awarded specifically for a traversal method that correctly handles index shifting. That is the backwards-traversal point, and it is one of the most commonly missed.

The 4 Most Costly FRQ Mistakes

After reviewing hundreds of student FRQ submissions — both in class and through AP CSA tutoring sessions — the same four errors appear on nearly every score report in the 5–7 range. Fixing just these four moves most students into the 8–9 range.

1. Not calling the provided methods. The question gives you helper methods for a reason. If you reimplement the logic manually instead of calling the provided method, you may still get the logic point but lose the method-call point. Read the class interface carefully and use what is given.

2. Writing code that only solves the example. The rubric tests general logic. Hard-coding values that work on the example input but fail on a general case gets zero credit for that rubric point.

3. Forgetting the return statement. This is the most common 8-out-of-9 mistake. A void method that accidentally has a return statement is a penalty. A non-void method missing its return statement misses the return-value rubric point. Always check.

4. Forwards traversal with ArrayList removal. Covered above. This costs the traversal correctness point, which is often worth 1–2 points on ArrayList removal questions.

public void removeAll(ArrayList<Integer> list, int target) {
    for (int i = 0; i < list.size(); i++) {    // Line 1
        if (list.get(i) == target) {            // Line 2
            list.remove(i);                     // Line 3
        }                                       // Line 4
    }
}

public int findMax() {
    int max = 0;
    for (int i = 0; i < data.length; i++) {
        if (data[i] > max) {
            max = data[i];
        }
    }
    return max;
}

public class Counter {
    private int value;

    public Counter(int value) {
        value = value;                   // intended to initialize instance variable
    }

    public int getValue() {
        return value;
    }
}