AP Computer Science A — Pattern-Matched Mock

The correct answer is 2.5. When a double is divided by an int, the int is promoted to a double before the division occurs, resulting in floating-point division. A common mistake is to think this performs integer division, which would result in 2.0 (choice A) or just 2 (choice C). The code is syntactically correct and will compile (ruling out D).

The correct output is false true true. b1 is false because == compares memory addresses for objects. str1 is a string literal from the string pool, while str2 is a new object created in memory. b2 is true because the .equals() method compares the actual character sequences of the strings. b3 is true because str3 is assigned the same memory address as str1. This question tests the critical difference between == and .equals() for String objects.

The correct formula for a random integer in the range [min, max] is (int)(Math.random() * (max - min + 1)) + min. For the range [10, 20], this is (int)(Math.random() * (20 - 10 + 1)) + 10, which simplifies to (int)(Math.random() * 11) + 10. Choice A generates numbers from 10 to 19. Choice C generates numbers from 11 to 20. Choice D generates numbers from 11 to 21.

The correct output is BD. The first if condition (a > b) (5 > 10) is false. The first else if condition (c > b && b > a) (15 > 10 AND 10 > 5) is true. Therefore, "B" is printed. Since it's an if-else if chain, the subsequent else if is skipped. Finally, the statement System.out.print("D"); is executed because it is outside the conditional block. A common mistake is to evaluate all if conditions, which would lead to printing "BCD".

The correct answer is 5. The while loop executes as long as n is greater than 0. The value of n is halved (using integer division) in each iteration. Let's trace the execution with n = 17:

1. n=17, x=1. n becomes 17 / 2 = 8.
2. n=8, x=2. n becomes 8 / 2 = 4.
3. n=4, x=3. n becomes 4 / 2 = 2.
4. n=2, x=4. n becomes 2 / 2 = 1.
5. n=1, x=5. n becomes 1 / 2 = 0. The loop terminates, and 5 is printed. This method essentially calculates the number of bits in the binary representation of n, or floor(log2(n)) + 1.

Choices A, B, and C all correctly compute the sum of odd integers from 1 to 100. Choice A iterates directly through the odd numbers. Choice B iterates through all numbers and uses a conditional to add only the odd ones. Choice C is the while loop equivalent of choice A. Choice D is incorrect; it computes the sum of even numbers from 0 to 98 (2*0 + 2*1 + ... + 2*49).

Let's trace the nested loops. The outer loop i runs from 0 to 2. The inner loop j runs from 2 down to i+1.

• When i = 0, j goes from 2 down to 1. System.out.print("*") is called twice. Output: **
• When i = 1, j goes from 2 down to 2. System.out.print("*") is called once. Output: *
• When i = 2, the condition j > i (2 > 2) is false, so the inner loop does not run. Output: (nothing) A println() is called after each outer loop iteration, so the final output is ** followed by a newline, * followed by a newline, and an empty line followed by a newline.

Choice B is the correct syntax. It uses the new keyword and calls the constructor with the required String argument. Then, it calls the instance method setYear on the created object myCar. Choice A fails because it calls a no-argument constructor which is not defined. Choice C uses incorrect syntax for object creation and method calling. Choice D incorrectly tries to call an instance method (setYear) as if it were a static method on the Car class itself.

The correct approach is to use a static variable. A static variable is shared among all instances of a class. By incrementing a static counter within the constructor, every time a new Student object is created, the shared counter goes up by one. An instance variable (Choice A) would give each student their own counter, which would always be 1. A local variable (Choice D) would be destroyed after the constructor finishes. Incrementing in a separate static method (Choice C) would require an explicit call and wouldn't happen automatically upon object creation.

The correct output is 10. In Java, object references are passed by value. Inside the manipulate method, the parameter g initially holds the same reference as myGadget. The line g.doubleValue() modifies the object that both g and myGadget point to, changing its internal value from 5 to 10. However, the next line, g = new Gadget(10), reassigns the local parameter g to point to a new Gadget object. This does not change what myGadget in the calling scope points to. Therefore, when myGadget.getValue() is called, it returns the value of the object it still points to, which is now 10.

The code performs a left shift on the array elements. Let's trace the state of arr: Initial: {10, 20, 30, 40, 50} After i=0: arr[0] = arr[1] -> {20, 20, 30, 40, 50} After i=1: arr[1] = arr[2] -> {20, 30, 30, 40, 50} After i=2: arr[2] = arr[3] -> {20, 30, 40, 40, 50} After i=3: arr[3] = arr[4] -> {20, 30, 40, 50, 50} The loop finishes. The value at arr[2] is 40. A common mistake is to mentally evaluate the shifts simultaneously instead of sequentially.

The method fails for an array containing only negative numbers. The variable maxVal is initialized to 0. If all numbers in the array are less than 0, the condition nums[i] > maxVal will never be true, and the method will incorrectly return 0 instead of the actual maximum value (which would be -1 for the array in choice C). A robust implementation would initialize maxVal to nums[0] or Integer.MIN_VALUE.

