# 12.6. Exam 5 for the AP CS A Exam (not timed)¶

The following problems are similar to what you might see on the AP CS A exam. Please answer each to the best of your ability.

(x == y) && (y == z) && (x == z)

(x==y) || (y==z) && (x == z)

(x - y) * (x - z) * (y - z) == 0

- I only
- We don't know the value of z
- II only
- II is true but there is (are) other statements that evaluate to true
- III only
- III is true but there is (are) other statements that evaluate to true
- I and II only
- For I, we don't know the value of z
- II and III only
- III executes to true if either a||b true, III is true because x-y will become 0 then 0 * a *b... = 0

12-6-1: Suppose `x, y, and z`

are variables of type `int`

. Consider the following three conditions

Which of these conditions is (are) always true if x == y is true?

- 1
- n != 0
- 8
- There are some recursive calls since n % 2 != 1
- 8*7*6*5*4*3*2
- Subtracts 2 from original number of 8, so could never call an odd number to be multiplied
- 8*6*4*2
- Will recursively call 8 -2, then 6-2, and lastly 4-2
- 7*5*3
- Subtracts 2 from original number of 8, so could never call an odd number to be multiplied

12-6-2: Consider the following method. What will be returned by a call to `multiply(8)`

?

```
public int multiply(int n)
{
if (n == 0)
return 1;
else if(n % 2 == 1)
return n;
else
return n * multiply(n - 2);
}
```

- double x = 0.6 * Math.random( ) + 0.4;
- This gives .4 <= x <1
- double x = 0.4 * Math.random( ) + 0.6;
- Math.random() returns 0(inclusive) to 1(exclusive) so this makes 0 + .6 the lower bound, and .99999 the upper bound
- double x = Math.random( ) - 0.4;
- This gives -.4 <= x < 6
- double x = (double) (Math.random( ) * 0.4);
- This doesn't ensure lower bound and upper bound
- double x = (double) (Math.random( ) + 0.6);
- This doesn't ensure lower bound and upper bound

12-6-3: Which of the following code segments correctly stores in `x`

a random real number such that `0.6 <= x < 1`

?

- -4
- Trace out the recursive calls. See https://tinyurl.com/AP19-Q6
- 4
- Trace out the recursive calls. See https://tinyurl.com/AP19-Q6
- 6
- Correct!
- 8
- Trace out the recursive calls. See https://tinyurl.com/AP19-Q6
- -6
- Trace out the recursive calls. See https://tinyurl.com/AP19-Q6

12-6-4: Suppose methods `f1`

and `f2`

are defined as follows. What value is returned from the call `f1(5)`

?

```
public int f1(int x)
{
if(x == 0)
return 0;
else
return f2(x -2);
}
public int f2(int x)
{
if(x == 1)
return 1;
else
return f1(x + 1) + x;
}
```

- It is legal for the value of a static variable to be changed in a constructor.
- Static variables can still have their values changed
- The constructor in a subclass must use the keyword super to initialize the private instance variables from its superclass.
- This is true, under the hood if you don't explicitly use the 'super' keyword, the compiler will do it for you automatically
- A constructor has no return type.
- This is true.
- A constructor must be private.
- Constructors should be public so that they can be called from outside the class to construct objects.
- If a subclass does not explicitly provide a constructor and its superclass has just one constructor with a parameter, an error will occur when an attempt is made to create an instance of a subclass object.
- Because of the inheritance, the constructor from super class will be called and it is expecting a passed in parameter

12-6-5: Which statement about constructors is `false`

?

- 10
- Trace out the recursive calls, see https://tinyurl.com/AP19-Q10
- 12
- Trace out the recursive calls, see https://tinyurl.com/AP19-Q10
- 16
- Trace out the recursive calls, see https://tinyurl.com/AP19-Q10
- 26
- Trace out the recursive calls, see https://tinyurl.com/AP19-Q10
- 32
- Trace out the recursive calls, see https://tinyurl.com/AP19-Q10

12-6-6: Consider the following method. What will the output of `mystery(6)`

return?

```
public int mystery(int n)
{
if(n == 1 || n ==2)
return 2;
else
return mystery(n -1) + mystery(n - 2);
}
```

a and b are both false

a is false and b is true

a is true and b is false

