AP Computer Science A Free Response QuestionsFRQ Archive and Java Coding Practice (2019 to 2025)

What do AP Computer Science A FRQs test?

Writing syntactically correct Java code that solves a specified problem, not describing or explaining what code does.

The free response section accounts for half of the AP Computer Science A score, and every one of its four questions requires you to produce working Java code from scratch. Where the multiple choice section tests reading and tracing code that someone else wrote, the FRQs test whether you can write your own. Each question provides a class context, a method signature, a written description of what the method must do, and sometimes helper methods you are permitted to call. Your job is to implement the body of the method correctly and without syntax errors that obscure intent. College Board's scoring guidelines award rubric points for specific behaviors: initializing variables correctly, writing loop bounds that cover all elements, returning the right type and value, and handling edge cases. A response that implements the right algorithm in the wrong Java syntax earns most of the points it would have earned, but a response that demonstrates no understanding of the required operation earns none of them. Per the AP Computer Science A Course and Exam Description published by College Board, the exam assesses all five Computational Thinking Practices, with Code Implementation (CTP 3) assessed directly on every FRQ.

The 4 AP Computer Science A FRQ types

Four distinct question types, each targeting a specific Java skill cluster, each worth approximately 9 points.

Unlike AP exams where FRQ types overlap, AP CS A assigns each of its four questions to a fixed skill category. The order in which the types appear on a given year's exam changes, but the four categories are stable across administrations. Per the AP CS A Course and Exam Description, every question requires students to write syntactically correct Java code. A Java Quick Reference sheet listing key method signatures is provided during the exam.

How are AP Computer Science A FRQs scored?

Analytic point rubrics that award credit for each correct Java operation, not for the overall solution.

Each of the four FRQs has a College Board scoring guideline that breaks the question into discrete rubric points, typically 9 points per question for a 36 point section total. Trained College Board Readers score each response by checking whether each rubric point is met. A rubric point might require: the loop runs from index 0 to the correct upper bound, the condition correctly identifies the target elements, the return statement returns the right variable of the right type, or the constructor initializes all instance variables. The key consequence is that partial credit accumulates point by point. A response that implements the correct algorithm with an off by one error in the loop bound earns every rubric point except the loop bounds point, which might be only one of nine. A response that writes a return statement returning a local variable of the wrong type loses only the return type point, not the entire question. There is no penalty for an incorrect attempt, so a response that writes some code earns more than a blank page. Per the AP CS A scoring guidelines, responses are scored holistically for clarity: when a syntax error would prevent compilation but the intent is clear, Readers use their judgment about whether the underlying operation was correct. However, errors that obscure what the student was attempting do not earn the points for the operations they obscure.

Worked example: how a real AP Computer Science A FRQ was scored

Class Design FRQ from a recent administration. Max score 9, among the lowest mean scores of the four FRQ types.

The Class Design FRQ asks students to write a complete Java class from a written specification, including instance variables, a constructor, and multiple methods. This type is instructive for understanding how rubric points are allocated because each structural element of the class is a separate scorable unit. The rubric example below is grounded in the stable rubric patterns documented across AP CS A Class Design questions in Chief Reader Reports from 2019 through 2022, which show consistent point loss on the same structural elements year after year. Each part pairs the rubric requirement with a response that earns the point and one that does not.

1. Declare private instance variables appropriate to the class specification

   Rubric: Point earned when the response declares one or more private instance variables with the correct data type that match what the constructor parameters and methods require. The variables must be declared at the class level, not inside the constructor body.

   Earns the point: Declaring private int count and private String label at the top of the class body, outside any method or constructor, with the correct types matching what the specification describes.

   Loses the point: Declaring the variables inside the constructor body as local variables (int count = 0 inside the constructor). These are local to the constructor and cannot be accessed by other methods. The rubric does not award the instance variable point because the variables are not fields.

2. Write a constructor that correctly initializes the instance variables

   Rubric: Point earned when the constructor has the correct parameter list matching the specification, and each instance variable is set equal to the corresponding parameter using this.variableName or the field name directly. The assignment must go to the field, not to a local variable.

   Earns the point: Writing public ClassName(int count, String label) and inside the body writing this.count = count and this.label = label, correctly assigning the parameter values to the instance variables.

   Loses the point: Writing the constructor with the correct parameters but assigning a parameter to a local variable with the same name rather than to the field: writing int count = count inside the constructor creates a new local variable and leaves the field at its default value. The field initialization point is not earned.

