# 2004 AP Computer Science A Exam Multiple Choice Explanations

The College Board released the complete 2004 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 2004 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 2004 AP CS A Exam Multiple Choice with AP CS Tutor Brandon Horn.

If you do not have and cannot get a copy of this, the 2014 AP CS A Course Description has 25 excellent practice multiple choice. The 2014 AP CS A Course Description is available for free on the College Board’s website.

## Question 1

Case I incorrectly evaluates to `true` if and only if all 3 of the conditions are `true`.

Case II correctly evaluates to `true` if and only if at least 1 of the conditions is `true`.

Case III computes the product of each difference. If at least 2 of the numbers are equal, at least 1 of the differences will be 0. If at least 1 of the differences is 0, the product will be 0 and the condition will evaluate to `true`. This correctly determines whether at least 2 of the value are equal.

## Question 2

In a sorted array (Case II), inserting a word requires determining the position to insert and shifting elements to make space. In an unsorted array (Case I), a word can be inserted at the end without any comparisons or shift. Answer A states the opposite.

In an unsorted array, finding a word requires a sequential search through each word. In a sorted array, finding a word can be accomplished with a must faster binary search. Answer C states this correctly while Answer B states the opposite.

Since the list is sorted in alphabetical order, rather than by word length, finding the longest word requires visiting each word regardless of the order in which the words are stored.

In an unsorted array, finding the first word in alphabetical order requires visiting each word. In a sorted array, the first word is the first word in alphabetical order. Answer E states the opposite.

## Question 3

The advantage of an `ArrayList` over an array is that an `ArrayList` resizes itself automatically. The length of an array must be specified at construction and cannot be changed.

An `ArrayList` does not offer a speed advantage for access, nor does it use less memory as Answers A and B state.

An `ArrayList` can only store objects; however, an array can store either objects or primitive types. This is an advantage of an array, not of an `ArrayList`.

Accessing the number of items in an `ArrayList` is accomplished as `list.size()`. Accessing the number of items in a list is accomplished as `array.length`.

## Question 4

Answer A incorrectly switches `<=` and `>=`.

Answer B has the same problem as Answer A and also incorrectly uses `||` instead of `&&`.

Answer C is not syntactically correct. Two separate boolean conditions are required.

Answer D correctly checks that `x` is at least `lower` and that it is no larger than `upper`.

Answer E incorrectly checks if either condition is `true` rather than if both are `true`.

## Question 5

Case I is syntactically incorrect because it attempts to access the private instance field `y`.

Case II correctly runs the `setY` method from the `EnhancedData` class.

Case III correctly runs the `setX` method from the `Data` class, which is the superclass of `EnhancedData`.

## Question 6

Both `s1` and `s2` start at 0 and are incremented by `num` each time `num` meets certain conditions.

`s1` is incremented if `num` is positive and is a multiple of 2. At the end of the method, `s1` is the sum of all positive even values in the array.

## Question 7

In order for the `else` statement to run, one or both of the conditions in the `if` statement that increments `s1` must be `false`. The first condition will be `false` when `num` is negative or 0. The second condition will be `false` when `num` is not a multiple of 2.

The `if` statement after the `else` will be `true` when `num` is negative. Since the `else` statement will be run for all negative values of `num` (as well as for some positive values), `s2` is the sum of all negative values in the array.

## Question 8

Answer A is incorrect because using inheritance results in more classes, not fewer.

Answer B is correct because subclasses can call superclass methods using the keyword `super`. This is a substantial benefit of inheritance.

Answer C is incorrect because all classes allow for data encapsulation, not just inherited classes. (Data encapsulating refers to the practice of exposing only behavior, in the form of methods, publicly while keeping all data, in the form of instance fields. private.)

Answer D does not make sense.

Answer E is incorrect because applications with more classes (see the explanation for Answer A) typically compile more slowly.

## Question 9

When `conditionalTest` is called, `a` is assigned the value 3 and `b` is assigned the value -2.

