AP CS A Practice Problems with Solutions

Answer: (B) 1

Trace the loop, tracking x and count:

Only x = 6 is divisible by 3 in this sequence. Output: 1.

Answer: (C) PUT

substring(3, 6) returns characters at indices 3, 4, and 5 (the end index is exclusive). The string "computer" has these indices:

Indices 3–5 give "put". After .toUpperCase(), the result is "PUT".

Answer: (D) 9

This is a standard maximum-finding algorithm. result starts at arr[0] = 4. The loop checks each subsequent element: 7 > 4 so result becomes 7; 2 is not > 7; 9 > 7 so result becomes 9; 1 is not > 9; 5 is not > 9. Final value of result is 9. Note that (E) 28 would be the sum, not the maximum.

Answer: (D) 12

Trace the call stack:

mystery(6)  → 6 + mystery(4)
  mystery(4)  → 4 + mystery(2)
    mystery(2)  → 2 + mystery(0)
      mystery(0)  → 0  (base case: 0 <= 0)
    mystery(2)  → 2 + 0 = 2
  mystery(4)  → 4 + 2 = 6
mystery(6)  → 6 + 6 = 12

The method sums all even positive integers from 2 up to n (when n is even): 6 + 4 + 2 = 12. Note that (E) 21 would be 1+2+3+4+5+6, which is what the method would return if it decremented by 1 instead of 2.

Answer: (B) [3, 7, 8, 1]

This problem tests the classic ArrayList removal bug. Trace carefully:

• i=0: list.get(0) = 3, odd, skip. i becomes 1.
• i=1: list.get(1) = 7, odd, skip. i becomes 2.
• i=2: list.get(2) = 2, even, remove. List is now [3, 7, 8, 1]. The 8 shifts from index 3 to index 2. i becomes 3.
• i=3: list.get(3) = 1, odd, skip. i becomes 4.
• i=4: list.size() = 4, loop ends.

After removing 2 at index 2, the 8 shifted into index 2. Then i incremented to 3, skipping index 2 entirely. The 8 was never checked. The correct approach is to iterate backwards or decrement i after each removal. The answer (A) [3, 7, 1] is what you'd get with a correct implementation.

Answer: (B) I am a circle

s is declared as type Shape but actually holds a Circle object. When s.describe() is called, Java uses Shape's version of describe() (since Circle doesn't override it). But inside describe(), the call to getType() is resolved at runtime based on the actual object type, which is Circle. So Circle's getType() runs, returning "circle". This is polymorphism: the declared type determines which methods are accessible; the actual type determines which version runs.

There is no compile error because describe() is defined in Shape, which is the declared type. There is no runtime error because Circle is a valid Shape.

public static int countInRange(int[] arr, int low, int high) {
    int count = 0;
    for (int val : arr) {
        if (val >= low && val <= high) {
            count++;
        }
    }
    return count;
}

Scoring notes:

• Initialize count to 0 before the loop. Declaring it without initialization is a compile error.
• Use >= and <=, not > and <. The problem says "inclusive" on both ends.
• Use && to require both conditions to be true simultaneously.
• Return count after the loop, not inside it.
• An enhanced for loop is appropriate here since you only need values, not indices.

Common mistakes: using || instead of && (returns count of values outside the range instead), returning inside the loop (returns too early), or forgetting to initialize count.

public class Student {
    private String name;
    private int grade;
    private double gpa;

    public Student(String name, int grade, double gpa) {
        this.name = name;
        this.grade = grade;
        this.gpa = gpa;
    }

    public String getName() {
        return name;
    }

    public int getGrade() {
        return grade;
    }

    public double getGPA() {
        return gpa;
    }

    public boolean isHonorRoll() {
        return gpa >= 3.5;
    }

    public void promote() {
        if (grade < 12) {
            grade++;
        }
    }

    public String toString() {
        return name + ", Grade " + grade + ", GPA: " + gpa;
    }
}

Scoring notes:

• Instance variables should be private. Using public instance variables is a style error that may cost points on the real exam.
• The constructor does not have a return type, not even void.
• isHonorRoll() should return a boolean expression directly: return gpa >= 3.5; is cleaner than an if/else that returns true or false.
• promote() is a void method; it modifies grade in place. The boundary check (grade < 12) prevents going above 12.
• toString() uses string concatenation to build the required format. Make sure the format matches exactly.

public static void removeDuplicates(ArrayList<Integer> list) {
    for (int i = list.size() - 1; i >= 1; i--) {
        for (int j = 0; j < i; j++) {
            if (list.get(i).equals(list.get(j))) {
                list.remove(i);
                break;
            }
        }
    }
}

How it works: the outer loop iterates backwards from the last element to index 1. For each element at index i, the inner loop checks whether the same value appears anywhere before it (at indices 0 through i−1). If a match is found, the element at index i is a duplicate and is removed. The break exits the inner loop immediately after removal, since there's no point checking further. Iterating backwards means that removing an element at index i doesn't affect the indices of earlier elements (0 through i−1), which the inner loop still needs to access.

Scoring notes:

• Use .equals(), not ==, to compare Integer objects. == checks object identity, not value equality, and will fail for values outside the cached range of −128 to 127.
• The return type is void. Do not add a return statement with a value.
• The backwards traversal is essential for correctness. A forward traversal with removal causes index-skipping bugs.

public static int sumArray(int[] arr, int index) {
    if (index == arr.length) {   // base case: ran past the end
        return 0;
    }
    return arr[index] + sumArray(arr, index + 1); // recursive case
}

Call stack for sumArray({3, 7, 2, 5}, 0):

sumArray(arr, 0)  → 3 + sumArray(arr, 1)
  sumArray(arr, 1)  → 7 + sumArray(arr, 2)
    sumArray(arr, 2)  → 2 + sumArray(arr, 3)
      sumArray(arr, 3)  → 5 + sumArray(arr, 4)
        sumArray(arr, 4)  → 0  (base case: 4 == arr.length)
      sumArray(arr, 3)  → 5 + 0 = 5
    sumArray(arr, 2)  → 2 + 5 = 7
  sumArray(arr, 1)  → 7 + 7 = 14
sumArray(arr, 0)  → 3 + 14 = 17

Scoring notes:

• The base case is index == arr.length, not index == arr.length - 1. When index equals the length, you've gone past the last valid element (last valid index is arr.length - 1). Returning 0 at this point correctly adds nothing.
• Each recursive call passes index + 1, moving one step closer to the base case every time.
• The problem says you may not use a loop, which is a hint that a recursive solution is expected. On the real exam, if recursion is required, using a loop will not earn credit for the recursive logic.