3. Write an accessor method (getter) that returns an instance variable

   Rubric: Point earned when the method has the correct return type matching the type of the instance variable, the method returns the instance variable (not a local copy or a hardcoded value), and the method signature matches the specification. A void return type or a missing return statement does not earn the point.

   Earns the point: Writing public int getCount() with return count in the body, where count is the private instance variable declared at the class level. The return type int matches the type of the variable and the specification.

   Loses the point: Writing public void getCount() with a print statement instead of a return statement, or writing public int getCount() and returning a literal like return 0 instead of the field. Both versions lose the accessor point: one has the wrong return type and no return value, the other returns the wrong value.

4. Write a method that uses the instance variables to compute and return a result

   Rubric: Point earned when the method accesses the instance variables (not hardcoded values), performs the correct operation described in the specification, and returns the correct type. If the specification says the method should return a boolean indicating whether a condition on the fields is true, the return statement must use the fields in the condition.

   Earns the point: A method specified to return whether the count exceeds a threshold: writing public boolean isLarge(int threshold) with return count > threshold. The method accesses the instance variable count, compares it to the parameter, and returns the boolean result of the comparison.

   Loses the point: Writing return label.length() > threshold instead of return count > threshold because the student confused which field to use, or writing if (count > threshold) { return true; } without an else branch that returns false, leaving the method without a return on the else path and causing a compile error that obscures intent.

Across all four parts the pattern is the same: the Java syntax required is not advanced, but each rubric point demands one specific structural element that students under time pressure omit or misplace. Fields must be class level, not local. Constructors must assign to fields, not to local variables. Accessors must return the field, not print it. Behavioral methods must use the fields, not constants. Practicing Class Design FRQs against the scoring guideline reveals these structural demands and trains you to write each element automatically. The students who earn 8 or 9 points on this FRQ type are not writing more complex Java than the students who earn 4 or 5 points. They are writing the same Java with all required structural elements present.

Common AP Computer Science A FRQ mistakes

1. 01

   Using == instead of.equals() to compare String values

   On any FRQ that involves comparing String objects, students who write if (str1 == str2) are testing whether the two variables point to the same object in memory, not whether their character sequences are equal. Because Java strings are objects, == almost always returns false even when the strings contain identical characters. The correct comparison is str1.equals(str2) or str1.equalsIgnoreCase(str2) when case should be ignored. Chief Reader Reports from 2019 through 2022 consistently identify this as a recurring error on FRQs involving String parameters or String instance variables. The Java Quick Reference sheet provided during the exam lists the equals method signature, reinforcing that equals is the intended comparison mechanism.

   AP Computer Science A Chief Reader Reports 2019 to 2022, String comparison sections

2. 02

   Off by one errors in array and ArrayList loop bounds

   The most frequently documented execution error across all four FRQ types is a loop that starts at index 1 instead of 0, or that runs while the index is less than or equal to the array length instead of strictly less than the length. A loop written as for (int i = 1; i < arr.length; i++) misses the element at index 0. A loop written as for (int i = 0; i <= arr.length; i++) throws an ArrayIndexOutOfBoundsException on the final iteration. Chief Reader Reports from 2019 through 2022 flag this error on both the Array or ArrayList FRQ and the 2D Array FRQ. The loop bounds point on these questions is specifically targeted at confirming that all elements are processed without overrunning the array.

   AP Computer Science A Chief Reader Reports 2019 to 2022, array traversal sections

3. 03

   Declaring instance variables inside the constructor instead of as class fields

   On Class Design FRQs, students frequently write the variable declarations inside the constructor body rather than at the class level. A declaration written as int count = 0 inside the constructor creates a local variable that exists only for the lifetime of the constructor call. Other methods in the class cannot access it, and it does not persist between method calls. The Class Design rubric always awards a specific point for declaring instance variables as private fields at the class level, and that point is not earned when declarations appear inside the constructor. This error is documented in Chief Reader Reports as one of the most consistent sources of point loss on the Class Design question.

   AP Computer Science A Chief Reader Reports 2019 to 2022, Class Design question commentary

4. 04

   Confusing row and column index order in 2D array access

   In Java, a two dimensional array declared as int[][] grid is indexed as grid[row][col]: the first subscript selects the row and the second selects the column. Chief Reader Reports consistently identify students who reverse this order, writing grid[col][row] or constructing nested loops with the column variable as the outer loop and the row variable as the inner loop. When the 2D array is square, this reversal may not cause a visible error in output, but it fails the rubric point that requires correct row major or column major traversal. When the array is rectangular (more rows than columns or vice versa), the reversed indexing throws an ArrayIndexOutOfBoundsException. The 2D Array FRQ has one of the lowest mean scores of the four types, and index confusion is the primary reason documented in recent Chief Reader Reports.

   AP Computer Science A Chief Reader Reports 2019 to 2022, 2D Array question commentary

