How to Get a 5 in AP Computer Science A

Every autumn a student asks us the same thing, usually in October, usually after a first test that did not go the way they expected. What does it actually take to get a 5? The honest answer used to be long. This year it is short, because the course changed underneath everyone and the 2026 results have just told us how that landed.

In May 2026, on the first exam set against the rebuilt four unit standards, 25 per cent of candidates scored a 5 and 23 per cent scored a 1. Those are the preliminary figures College Board has published so far, with the test taker count and mean score still to come, so treat them as the shape rather than the last word. Read those two numbers next to each other for a second. This is not a paper where most people cluster in the middle and a few drift to the edges. It is a paper that splits its candidates into two groups, and the thing that decides which group a student lands in is smaller and more specific than most families expect.

What the 2026 scores actually say

Here is the distribution as College Board has published it so far, alongside AP Computer Science Principles for scale, because the comparison surprises almost everyone. Both tables are still marked preliminary.

The Java course, the one with a reputation for being the hard one, hands out two and a half times as many 5s as the friendlier looking Principles course. That is not because the Java paper is easy. It is because it is a skills exam. You can either write a loop that traverses a collection correctly under time pressure or you cannot, and that ability does not sit on a smooth curve. It arrives, usually suddenly, after enough hours at a keyboard.

The four questions you will be asked to write

Section 2 is worth 45 per cent of the score and consists of four free response questions, typed as Java, with a Java Quick Reference available throughout. The important thing, and the single most under used fact in AP Computer Science A preparation, is that the four questions are always the same four types in the same order.

• Question 1, Methods and Control Structures. You are given a class and asked to use it. Create objects, call methods, wrap the calls in conditionals and loops. Nothing here asks you to design anything.
• Question 2, Class Design. You write a whole class from a written specification, constructor and all. This is the question where students lose marks to missing accessor methods rather than to hard logic.
• Question 3, Data Analysis with ArrayList. Build, traverse and modify an ArrayList. Almost every year some part of this question rewards a student who knows what happens to the indices when you remove an element mid loop.
• Question 4, 2D Array. Traverse a grid. Sometimes every cell, sometimes one row, sometimes one column, sometimes until you find a target and stop.

Four fixed shapes means preparation can be specific in a way it cannot be for most subjects. A student who has written twenty class definitions to specification does not have to think about question 2 on exam day, and the twelve minutes that buys is usually the difference between finishing question 4 and leaving it half written.

Where the marks live, unit by unit

The rebuilt course has four units, and the Course and Exam Description publishes what share of the multiple choice each one carries. The distribution is lopsided, and most study plans do not reflect it.

Now put that next to Section 2. Questions 3 and 4 are both collections questions. Add the two sections together and working with collections decides close to half the exam. If a student has three hours a week to give this course, the arithmetic says roughly ninety minutes of it belongs to arrays, ArrayLists and grids, every week, from the point they are introduced until the exam.

The ArrayList slip that costs the most marks

Here is the specific thing we see in real student work more than any other. The task is ordinary: given a list of scores, remove every score below 50. The obvious loop looks completely correct.

for (int i = 0; i < scores.size(); i++) {
    if (scores.get(i) < 50) {
        scores.remove(i);
    }
}

Run it on [70, 40, 45, 90, 30] and it prints this. The program is compiled and run, and the output below is what the JVM actually produced, not what it ought to produce.

[70, 45, 90]

The 45 survived. When remove(1) deletes the 40, every later element shifts one place left, so 45 slides into index 1. Meanwhile i has moved on to 2. The loop never looks at 45 at all. Counting downwards fixes it, because removing an element only ever shifts the elements you have already inspected.

for (int i = scores.size() - 1; i >= 0; i--) {
    if (scores.get(i) < 50) {
        scores.remove(i);
    }
}

[70, 90]

Two dimensions, one mental model

Question 4 frightens students far more than it deserves to. A 2D array in Java is an array of arrays, which means grid.length is the number of rows and grid[0].length is the number of columns. Once that lands, a column traversal is just the two loops written in the other order.

