University of Washington, AP/CS A

Lab 5: arrays

Except where otherwise noted, the contents of this document are Copyright 2013 Stuart Reges and Marty Stepp.

lab document created by Marty Stepp, Stuart Reges and Whitaker Brand

Today's lab

Goals for this lab:

Exercise : Array declaration syntax practice-it

Which of the following choices is the correct syntax for declaring/initializing an array of integers?

Exercise : Quick initialization syntax practice-it

Which of the following choices is the correct syntax for quickly declaring/initializing an array of integers to store a particular list of values?

Exercise a: Array code tracing practice-it

Fill in the array with the values that would be stored after the code executes:

int[] data = new int[8];
data[0] = 3;
data[7] = -18;
data[4] = 5;
data[1] = data[0];
index 0 1 2 3 4 5 6 7
value 3 3 0 0 5 0 0 -18

Exercise : Array code tracing 2 practice-it

Fill in the array with the values that would be stored after the code executes:

int[] list = {2, 18, 6, -4, 5, 1};
for (int i = 0; i < list.length; i++) {
    list[i] = list[i] + (list[i] / list[0]);
}
index 0 1 2 3 4 5
value 3 24 8 -5 6 1

Exercise : Array reference mystery practice-it

What values are stored in the array at the comment in main? Note that the incrementAll method returns void, but does take an int[] parameter.

public static void main(String[] args) {
    int[] nums = {2, 4, -1, 3};
    incrementAll(nums);

    // HERE!
}

public static void incrementAll(int[] data) {
    for (int i = 0; i < data.length; i++) {
        data[i]++;
    }
}
index 0 1 2 3
value 3 5 0 4

Exercise : array mystery practice-it

Suppose that each array at right were passed as a parameter to the mystery method below. Fill in the boxes with the array contents after each method call.

Hint: it might be helpful to draw out an array an update its values as you trace through the code!
public static void mystery(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        if (a[i] < a[i + 1]) {
            a[i] = a[i + 1];
        }
    }
}
int[] a1 = {2, 4};
mystery(a1);
{4, 4}
[^0-9,]+
int[] a2 = {1, 3, 6};
mystery(a2);
{3, 6, 6}
[^0-9,]+
int[] a3 = {7, 2, 8, 4};
mystery(a3);
{7, 8, 8, 4}
[^0-9,]+
int[] a4 = {5, 2, 7, 2, 4};
mystery(a4);
{5, 7, 7, 4, 4}
[^0-9,]+
int[] a5 = {2, 4, 6, 3, 7, 9};
mystery(a5);
{4, 6, 6, 7, 9, 9}
[^0-9,]+

Exercise : array simulation practice-it

Consider the following method:
public static void mystery(int[] array) {
    for (int i = 0; i < array.length; i++) {
        array[i] = i * array[i];
    }
}

Indicate in the right-hand column what values would be stored in the int[] array after mystery() executes with the int[] array in the left-hand column passed in as a parameter.

{}
{}
{7}
{0}
{3, 2}
{0, 2}
{5, 4, 3}
{0, 4, 6}
{2, 4, 6, 8}
{0, 4, 12, 24}

Exercise : array simulation practice-it

Consider the following method:

public static void arrayMystery(int[] a) {
    for (int i = 1; i < a.length - 1; i++) {
        a[i] = a[i - 1] - a[i] + a[i + 1];
    }
}

In the left-hand column below are specific lists of integers. Indicate in the right-hand column what values would be stored in the list after method mystery executes if the integer list in the left-hand column is passed to it as a parameter.

{42, 42}
{42, 42}
{6, 2, 4}
{6, 8, 4}
{7, 7, 3, 8, 2}
{7, 3, 8, 2, 2}
{4, 2, 3, 1, 2, 5}
{4, 5, 3, 4, 7, 5}
{6, 0, -1, 3, 5, 0, -3}
{6, 5, 9, 11, 6, 3, -3}

Exercise : array simulation

Consider the following method:

public static void arrayMystery(String[] a) {
    for (int i = 0; i < a.length; i++) {
        a[i] += a[a.length - 1 - i];
    }
}

In the left-hand column below are specific lists of strings. Indicate in the right-hand column what values would be stored in the list after method mystery executes if the string list in the left-hand column is passed to it as a parameter.

{"a", "b", "c"}
{"ac", "bb" ,"cac"}
{"a", "bb", "c", "dd"}
{"add", "bbc", "cbbc", "ddadd"}
{"z", "y", "142", "w", "xx"}
{"zxx", "yw", "142142", "wyw", "xxzxx"}

