Comprehensive 2015 Collegeboard MCQ Reflection • 50 min read

My Score: 30/39

Overall, the test went fairly well. While some questions posed challenges, I felt confident in my ability to navigate through the majority of them. The questions that proved to be particularly difficult often required a deeper level of analysis, and in those instances, I applied various problem-solving strategies to the best of my ability. For example, questions that involved complex algorithms or required a more nuanced understanding of certain programming paradigms proved to be trickier than anticipated. I also realized that some of my errors stemmed from misinterpreting the logic within certain code snippets or overlooking specific nuances embedded in the questions. It is this awareness that prompts me to utilize the upcoming winter break as an opportune time for targeted practice.

Questions I got incorrect:

Question 14:

For this question, you were supposed to identify the potential error in the “biggest” method. I chose the incorrect answer, Option D, when the correct answer was Option C. I mistakenly thought that the method might not work correctly when both “a” and “c” have equal values. However, the actual issue lies in the comparison between “a” and “b” in the second condition of the first “else if” statement. The method may not work correctly when “a” and “b” have equal values because in such a case, it would return the value of “b” instead of “a.” This is why the correct answer is Option C.

Collegeboard Explanation: Consider the example where a = 5, b = 3, and c = 5. In this case, the first boolean condition evaluates to false since a is not greater than c and the second boolean condition evaluates to false since b is not greater than a, and the value of c is returned, which is the greatest of all three integers. Consider the second example where a = 5, b = 6, and c = 5. In this case, the first boolean condition evaluates to false since a is not greater than b and the second boolean condition evaluates to true since b is greater than a and b is greater than c, and the value of b is returned which is the greatest of the three values. Consider the third example where a = 5, b = 5, and c = 5. In this case, the first boolean condition evaluates to false since a is not greater than b and the second boolean condition evaluates to false since b is not greater than a, and the else is executed so the value of c is returned. Since all three values were equal any of the values could be returned as the greatest of the three values.

Question 17:

For this question, you were supposed to determine the value returned from a call to the “doWhat” method with a positive integer parameter. I chose the incorrect answer, Option C, when the correct answer was Option D. I mistakenly thought that the method was summing even integers, but it was actually summing odd integers between 1 and the given parameter “num.” The loop in the method increments by 2, ensuring that it includes only odd integers. This is why the correct answer is Option D, representing the sum of all odd integers between 1 and num, inclusive.

Collegeboard Explanation: This would be the result if loop was initialized to 0 instead of 1.

Question 21:

For this question, you were supposed to determine what is printed as a result of the call to the “whatsItDo” method with the parameter “WATCH.” I chose the incorrect answer, Option C, when the correct answer was Option D. I mistakenly thought that the method was printing substrings excluding the first character. However, the method actually prints substrings including the first character but excluding the last one. Therefore, the correct answer is Option D, representing the printed substrings:

• WATC
• WAT
• WA
• W

Collegeboard Explanation: This would be the result of temp being assigned a substring of the parameter with the first character removed in the first recursive call and then the last character removed in subsequent calls.

Question 23:

For this question, you were supposed to determine the values in the array arr after two passes of the for loop. I chose the incorrect answer, Option B, when the correct answer was Option C.

After two passes of the for loop, the array arr would be {3, 4, 5, 2, 1}. During each pass, the algorithm compares the current element with the elements before it and swaps them if necessary. In this case, the array is sorted in ascending order after two passes, resulting in Option C being the correct answer.

Collegeboard Explanation: This insertion sort method begins sorting the array from the beginning putting the first three numbers in order during the first two passes. Only 3, 4, and 5 will be in the right order.

Question 24:

For this question, you were supposed to identify the methods that can be added to the SomeMethods class without causing a compile-time error. I chose the incorrect answer, Option B, when the correct answer was Option D.

I mistakenly thought that both the methods with signatures public void one(int value) (Option I) and public void one(String first, int second) (Option II) could be added. However, the correct answer is Option D, as only the methods with signatures public void one(String first, int second) (Option II) and public void one(int first, int second, int third) (Option III) can be added without causing a compile-time error. The reason is that the method signatures must be distinct, and Option I conflicts with the existing method public void one(int first) in the SomeMethods class.

Collegeboard Explanation: Choice I will cause a compiler error if added to the SomeMethods class because it has the same method signature as public void one (int first), since it has the same name (one) and each parameter list consists of a single int parameter. Choice III can be added to the SomeMethods class because there are three int parameters and no other method named one has three int parameters

Question 27:

For this question, you were supposed to determine the value of the array data after three passes of the outer loop. I chose the incorrect answer, Option B, when the correct answer was Option A.

After three passes of the outer loop, the array data will be sorted in increasing order. The correct answer is Option A: {1, 2, 3, 4, 5, 6}. The sorting algorithm correctly compares and swaps elements, leading to the sorted order as indicated in Option A.