5. 05

   Writing a method with the wrong return type or omitting the return statement

   Every method in Java that is not void must have a return statement that returns a value of the declared return type. On FRQs that ask students to write a method returning an int, double, boolean, or object, responses that declare the method as void, that return a value of the wrong type, or that reach the end of the method without a return statement on every execution path lose the return type rubric point. A particularly common failure is writing an if block that returns a value for one condition but omitting the else branch that returns a value for the other condition, leaving a path where the method falls off the end without returning. Chief Reader Reports note this pattern on both the Methods and Control Structures and Class Design FRQs.

   AP Computer Science A Chief Reader Reports 2019 to 2022, method return type sections

6. 06

   Failing to call super() correctly in subclass constructors

   When a Class Design FRQ involves writing a subclass that extends an existing superclass, the subclass constructor must call the superclass constructor using super() with the correct arguments as its first statement. Students who omit the super() call, call it with wrong argument types, or place it after other statements in the constructor body produce code that either fails to compile or initializes the superclass fields incorrectly. Chief Reader Reports note that students who understand accessor and mutator methods well still lose the constructor point on inheritance questions by omitting or misusing super(). The Java Quick Reference sheet does not list constructor signatures for the superclass in the question context, so students must read the provided class description carefully to determine the correct super() arguments.

   AP Computer Science A Chief Reader Reports 2019 to 2022, inheritance and Class Design sections

How to practice AP Computer Science A FRQs effectively

Timed coding reps with a blank editor, then scoring yourself against the official rubric point by point.

The highest return practice for AP CS A FRQs is working released questions under realistic conditions: a text editor with no autocomplete or error highlighting, a strict 22 minute per question limit (90 minutes divided by 4), and no reference material other than the Java Quick Reference sheet. After completing a question, open that year's official scoring guideline, which is linked from this page for every available year, and check each rubric point one by one. Mark every point you missed and write down the specific Java element that was wrong or absent: the loop bound, the return type, the field declaration location, the comparison operator. After three or four practice cycles, your error pattern becomes clear and almost always traces to one of the six documented errors above, not to a gap in Java knowledge. The scoring guidelines include sample student responses at different score levels, which show precisely how much Java an 8 of 9 response writes versus a 4 of 9 response. Those comparisons are the most efficient calibration tool available before exam day.

1. 1

   Read all four questions before writing. Identify which FRQ type each question is, then start with the type you are most confident in. You may complete the four questions in any order, and beginning with a strong answer builds momentum and banks secure points early.

2. 2

   Write the method signature exactly as specified. Copy the return type, method name, and parameter types directly from the question. A method signature with the wrong return type or wrong parameter type loses the signature point even when the body is correct.

3. 3

   When writing a Class Design FRQ, declare instance variables at the top of the class body before writing the constructor. Fields must be class level. Declarations inside the constructor create local variables that other methods cannot access.

4. 4

   For every method that is not void, confirm that your return statement returns the correct type. Write the return statement first, then fill in the body that produces what you are returning. This prevents the common error of reaching the end of a method without a return on every path.

5. 5

   Use.equals() for all String comparisons, never ==. If you are not sure which comparison to use, the Java Quick Reference sheet lists the equals method for String. Using == on Strings will almost always produce incorrect behavior and costs the correctness point on any part that checks String equality.

6. 6

   On array and ArrayList FRQs, write your loop bounds carefully: start at 0 and use strictly less than the length, not less than or equal. After writing the loop, trace through it mentally with a small example array of 3 elements to verify that your loop processes index 0, index 1, and index 2 and stops before going out of bounds.

7. 7

   On 2D Array FRQs, write out grid[row][col] as a comment before coding, then build your nested loops so the outer loop iterates over rows and the inner loop iterates over columns. Explicitly label your loop variables row and col rather than i and j to avoid confusion when writing the array access inside the loop body.

8. 8

   Attempt every part of every question. There is no penalty for an incorrect attempt, and a partially correct implementation earns the rubric points it satisfies even if other parts are wrong. A blank method body earns zero; a method body with the right loop structure but the wrong condition still earns the loop structure point.

AP Computer Science A FRQ FAQ

More AP Computer Science A resources