AP Computer Science A — Pattern-Matched Mock

Let's break this down! The first part is (7 / 2). Since both 7 and 2 are integers, Java performs integer division, which truncates any remainder. So, 7 / 2 evaluates to 3, not 3.5. Then, (double) 3 casts this result to 3.0. The second part is 7 / 2.0. Because 2.0 is a double, Java promotes the 7 to 7.0 and performs floating-point division, resulting in 3.5. Finally, 3.0 + 3.5 gives us 6.5. A common mistake is to think the cast (double) applies to the division itself, but it only applies after the integer division has already happened!

This question tests your understanding of substring and indexOf. Let's trace it. str.indexOf("C") finds the index of 'C', which is 3. str.substring(3) will give you the rest of the string from that index onward, so part1 becomes "CS-A-ROCKS". Next, str.indexOf("-") finds the first hyphen at index 2. str.substring(0, 2) gives you the characters from index 0 up to (but not including) index 2. So, part2 becomes "AP". Finally, the println statement concatenates these with a hyphen in between: "CS-A-ROCKS" + "-" + "AP", which results in "CS-A-ROCKS-AP".

This is a classic if-else scenario. We need to handle both conditions. Choice B correctly sets shippingCost to 0.0 if the orderTotal is greater than or equal to 50.00, and to 5.99 otherwise. Choice A is a common mistake; it sets shippingCost to 0.0 but then immediately overwrites it with 5.99 in all cases. Choice C doesn't handle the case where orderTotal is 50.00 or more, leaving shippingCost uninitialized. Choice D is very close, but the condition > 50.00 misses the case where the total is exactly $50.00, which should get free shipping.

Let's trace the nested loops carefully. The outer loop variable i starts at 1 and doubles each time, as long as it's less than n (which is 10).

• When i is 1: The inner loop runs from j = 0 to j < 1 (1 time). x becomes 1.
• When i is 2: The inner loop runs from j = 0 to j < 2 (2 times). x becomes 1 + 2 = 3.
• When i is 4: The inner loop runs from j = 0 to j < 4 (4 times). x becomes 3 + 4 = 7.
• When i is 8: The inner loop runs from j = 0 to j < 8 (8 times). x becomes 7 + 8 = 15.
• The next value for i would be 16, which is not less than 10, so the outer loop terminates. The final value of x is 15.

This is a core concept of object-oriented programming! A constructor's job is to run when you create a new object (using the new keyword) and set up its initial state. This means assigning starting values to its instance variables. Choice A describes a copy constructor or clone method, not a general constructor. Choice C describes the purpose of methods, not constructors. Choice D is an implementation detail handled by the Java Virtual Machine, not the purpose of a constructor.

This question tests the difference between static and instance variables. The count variable is static, meaning it's shared across all Gadget objects. The id variable is an instance variable, so each Gadget gets its own copy.

1. new Gadget() (for g1): id is set to the current count (0), then count becomes 1. So, g1.id is 0.
2. new Gadget() (for g2): id is set to the current count (1), then count becomes 2. So, g2.id is 1.
3. new Gadget() (for g3): id is set to the current count (2), then count becomes 3. So, g3.id is 2. The print statement asks for g2.getId(), which returns g2's personal id value: 1. Then it asks for Gadget.getCount(), which returns the final value of the shared static variable count: 3. So, the output is 1 3.

This is a very important rule to remember! You cannot modify the structure of an ArrayList (by adding or removing elements) while you are iterating over it using an enhanced for-each loop. Doing so will throw a ConcurrentModificationException at runtime, and many compilers will flag this as a potential error. Choice B attempts to remove an element during a for-each loop, which is forbidden. Choices A, C, and D are all valid ways to interact with an ArrayList. To correctly remove elements while iterating, you must use a standard for loop and carefully manage the index, usually by iterating backward.

This code segment is a classic algorithm for reversing an array in place. Let's trace it. The loop runs for i from 0 up to arr.length / 2, which is 5 / 2 = 2. So i will be 0 and 1.

• When i = 0: It swaps arr[0] (value 10) with arr[5 - 1 - 0] which is arr[4] (value 50). The array becomes {50, 20, 30, 40, 10}.
• When i = 1: It swaps arr[1] (value 20) with arr[5 - 1 - 1] which is arr[3] (value 40). The array becomes {50, 40, 30, 20, 10}. The loop then terminates. The middle element arr[2] (value 30) is never touched, which is correct for reversing an array with an odd number of elements. The final result is the reversed array.