- I only
- This is true because !false && !false becomes true && true
- II only
- If either a or b (or both a AND b) is true whole expression becomes false
- III only
- If either a or b (or both a AND b) is true whole expression becomes false
- II and III only
- If either a or b (or both a AND b) is true whole expression becomes false
- I, II, and III
- If either a or b (or both a AND b) is true whole expression becomes false

12-6-7: Suppose `a and b`

are `boolean`

variables. The expression below

`!a && !b`

…will evaluate to `false`

whenever

- 1 6
- condition (y % x ==1) never true. Trace it out https://tinyurl.com/AP19-Q12
- 7 12
- condition (y % x ==1) never true. Trace it out https://tinyurl.com/AP19-Q12
- -3 12
- condition (y % x ==1) never true. Trace it out https://tinyurl.com/AP19-Q12
- 4 12
- condition (y % x ==1) never true
- -3 6
- condition (y % x ==1) never true. Trace it out https://tinyurl.com/AP19-Q12

12-6-8: Consider the following code segment. What will be the output after execution of this code segment?

```
int x = 10, y = 0;
while(x > 5){
y = 3;
while(y < x){
y *= 2;
if( y % x == 1)
y += x;
}
x -= 3
}
System.out.println(x + " " + y);
```

- -5
- the %, *, and / all have the same precedence
- 0
- the %, *, and / all have the same precedence
- 13
- the %, *, and / all have the same precedence
- -1
- the %, *, and / all have the same precedence
- 12
- the %, *, and / all have the same precedence

12-6-9: What value is stored in `result`

if:

```
int result = 13 - 3 * 6 / 4 % 3
```

- 0
- k > 2 so will print out "SMALL"
- 1
- k can be greater than 3
- k -1
- max of k-1 iterations (end - start + 1 is k - 2 + 1)
- k -2
- it is <= k so inclusive of k
- k
- max of k -1 iterations

12-6-10: Consider the folllowing code segment. Assume `k`

is some positive integer greater than 2. How many times will “SMALL” be printed?

```
for(int i = 2; i <= k; i++)
{
if(arr[i] < someValue)
System.out.print("SMALL");
}
```

- It prints string str
- Prints out the leftmost character at the start of the recursive call. Then always trims off the left most character, but substring(x) with single parameter x gives the remaining string from index x until the end. See https://tinyurl.com/AP19-Q17
- It prints string str in reverse order
- substring(0,1) prints leftmost char not the rightmost char
- It prints only the first two characters of string str
- there is a recursive call of a substring at each iteration
- It prints only the first two characters of string str
- goes until s.length > 0
- It prints only the last character of string str
- goes until s.length > 0 and there are recursive calculates

12-6-11: Which best describes what the `printSomething`

method below does?

```
public void printSomething(String str)
{
if(str.length() > 0)
{
System.out.print(str.substring(0,1));
printSomething(str.substring(1));
}
}
```

- 9
- Second for loop goes until colum <= row index
- 15
- Second for loop goes until colum <= row index
- 19
- Second for loop goes until colum <= row index
- 21
- adds the lower half of the matrix
- 31
- Second for loop goes until colum <= row index

12-6-12: A square matrix is declared as

`int[][] mat = new int [SIZE][SIZE]`

where `SIZE`

is an appropriate integer constant. Consider the code below.

If mat is initialized to be:

```
2 6 3
4 5 1
7 1 2
```

What value will be returned by a call to `sum(mat)`

?

```
public static int sum(int[][] mat)
{
int total = 0;
for(int r = 0; r < mat.length; r++)
{
for(int c = 0; c <= r; c++)
{
total += mat[r][c];
}
}
return total;
}
```

- Find the smallest element in arr and swap it into arr[0]
- This is for selection sort
- Compare arr[0] with arr[1] and, if necessary, shift and replace elements such that arr[0] is less than arr[1]
- This is for bubble sort
- Compare arr[0] with the middle element of arr, arr[mid] , and if arr[0] is less than arr[mid] , swap these elements
- Merge sort deals with cutting sets into halves and repeating this process
- Compare the first and last elements, and if the first is less than the last, swap these elements.
- Merge sort deals with cutting sets into halves and repeating this process
- Break the array into roughly two equal halves.
- Firs step is to cut sets in halves until you get to a single element in a 'set'

