Early Solutions to the 2026 AP Computer Science A FRQs | Step by Step

Question 1 - Account

Part A: Constructor That Finds the First Available Username

Step 1: Decide what changes and what stays fixed

• requestedName never changes. Every numbered candidate must be built from this original base name.
• candidate is the username currently being tested.
• suffix is the next integer that will be appended if candidate is unavailable.

Step 2: Establish the loop order

1. Start candidate as requestedName so the unmodified name is checked first.
2. Start suffix at 1 because the first variation must end in 1.
3. While candidate is unavailable, replace it with requestedName + suffix and then advance suffix.
4. When the loop ends, candidate is the first available username; assign it to the instance variable.

Exam-ready constructor

public Account(String requestedName)
{
  String candidate = requestedName;
  int suffix = 1;
  while (!isAvailable(candidate))
  {
    candidate = requestedName + suffix;
    suffix++;
  }
  username = candidate;
}

Question 1A - Dry Run and Correctness

Example trace: requestedName is "Luis-Cruz"

Assume "Luis-Cruz", "Luis-Cruz1", and "Luis-Cruz2" are unavailable, while "Luis-Cruz3" is available.

Zero-iteration case

If "PSmith" is available, the while condition is false immediately. No number is appended, and username is assigned "PSmith". This is exactly the required behavior.

Why this constructor is correct

• It calls isAvailable on every candidate that is considered, including the original requested name.
• The generated sequence is requestedName, requestedName1, requestedName2, ... with no gaps.
• The loop stops only when the current candidate is available, so the assigned value is valid.
• Because candidates are tested in increasing suffix order, the first available variation is selected.

Common mistakes to avoid

Part B: getShortenedName

Step 1: Reframe the deletion rule

Each hyphen defines a two-character pair to remove: the character immediately before it and the hyphen itself. The preconditions guarantee that a hyphen is never first, never last, and never adjacent to another hyphen, so every removal pair is well-defined.

Step 2: Scan without modifying username

1. Maintain index, the position currently being considered, and shortened, the output built so far.
2. If the character after index is a hyphen, then the current character is the character that must be removed. Skip both positions by adding 2 to index.
3. Otherwise copy the current character into shortened and advance index by 1.
4. Return shortened after every position has been handled.

Exam-ready method

public String getShortenedName()
{
  String shortened = "";
  int index = 0;
  while (index < username.length())
  {
    if (index < username.length() - 1
        && username.substring(index + 1, index + 2).equals("-"))
    {
      index += 2;
    }
    else
    {
      shortened += username.substring(index, index + 1);
      index++;
    }
  }
  return shortened;
}

Question 1B - Dry Run and Edge Cases

Trace for username = "Amy-Marie-Lin"

Returned value: "AmMariLin"

No-hyphen case

For username = "SammyB3", the look-ahead condition is never true. Every character is copied, so the returned value is "SammyB3".

Boundary observations

• The condition index < username.length() - 1 prevents substring(index + 1, index + 2) from going past the end of the String.
• A final ordinary character is copied normally because there is no following hyphen.
• For a name such as "A-B-C", the method skips A-, then B-, and returns "C".

Common mistakes to avoid

Question 2 - Complete Bottle Class

Step 1: Choose the instance variables

Step 2: Translate the constructor

The constructor receives the capacity. The prompt says every new bottle is filled to capacity, so both fields initially receive the same value.

Step 3: Translate updateAmount in the required order

1. Subtract amountRemoved from the current amount.
2. Compare the new amount with 0.25 * capacity.
3. If the new amount is strictly less than that threshold, reset amount to capacity.
4. Return the final amount.

Complete class

public class Bottle
{
  private double capacity;
  private double amount;

  public Bottle(double bottleCapacity)
  {
    capacity = bottleCapacity;
    amount = bottleCapacity;
  }

  public double updateAmount(double amountRemoved)
  {
    amount -= amountRemoved;
    if (amount < 0.25 * capacity)
    {
      amount = capacity;
    }
    return amount;
  }
}

Question 2 - Verification and Boundary Cases