When you create a 2D array like new int[rows][cols], you are creating a grid. The first number specifies the number of rows, and the second number specifies the number of columns. The total number of elements is simply the number of rows multiplied by the number of columns. In this case, it's 4 rows * 5 columns = 20 elements.

This is a classic recursion problem. The base case, n < 10, correctly handles single-digit numbers by returning the number itself. For the recursive step, we need to break the problem down. The sum of the digits of a number (like 123) is the last digit (3) plus the sum of the digits of the rest of the number (12). In Java, we get the last digit with the modulo operator: n % 10. We get the rest of the number by using integer division: n / 10. Therefore, the recursive step should be to return the last digit (n % 10) plus the result of calling the function on the rest of the number (sumDigits(n / 10)). Choice A correctly implements this logic.

This question tests your knowledge of De Morgan's laws. De Morgan's laws state that !(A && B) is equivalent to (!A || !B), and !(A || B) is equivalent to (!A && !B). In our expression, we have !(a && b). Applying the first law, this part becomes (!a || !b). So the entire expression !(a && b) || c becomes (!a || !b) || c. Since the || operator is associative, the parentheses are not strictly necessary, but choice A shows the direct substitution.

When you need to repeat an action a specific, known number of times, a for loop is the perfect tool. In this case, we want to call the move() method exactly n times. A for loop like for (int i = 0; i < n; i++) { robot.move(); } is the standard and most readable way to accomplish this. An if statement only executes once. A switch statement is for choosing one path out of many based on a value. A try-catch block is for handling errors (exceptions).

This question checks your familiarity with the Math class. Math.pow(base, exponent) calculates the base raised to the power of the exponent. So, Math.pow(2, 3) is 2³, which is 8.0. Math.sqrt(number) calculates the square root of a number. So, Math.sqrt(16) is 4.0. Both methods return a double. The final calculation is 8.0 + 4.0, which equals 12.0.

Let's evaluate each choice with x = 5 and y = 10.

• A: 5 > 5 is false. Since it's an && (AND), the whole expression is false immediately.
• B: 5 >= 5 is true. 10 <= 10 is true. true && true is true. This is our answer.
• C: 5 > 5 is false. 10 > 10 is false. false || false is false.
• D: x == 5 is true. !(true) is false. This question highlights the importance of understanding the difference between > (greater than) and >= (greater than or equal to).

This is a great exercise in tracing ArrayList modifications. Let's go step-by-step:

1. list is [A, B, C]
2. list.add(1, "X"): This inserts "X" at index 1, shifting everything else to the right. list becomes [A, X, B, C].
3. list.set(3, "Y"): This replaces the element at index 3 with "Y". list becomes [A, X, B, Y].
4. list.remove(0): This removes the element at index 0. list becomes [X, B, Y]. Finally, printing the list gives us [X, B, Y].

This is a fundamental concept in Java. The primitive types are the basic building blocks of data: int, double, char, boolean, long, short, byte, and float. String, on the other hand, is an object type. You can tell because it's capitalized (by convention) and you can call methods on it (like .length() or .substring()). Primitive types are just simple values and don't have methods.

Let's trace the method with the given array {1, 2, 3, 4, 5}. The method adds even numbers and subtracts odd numbers.

• result starts at 0.
• arr[0] is 1 (odd): result becomes 0 - 1 = -1.
• arr[1] is 2 (even): result becomes -1 + 2 = 1.
• arr[2] is 3 (odd): result becomes 1 - 3 = -2.
• arr[3] is 4 (even): result becomes -2 + 4 = 2.
• arr[4] is 5 (odd): result becomes 2 - 5 = -3. The loop finishes, and the method returns the final value of result, which is -3.

While interfaces and abstract classes are not a major topic on the exam, understanding their basic properties is helpful. The key difference is that Java supports multiple inheritance of type (through interfaces) but not multiple inheritance of state (through classes). Therefore, a class can implement many interfaces, but it can only extend one parent class (whether abstract or concrete). Choice B is incorrect; interfaces can only have public static final constants, not instance variables. Choice C is incorrect; abstract classes can and often do have constructors to initialize their fields, which are called by subclass constructors. Choice D is incorrect for the reason mentioned above.

The this keyword is a reference to the current object—the object whose method or constructor is being called. It's most commonly used to distinguish between an instance variable and a parameter with the same name. For example, in a constructor public Student(String name) { this.name = name; }, this.name refers to the instance variable, while name refers to the parameter. It's a way for an object to talk about itself.