Exercise : max errors practice-it

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// Returns the largest value in the given array.
public static int max(int data[10]) {
    int max = 0;
    for (int i = 0; i < data[].length(); i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max[];
}

The above attempted solution to Practice-It problem "max" has some problems. Open Practice-It from the link above, copy/paste this code into it, and fix the errors. Complete the code so that it passes the test cases.

Exercise - solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// Returns the largest value in the given array.
public static int max(int[] data) {
    // every value of data could be negative, in which case setting max = 0 is incorrect
    // max = data[0] is safe as the value at the 0th index is definitely in data
    int max = data[0];
    for (int i = 1; i < data.length; i++) {
        if (data[i] > max) {
            max = data[i];
        }
    }
    return max;
}

Exercise : minGap practice-it

Write a method named minGap that accepts an integer array as a parameter and returns the minimum 'gap' between adjacent values in the array. The gap between two adjacent values in a array is defined as the second value minus the first value. For example, suppose a variable called array is an array of integers that stores the following sequence of values:

int[] array = {1, 3, 6, 7, 12};

The first gap is 2 (3 - 1), the second gap is 3 (6 - 3), the third gap is 1 (7 - 6) and the fourth gap is 5 (12 - 7). Thus, the call of minGap(array) should return 1 because that is the smallest gap in the array. If you are passed an array with fewer than 2 elements, you should return 0.

Click on the check-mark above to try out your solution in Practice-it!

Exercise : percentEven practice-it

Write a method named percentEven that accepts an array of integers as a parameter and returns the percentage of even numbers in the array as a real number. For example, if a variable named nums refers to an array of the elements {6, 2, 9, 11, 3}, then the call of percentEven(nums) should return 40.0. If the array contains no even elements or no elements at all, return 0.0.

Click on the check-mark above to try out your solution in Practice-it!

Exercise : swapAll practice-it

Write a method named swapAll that accepts two arrays of integers as parameters and swaps their entire contents. You may assume that the arrays passed are not null and are the same length.

For example, if the following arrays are passed:

int[] a1 = {11, 42, -5, 27, 0, 89};
int[] a2 = {10, 20, 30, 40, 50, 60};
swapAll(a1, a2);

After the call, the arrays should store the following elements:

a1: {10, 20, 30, 40, 50, 60}
a2: {11, 42, -5, 27, 0, 89}

Exercise : stretch practice-it

Write a method named stretch that accepts an array of integers as a parameter and returns a new array twice as large as the original, replacing every integer from the original array with a pair of integers, each half the original. If a number in the original array is odd, then the first number in the new pair should be one higher than the second so that the sum equals the original number.

For example, if a variable named list refers to an array storing the values {18, 7, 4, 24, 11}, the call of stretch(list) should return a new array containing {9, 9, 4, 3, 2, 2, 12, 12, 6, 5}. (The number 18 is stretched into the pair 9, 9, the number 7 is stretched into 4, 3, the number 4 is stretched into 2, 2, the number 24 is stretched into 12, 12 and the number 11 is stretched into 6, 5.)

Click on the check-mark above to try out your solution in Practice-it!

Exercise : copyRange practice-it

Write a method named copyRange that takes as parameters two arrays a1 and a2, two starting indexes i1 and i2, and a length l, and copies the first l elements of a1 starting at index i1 into array a2 starting at index i2.

For example, if the following arrays are declared:

int[] a1 = {10, 20, 30, 40, 50, 60};
int[] a2 = {91, 92, 93, 94, 95, 96};
copyRange(a1, a2, 0, 2, 3);

After the preceding call, the contents of a2 would be {91, 92, 10, 20, 30, 96}. You may assume that the parameters' values are valid, that the arrays are large enough to hold the data, and so on.

Exercise : equals practice-it

Write a method named equals that accepts two arrays of integers as parameters and returns true if they contain exactly the same elements in the same order, and false otherwise. Note that the arrays might not be the same length; if the lengths differ, return false. Do not call Arrays.equals in your solution.

For example, if the following arrays are declared:

int[] a1 = {10, 20, 30, 40, 50, 60};
int[] a2 = {10, 20, 30, 40, 50, 60};
int[] a3 = {20, 3, 50, 10, 68};

The call equals(a1, a2) returns true but the call equals(a1, a3) returns false.