7.7. Multiple-Choice Exercises¶

7.7.1. Easier Multiple Choice Questions¶

7-7-1: Which index is the last element in an array called nums at?

nums.length
Since the first element in an array is at index 0 the last element is the length minus 1.
nums.length - 1
Since the first element in an array is at index 0 the last element is the length minus 1.

7-7-2: Which of the following declarations will cause a compile time error?

int[] scores = null;
You can initialize an array reference to null to show that it doesn't refer to any array yet.
int[] scoreArray = {50,90,85};
You can provide the values for an array when you declare it.
String[] nameArray = new String[10];
You can declare and array and create the array using the new operator in the same statement.
String[] nameArray = {5, 3, 2};
You can not put integers into an array of String objects.
int[] scores = new int[5];
You can declare and array and create it in the same statement. Use the new operator to create the array and specify the size in square brackets.

7-7-3: What is returned from arr[3] if arr={6, 3, 1, 2}?

1
This would be returned from arr[2].
2
This returns the value in arr at index 3. Remember that the first item in an array is at index 0.
3
This would be returned from arr[1].
6
This would be returned from arr[0].
4
This would be returned from arr.length

7-7-4: What is returned from mystery when it is passed {10, 30, 30, 60}?

public static double mystery(int[] arr)
{
   double output = 0;
   for (int i = 0; i < arr.length; i++)
   {
      output = output + arr[i];
   }
   return output / arr.length;
}

17.5
This would be true if the loop stopped at arr.length - 1.
30.0
This would be true if the loop started at 1 instead of 0.
130
This would be true if it returned output rather than output / arr.length
32
This would be true if output was declared to be an int rather than a double.
32.5
This sums all the values in the array and then returns the sum divided by the number of items in the array. This is the average.

You can step through the code above using the Java Visualizer by clicking on the following link Prob-7-9-4.

7-7-5: Given the following values of a and the method doubleLast what will the values of a be after you execute: doubleLast()?

private int[ ] a = {-10, -5, 1, 4, 8, 30};

public void doubleLast()
{

   for (int i = a.length / 2; i < a.length; i++)
   {
      a[i] = a[i] * 2;
   }
}

{-20, -10, 2, 8, 16, 60}
This would true if it looped through the whole array. Does it?
{-20, -10, 2, 4, 8, 30}
This would be true if it looped from the beginning to the middle. Does it?
{-10, -5, 1, 8, 16, 60}
It loops from the middle to the end doubling each value. Since there are 6 elements it will start at index 3.
{-10, -5, 1, 4, 8, 30}
This would be true if array elements didn't change, but they do.

You can step through the code above using the Java Visualizer by clicking on the following link Prob-7-9-5.

7-7-6: What are the values in a after multAll(3) executes?

private int[ ] a = {1, 3, -5, -2};

public void multAll(int amt)
{
   int i = 0;
   while (i < a.length)
   {
      a[i] = a[i] * amt;
      i++;
   } // end while
} // end method

{1, 3, -5, -2}
This would be true if the contents of arrays could not be changed but they can.
{3, 9, -15, -6}
This code multiplies each value in a by the passed amt which is 3 in this case.
{2, 6, -10, -4}
This would be correct if we called multAll(2) instead of multAll(3).
The code will never stop executing due to an infinite loop
The variable i starts at 0 and increments each time through the loop and stops when it equals the number of items in a.

7-7-7: What are the values in a after mult(2) executes?

private int[ ] a = {1, 3, -5, -2};

public void mult(int amt)
{
   int i = 0;
   while (i < a.length)
   {
      a[i] = a[i] * amt;
   } // end while
} // end method

{1, 3, -5, -2}
Does the value of i ever change inside the loop?
{3, 9, -15, -6}
Does the value of i ever change inside the loop?
{2, 6, -10, -4}
Does the value of i ever change inside the loop?
The code will never stop executing due to an infinite loop
The value of i is initialized to 0 and then never changes inside the body of the loop, so this loop will never stop. It is an infinite loop.

7.7.2. Medium Multiple Choice Questions¶

7-7-8: Which of the following statements is a valid conclusion. Assume that variable b is an array of k integers and that the following is true:

b[0] != b[i] for all i from 1 to k-1

The value in b[0] does not occur anywhere else in the array
The assertion denotes that b[0] occurs only once, regardless of the order or value of the other array values.
Array b is sorted
The array does not necessarily need to be in order for the assertion to be true.
Array b is not sorted
We can't tell if it is sorted or not from this assertion.
Array b contains no duplicates
The only value that must not have a duplicate is b[0]
The value in b[0] is the smallest value in the array
b[0] can be any value, so long as no other array element is equal to it.