The first `if` statement evaluates to `false` because `b` is not greater than 0. Execution moves to the `else if` which evaluates to `true` because b is less than 0. The method prints `C`.

Due to short circuit or lazy evaluation the condition after the `||` is never evaluated.

## Question 10

Case I correctly runs the `getValue` method to obtain the stored value as an `int`, which it then correctly prints.

Case II incorrectly attempts to access the private instance field `myStoredValue`.

Case III prints `m` which automatically runs the `toString` method of `IntCell`. The `toString` method of `IntCell` returns the stored value as a string, which Case III correctly prints.

## Question 11

After the first assignment, `x` stores twice the value it stored at the start of the method. If the first and second statements were combined, they would be equivalent to `x = 2x + 2x`. If all 3 assignment statements were combined, they would be equivalent to `x = 4x + 4x` or `8 * x`.

## Question 12

The loop executes for each value of `k` from 1 to 19, inclusive. The `if` statement is `true` if the remainder when `k` is divided by 3 is 1. This is `true` for the values below, which are the values printed.

`1 4 7 10 13 16 19`

## Question 13

The line `prod = prod * k` is immediately after the assignment the user’s input to `k`. If the user enters a negative number, it is included in the product.

The loop will still terminate when the user enters a negative number; however, the number will also be incorrectly included in the product.

## Question 14

`valueOne` and `valueTwo` are both of the primitive type `int`. Primitive types can be compared using `==`. Methods cannot be run on primitive types. Each answers except Answer B incorrectly runs a method on `valueOne`.

## Question 15

Each `return` statement is inside an `if` statement. This means that there might be a path through the code that does not result in `someCode` returning an `int`.

To correct the issue, `someCode` must have a `return` statement within an `else` or entirely outside of an `if` statement.

It does not matter whether it is actually possible for all of the conditions to evaluate to `false`. The Java compiler does not reason about the contents of the conditions. For example, the method below has the same error as `someCode`.

``````public int someMethod(int a)
{
if(a >= 0)
return 0;

if(a < 0)
return 1;
}
``````

See Return statements for additional discussion.

## Question 16

The values of `num1` and `num2` after each run of the loop are below.

`num1` `num2`
Before 1st run: 0 3
After 1st run: 2 2
After 2nd run: 4 1
After 3rd run: 6 0

The loop terminates because `num2` is 0. The second condition is never evaluated, so no exception is generated.

## Question 17

For an inheritance hierarchy to make sense, any instance of the subclass must also be an instance of the superclass. A `Bear` is an `Animal`. A `Zoo` has `Animal` objects.

In Answer A, `Animal` incorrectly extends `Bear`. Not all animals are bears, so the hierarchy doesn’t make sense.

In Answer B, `Bear` correctly extends `Animal`. All bears are animals, so the hierarchy makes sense. A zoo has animals, and an `Animal[]` is an acceptable way to store them.

In Answer C, `Animal` incorrectly extends `Zoo`. Also, `Animal` incorrectly stores a `Bear` as an instance fields.

Answer D is both syntactically and logically incorrect. A class can have at most 1 superclass. Also, a bear is not a zoo.

In Answer E, `Bear` incorrectly implements `Zoo`. The problem description states that a zoo contains many animals, not that is specifies methods that a bear must implement.

## Question 18

`selectSort` attempts to implement the selection sort algorithm. `pos` is intended to store the position of the smallest element from `j` to `numbers.length &#8211; 1`, inclusive.

The implementation incorrectly initializes `pos` to 0, the first element in the array. This works only for the first run of the outer loop. On the second run, `pos` will incorrectly remain 0 since the smallest element has previously been swapped to the beginning of the array.

To correct the issue, `pos` should be initialized to `j` on Line 2.

See Selection sort for the AP CS A Exam for a demonstration of the algorithm and other resources.

## Question 19

When `n < 0`, `f1` explicitly returns 0 and `f2` returns 0 because the loop never runs.