Let's trace the state of the ArrayList:

1. words.add("a"): [a]
2. words.add("b"): [a, b]
3. words.add("c"): [a, b, c]
4. words.add(1, "d"): Inserts "d" at index 1, shifting subsequent elements. The list becomes [a, d, b, c].
5. words.remove(2): Removes the element at index 2, which is "b". The list becomes [a, d, c]. Finally, System.out.println(words) prints the string representation of the list.

This is a classic pitfall. When an element is removed from an ArrayList at index i, the size of the list decreases, and all subsequent elements shift to the left. The element that was at index i+1 is now at index i. However, the loop proceeds by incrementing i, so it will check index i+1 next, effectively skipping the element that just moved into the current position i. The correct way to do this with a forward loop is to decrement i after a removal, or to iterate backwards from list.size() - 1 down to 0.

matrix is a 2D array. matrix[1] refers to the second inner array, which is {4, 5, 6}. matrix[1][2] then refers to the element at index 2 within that second array, which is 6.

The method calculates the sum of all elements in the grid. The outer loop iterates through the columns (c), and the inner loop iterates through the rows (r) for each column. This is known as column-major traversal. Row-major traversal would have the outer loop for rows and the inner loop for columns. Choice C is incorrect as it sums all elements, not just the diagonal. Choice D is incorrect; the code works for any rectangular grid because grid.length is the number of rows and grid[0].length is the number of columns.

A sequential search (or linear search) checks each element of the array one by one, starting from the beginning. In the worst-case scenario, the target value is the very last element in the array, or it is not in the array at all (though the prompt says it is). In this worst case, the algorithm must compare the target with every single one of the n elements before finding it.

The primary advantage of binary search is its efficiency. Because it eliminates half of the remaining search space with each comparison, its worst-case time complexity is logarithmic, O(log n). Sequential search has a linear worst-case time complexity, O(n). For large arrays, this difference is dramatic. Choice A is incorrect; both require similar amounts of memory. Choice B is false; binary search is more complex to implement correctly than sequential search. Choice D is the opposite of the truth; binary search requires the array to be sorted, while sequential search works on any array.

Insertion Sort has this characteristic. In its worst-case (a reverse-sorted array), it has O(n²) complexity. However, if the array is already sorted, Insertion Sort performs in O(n) time, making it very efficient for nearly sorted data. Selection Sort is always O(n²) regardless of the initial order. Merge Sort is always O(n log n). Binary Search (Choice D) is a searching algorithm, not a sorting algorithm.

This method calculates 2ⁿ. Let's trace the calls: mystery(4) -> 2 * mystery(3) mystery(3) -> 2 * mystery(2) mystery(2) -> 2 * mystery(1) mystery(1) -> 2 * mystery(0) mystery(0) -> returns 1 (base case) Now, substitute back: mystery(1) returns 2 * 1 = 2 mystery(2) returns 2 * 2 = 4 mystery(3) returns 2 * 4 = 8 mystery(4) returns 2 * 8 = 16 The base case n == 0 prevents infinite recursion.

The expression is evaluated from left to right. First, 15 / 4 is performed. Since both operands are integers, this is integer division, which results in 3. Then, the expression becomes 3 * 2.0. Since one operand is a double, the int 3 is promoted to 3.0, and the result is 6.0.

This question tests short-circuit evaluation. For an OR (||) expression, if the left-hand side is true, the entire expression must be true, so the right-hand side is not evaluated. Here, x > 5 (6 > 5) is true. Therefore, the second part of the expression, y < 10, is skipped entirely. This means choice A is also correct, but choice D is the more precise explanation of the language's behavior.

The substring(beginIndex, endIndex) method in Java returns a new string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1. The indices are 0-based. So, it includes the character at index 3 ('p') and goes up to, but does not include, the character at index 7 ('r'). The characters at indices 3, 4, 5, and 6 are 'p', 'u', 't', 'e'. So the result is "pute". Wait, I made a mistake in my own reasoning. Let's re-check. c=0, o=1, m=2, p=3, u=4, t=5, e=6, r=7. substring(3, 7) starts at index 3 ('p') and ends before index 7 ('r'). So it includes indices 3, 4, 5, 6. The characters are 'p', 'u', 't', 'e'. My initial answer C was wrong. Let me re-evaluate. c=0, o=1, m=2, p=3, u=4, t=5, e=6. Oh, substring(3,7) should be pute. Let me check the choices again. pute is choice A. I seem to have mislabeled my own question. Let me re-write the question to make mput the answer. "computer".substring(2, 6) would be mput. Let's use that.

Corrected Stem: What is the output of "computer".substring(2, 6)? Explanation: The substring begins at index 2 ('m') and extends to the character at index 6-1=5 ('t'). It includes characters at indices 2, 3, 4, and 5, which are 'm', 'p', 'u', 't'. The result is "mput".