7-7-9: Consider the following code segment. Which of the following statements best describes the condition when it returns true?

boolean temp = false;
for (int i = 0; i < a.length; i++) {
   temp = (a[i] == val);
}
return temp;

whenever the first element in a is equal to val
It is the last value in a that controls the final state of temp, as the loop is progressing through the array from 0 to the end.
Whenever a contains any element which equals val
Because temp is reset every time through the loop, only the last element controls whether the final value is true or false.
Whenever the last element in a is equal to val
Because each time through the loop temp is reset, it will only be returned as true if the last value in a is equal to val.
Whenever more than 1 element in a is equal to val
Because temp is reset every time through the loop, only the last element controls whether the final value is true or false, so it is possible for just the last value to be equal to val.
Whenever exactly 1 element in a is equal to val
Because temp is reset every time through the loop, only the last element controls whether the final value is true or false, so it is possible for several elements to be equal to val.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-2.

7-7-10: Consider the following data field and method findLongest. Method findLongest is intended to find the longest consecutive block of the value target occurring in the array nums; however, findLongest does not work as intended. For example given the code below the call findLongest(10) should return 3, the length of the longest consecutive block of 10s. Which of the following best describes the value actually returned by a call to findLongest?

private int[] nums = {7, 10, 10, 15, 15, 15, 15, 10, 10, 10, 15, 10, 10};

public int findLongest(int target) {
   int lenCount = 0; // length of current consecutive numbers
   int maxLen = 0;   // max length of consecutive numbers
   for (int k = 0; k < nums.length; k++) {
      if (nums[k] == target) {
         lenCount++;
      } else if (lenCount > maxLen) {
         maxLen = lenCount;
      }
   }
   if (lenCount > maxLen) {
      maxLen = lenCount;
   }
   return maxLen;
}

It is the length of the shortest consecutive block of the value target in nums
It doesn't reset lenCount ever, so it just counts all the times the target value appears in the array.
It is the length of the array nums
The only count happens when lenCount is incremented when nums[k] == target. nums.length is only used to stop the loop.
It is the length of the first consecutive block of the value target in nums
It doesn't reset lenCount ever, so it just counts all the times the target value appears in the array.
It is the number of occurrences of the value target in nums
The variable lenCount is incremented each time the current array element is the same value as the target. It is never reset so it counts the number of occurrences of the value target in nums. The method returns maxLen which is set to lenCount after the loop finishes if lenCount is greater than maxLen.
It is the length of the last consecutive block of the value target in nums
It doesn't reset lenCount ever, so it just counts all the times the target value appears in the array.

Before you keep reading...

Making great stuff takes time and $$. If you appreciate the book you are reading now and want to keep quality materials free for other students please consider a donation to Runestone Academy. We ask that you consider a $10 donation, but if you can give more thats great, if $10 is too much for your budget we would be happy with whatever you can afford as a show of support.

Support Runestone Academy Today

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-3. Can you fix the code in the Java Visualizer so that it works as intended?

7-7-11: Consider the following data field and method. Which of the following best describes the contents of myStuff in terms of m and n after the following statement has been executed?

private int[] myStuff;

//precondition: myStuff contains
//   integers in no particular order
public int mystery(int num) {
   for (int k = myStuff.length - 1; k >= 0; k--) {
      if (myStuff[k] < num) {
          return k;
      }
   }
   return -1;
}

int m = mystery(n)

All values in positions m+1 through myStuff.length-1 are greater than or equal to n.
Mystery steps backwards through the array until the first value less than the passed num (n) is found and then it returns the index where this value is found. Nothing is known about the elements of the array prior to the index at which the condition is met.
All values in position 0 through m are less than n.
Mystery steps backwards through the array and quits the first time the value at the current index is less than the passed num (n). This would be true if we went forward through the array and returned when it found a value greater than the passed num (n).
All values in position m+1 through myStuff.length-1 are less than n.
This would be true if it returned when it found a value at the current index that was greater than num (n).
The smallest value is at position m.
The condition compares the value at the current index of the array to the passed num. It returns the first time the condition is met so nothing is known about the values which are unchecked. One of the unchecked values could be smaller.
The largest value that is smaller than n is at position m.
The condition checks for any value that is smaller than the passed num and returns from mystery the first time that the condition is encountered. The values are not ordered so we don't know if this is the largest value smaller than n.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-4.