Collegeboard Explanation: This is the result of completing all passes through the outer loop.

Question 30:

For this question, I selected option B, thinking that the second code segment alone would be sufficient to replace the missing code in the getCost method. However, the correct choice is actually option D, which combines the first and second code segments.

The correct code segment to replace the missing code in the getCost method is:

if (numBoxes >= 10) {
    totalCost = numBoxes * 1.50;
}
else if (numBoxes >= 5) {
    totalCost = numBoxes * 3.00;
}
else if (numBoxes > 0) {
    totalCost = numBoxes * 5.00;
}

This ensures that the correct pricing conditions are applied to calculate the total cost based on the number of boxes ordered. I apologize for any confusion in my previous response.

Collegeboard Explanation: Choice I will compute the incorrect price for numBoxes being greater than or equal to 5. For example, if numBoxes is 10, the first boolean expression will evaluate to true and totalCost will be assigned the correct price of 15. However, the second boolean expression will also evaluate to true, changing the value of totalCost to 30. The third boolean expression will also evaluate to true, changing the value of totalCost to 50.

Question 33:

For this question, I selected option D, thinking that the second and third code segments would correctly assign the maximum element of the array to the variable max. However, the correct choice is actually option E, as all three code segments will always correctly assign the maximum element of the array to the variable max.

• Code Segment I uses a for-each loop and initializes max to the minimum integer value before iterating through the array to find the maximum.
• Code Segment II initializes max to 0, and through a loop, iterates over the array while updating max if a larger value is encountered.
• Code Segment III initializes max to the first element of the array and iterates through the array, updating max if a larger value is found.

Collegeboard Explanation: Choice I sets max to Integer.MIN_VALUE, which is the smallest possible integer value. Then it accesses each element in arr and assigns them value. If value is greater than max, max is assigned value since it is now the largest value so far.

Question 36:

For this question, I selected option C, thinking that the maximum number of times the statement indicated by / * Calculate midpoint * / could execute would be 20. However, the correct choice is option D, which indicates that the maximum number of executions is 11.

In the provided binary search method, the statement is executed within a while loop that continues until start is equal to end (the last possible iteration before termination). In the worst-case scenario where the target is not found, the loop will execute a maximum of 11 times.

Collegeboard Explanation: The binary search eliminates half of the array during each iteration, as such you would need fewer iterations than 20.

Additional Questions:

Chosen from Mr Mortensen’s list of frequently missed questions, as well as questions that I struggled with a bit.

Question 8 - Operation method on 2D int array (focus: how to get faster on loops):

public static int[] operation(int[][] matrix, int r, int c) {
    // Create an array to store the result, with the length of the matrix
    int[] result = new int[matrix.length];

    // Iterate through each column in the specified row 'r' of the matrix
    for (int j = 0; j < matrix.length; j++) {
        // Perform the matrix operation: Multiply the element at row 'r' and column 'j'
        // with the element at row 'j' and column 'c', and store the result in the 'result' array
        result[j] = matrix[r][j] * matrix[j][c];
    }

    // Return the array containing the result of the matrix operation
    return result;
}

public static void main(String[] args) {
    // Define a 2D matrix 'mat'
    int[][] mat = {
            {3, 2, 1, 4},
            {1, 2, 3, 4},
            {2, 2, 1, 2},
            {1, 1, 1, 1}
    };

    // Call the 'operation' method with row index 1 and column index 2
    int[] arr = operation(mat, 1, 2);
}

When I executed the provided code, I observed the following outcome:

The matrix mat is initially defined as:

{3, 2, 1, 4},
{1, 2, 3, 4},
{2, 2, 1, 2},
{1, 1, 1, 1}

I called the operation method with arguments mat, 1, and 2, indicating that the operation is to be performed on the row with index 1 and the column with index 2.

Inside the operation method:

• An array result is created with a length equal to the number of columns in the matrix (matrix.length).
• It iterates through each column in the specified row (r = 1), multiplying the element at row 1 and the current column (matrix[r][j]) with the element at the current row and column 2 (matrix[j][c]).
• The result of each multiplication is stored in the result array.

The resulting array is then returned.

In the main method, the obtained array is printed.

After calculating the results for each column:

• For j = 0: result[0] = mat[1][0] * mat[0][2] = 1 * 1 = 1
• For j = 1: result[1] = mat[1][1] * mat[1][2] = 2 * 3 = 6
• For j = 2: result[2] = mat[1][2] * mat[2][2] = 3 * 1 = 3
• For j = 3: result[3] = mat[1][3] * mat[3][2] = 4 * 1 = 4

The resulting array arr is {1, 6, 3, 4}. Therefore, upon running the code, it printed:

1 6 3 4

Question 12 - Compound Boolean expression with variables x and y (focus: DeMorgan’s law and truth tables):

