AP Computer Science A AP Computer Science A Practice Test 2025

When both operands of the / operator are int, Java performs integer division, which truncates the decimal portion. So 17 / 5 evaluates to 3 (not 3.4). This integer result 3 is then assigned to the double variable z, which stores it as 3.0. Therefore, System.out.println(z) prints 3.0.

The correct answer is (b) 3.0.

The indexOf("GR") method searches for the first occurrence of "GR" in "PROGRAMMING". The string is indexed as: P(0) R(1) O(2) G(3) R(4) A(5) M(6) M(7) I(8) N(9) G(10). The substring "GR" starts at index 3 (G at index 3, R at index 4). So k = 3.

Then word.substring(3, 7) extracts characters from index 3 (inclusive) to index 7 (exclusive): G(3) R(4) A(5) M(6) = "GRAM".

The correct answer is (c) GRAM.

In Java, the && operator has higher precedence than ||. So the expression is evaluated as:

a > b || (b > 10 && c < 5)

Step by step:

• a > b evaluates to 8 > 15 which is false
• b > 10 evaluates to 15 > 10 which is true
• c < 5 evaluates to 3 < 5 which is true
• b > 10 && c < 5 evaluates to true && true which is true
• false || true evaluates to true

Since the condition is true, the code prints "YES".

The correct answer is (a) YES.

The loop iterates with i taking values 1, 2, 3, and 4. In each iteration, i * i is added to total.

• Iteration 1: i = 1, total = 0 + 1*1 = 1
• Iteration 2: i = 2, total = 1 + 2*2 = 5
• Iteration 3: i = 3, total = 5 + 3*3 = 14
• Iteration 4: i = 4, total = 14 + 4*4 = 30

After the loop completes, total is 30.

The correct answer is (d) 30.

The code finds the maximum value in the array {4, 9, 2, 7, 5, 8} by initializing max to nums[0] which is 4, then comparing each subsequent element.

• i = 1: nums[1] = 9 > 4 (true), so max = 9
• i = 2: nums[2] = 2 > 9 (false), max stays 9
• i = 3: nums[3] = 7 > 9 (false), max stays 9
• i = 4: nums[4] = 5 > 9 (false), max stays 9
• i = 5: nums[5] = 8 > 9 (false), max stays 9

The final value of max is 9.

The correct answer is (b) 9.

Let's trace through the ArrayList operations step by step:

1. colors.add("Red") -> ["Red"]
2. colors.add("Blue") -> ["Red", "Blue"]
3. colors.add("Green") -> ["Red", "Blue", "Green"]
4. colors.add(1, "Yellow") inserts "Yellow" at index 1, shifting everything after it -> ["Red", "Yellow", "Blue", "Green"]
5. colors.remove(2) removes the element at index 2, which is "Blue" -> ["Red", "Yellow", "Green"]

Now colors.size() returns 3 and colors.get(2) returns "Green" (the element at index 2).

So the output is 3 Green.

The correct answer is (c) 3 Green.

The loop iterates through column indices col = 0, 1, 2. In each iteration, it accesses grid[col][col], which are the diagonal elements of the 3x3 matrix.

• col = 0: grid[0][0] = 1
• col = 1: grid[1][1] = 5
• col = 2: grid[2][2] = 9

sum = 1 + 5 + 9 = 15

Note: Although the loop variable is named col, it is used as both the row and column index, so it traverses the main diagonal of the matrix.

The correct answer is (b) 15.

This question tests the concept of polymorphism in Java. The variable pet has a compile-time type of Animal but a runtime type of Puppy.

In Java, when a method is called on an object, the runtime type (the actual object type) determines which version of the overridden method is executed. This is called dynamic method dispatch.

Since the actual object is a Puppy, and Puppy overrides the speak() method to return "Yip", the call pet.speak() invokes Puppy's version of speak(), which returns "Yip".

The correct answer is (d) Yip.

We trace the recursive calls for mystery(7):

1. mystery(7): n = 7, not <= 1, returns 7 + mystery(5)
2. mystery(5): n = 5, not <= 1, returns 5 + mystery(3)
3. mystery(3): n = 3, not <= 1, returns 3 + mystery(1)
4. mystery(1): n = 1, base case reached, returns 1

Now we unwind:

• mystery(1) = 1
• mystery(3) = 3 + 1 = 4
• mystery(5) = 5 + 4 = 9
• mystery(7) = 7 + 9 = 16

The correct answer is (c) 16.

We trace the binary search for target = 23 in the sorted array {2, 5, 8, 12, 16, 23, 31, 42} (indices 0 through 7):

Iteration 1 (count = 1):

• low = 0, high = 7, mid = (0 + 7) / 2 = 3
• arr[3] = 12, which is < 23, so low = 3 + 1 = 4

Iteration 2 (count = 2):

• low = 4, high = 7, mid = (4 + 7) / 2 = 5
• arr[5] = 23, which == 23, so we return count = 2

The binary search finds 23 after 2 comparisons.

The correct answer is (b) 2.