7-7-12: Consider the following field arr and method checkArray. Which of the following best describes what checkArray returns?

private int[] arr;

// precondition: arr.length != 0
public int checkArray()
{
    int loc = arr.length / 2;
    for (int k = 0; k < arr.length; k++)
    {
        if (arr[k] > arr[loc])
        {
            loc = k;
        }
    }
    return loc;
}

Returns the index of the largest value in array arr.
This code sets loc to the middle of the array and then loops through all the array elements. If the value at the current index is greater than the value at loc then it changes loc to the current index. It returns loc, which is the index of the largest value in the array.
Returns the index of the first element in array arr whose value is greater than arr[loc].
This would be true if there was a return loc after loc = k in the if block.
Returns the index of the last element in array arr whose value is greater than arr[loc].
This would be true if it returned loc after setting loc = k and if it started at the end of the array and looped toward the beginning of the array.
Returns the largest value in array arr.
It returns the index to the largest value in array arr, not the largest value.
Returns the index of the largest value in the second half of array arr.
k loops from 0 to arr.length - 1. So it checks all of the elements in the array.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-5.

7-7-13: Given the following field and method declaration, what is the value in a[1] when m1(a) is run?

int[] a = {7, 3, -1};

public static int m1(int[] a)
{
   a[1]--;
   return (a[1] * 2);
}

4
This would be true if it was return (a[1] *= 2);, which would change the value at a[1].
2
The statement a[1]--; is the same as a[1] = a[1] - 1; so this will change the 3 to 2. The return (a[1] * 2) does not change the value at a[1].
12
This would be true if array indicies started at 1 instead of 0 and if the code changed the value at index 1 to the current value times two.
6
This would be true if array indices started at 1 rather than 0.
3
This can't be true because a[1]--; means the same as a[1] = a[1] - 1; so the 3 changes to 2. Parameters are all pass by value in Java which means that a copy of the value is passed to a method. But, since an array is an object a copy of the value is a copy of the reference to the object. So changes to objects in methods are permanent.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-6.

7-7-14: Consider the following code. What is the maximum amount of times that HELLO could possibly be printed?

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

k - 1
This loop will start at 1 and continue until k is reached as long as arr[i] < someValue is true. The last time the loop executes, i will equal k-1, if the condition is always true. The number of times a loop executes is equal to the largest value when the loop executes minus the smallest value plus one. In this case that is (k - 1) - 1 + 1 which equals k - 1.
k + 1
This would be true if arr[i] < someValue was always true and the loop started at 0 instead of 1 and continued while it was less than or equal to k.
k
This would be true if arr[i] < someValue was always true and the loop started at 0 instead of 1.
1
This would be the case if only one element in the array would fulfill the condition that arr[i] < someValue.
0
This is the minimum number of times that HELLO could be executed. This would be true if k was less than i initially.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-7.

7-7-15: Consider the following method changeArray. An array is created that contains {2, 8, 10, 9, 6} and is passed to changeArray. What are the contents of the array after the changeArray method executes?

public static void changeArray(int[] data)
{
   for (int k = data.length - 1; k > 0; k--)
      data[k - 1] = data[k] + data[k - 1];
}

{2, 6, 2, -1, -3}
This would be correct if data[k] was modified in the for-loop. In this for-loop, data[k - 1] is the element that changes.
{-23, -21, -13, -3, 6}
This would be correct if data[k - 1] was subtracted from data[k]. Notice that for every instance of the for-loop, data[k] and data[k - 1] are added together and data[k - 1] is set to that value.
{10, 18, 19, 15, 6}
This would be correct if the for-loop began at 1 and continued to data.length - 1. Notice the for-loop indexing.
This method results in an IndexOutOfBounds exception.
The indexing of this method is correct. The for-loop begins at the last valid index and ends when k is equal to 0, and the method does not access any values other than the ones specified.
{35, 33, 25, 15, 6}
This method starts at the last valid index of the array and adds the value of the previous element to the element at index k - 1.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-8.

7-7-16: Assume that arr1={1, 5, 3, -8, 6} and arr2={-2, -1, -5, 3, -4} what will the contents of arr1 be after copyArray finishes executing?

public static void copyArray(int[] arr1, int[] arr2)
{
   for (int i = arr1.length / 2; i < arr1.length; i++)
   {
      arr1[i] = arr2[i];
   }
}