This is a crucial and often tricky concept! When you use == with objects like String, you are comparing their memory addresses, not their content. Because Java is efficient, string literals like "hello" are often pooled. This means s1 and s2 point to the exact same object in memory, so s1 == s2 is true. However, when you use new String("hello"), you are explicitly telling Java to create a brand new object in a different memory location, even though it contains the same characters. Therefore, s1 and s3 point to different objects, and s1 == s3 is false. To compare the actual content of strings, you should always use the .equals() method, e.g., s1.equals(s3) would be true.

The single most important requirement for a binary search is that the data must be sorted. The entire algorithm is based on the ability to eliminate half of the remaining search space with each comparison by knowing whether to look in the lower half or the upper half. If the array isn't sorted, this logic completely breaks down. While implementations might vary in how they handle duplicates (choice A), they can still function. The number of elements (choice C) and the type of values (choice D) do not affect the fundamental requirement of the algorithm.

Accessing elements in a 2D array uses the format array[row][column], and remember that indices are 0-based! The first index, 1, refers to the row number. Row 0 is {1, 2, 3}, so row 1 is {4, 5, 6}. The second index, 2, refers to the column number within that row. In row 1, column 0 is 4, column 1 is 5, and column 2 is 6. Therefore, grid[1][2] is 6.

This is the definition of encapsulation! Think of it like a car. You, the driver, are given a simple interface (steering wheel, pedals, gear shift) to use the car. You don't need to know the complex details of how the engine, transmission, or electronics work. In programming, we achieve this by making instance variables private (hiding the details) and providing public methods (exposing the functionality) to interact with them. This protects the data and makes the class easier to use.

This code uses a standard nested loop to traverse every element in a 2D array. This is often called a row-major traversal. The outer loop iterates through the rows (r), and the inner loop iterates through the columns (c) of each row. Inside the inner loop, it checks if the current element matrix[r][c] is less than 0 (i.e., negative). If it is, it increments the count variable. It doesn't sum the values (like in D) or just check for the presence in a row (like in A). It simply counts every single negative number, so C is the correct answer.

This is the definition of Selection Sort. Think of it as 'selecting' the smallest remaining item in each pass. In the first pass, it finds the smallest element in the entire array and swaps it with the first element. In the second pass, it finds the smallest element in the rest of the array (from the second element onward) and swaps it with the second element, and so on. Insertion Sort works by building the sorted array one element at a time, inserting each new element into its proper place. Merge Sort is a recursive divide-and-conquer algorithm. Binary Sort isn't a standard sorting algorithm name; it's likely a confusion with binary search.

While you can use a while loop for situations A and B, they are better suited for for loops (a for-each loop for A, and a standard for loop for B). The true strength of a while loop is when the number of iterations is not known beforehand. For example, reading user input until they type 'quit', or processing items from a queue until it's empty. The loop continues as long as a condition is met, making it perfect for event-driven or condition-driven repetition. Choice D describes an if-else statement.

This question tests compound assignment operators and integer division.

1. int x = 10; : x is 10.
2. x += 5; : This is shorthand for x = x + 5;. So x becomes 10 + 5 = 15.
3. x /= 3; : This is shorthand for x = x / 3;. Since x is an integer, this is integer division. 15 / 3 is 5. So x becomes 5. The final value of x is 5.

This is a very useful method from the Integer wrapper class. Its job is to take a String that represents a number and convert it into the primitive data type int. While the method belongs to the Integer class, its return type is the primitive int. This is a common point of confusion. The method Integer.valueOf("123") would return an Integer object.

The length() method of the String class returns the total number of characters in the string. Don't confuse this with the length property of an array (arr.length), which is not a method call. Also, remember that the index of the last character is word.length() - 1 because strings (and arrays) are 0-indexed.

Let's trace the recursive calls:

• rec(5) is called. Since 5 > 1, it returns 5 * rec(3).
• rec(3) is called. Since 3 > 1, it returns 3 * rec(1).
• rec(1) is called. Since 1 <= 1, it hits the base case and returns 1. Now, let's substitute the values back up the call stack:
• The rec(3) call becomes 3 * 1, which is 3.
• The original rec(5) call becomes 5 * 3, which is 15. The final result is 15.

This logic describes the exclusive OR (XOR) operation. The customer gets a discount if one condition is true, but not both. Let's break down choice B: (isMember || hasCoupon) checks if they are a member OR have a coupon (or both). This part is true if they qualify for any discount. !(isMember && hasCoupon) checks if they are NOT both a member AND have a coupon. By combining these with &&, we enforce that the first part is true AND the second part is true, which perfectly matches the requirement. Choice A is a simple OR, which would include the case where both are true.