When `n == 0`, `f1` calls `f(-1)` and returns the sum of the result and 0, or 0. `f2` returns 0 because the loop still never runs.

Case III is more interesting. In both `f1` and `f2`, the value of `n` is decremented by 1 for each iteration or recursive call. The methods will always return the same value. For each run, the value `n * 10` is added to the result. For example, consider `f1(3)` and `f2(3)`.

``````f1(3)
= f1(2) + 30
= f1(1) + 20 + 30
= f1(0) + 10 + 20 + 30
= 0 + 10 + 20 + 30
``````

In `f2(3)`, the same result is accomplished iteratively. For each value of `n`, the value of `answer` is shown below.

``````3: answer = 0 + 30
2: answer = 0 + 30 + 20
1: answer = 0 + 30 + 20 + 10
``````

## Question 20

Statement I causes a compile time error because `methodB` is not in class `A` and class `A` does not know about class B `B`.

Statement II does not cause an error because `methodA` is in class `A` and class `B` extends class `A` and inherits all public methods.

Statement III causes a compile time error because `a1` is private in class `A`. A subclass cannot access private instance fields of its superclass.

## Questions 21-25

These questions referenced the old Marine Biology Case Study and are no longer relevant to newer AP CS A Exams.

## Question 26

My Stack based trace of 2004 AP CS A Multiple Choice #26 shows a step by step solution.

See Recursive method tracing for an explanation of the technique.

Some of my students prefer to solve this using a different method, shown below.

``````f(6) =
g(5) =
f(4) + 5 =
g(3) + 5 =
f(2) + 3 + 5 =
g(1) + 3 + 5 =
f(0) + 1 + 3 + 5 =
0 + 1 + 3 + 5 =
9
``````

I don’t like this alternate method, but it is correct.

## Question 27

When a subclass has a method with the same signature as its superclass, the subclass method overrides the superclass method. This makes Answers A and B incorrect.

The initialization statement for `v` declares it as a `Vehicle` reference to an object of type `Car`. When the reference type differs from the object type, the reference type determines what methods can be run and the object type determines what methods are run.

When `setPrice` is run on `v` the object type (`Car`) determines what method is run (the one from `Car`). The reference type (`Vehicle`) determines only that the method can be run.

The `setPrice` method from `Car` is run.

I often explain this to my students as the most specific method possible gets run. `Car` is more specific than `Vehicle` so the method from `Car` is run.

## Question 28

When I see a `print` statement in a recursive method on an Exam, I get excited. `print` statements often make recursion problems way easier to solve. See Recursive methods with print statements for an explanation of the approach.

Method `recur` has a base case of `n == 0`. The recursive call is made with `n - 2`. When `n` is odd, the base case will never be reached.

The question asks what happens when `recur(7)` is called. Infinite recursion will occur since the recursive calls will never reach the base case. `recur(7)` calls `recur(5)` calls `recur(3)` calls `recur(1)` calls `recur(-1)` and so on.

The position of the call to `print`, relative to the recursive call to `recur` determines whether many numbers will be printed or none at all. Since the call to `print` is after the recursive call, no numbers will be printed.

## Question 29

Whenever you are asked to perform arithmetic with numbers in a base other than 10, convert the numbers to base 10, perform the required operations, the convert the numbers back to the required base. My Base Conversion Practice Problem demonstrates simple algorithms to convert between base 10 and any other base.

100 in base 16 is 256 in base 10.

10 in base 16 is 16 in base 10.

256 - 16 = 240. The answers are already in base 10, so there is no need to convert the answer to another base.

## Question 30

Although the answers refer to `BoundedIntArray` and its instance fields, none of the answers actually depend on its implementation. The question asks why instance fields should be private.

Answer A is incorrect because objects can be initialized regardless of whether their instance fields are public or private.

Answer B is incorrectly states that code that depends on `BoundedIntArray` can be tested before `BoundedIntArray` has been completed. Although such code can be written before `BoundedIntArray` has been completed, it cannot be tested because it cannot be run.

