Part 1Time Strategy (90 min ÷ 4 FRQs)

Don't try to spend 22.5 minutes on each question. The questions aren't equal weight, and your speed depends on the type. Here's how to budget:

Part 2The 4 FRQ Slots (Verified vs. Official CED)

Q1 — Methods and Control Structures (7 pts)

• Write two methods OR one constructor and one method of a given class.
• Part A (4 pts): requires iterative or conditional statements, plus calls to methods in the specified class.
• Part B (3 pts): requires String methods (substring, indexOf, equals, length, compareTo).
• If a second class is referenced, a variable of that type is passed in — call its methods on that variable, do NOT instantiate a new one.
• Common Part A patterns: accumulator, count, find-first, build-new-string, while-not-null loop.

Q2 — Class Design (7 pts)

• Write the complete class: class header + private instance variables + 1 constructor + 1 method. That's it.
• Read the provided method table FIRST: it shows constructor signature, return types, and a plain-English explanation for each method — use it as your blueprint.
• In the table: constructor row = what to initialize; return type column = what to declare; explanation column = your algorithm.
• Every field they describe, you declare as a private instance variable.
• Constructor must initialize all fields. The method must read or modify state.
• A second class may be referenced — if so, treat its objects as parameters, don't try to write that class.

Q3 — Data Analysis with ArrayList (5 pts)

• Just 1 method. Usually traverse + filter + accumulate or count.
• The ArrayList holds objects of a provided class — you'll call getter methods on each element (e.g. it.getCost(), it.isAvailable()).
• Adjacent comparison: compare list.get(i) with list.get(i+1) — loop only to size()-1 to avoid IndexOutOfBoundsException.
• Nested pair comparison: outer i from 0 to size()-1, inner j from i+1 to size().
• Filter/remove: iterate backward OR decrement i after remove to avoid skipping elements.
• Use enhanced for-each when you don't need indices — cleaner code, fewer off-by-one bugs.
• size() not length; get(i) not [i]; remove(i) shifts right elements left.

Q4 — 2D Array (6 pts)

• Just 1 method. Usually nested-loop traversal: outer = rows, inner = cols (or vice versa for column-major).
• Like Q3, the 2D array typically holds objects — call getter methods on each cell (e.g. sched[r][c].getStatus()).
• Row-major: outer r from 0 to arr.length, inner c from 0 to arr[0].length.
• Column-major: outer c from 0 to arr[0].length, inner r from 0 to arr.length. Use this when comparing within columns.
• Track-the-max/min pattern: maintain a bestIndex and bestValue outside the loop, update inside.
• Watch off-by-one: arr.length = number of rows; arr[0].length = number of cols.

Part 3Algorithm Pattern Library

These are the 13 patterns that show up across virtually every AP CSA FRQ. Memorize them, and Q1-Q4 become assembly rather than invention.

int total = 0;
for (int i = 0; i < arr.length; i++) {
    total += arr[i];
}
return total;

int count = 0;
for (String s : list) {
    if (s.length() > 3) {
        count++;
    }
}
return count;

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

ArrayList result = new ArrayList();
for (String s : original) {
    if (meetsCondition(s)) {
        result.add(s);
    }
}
return result;

for (int i = list.size() - 1; i >= 0; i--) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
    }
}

double sum = 0.0;
int count = 0;
for (Item it : inventory) {
    if (it.isAvailable() && it.getCost() >= lower
                        && it.getCost() <= upper) {
        sum += it.getCost();
        count++;
    }
}
return sum / count;

// Loop to size()-1 to avoid IndexOutOfBoundsException
for (int i = 0; i < list.size() - 1; i++) {
    if (list.get(i).equals(list.get(i + 1))) {
        // adjacent duplicates found
    }
}

// Start inner at i+1 to avoid duplicate comparisons
for (int i = 0; i < list.size() - 1; i++) {
    for (int j = i + 1; j < list.size(); j++) {
        if (list.get(i).equals(list.get(j))) {
            // matching pair at i and j
        }
    }
}

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

// Use this when comparing values WITHIN a column
int bestCol = 0;
int bestCount = grid.length;  // max possible
for (int c = 0; c < grid[0].length; c++) {
    int count = 0;
    for (int r = 0; r < grid.length; r++) {
        if (grid[r][c].getStatus().equals(target)) {
            count++;
        }
    }
    if (count < bestCount) {
        bestCount = count;
        bestCol = c;
    }
}
return bestCol;