12-6-13: The elements of an array are to be sorted in increasing order. Which represent the first step of a merge sort algorithm?

- return 4 * n;
- 3 iterations of the loop and each loop does n^2
- return 8 * n;
- 3 iterations of the loop and each loop does n^2
- return 64 * n;
- 3 iterations of the loop and each loop does n^2
- return (int) Math.pow(n,4);
- 3 iterations of the loop and each loop does n^2
- return (int) Math.pow(n,8);
- Method basically does (n^2)^3 which is the same as n ^ 8

12-6-14: Which of the following could replace the body of `compute`

so it does the same thing.

```
public static int compute(int n)
{
for(int i = 1; i < 4; i++)
{
n *= n;
}
return n;
}
```

- 36
- Outer loop does gets incremented by 2, NOT by 1. Also, j starts at 1, NOT 0
- 30
- Inner loop starts at 1 and is ends at 5 inclusive so exectues 5 times
- 35
- Outer loop does gets incremented by 2, NOT by 1
- 15
- Outerloop executes 3 times and inner loop executes 5 times.
- 18
- See http://tinyurl.com/AP19-Q23

12-6-15: How many times will the `asterik("*")`

be printed?

```
for(int k = 4; k < 10; k +=2)
{
for(int j = 1; j <= 5; j++)
{
System.out.print("*");
}
}
```

- run eat
- Because the fido is an "Underdog", we will call the eat() from class Underdog, http://tinyurl.com/AP19-Q25
- run eat sleep
- Because the fido is an "Underdog", we will call the eat() from class Underdog, http://tinyurl.com/AP19-Q25
- run eat sleep bark
- Because the fido is an "Underdog", we will call the eat() from class Underdog, http://tinyurl.com/AP19-Q25
- run eat bark sleep
- Nothing is printed due to infinite recursion

12-6-16: Consider the following code. What is printed?

```
class Dog{
public void act(){
System.out.print("run ");
eat();
}
public void eat(){
System.out.print("eat ");
}
}
public class UnderDog extends Dog{
public void act(){
super.act();
System.out.print("sleep ");
}
public void eat(){
super.eat();
System.out.print("bark ");
}
public static void main(String[] args){
Dog fido = new UnderDog();
fido.act();
}
}
```

- -1
- x becomes 0 and y becomes 1 so 0 - 1 = -1
- 1
- make sure to do x-y and not y-x
- 0
- http://tinyurl.com/AP19-Q26
- -2
- http://tinyurl.com/AP19-Q26
- 2
- http://tinyurl.com/AP19-Q26

12-6-17: What is the output of the `System.out.println`

statement?

```
int x = 3, y = -2;
while(x > y)
{
x--;
y++;
}
System.out.println(x - y);
```

- 4
- i%2 -1 ==0 means "is this number odd". See http://tinyurl.com/AP19-Q27
- 5
- i%2 -1 ==0 means "is this number odd". See http://tinyurl.com/AP19-Q27
- 6
- i%2 -1 ==0 means "is this number odd". See http://tinyurl.com/AP19-Q27
- 7
- i%2 -1 ==0 means "is this number odd". See http://tinyurl.com/AP19-Q27
- 8
- i%2 -1 ==0 means "is this number odd". See http://tinyurl.com/AP19-Q27

12-6-18: What will be the value of `sum`

after the execution of code above?

```
int sum = 0;
for(int i = 0; i < 3; i++)
{
if((i % 2) - 1 ==0)
sum += 3;
else
sum++;
}
```

- mput
- The .substring() function is inclusive left, exclusive right. Also if passed a single parameter it will take that as the starting index for the substring up to the rest of the string.
- mpu
- The .substring() function is inclusive left, exclusive right. Also if passed a single parameter it will take that as the starting index for the substring up to the rest of the string.
- mp
- The .substring() function is inclusive left, exclusive right. Also if passed a single parameter it will take that as the starting index for the substring up to the rest of the string.
- omp
- Om

12-6-19: What is printed out by the following code?

```
String s = "Computer Science is fun!";
String s1 = s.substring(0,8);
String s2 = s1.substring(1);
String s3 = s2.substring(1,3);
System.out.println(s3);
```