Free forever Calculate score
AP Computer Science A · Free response

AP Computer Science A FRQ: how to write the free-response code.

The AP Computer Science A FRQ section is 45% of your exam score, and it is the real test of the course: four questions where you write working Java by hand. Most of the marks are won and lost on things that have nothing to do with clever code.

Written by Mahmudul HasanUpdated September 2026Part of the AP FRQ guides

What the AP CSA free response looks like

Section II is four free-response questions in 90 minutes, worth 45% of your score, and every one asks you to write Java code to a specification. You type your answers in Bluebook, and the Java Quick Reference — the list of accessible library methods — is available the whole time, so the challenge is writing correct logic, not memorizing method names.

The four questions cover the course’s core skills: writing methods with control structures, designing a class, working with an ArrayList, and traversing a 2D array. They are independent. Each has its own scenario and its own classes, so a bad start on Q1 costs you nothing on Q4. Every question is multi-part, and the parts are scored separately.

In College Board’s own framing, set out in the Course and Exam Description, all four assess the same skill, Computational Thinking Practice 2: Develop Code, which is why the rubric rewards working logic over elegant style.

The four free-response questions

#Question typeWhat you writeWhere the point goes missing
Q1Methods and Control StructuresTwo methods, or a constructor and a method, using conditionals, loops and method calls to meet a specification. Part B reliably involves String methods.Know substring, indexOf, length and equals cold.
Q2Class DesignA whole class built from a specification: the class header, its instance variables, a constructor, and the methods it must expose.The class header earns its own point. Students forget it.
Q3Data Analysis with ArrayListOne method that creates, traverses and manipulates the elements of an ArrayList.Removing while iterating forward skips elements.
Q42D ArrayOne method that uses, analyses and manipulates data held in a 2D array.Row index first, then column. Swapping them is the classic slip.

How the AP Computer Science A FRQ is scored

Each question is scored point by point against College Board’s published rubric. A correct method header, the right loop or conditional, correct array or ArrayList traversal, and the correct return value each earn their own point.

The grader cares about what your code does, not its style. Partial credit is given for the parts you get right, so a method that is mostly correct still scores well. A minor syntax error is often forgiven when your intent is clear, but logic errors cost points: an off-by-one loop, a wrong bound, a missing return.

Here is what that looks like on a made-up Q1-style task. The specification asks for a method that counts how many scores in an array are above a cutoff.

public int countAbove(int[] scores, int cutoff) {   // 1 — header matches the spec
    int count = 0;
    for (int i = 0; i < scores.length; i++) {     // 2 — correct loop bounds
        if (scores[i] > cutoff) {                 // 3 — correct conditional
            count++;
        }
    }
    return count;                                   // 4 — correct return value
}
  1. The method header matches the specification exactly — return type, name, parameters.
  2. The loop bounds start at 0 and stop at scores.length.
  3. The conditional compares the right way round.
  4. The return value is the count, returned once, outside the loop.

Four points, four separate things. A student who writes the header and the loop but gets the comparison backwards still banks two of them, which is why you write every part even when you are unsure.

Where students lose the most points

Going off by one on a loop bound
Getting the start or end index wrong is the most common way to miss array points.
Not matching the method signature
Match the return type and the parameters in the specification exactly.
Reaching past the class’s public methods
Use the public methods you are given instead of accessing private data directly.
Mixing up 2D array indices
Traverse rows and columns carefully; swapping the two is an easy slip.
Leaving a part blank
Each part carries points, so attempt them all, even partially.

How to practice the AP CSA FRQ

Write code by hand, away from a compiler, because that is the test condition. Work College Board’s official past exam questions under a timer, then grade yourself against the published scoring guidelines. That is how you learn where the points live.

Get comfortable with the methods on the Java Quick Reference too, so you reach for them without thinking.

The Progress Check walkthroughs are the closest thing to FRQ practice on this site, with the same reasoning at smaller scope. Once a timed attempt gives you a raw score, the AP CSA score calculator turns it into a 1–5, and the full AP Computer Science A review guide covers how the free response fits with the multiple choice.

The rubric-first habit carries across subjects. The AP Lang rhetorical analysis essay is marked the same way: point by point, against stated criteria, with nothing awarded for polish.

Frequently asked questions

Quick answers to the questions students actually ask.

How many free-response questions are on AP Computer Science A?

Four, in 90 minutes, worth 45% of your score. Each one asks you to write Java: methods and control structures, class design, an ArrayList question, and a 2D array question.

Do you write real code on the AP CSA free response?

Yes. You write working Java by hand in Bluebook — methods, classes, and code that traverses and manipulates arrays and ArrayLists.

Is the Java Quick Reference available on the AP CSA FRQ?

Yes. The Java Quick Reference, which lists the accessible library methods, is provided in Bluebook, so you do not have to memorize method signatures.

How is the AP Computer Science A FRQ scored?

Each question is scored point by point against College Board’s rubric, which rewards specific code components — correct headers, logic, traversal, and return values — with partial credit for correct pieces.

How do I earn full marks on the AP CSA FRQ?

Match the method signatures exactly, watch loop bounds and off-by-one errors, use the class’s public methods, and write clear, correct Java — the rubric rewards what your code does.

Related

Keep going.

Scroll to Top