// Build first letter of each word
String temp = message;
String result = temp.substring(0, 1);
while (temp.indexOf(" ") >= 0) {
    int i = temp.indexOf(" ");
    temp = temp.substring(i + 1);
    result += temp.substring(0, 1);
}
return result;

// Use when a helper returns null to signal end
String w = getNextWord(start);
while (w != null) {
    message += " " + w;
    count++;
    w = getNextWord(w);
}

// Random int in [lo, hi] inclusive
int n = (int)(Math.random() * (hi - lo + 1)) + lo;
// Random index into array:
int idx = (int)(Math.random() * arr.length);

Part 4String Methods Deep Dive (Q1 Part B is ALWAYS this)

// substring is on the Quick Reference; charAt is not.
// Use substring -- comparisons stay String-based with .equals().
str.substring(i, i + 1)  // returns a one-char String

if (str.substring(0, 1).equals("A")) {
    // starts with A
}

if (str.substring(str.length() - 1).equals("z")) {
    // ends with z
}

if (str.indexOf("ing") != -1) {
    // "ing" is present somewhere
}

// compareTo returns < 0 if str1 comes BEFORE str2
if (str1.compareTo(str2) < 0) {
    // str1 is alphabetically first
}

int sp = str.indexOf(" ");
String first = str.substring(0, sp);
String rest  = str.substring(sp + 1);

int count = 0;
for (int i = 0; i < str.length(); i++) {
    if (str.substring(i, i + 1).equals("a")) {
        count++;
    }
}

Part 5Math Methods Deep Dive

// Random int in [lo, hi] inclusive
int n = (int)(Math.random() * (hi - lo + 1)) + lo;

int idx = (int)(Math.random() * arr.length);

int q   = 7 / 2;  // q = 3, NOT 3.5
int rem = 7 % 2;  // rem = 1

double avg = (double) sum / count;  // cast ONE operand

int clamped = Math.min(Math.max(val, lo), hi);

int diff = Math.abs(a - b);

Part 6Object Method Patterns (3 of 4 FRQs Need This)

FRQs give you a class with methods. You must call those methods on objects, not access fields directly. These patterns cover every exam scenario.

for (Student s : roster) {
    int g = s.getGrade();   // call method, not s.grade
    if (g >= 90) {
        count++;
    }
}

for (int i = 0; i < items.length; i++) {
    String name = items[i].getName();
}

// If getScore() returns a ScoreRecord with getTotal():
int total = player.getScore().getTotal();

// FRQ says "use the provided method someHelper(x)"
public int myMethod(int x) {
    return someHelper(x) + 1;  // call it directly
}

public class Box {
    private int size;
    public Box(int size) {
        this.size = size;  // this.size = field, size = param
    }
}

ArrayList deck = new ArrayList();
for (int v = 1; v <= 13; v++) {
    deck.add(new Card(v, "Hearts"));
}

