The College Board released the complete 2009 AP Computer Science A Exam, including the multiple choice section. While their released exam includes detailed explanations for each free response question, it does not offer detailed explanations for each multiple choice question. Question by question explanations for the 2009 AP Computer Science A Multiple Choice Section are below.
You must purchase the released exam itself from the College Board’s Online Store. Refer to the College Board product for the original questions and for the letter answers.
Review the 2009 AP CS A Exam Multiple Choice with AP CS Tutor Brandon Horn.
2009 AP CS Exam Free Response Solutions
Recommended Practice Topics
value is unchanged before it is printed the first time, so the first number output is 15. value is incremented after the call to println and the loop stops when value == 28 so the last number output is 27.
Case I: The && operation evaluates to true if and only if both operands are true. The condition in Case I is evaluated as (bonusOne && bonusTwo) && bonusThree. For the condition to evaluate to true all 3 variables must be true. This correctly implements the intended condition.
Case II: The || operation is true if at least 1 operand is true. The condition in Case II evaluates to true if at least 1 of the variables is true, which is not the intent.
Case III: The conditions are evaluated independently. It is possible for grade to be incremented by 0, 5, 10 or 15 points depending on the values of the variables. This is not the intent.
Interchanging, often called swapping, the values of at 2 positions in an array, or in an ArrayList requires the use of a variable to store the value that would otherwise be lost when one value in the array is replaced with the other.
Answers A and B fail to use a temporary variable. Answer C uses a temporary variable but stores the wrong value. Answer E stores the correct variable but does not use the temporary variable.
Answer D correctly stores one of the values in the temporary variable, overwrites the original copy then retrieves the temporary copy.
The Quick Reference contains documentation for each ArrayList method called. The list after each step is below.
[A, B, C]
[D, A, B, C]
[D, A, B]
[E, D, A, B]
A superclass contains fields and methods that are used by all of its subclasses. The term superclass is not intended to imply importance or complexity, but rather indicates that the superclass is above a subclass in a class hierarchy.
In the GridWorld Case Study, the Actor class is a superclass for subclasses such as Bug, Rock and Critter. Actor contains methods common to all its subclasses such as getLocation and getGrid.
Answers B and C incorrectly refer to the complexity of a superclass. Answer D suggests that data should be public, which is not only unnecessary but also violates the principle of encapsulation.
Answer E states that the superclass should provide the most specific details; however, a superclass is actually less specific than its subclasses. For example, an Actor could be a Bug, a Critter or another subclass. The subclass is can contain details specific to itself. For example, Critter contains the method getMoveLocations.
If k is initialized to 1, the outer loop will never run, so the inner loop will never run, so Hello will not be printed at all.
If k is initialized to n, the outer loop will run n – 1 times. (If p was initialized to 1, the outer loop would run n times.) Each time the outer loop runs, the inner loop will run n – 1 times.
(n – 1) runs of the outer loop multiplied by (n – 1) runs of the inner loop is (n – 1)2.
Case I uses a straightforward for loop to traverse the vals. total is incremented by vals[pos] during each run of the loop. After the loop total contains the sum of all values in vals, as intended.
Case II attempts to traverse vals backwards, which would work, except pos is initialized to vals.length. vals.length is not a valid index in vals, so the loop throws an ArrayIndexOutOfBoundsException on its first iteration.
Case III uses a while loop to traverse vals. The loop is exactly equivalent to the for loop from Case I, so it works as intended.
The loop runs 5 times. Each value of rep and the String printed are shown below.
Everything is printed on the same line, so the output is abbccddeef.
Tracing the method for 50 iterations of the loop would take too long, so it is important to determine what each variable represents. Each if statement is independent (there are no else if statements, so:
typeA is incremented for each value of k that is a multiple of both 2 and 5.
typeB is incremented for each value of k that is a multiple of 2 (regardless of whether it is also a multiple of 5).
typeC is incremented for each value of k that is a multiple of 5 (regardless of whether it is also a multiple of 2).
The loop is run for values of k from 1 to 50, inclusive. Within that range, there are 5 multiples of both 2 & 5, 25 multiples of 2 and 10 multiples of 5. The method outputs 5 25 10.
/* expression */ should evaluate to true if and only if the value in nameList at position j is equal to name.
nameList is an ArrayList so the element at position j is accessed as nameList.get(j). The contents of String objects are compared using the equals method, not ==.
The correct comparison is nameList.get(j).equals(name).
Case I returns n * 10 for all values of n that are multiples of both 3 and 4. It returns n for all other values of n.
In the table of example inputs and outputs, someProcess(3) returns 30. Case I would return 3 because 3 is not a multiple of both 3 and 4. Case I will not produce the intended results.
Case II returns n * 10 for all values of n that are multiples of either 3 or 4. It returns n for all other values of n.
This corresponds exactly with the table given. Each value of n that is a multiple of either 3 or 4 results in a return vale of n * 10. All other values of n result in a return value of n.
Case III is equivalent to Case I. Both conditions must evaluate to true for the method to return n * 10.
x is an integer >=0. x / 10 is x without its least significant (last) digit. x % 10 is the least significant digit itself. The recursive call to mystery is prior to the call to print, so the last digit removed is the first digit printed. The last digit removed is 1. The second to last digit removed is 2 and so on. mystery is just an elaborate way of printing x.
My Stack based trace of 2009 AP CS A Multiple Choice #13 shows a step by step solution.
Case I attempts to calculate the value for yrs as extraMonths % 12 and the value for mos as extraMonths / 12. There are 2 issues with this approach. The assignments are reversed. There are extraMonths / 12 additional years and extraMonths % 12 additional months. Also, Case I fails to take into account the situation in which months + mos exceeds 12.
Case II correctly converts the original age into months as years * 12 + months. It then adds extraMonths to correctly calculate the new age in months. Case II then converts the total number of months into years (totalMonths / 12) and months (totalMonths % 12) and assigns the results to years and months. Case II works as intended.
Case III first computes the total number of months, including the new months as months + extraMonths. Case III correctly determines how many years are represented by those months as totalMonths / 12 and correctly adds the result to years. The total number of months is what remains after converting all groups of 12 months to years, totalMonths % 12. Case III correctly assigns this to months. Case III works as intended.
inRangeMessage returns “Not in range” if either part of the condition is true; otherwise, it returns “In range”. In other words, inRangeMessage returns “In range” if and only if value >= 0 && value <= 100.
Case I incorrectly returns “In range” if value >= 0 without checking whether value <= 100.
Case II checks each out of range condition separately and returns “Not in range” if either condition is true. If neither condition is true, it correctly returns “In range”. Case II works as intended.
Case III has the same problem as Case I. Case III immediately returns “In range” if value >= 0 without checking the upper bound.
After the 3 assignment statements, one and three refer to the same instance of SomeClass. two refers to a different instance. The statement one.increment(200) increments the value of num in the object to which both one and three refer. The object to which two refers in unaffected.
Immediately prior to the println statement, one and three refer to the same object inside which num stores 300. two refers to a different object inside which num stores 100.
sortArray implements a variant of selection sort that sorts the array starting at the end. /* missing code */ controls the inner loop, which is responsible for finding the maximum value from 0 to j. pos starts at j, so the inner loop only needs to traverse the elements from 0 to j – 1. The order in which it does this is irrelevant, but it must cover each element in the range and ignore all elements outside the range.
Answer A incorrectly excludes the element at position 0.
Answer B correctly visits each element in the range and no other elements.
Answer C incorrectly excludes the element at position 0 and incorrectly continues until the end of the array, rather than stopping at j – 1. Although stopping at j would also be acceptable, proceeding farther means that the loop will visit elements from the already sorted part of the array while seeking the minimum.
Answer D has a condition that would prevent the loop from running (k > arr.length).
Answer E correctly includes the element at position 0, but also incorrectly continues into the already sorted part. Answer E also exceeds the bounds of the array by including arr.length.
Let a = x && y. The statement is equivalent to a || ! a which always evaluates to true.
As specified in the Quick Reference, Math.random() generates a random value in the range 0 <= r < 1. Math.random() * 5.0 generates a random value in the range 0 <= r < 5.0. Math.random() * 5.0 + 0.5 generates a random value in the desired range.
Multiplying the result of Math.random changes the maximum possible value. Adding to the result of Math.random changes both the minimum and maximum possible values. It is possible to generate numbers within any desired range by combining these operations.
Case I explicitly checks each part of the specified conditions and returns the correct value in each case.
Case II uses the same correct technique, but includes the extra variable pass. pass is initialized to false then changed to true if and only if one of the desired conditions is met. Case II works correctly.
Case III is a more efficient variant of the same combination of checks that avoids the if statements and just returns the result of a single correct boolean condition. Case III works correctly.
The Quick Reference contains documentation for each Location class method called. loc2.getAdjacentLocation(Location.EAST) returns a Location object representing (3, 3). The first condition evaluates to true and “aaa” is printed.
loc1 and loc2 have the same row value. The second condition is also true and “XXX” is printed.
loc1.getDirectionToward(loc2) returns 270 (Location.WEST). The third condition is false so nothing else is printed.
Case I correctly calculates the desired direction by getting the direction the bug is facing, adding Location.RIGHt for the 90 degree right turn, then modding the result by Location.FULL_CIRCLE (360) to correctly handle values that exceed 360. Case I then runs super.turn until the bug’s direction matches the desired direction. super.turn turns 45 degrees to the right, so running it repeatedly will eventually result in the bug facing in the desired direction. Case I works as intended.
Case II takes a much simpler approach and runs super.turn twice, which correctly accomplishes a 90 degree right turn.
Case III explicitly sets the direction to the bug’s original direction plus Location.RIGHT. The setDirection method handles values >= 360 so Case III also works correctly.
Both Bug and Critter extend Actor which has method getDirection. Lines 1, 2, and 3 are syntactically correct (do not cause a compile time error).
Rock does not contain a getMoveLocations method, so Line 4 is syntactically incorrect (causes a compile time error).
Critter does contain a getMoveLocations method with the appropriate signature, so Line 5 is syntactically correct.
The act method of TestBug uses the canMove and move methods from its superclass Bug. canMove from Bug checks if the location in front of the bug is empty or contains a flower while move moves to the location in front of the bug.
When act is run on t, the TestBug does the following:
- Checks its forward location (2, 2) and finds it empty
- Moves to location (2, 2)
- Checks the next forward location (1, 2) and finds it empty
- Moves to location (1, 2)
The code in the else statement is never run. The bug just moves forward two locations and does not change its direction.
Case I: DancingCritter.getActors returns a list of neighboring DancingCritter objects rather than the list of all neighbors returned by Critter.getActors. When DancingCritter.processActors calls super.processActors, the superclass method does not receive the neighbors it is supposed to remove.
Case II: DancingCritter.processActors fails to call the superclass method to remove actors like a Critter.
Case III: makeMove is an acceptable place to turn. DancingCritter.makeMove adheres to the postconditions of makeMove, which permit turning.
This problem is most easily solved by tracing the loop for each value of k. It can also be solved by recognizing the pattern; however, correctly identifying the number of times the loop runs is critical. A trace of the loop for each value of k is below.
0: 0 is printed
2: 2 is printed
3: 0 is printed
5: 2 is printed
6: 0 is printed
8: 2 is printed
9: 0 is printed
k becomes 11 and the loop terminates. All values are printed on the same line as 0 2 0 2 0 2 0.
The given method should assume that all numbers are even until it is determined that at least one is not. isEven should be initialized to true and set to false as soon as a number that is not even is detected. This is exactly what Answer C does.
Answer A initializes isEven to false and sets it to true as soon as a single even number is found. This detects whether any number in arr is even, not whether all numbers are even.
Answers B, D and E all contain the same error. The else statement in each answer’s /* loop body */ means that the final value of isEven is based only on the last value checked from arr. The initial value assigned to isEven is irrelevant as is the condition checked in each answer’s if statement.
In the last line, !result is equivalent to !(x < y) which is equivalent to (x >= y).
The last line is actually equivalent to ( (x >= y) && (x >= y) ) which is obviously true if and only if x >= y.
When n is 4, the outer loop runs 4 times. For each run of the outer loop, the inner loop runs outer + 1 times. Each time the inner loop runs, it prints outer. A trace of the output from the inner loop for each value of outer is below.
1: 1 1
2: 2 2 2
3: 3 3 3 3
All output is on the same line, so the output is 0 1 1 2 2 2 3 3 3 3
Answers A and B compile because Base has the required constructors. The reference and object types are identical.
Answer C compiles because Sub (the object type) is a subclass of Base (the reference type). Referring to a subclass object with a superclass reference is acceptable.
Answer D compiles because Sub has the required constructor. The reference and object types are identical.
Answer E does not compile because Sub does not have a constructor with a parameter (so new Sub(5) is not syntactically valid).
If a is not less than b and a is not greater than b, a must be equal to b. The expression is equivalent to a == b.
This problem is most easily solved by tracing the loop.
Before 1st run: a = 24, b = 30
1st run: r = 24, a = 30, b = 24
2nd run: r = 6, a = 24, b = 6
3rd run: r = 0, a = 6, b = 0
The loop terminates after the 3rd iteration because b != 0 is false. After the loop, r does not exist (its scope is the loop), a = 6 and b = 0. The println statement prints a which is 6.
The outer loop runs lim times. The inner loop runs lim – outer + 1 times for each run of the outer loop. lim is 10. For each value of outer, s is incremented as shown below.
1: s += 10
2: s += 9
3: s += 8
10: s += 1
s is 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 which is 55.
The loop must continue until pos exceeds the bounds of arr or until val is found. To avoid an exception when checking arr[pos], the bounds check must be performed first.
Answer A correctly stops the loop when either condition described above is met. It also prevents an exception by checking that pos is valid before checking arr[pos].
Answer B fails to ensure that pos is valid before checking arr[pos], so it will crash if val is not found.
Answer C incorrectly allows the loop to continue if either condition is true rather than requiring that both be true.
Answer D incorrectly continues the loop only if val has been found, rather than when val has not been found. It will also crash if it gets to the end of arr (if every value is val).
Answer E will always continue until it exceeds the bounds of arr and crashes.
Case I visits the numbers 1, 4, 7, 10, 13, 16, 19 and prints those such that k % 3 == 1. This condition is true for each number visited, so the loop produces the desired output.
Case II visits each number 1 <= k < 20 and prints those such that k % 3 == 1. This condition is true for each number in the desired output and no others, so the loop produces the desired output.
Case III visits the numbers 1, 4, 7, 10, 13, 16, 19 and prints each number. This produces the desired output.
All arguments in Java are passed by value. This means that the parameter becomes a copy of the value of the argument. For an object reference the parameter becomes a copy of the value of the reference. The object to which the reference refers is not copied. In other words, both the argument and the parameter refer to the same object. Variables of type int are references to objects of type int.
When nums is passed to as an argument to changeIt, list becomes a copy of the reference to the array. The array itself is not copied. nums and list are separate references to the same array. The first line of changeIt assigns list to refer to a new int. nums remains a reference to the original array. None of the changes to the array to which list refers affect the array to which nums refers.
When the primitive type value is passed as an argument to changeIt, num is assigned the value 6. There is no further connection between num and value. The change made to num in changeIt has no affect on value.
Case I incorrectly declares a local variable seq and fills it with random values. The instance fields seq remains null.
Case II correctly initializes the instance fields and fills it with random values.
Case III declares an initializes a temporary ArrayList, fills it with random values, then assigns the instance field seq to refer to it. Although this unnecessary, it does work as intended.
Calculations with double values are subject to roundoff error. Calculations with int values are subject to overflow; however, a and b are not of type int. None of the other answers would explain the discrepancy.
recur first computes and stores val % 3 as a String dig. It then either returns dig or returns dig with the value of a recursive call concatenated.
My Stack based trace of 2009 AP CS A Multiple Choice #39 shows a step by step solution.
My Stack based trace of 2009 AP CS A Multiple Choice #40 shows a step by step solution.