When I read this expression, I broke it into the following parts:

1. (x && y): This part is true only if both x and y are true.

2. !(x || y): This part is true only if neither x nor y is true, meaning both x and y are false.

3. The outermost part is && (logical AND) between the results of the two inner parts.

So, for the entire expression to be true, both conditions (x && y) and !(x || y) must be true simultaneously. However, this is a logical contradiction because it requires both x and y to be both true and false at the same time, which is impossible.

Therefore, the overall result of the expression is false.

Question 18 - Print statement with mathematical operators (focus: integer math and order of ops):

When I executed the statement System.out.println(404 / 10 * 10 + 1);, I had to break down the expression:

1. 404 / 10 turned out to be 40.
2. Multiplying 40 by 10 resulted in 400.
3. Adding 1 to 400 gave the final result of 401.

So, the output of the statement was 401.

Question 35 - Iterative binarySearch of 1D int array (focus: purpose, speed, accuracy):

This is the question I will be presenting

public static int binarySearch(int[] data, int target) {
    int start = 0;
    int end = data.length - 1;

    // Continue the search as long as the start index is less than or equal to the end index
    while (start <= end) {
        // Calculate the midpoint of the current search range
        int mid = (start + end) / 2;

        // If the target is less than the value at the midpoint, adjust the end index
        if (target < data[mid]) {
            end = mid - 1;
        }
        // If the target is greater than the value at the midpoint, adjust the start index
        else if (target > data[mid]) {
            start = mid + 1;
        }
        // If the target is equal to the value at the midpoint, return the index
        else {
            return mid;
        }
    }

    // If the target is not found, return -1
    return -1;
}

If you were to plug in the provided values:

int[] values = {1, 2, 3, 4, 5, 8, 8, 8};
int target = 8;

// Calling the binarySearch method and storing the result in the 'result' variable
int result = binarySearch(values, target);

Here’s a breakdown of the process:

1. Initially, the search range is set with start = 0 and end = 7 (length of the array - 1).
2. In the first iteration, the midpoint mid is calculated as (0 + 7) / 2 = 3. Since the target (8) is greater than data[3] (4), the search continues in the right half of the array, and start is updated to 4.
3. In the second iteration, the midpoint is calculated as (4 + 7) / 2 = 5. Here, the target (8) is equal to data[5], so the method returns 5 as the index where the target is found.

As a result, the value returned by the call binarySearch(values, target) is 5. This indicates that the target value 8 is found at index 5 in the given array values.

Question 39 - List with Alex, Bob, Carl (focus: List, .size, .add, overwrite):

// Creating a list to store student names
List<String> students = new ArrayList<String>();
students.add("Alex");
students.add("Bob");
students.add("Carl");

// Reflecting on the problem and approaching it using a for loop
for (int k = 0; k < students.size(); k++) {
    // Inside the loop, replacing each element at index 'k' with "Alex"
    // Printing the original element followed by two spaces
    System.out.print(students.set(k, "Alex") + "  ");
}
System.out.println(); // Moving to the next line for clarity

// Reflecting on the problem and approaching it using a for-each loop
for (String str : students) {
    // Printing each element followed by two spaces
    System.out.print(str + "  ");
}

In approaching this problem, I initialized an ArrayList named students to store the names of students. Three strings (“Alex”, “Bob”, “Carl”) were added to this list. The goal was to replace each student’s name with “Alex” and then print the original names followed by the modified list of names.

Using a for loop, each element in the list was replaced with “Alex” using students.set(k, “Alex”). The set method returned the original element, allowing me to print it followed by two spaces. After this loop, a for-each loop was used to print each modified element in the list.

Considering this approach, the expected output after the first loop would be “Alex Bob Carl “ because each element in the list was replaced with “Alex” during the loop, and the original elements were printed. Following this, the output after the second loop would be “Alex Alex Alex “ since all elements in the list were set to “Alex” during the first loop.

Thus, the final output would be:

Alex Bob Carl
Alex Alex Alex

Final Reflection:

The analysis of the Java code problem pinpointed areas for improvement in my foundational understanding. Specifically, a brief confusion in the binary search algorithm emphasized the need for reinforcement in fundamental principles. Reflecting on the code segment highlighted the importance of a more systematic approach in testing environments and the value of regular, focused practice. The absence of a nested loop in the provided code emphasized the necessity to concentrate on problems involving nested constructs for more efficient problem-solving. While I demonstrated adaptability in unfamiliar concepts like De Morgan’s law, targeted practice in this area and refining skills related to operations such as integer division would contribute to building a more robust foundation in Java programming. To progress, I aim to enhance my understanding of fundamental principles, adopt a structured approach to practice, concentrate on problems with nested loops, and dedicate focused practice to specific topics like De Morgan’s law and integer division.