Part 7Official Penalties (and What's Forgiven)

Penalty points are only deducted in a part that already earned credit. No part can go negative. Max 3 penalty points per question. Each penalty applies only ONCE per question even if repeated.

1-point penalties (avoid these)

• Array/collection access confusion: using [] instead of .get() when assessed
• Extraneous code that causes a side effect (e.g. printing to output, broken precondition check)
• Local variable used but none declared anywhere
• Destruction of persistent data (e.g. modifying value referenced by a parameter)
• Returning a value from a void method or constructor

Errors graders forgive (no penalty)

• Extraneous code with NO side effect (valid precondition check, no-op)
• Spelling/case discrepancy where correction is unambiguous (e.g. ArayList)
• Local variable not declared, IF other variables are declared in some part
• private/public qualifier on a local variable
• Missing public qualifier on class or constructor header
• Keyword used as an identifier
• Math symbols used for operators (× · ÷ ≤ ≥ <> ≠)
• [] vs () vs <> confusion
• = instead of == and vice versa
• length/size confusion for array, String, List, ArrayList; with or without ()
• Extraneous [] when referencing entire array
• [i,j] instead of [i][j]
• Extraneous size in array declaration: int[size] nums = new int[size]
• Missing ; where structure clearly conveys intent
• Missing { } where indentation clearly conveys intent
• Missing () on parameter-less method calls
• Missing () around if/while/for conditions

Part 8Pre-Code Planning Ritual (4 minutes)

Do this BEFORE writing any code. Students who skip planning write twice as much wrong code.

Step 1 (30 sec) — Read the WHOLE question

Read every part (a), (b), (c) before writing anything. Underline: return type, parameter names, what the method DOES. Circle: any provided methods you are required or allowed to call.

Step 2 (30 sec) — Classify the algorithm

Is this: accumulate / count / find / build-list / remove / 2D traverse? Pick the pattern from Part 3. Write the loop skeleton FIRST (header + braces), then fill in body.

Step 3 (1 min) — Write method signature

public [returnType] [methodName]([params]) {. If you are writing a class (Q2), list all fields and constructor first. Write the return statement placeholder: return ____;

Step 4 (1 min) — Trace a small example by hand

Pick 2-3 values and trace what your loop should do step by step. If the output doesn't match what the problem says, fix BEFORE coding.

Step 5 (1 min) — Write the code

Fill in the loop body based on your trace. Use the Quick Reference for ArrayList/String/Math method names.

Part 9"I'm Stuck" 7-Step Rescue Protocol

Working through these in order earns you partial credit even if you can't fully solve the problem. Do not skip ahead. Each step is its own potential point.

1. Write the method signature and a placeholder return statement

public int findTotal(int[] nums) {
    // ...
    return 0;  // placeholder
}

2. Write what the method is SUPPOSED to do in a comment

// This method sums all values in nums that are > 0

3. Identify which pattern this is (Part 3 of this guide)

// Pattern: Accumulator -- need a running total variable

4. Write the loop skeleton, even if empty

for (int i = 0; i < nums.length; i++) {
    // TODO
}

5. Write ONE line inside the loop you are confident in

total += nums[i];  // add each element

6. Add the condition if needed

if (nums[i] > 0) {
    total += nums[i];
}

7. Replace placeholder return with real return

return total;

Part 10Partial Credit Strategies

Each FRQ is worth 5-7 points distributed across multiple criteria. You can earn 3-5 points with a partially correct answer. Never leave a question blank.

Write the method signature correctly

Worth 0 direct points but required before any other points. No signature = 0 on that part.

Declare and initialize the right variable type

Example: ArrayList result = new ArrayList(); earns the "creates list" point.

Write a correct loop structure even with wrong body

A correct for loop with correct bounds often earns 1 point even if the body is wrong.

Call the right method name (even with wrong args)

list.remove(...) earns the "uses remove" point even if the index is off.

Return the correct type even if the value is wrong

return result; earns the "returns list" point even if result isn't fully built.

Write javadoc-style comments explaining intent

Graders may give benefit of the doubt if your intent is clear and the code partially implements it.

Part 11Top 10 Killer Mistakes

1. Using == to compare Strings

if (s == "hello") { }       // WRONG
if (s.equals("hello")) { }  // CORRECT

2. Using [] to access ArrayList elements

list[i]      // WRONG
list.get(i)  // CORRECT

3. Using .length for ArrayList

list.length  // WRONG
list.size()  // CORRECT

4. Removing from ArrayList while iterating forward

// WRONG: forward loop skips element after each remove
// CORRECT: iterate backward
for (int i = list.size() - 1; i >= 0; i--) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
    }
}

5. Integer division truncates silently

double avg = sum / count;             // WRONG (both ints)
double avg = (double) sum / count;    // CORRECT

6. Off-by-one in loops

// WRONG -- ArrayIndexOutOfBoundsException:
for (int i = 1; i <= arr.length; i++) { }
// CORRECT:
for (int i = 0; i < arr.length; i++) { }

7. Modifying a parameter array/list (destroys persistent data)

// -1 penalty: changing values in the passed-in array directly
// Read from it; do not reassign its elements

8. Returning a value from a void method or constructor

// void method: return;  is OK
// return someValue;  inside void method = -1 penalty

9. Treating charAt() like it's on the Quick Reference

str.charAt(i)            // works, but NOT on the Quick Ref
str.substring(i, i + 1)  // listed -- safer choice
// substring returns a String, so use .equals() to compare

10. Forgetting to initialize accumulator variables

// WRONG: int total;  total += x;
// CORRECT: int total = 0;  total += x;