Choice B shows the complete and correct syntax for creating a generic ArrayList. The <String> part specifies that this list will only hold String objects, which is a good practice called using generics. Choice A creates a raw, non-generic ArrayList, which is outdated and less safe, but it would compile with warnings. Choice C tries to use array syntax ([]) to add an element, which is incorrect for an ArrayList; you must use the .add() method. Choice D is also correct in modern Java (Java 7+), as the type can be inferred on the right side (this is called the 'diamond operator'). However, Choice B is the most explicit and universally correct syntax taught in AP CS A.

The % symbol is the modulo operator, which gives you the remainder of a division. When you divide 15 by 4, it goes in 3 times (3 * 4 = 12), and there is a remainder of 3 (15 - 12 = 3). So, 15 % 4 evaluates to 3.

To create an object (instantiate a class), you must use the new keyword, followed by a call to one of the class's constructors. The Book class has a constructor that takes a String argument. Choice C correctly uses the new keyword and passes the required string to the constructor. Choice A is missing new. Choice B is trying to call a no-argument constructor, which hasn't been defined in this case. Choice D has incorrect syntax.

This question is about informal run-time analysis (Big O notation). O(n²) means the runtime is proportional to the square of the input size n. Let the original runtime be T ≈ k n². If we double the input size to 2n, the new runtime T' will be T' ≈ k (2n)² = k (4n²) = 4 (k n²) = 4 T. So, the runtime quadruples (increases by a factor of 4). This is characteristic of algorithms with nested loops that both iterate over the input, like a basic selection sort.

This question tests the crucial difference between how primitive types/Strings (pass-by-value) and arrays/objects (pass-by-reference-value) behave as parameters. When a (an array) is passed to the method, the method receives a copy of the reference, which still points to the original array in memory. Therefore, changing arr[0] inside the method changes the original array. However, String objects are immutable. When s is passed, the line str += "!!!" does not change the original string s. Instead, it creates a new string "Hi!!!" and makes the local variable str point to it. The original s in the calling code remains unchanged. So, s is still "Hi" and a[0] is 99.

Let's count the iterations for each loop:

• A: i will be 1, 2, 3, 4. That's 4 times.
• B: i will be 0, 1, 2, 3, 4, 5. That's 6 times.
• C: i will be 5, 4, 3, 2, 1. That's 5 times. This is the correct answer.
• D: i will be 1, 3, 5. That's 3 times. This is a good reminder to be very careful with your loop bounds (< vs <=) and starting/ending values.

This question tests polymorphism and casting. You can always assign a subclass object to a superclass variable (this is called upcasting), because a Fruit is a Food. So, f = a; (Choice A) is perfectly fine. However, you cannot assign a superclass object to a subclass variable directly. The object f is just a Food, it might not be a Fruit (it could be a Vegetable). The compiler prevents this with an error, so a = f; (Choice B) is illegal. To make it work, you would need an explicit cast a = (Fruit)f;, which would then risk a ClassCastException at runtime if f wasn't actually a Fruit.

While computational cost and algorithm choice are technical challenges, the primary ethical concern is about the impact on people. Large data sets, even when anonymized, can often be 'de-anonymized' by cross-referencing with other data sets, potentially exposing sensitive personal information. This raises significant privacy issues that programmers and data scientists must consider. The AP curriculum emphasizes the importance of being responsible with the data we handle.

This is a clever way to count occurrences of a character. Let's trace the while loop:

1. Initial: str is "banana", count is 0. str.indexOf("a") is 1, which is not -1. Loop enters.
2. Iteration 1: count becomes 1. str.indexOf("a") is 1. str becomes str.substring(1 + 1), which is str.substring(2), so str is now "nana".
3. Loop check: str is "nana". str.indexOf("a") is 1, not -1. Loop enters.
4. Iteration 2: count becomes 2. str.indexOf("a") is 1. str becomes str.substring(1 + 1), which is str.substring(2), so str is now "na".
5. Loop check: str is "na". str.indexOf("a") is 1, not -1. Loop enters.
6. Iteration 3: count becomes 3. str.indexOf("a") is 1. str becomes str.substring(1 + 1), which is str.substring(2), so str is now "".
7. Loop check: str is "". str.indexOf("a") is -1. The loop condition is false, and the loop terminates. The final value of count, 3, is printed.