[-2, -1, -5, 3, -4]
This would be true if i started at 0 instead of arr1.length / 2.
[-2, -1, 3, -8, 6]
This would be true if i started at 0 and ended when it reached arr1.length / 2.
[1, 5, -5, 3, -4]
This loop starts at arr2.length / 2 which is 2 and loops to the end of the array copying from arr2 to arr1.
[1, 5, 3, -8, 6]
This would be correct if this loop didn't change arr1, but it does.
[1, 5, -2, -5, 2]
This would be correct if it set arr1[i] equal to arr[i] + arr[2] instead.

You can step through the code above with the Java Visualizer by clicking the following link Prob-7-10-9.

7-7-17: Given the following code segment, which of the following will cause an infinite loop? Assume that temp is an int variable initialized to be greater than zero and that a is an array of ints.

for ( int k = 0; k < a.length; k++ )
{
   while ( a[ k ] < temp )
   {
      a[ k ] *= 2;
   }
}

The values don't matter this will always cause an infinite loop.
An infinite loop will not always occur in this code segment.
Whenever a includes a value that is less than or equal to zero.
When a contains a value that is less than or equal to zero then multiplying that value by 2 will never make the result larger than temp (which was set to some value > 0), so an infinite loop will occur.
Whenever a has values larger then temp.
Values larger then temp will not cause an infinite loop.
When all values in a are larger than temp.
Values larger then temp will not cause an infinite loop.
Whenever a includes a value equal to temp.
Values equal to temp will not cause the infinite loop.

You can step through the code above using the Java Visualizer by clicking on the following link Prob-7-10-10. Can you fix the code so that it won’t result in an infinite loop?

7-7-18: Given the following array instance variable and method, which of the following best describes the contents of myStuff after (int m = mystery(n);) has been executed?

// private field in the class
private int[ ] myStuff;

//precondition: myStuff contains
//  integers in no particular order
public int mystery(int num)
{
   for (int k = myStuff.length - 1; k >= 0; k--)
   {
       if (myStuff[k] < num)
       {
          return k;
       }
   }
   return -1;
 }

All values in positions m+1 through myStuff.length-1 are greater than or equal to n.
Mystery steps backwards through the array until the first value less than the passed num (n) is found and then it returns the index where this value is found.
All values in position 0 through m are less than n.
This would be true if mystery looped forward through the array and returned when it found a value greater than the passed num (n).
All values in position m+1 through myStuff.length-1 are less than n.
This would be true if it returned when it found a value at the current index that was greater than num (n).
The smallest value is at position m.
It returns the first time the condition is met so nothing is known about the values which are unchecked.

7.7.3. Hard Multiple Choice Questions¶

7-7-19: Consider the following data field and incomplete method, partialSum, which is intended to return an integer array sum such that for all i, sum[i] is equal to arr[0] + arr[1] + ... + arr[i]. For instance, if arr contains the values {1, 4, 1, 3}, the array sum will contain the values {1, 5, 6, 9}. Which of the following is true about the two implementations of missing code on line 9 that are proposed?

private int[] arr;

public int[] partialSum() {
   int[] sum = new int[arr.length];

   for (int j = 0; j < sum.length; j++)
      sum[j] = 0;

   /* missing code */
   return sum;
}


Implementation 1

for (int j = 0; j < arr.length; j++)
    sum[j] = sum[j - 1] + arr[j];


Implementation 2

for (int j = 0; j < arr.length; j++)
   for (int k = 0; k <= j; k++)
      sum[j] = sum [j] + arr[k];

Both implementations work as intended and are equally fast.
Implementation 1 doesn't work and will cause an ArrayIndexOutOfBoundsException. If Implementation 1 was correct, it would be faster.
Both implementations work as intended, but implementation 1 is faster than implementation 2.
Implementation 1 doesn't work and will cause an ArrayIndexOutOfBoundsException.
Both implementations work as intended, but implementation 2 is faster than implementation 1.
Implementation 1 doesn't work and will cause an ArrayIndexOutOfBoundsException. If it did work, it would be faster than 2.
Implementation 1 does not work as intended, because it will cause an ArrayIndexOutOfBoundsException.
When j is 0, sum[j-1] will be sum[-1] which will cause an ArrayIndexOutOfBoundsException.
Implementation 2 does not work as intended, because it will cause an ArrayIndexOutOfBoundsException.
Implementation 1 doesn't work and will cause an ArrayIndexOutOfBoundsException.