Answer C correctly states that client code could remain unchanged if the implementation of `BoundedIntArray` is changed. What this means is that client code that uses only the public methods of `BoundedIntArray` would not need to be changed if `BoundedIntArray` was changed to use an `ArrayList<Integer>` instead of an `int[]`. If the instance fields were public and client code referred to them directly, the client code would have to be changed if the instance fields were changed.

Answers D and E incorrectly suggest that public methods cannot access private instance fields.

## Question 31

The first line initializes `arr1` to refer to a list of 100 elements with 5 as the index of the first element. `arr1` is indexed from 5 to 104.

The second line initializes `arr2` to refer to a list of 100 elements with 0 as the index of the first element. `arr2` is indexed from 0 to 99.

## Question 32

An interface is nothing more than a list of methods required in classes that implement the interface. An interface does not contain implementations of methods, instance fields, or constructors. It cannot be instantiated (see Question 33).

Abstract methods do not contain implementation. None of the methods of an interface contain implementations, so they are all abstract. The `abstract` modifier is not necessary for interface methods because they must be abstract.

## Question 33

Case I is obviously legal. An `Integer` reference is initialized to refer to a correctly constructed `Integer` object.

Case II is also legal. `Integer` implements the `Comparable` interface, so a `Comparable` reference can refer to an `Integer` object.

Case III is not legal. `Comparable` is an interface and cannot be instantiated. `new Comparable(7)` attempts to instantiate (make an instance of) `Comparable`.

## Question 34

Answer A is incorrect because there is no constructor in `Circle` that accepts 3 `double` values.

Answer B is syntactically incorrect. Placing `double` values in parentheses does not construct an object of type `Point`.

Answer C correctly constructs an object of type `Point` and correctly passes the object and a `double` to the `Circle` constructor.

Answers D and E incorrectly access private instance fields of `Circle`.

## Question 35

Since the method is intended to be inside the `Circle` class, it will already have access to the center and radius of the circle. The only parameter needed is an object of type `Point`. The method should return `true` if the point is inside the circle, `false` otherwise. The method should return a `boolean`.

## Question 36

The method is a variant of selection sort that sorts the array in non-decreasing (increasing) order starting from the end of the array.

Each iteration of the outer `for` loop finds the largest value in the unsorted portion of the array and swaps it with the element at position `pass`. After 2 iterations of the outer `for` loop, the 2 largest elements of the array will have been swapped with the last 2 elements of the array.

Although answer C contains the 2 largest elements in the correct positions, the elements previously at those positions have not been correctly swapped into the original positions of the 2 largest elements.

See Selection sort for the AP CS A Exam for a demonstration of the algorithm and other resources.

## Question 37

You are asked to give code that will determine if the value at `index` exceeds the current maximum and to update the current maximum.

The maximum is stored as an index (`posOfMax`) not as a value. To check if the value at `index` is larger, the condition would be `numbers[index] &gt; numbers[posOfMax]`. To update the maximum, the statement would be `posOfMax = index;`

See Finding the minimum or maximum for additional information about the standard algorithm.

## Question 38

When an element is removed from an `ArrayList` all subsequent elements are shifted down. `removeDups` incorrectly increments `k` regardless of whether an element is removed. Whenever an element is removed, `removeDups` skips the next element. If the next element is also a duplicate, it will not be removed.

When `removeDups` is run on the given array, the resulting array is `2 7 5 5 6 3 3`.

## Question 39

To correct the issue identified in Question 38, `k` should only be incremented if nothing was removed. In other words, `k++` should be in an `else` statement.

## Question 40

There are 6 rows of output so the outer loop must run 6 times. This eliminates Answers D and E.

In Answer A, the inner loop condition is `k < j`. The inner loop runs one less time than necessary for each run of the outer loop.

In Answer B, the inner loop incorrectly prints `j` instead of `k`. Each row would contain the same value repeated multiple times.