This is a standard for loop structure. The loop variable k takes on the values 0, 1, 2, ..., up to N-1. The total number of values in this sequence is (N-1) - 0 + 1, which equals N. Therefore, the loop body executes N times. This is a fundamental concept for loop analysis.

A class variable is another name for a static variable. It is a single variable that is shared by all instances of the class. It is declared with the static keyword at the class level (outside any method). Choice A is a local variable. Choice B is an instance variable. Choice D is a parameter, which is a type of local variable.

The constructor defined is public Item(String n, double p). To create an object, you must call new followed by a constructor call that matches a defined signature. Choice B matches this signature exactly, providing a String first and a double second. Choice A is missing the double argument. Choice C has the arguments in the wrong order. Choice D calls a no-argument constructor, which has not been defined for this class.

this is a reference to the current object. Its most common use is to resolve ambiguity when a method parameter or local variable has the same name as an instance variable. For example, in a constructor public MyClass(int x) { this.x = x; }, this.x refers to the instance variable, and x refers to the parameter. Choice A is done with new. Choice B is done with super. Choice D is done with static.

When an array of a primitive numeric type (like int, double, etc.) is created in Java, its elements are automatically initialized to the default value for that type. The default value for int is 0. The default for object types (like String) is null.

This is the standard algorithm for swapping two variables. You must use a temporary variable to hold one of the original values. In Choice A, the original value of arr[i] is lost when arr[i] = arr[j] is executed, so both elements end up with the original value of arr[j]. Choices C and D also fail to preserve one of the original values correctly during the assignment process.

int is one of Java's 8 primitive data types. Integer is a class from the java.lang package that 'wraps' an int value in an object. This is necessary for situations where an object is required, such as storing numbers in an ArrayList or other collection classes. This process is known as boxing (int to Integer) and unboxing (Integer to int).

Statement A is false. ArrayLists can only store objects, not primitive types. To store primitive values like int or double, you must use their corresponding wrapper classes (Integer, Double). Statement B is true and is the primary advantage of ArrayLists over arrays. Statement C is true. Statement D is true and is the reason statement A is false.

For a 2D array in Java, which is an array of arrays, .length gives the number of rows (the size of the outer array). In this case, m is an array containing 4 elements, where each element is an int[] of size 5. Therefore, m.length is 4. To get the number of columns, you would use m[0].length, which would be 5.

This description perfectly matches Selection Sort. In each pass, it selects the smallest remaining element and swaps it into its correct final position. Insertion sort builds the final sorted array one item at a time by taking the next item and inserting it into its proper place in the already sorted part. Merge sort is a divide-and-conquer algorithm.

A base case is a condition under which the method returns a value without making another recursive call. This is the mechanism that stops the chain of recursion. Without a base case, the method would keep calling itself indefinitely, leading to a StackOverflowError.

Due to the order of operations, the division inside the parentheses is performed first. 10 / 4 is integer division, which results in 2. Then, this integer 2 is cast to a double, resulting in 2.0. To get 2.5, the cast would need to be applied to one of the operands before the division, like (double) 10 / 4.

This is the standard algorithm for determining a leap year. Let's test the choices:

• 1900: 1900 % 4 == 0 is true, but 1900 % 100 != 0 is false. So the first part of the OR is false. 1900 % 400 == 0 is also false. Result: false.
• 2019: 2019 % 4 == 0 is false. The whole expression is false. Result: false.
• 2000: 2000 % 4 == 0 is true, but 2000 % 100 != 0 is false. So the first part of the OR is false. However, 2000 % 400 == 0 is true. Since it's an OR, the result is true.
• 2100: Same logic as 1900. Result: false.

This question tests the immutability of String objects in Java. The concat method does not change the original string. Instead, it returns a new string that is the result of the concatenation. Since the return value of s.concat(" Rocks!") is not assigned back to s or any other variable, the original string s remains unchanged.

Let the runtime be T(n) = c * n * log(n). If we double the input size to 2n, the new runtime is T(2n) = c * (2n) * log(2n). Using log properties, log(2n) = log(2) + log(n). So, T(2n) = 2cn * (log(2) + log(n)) = 2cn*log(n) + 2cn*log(2). This is 2 * T(n) + 2cn*log(2). Since 2cn*log(2) is a positive term, the new runtime is slightly more than double the original runtime. This is a key characteristic of O(n log n) complexity.

Abstraction is the concept of simplifying complex reality by modeling classes based on the relevant attributes and behaviors they share, and hiding the complex implementation details. For example, when you drive a car, you use the steering wheel and pedals (the public interface), without needing to know how the engine or transmission works (the private implementation). Choice B describes polymorphism. Choice C describes inheritance. Choice D is the opposite of good abstraction/encapsulation.

This code uses an enhanced for loop (or for-each loop) to iterate through the nums array. It checks if each number x is even (x % 2 == 0). The even numbers in the array are 2 and 4. For each of these, count is incremented. So, count is incremented twice, and its final value is 2.