AP CS A FRQ Tips: How to Maximize Your Score

The Free Response Questions (FRQs) make up 50% of your AP Computer Science A score. That's 4 questions in 90 minutes, each worth 9 points. Unlike multiple choice, there's no guessing here: you need to write actual Java code. But the scoring rubric rewards specific, predictable things, and once you understand what AP Readers are looking for, you can consistently pick up points that other students miss.

I've scored thousands of FRQ responses as a College Board AP Reader. Here's what I've learned about how students earn (and lose) points.

Understanding the FRQ Format

Each year, the four FRQs follow a predictable pattern. Knowing the question types in advance lets you practice strategically:

Each question usually has 2 to 3 parts (labeled a, b, c), and later parts often build on earlier ones.

How FRQs Are Actually Scored

Each FRQ is worth 9 points, but the points are not awarded for "getting the right answer." Instead, the rubric breaks the solution into individual scoring criteria. A typical part might be scored like this:

• +1 for correctly iterating over the array
• +1 for the correct conditional check
• +1 for correctly accumulating or returning the result

This means you can earn points for parts of your solution even if the whole thing doesn't work perfectly. A student who writes a method with the correct loop structure but a small logic error in the conditional might earn 2 out of 3 points. A student who leaves the question blank earns 0.

The takeaway: always write something. A partially correct solution almost always earns more than a blank one.

Strategy 1: Read the Entire Problem Before Writing

Before writing a single line of code, read all parts of the FRQ. This matters for two reasons:

1. Later parts give context for earlier parts. Part (c) might reveal that the method you wrote in part (a) is supposed to handle empty arrays, something you wouldn't have considered otherwise.
2. You can identify which parts are easiest. Sometimes part (b) is straightforward while part (a) is tricky. Knowing this upfront helps you budget your time.

Spend about 2 minutes reading the full question. Underline key verbs ("return," "modify," "create a new") and note the method signatures.

Strategy 2: Use the Provided Methods

FRQ problems frequently provide helper methods, accessor methods, or tell you that certain methods exist in a class. You must use them.

For example, if the problem description says:

/** Returns the number of items in the inventory. */
public int getCount()

/** Returns the item at the given index. */
public Item getItem(int index)

Then use getCount() and getItem(i) in your solution, even if you could access the underlying array directly. AP Readers specifically check for this. Reimplementing provided functionality will not earn you the points allocated for using those methods, and it introduces opportunities for bugs.

Strategy 3: Write the Method Signature First

The method signature is given to you in the problem. Copy it exactly, then fill in the body. This guarantees you don't lose points for a wrong return type, wrong method name, or wrong parameter list.

// The problem gives you:
// public ArrayList<String> removeDuplicates(ArrayList<String> list)

// Step 1: Write the signature
public ArrayList<String> removeDuplicates(ArrayList<String> list) {

    // Step 2: Declare any variables you'll need
    ArrayList<String> result = new ArrayList<String>();

    // Step 3: Write the core logic
    for (int i = 0; i < list.size(); i++) {
        if (!result.contains(list.get(i))) {
            result.add(list.get(i));
        }
    }

    // Step 4: Return the result
    return result;
}

Following this structure keeps your code organized and makes it easier for Readers to find the scoring criteria in your solution.

Strategy 4: Know the Standard Patterns

Most FRQ solutions use one of a small number of common patterns. Practicing these until they're automatic will save you significant time on the exam:

Traversal with accumulator

int count = 0;
for (int i = 0; i < arr.length; i++) {
    if (/* condition */) {
        count++;
    }
}
return count;

Search and return

for (int i = 0; i < arr.length; i++) {
    if (/* found it */) {
        return i;  // or return arr[i]
    }
}
return -1;  // not found

Build a new list from an existing one

ArrayList<String> result = new ArrayList<String>();
for (int i = 0; i < list.size(); i++) {
    if (/* keep this element */) {
        result.add(list.get(i));
    }
}
return result;

Remove elements from an ArrayList

for (int i = list.size() - 1; i >= 0; i--) {
    if (/* should remove */) {
        list.remove(i);
    }
}

2D array traversal

for (int row = 0; row < grid.length; row++) {
    for (int col = 0; col < grid[row].length; col++) {
        // process grid[row][col]
    }
}

If you can write all five of these patterns from memory without hesitation, you're well prepared for the FRQ section.

Strategy 5: Assume Earlier Parts Work

This is one of the most important rules on the AP CS A exam, and many students don't know it: if part (b) asks you to call the method from part (a), you will earn full credit on part (b) even if your part (a) is wrong, as long as your part (b) logic is correct.

In other words, the parts are graded independently. So if you're stuck on part (a), write your best attempt, move to part (b), and use the method from part (a) as if it works perfectly. Don't skip part (b) because you're unsure about part (a).

Strategy 6: Handle Edge Cases Explicitly

AP Readers test your solution against edge cases. The most common ones to watch for:

• Empty array or list: if arr.length == 0, does your method return the correct value without crashing?
• Single element: does your logic work when there's only one item?
• All elements meet the condition: if you're filtering, what happens when every element passes (or none do)?
• First or last element is special: if you're comparing adjacent elements, make sure you don't go out of bounds.

After writing your solution, quickly trace through it with an empty input and an input of size 1. This takes under a minute and can save you 1 to 2 points.

Strategy 7: Don't Erase; Cross Out

If you're writing on paper and you change your mind about a solution, draw a single line through the old code. Don't erase it completely.

Here's why: AP Readers will grade whichever version is more complete. If you erase your first attempt and don't finish the rewrite, you get 0 for that part. If you cross it out and the rewrite is incomplete, Readers can still grade the crossed-out version and give you partial credit.

Strategy 8: Manage Your Time

You have 90 minutes for 4 questions. Here's a time budget that works:

FRQ 2 (Class Design) gets extra time because you need to write instance variables, a constructor, and multiple methods. Adjust based on your strengths, but never spend more than 25 minutes on any single question. A partial answer on all four questions will almost always outscore a perfect answer on two and blanks on the other two.

Strategy 9: Write Clean, Readable Code

AP Readers grade hundreds of exams. Clean code is easier to follow, which means Readers are more likely to find (and give you credit for) the correct parts of your solution.

• Use meaningful variable names: row, col, index, count instead of x, a, b
• Use consistent indentation so loop bodies are clear
• Don't write overly clever one-liners; straightforward code is easier to grade and less likely to contain bugs
• You don't need comments, but if your approach is unusual, a brief note can help the Reader understand your intent

Strategy 10: Practice with Real FRQs

The best way to prepare for FRQs is to practice with actual past exam questions. The College Board publishes every FRQ from previous years along with scoring guidelines and sample responses.

Here's how to practice effectively:

1. Time yourself. Write your solution in 20 minutes, on paper if possible. The real exam doesn't have a compiler, so you need to practice writing syntactically correct code without one.
2. Score yourself using the rubric. The College Board's scoring guidelines show exactly which points are awarded for which criteria. Compare your solution line by line.
3. Review the sample responses. The published "9/9" sample responses show what a perfect answer looks like. Study them for patterns you can reuse.

Aim to complete at least 8 to 10 full FRQs before exam day (2 to 3 of each type).

Want Expert Feedback on Your FRQs?

In ExamReadyUSA's 4-week AP CS A Crash Course, students write FRQ-style homework every week and receive personal written feedback graded against the AP rubric. Groups are capped at 5 students, and every session is taught by Namrata Poladia, a College Board AP Reader who scores real AP exams.