Trace for the 1,000 mL water bottle

Trace for the 40 mL shampoo bottle

Why the class is correct

• capacity remains available for every future call and is never overwritten.
• amount is updated cumulatively, so each call begins with the amount left by the previous call.
• The refill test occurs after removal, matching the wording and examples.
• The precondition guarantees amountRemoved is positive and no greater than the current amount, so no extra validation is required.

Common mistakes to avoid

Question 3 - Attendance

Step 1: Recognize the matching problem

A CourseRecord in historyList cannot be compared with just any CourseRecord in mathList. The records must first be matched by student ID. Only after the IDs match should the two absence counts be compared.

Step 2: Use nested traversal

1. Visit each history record.
2. Search mathList for a record with the same student ID.
3. When a match is found, compare the absence counts and increment count only when history is greater.
4. Break out of the inner loop after the matching ID is processed. The preconditions guarantee no duplicate ID in mathList.

Exam-ready method

public int moreHistoryThanMathAbsences()
{
  int count = 0;
  for (CourseRecord historyRecord : historyList)
  {
    for (CourseRecord mathRecord : mathList)
    {
      if (historyRecord.getStudentID().equals(
          mathRecord.getStudentID()))
      {
        if (historyRecord.getAbsences()
            > mathRecord.getAbsences())
        {
          count++;
        }
        break;
      }
    }
  }
  return count;
}

Question 3 - Dry Run and Proof of Correct Counting

Students appearing in both lists

Final count: 2

The history-only IDs "rc29" and "br98" are ignored because no matching math record exists. The math-only IDs are never selected by the outer loop and therefore also do not affect the count.

Why the method counts exactly the correct students

• Every historyList record is examined once by the outer loop.
• For that record, every mathList record is considered until the matching ID is found or the list ends.
• count increases only after both required conditions are true: matching IDs and greater history absences.
• Because IDs are unique within each list, a student can increase count at most once.
• The method only calls accessor methods; it never adds, removes, reorders, or replaces list elements, so both lists remain unchanged.

Efficiency

If H is the size of historyList and M is the size of mathList, the worst-case running time is O(H x M), and the extra space is O(1). This direct approach is fully appropriate for the information and tools supplied in the prompt.

Common mistakes to avoid

Question 4 - GameBoard

Step 1: Track the two facts needed

Step 2: Traverse only the requested row

1. Initialize firstColor from board[targetRow][0]. The preconditions guarantee the row has elements and no element is null.
2. Loop across the columns in board[targetRow].
3. Add each Space's points to sum.
4. Compare each Space's color with firstColor using .equals. If any differs, set allSameColor to false.
5. After the loop, return 2 * sum when allSameColor is true; otherwise return sum.

Exam-ready method

public int getPointsForRow(int targetRow)
{
  int sum = 0;
  String firstColor = board[targetRow][0].getColor();
  boolean allSameColor = true;
  for (int col = 0; col < board[targetRow].length; col++)
  {
    Space current = board[targetRow][col];
    sum += current.getPoints();
    if (!current.getColor().equals(firstColor))
    {
      allSameColor = false;
    }
  }
  if (allSameColor)
  {
    return 2 * sum;
  }
  return sum;
}

Question 4 - Dry Run and Correctness

Row 0 from the sample board

Points: 100 + 100 + 500 + 500 + 100 = 1300. The colors are orange, red, blue, green, and red, so allSameColor becomes false. The method returns 1300.

Row 2 from the sample board

Points: 200 + 300 + 100 + 200 + 200 = 1000. Every Space is red, so allSameColor remains true. The method returns 2 * 1000 = 2000.

Why the method is correct

• Every element in targetRow contributes exactly once to sum.
• allSameColor starts true and can only change to false, so one mismatch is enough to record that the row is mixed.
• If no mismatch is found, every color equals firstColor and the sum is doubled exactly once.
• The method uses board[targetRow].length, so it traverses the actual requested row rather than assuming all rows have the same length.

Efficiency

For C columns in targetRow, the running time is O(C) and the extra space is O(1).

Common mistakes to avoid