public class Grid {
    public static void main(String[] args) {
        int[][] grid = {{3, 8, 1},
                        {4, 0, 6},
                        {9, 2, 7}};

        for (int c = 0; c < grid[0].length; c++) {
            int sum = 0;
            for (int r = 0; r < grid.length; r++) {
                sum += grid[r][c];
            }
            System.out.println("column " + c + " sums to " + sum);
        }
    }
}

column 0 sums to 16
column 1 sums to 10
column 2 sums to 14

That is the entire idea. Row major puts r on the outside, column major puts c on the outside, and everything else on question 4 is a variation on which cells you visit and what you do when you get there. Students who write this out ten times stop being frightened of it, and there is no shortcut that gets to the same place faster.

What is no longer on the exam

This is where a lot of preparation time is being wasted right now, because most study guides and most second hand textbooks still describe the ten unit course. The 2025-26 revision removed a substantial block of content.

• Inheritance, polymorphism, extends, super and interfaces. Gone from the required content. There is no inheritance free response question, and there is no inheritance unit.
• Writing recursive methods. Removed, but read that precisely. Recursion itself is still examined inside Unit 4: candidates are given a recursive method and asked to trace the calls and state what comes back. What they are never asked to do is write one.
• File input and output, with Scanner. Moved the other way, into the required sequence. Reading data from a file is now part of the course rather than an enrichment topic.
• Working with data sets. Added, which is the clearest signal of where the course is heading.

A study plan that matches those weights

Most plans fail because they allocate equal time to unequal things. This one allocates by weight, and assumes a student starting in September for a May exam.

1. September to October, get fluent in the basics. Units 1 and 2. The goal is not understanding, it is speed. Tracing a nested loop should feel like reading, not like solving.
2. November, write classes to specification. Unit 3 is the smallest unit by weight but it is a whole free response question. Twenty small classes written to a written spec, from a description someone else wrote, not from your own idea.
3. December to February, live inside collections. Unit 4, and this is the long stretch on purpose. Arrays, then ArrayList, then 2D. Every practice problem uses a collection.
4. March, do full papers under time. Not questions, papers. Three hours, no pauses. The skill being trained here is pacing, and it can only be trained in one sitting units.
5. April, work only on what you got wrong. Go back over the marked papers and rebuild the two or three specific misconceptions that keep appearing. Almost nobody has more than three.

If your child is reading this in February rather than September, the plan compresses but the order does not change. Collections still come before full papers, because doing timed papers on a skill you do not yet have simply measures the gap repeatedly.

The digital exam, in practice

The exam is taken digitally in Bluebook, three hours end to end, with Section 1 carrying 42 multiple choice questions at 55 per cent of the score and Section 2 carrying the four written questions at 45 per cent. The practical consequence is worth rehearsing before exam day: students type their Java rather than write it, and the editor is not the editor they practise in.

There is no compiler behind it and nothing tells you that a bracket is missing. Students who have only ever written Java inside an IDE that highlights errors as they type are relying on a helper that will not be there. Two or three practice sessions in a plain text editor with the syntax highlighting turned off is an unglamorous exercise that reliably saves marks.

The students who get 5s are not the ones who understood recursion the fastest. They are the ones who wrote the same four question types until the shapes stopped being surprising.

, What we tell every AP Computer Science A parent in the first class

Where a teacher actually helps

Most of what is above, a determined student can do alone. Two parts of it are much harder alone. The first is catching a misconception while it is forming, because a student who believes something wrong about how remove shifts indices will practise that belief for weeks unless somebody watches them work. The second is pacing, which is a habit rather than a piece of knowledge.

Our AP Computer Science A classes are live, either one to one or in a batch of five to eight students, taught from India to students across the world. We do not sell recordings in place of teaching, because a recording cannot see a student trace a loop wrongly and stop them mid keystroke. The first class is free and there is no card involved, so the sensible way to test any of this is to bring a question your child got wrong and watch what happens to it.

Frequently asked questions