This is a declaration statement, that declares and initializes a variable named palette of type Color[]. The initial value of this variable is a newly created array that has space for 12 items. To be specific about what the computer does: It creates a new 12-element array object on the heap, and it fills each space in that array with null. It allocates a memory space for the variable, palette. And it stores a pointer to the new array object in that memory space.

The base type of an array refers to the type of the items that can be stored in that array. For example, the base type of the array in the previous problem is Color.

To sort an array means to rearrange the items in the array so that they are in increasing or decreasing order (according to some criterion).

The advantage of binary search is that it is much faster. On a list of one million items, linear search would take an average of five hundred thousand steps to find an item, whereas binary search would take only 20 steps. The disadvantage is that binary search only works on a sorted list, so some extra work must be done to keep the sort the list or to keep the list in sorted order as it is created.

A dynamic array is like an array in that it is a data structure that stores a sequence of items, all of the same type, in numbered locations. It is different from an array in that there is no preset upper limit on the number of items that it can contain. This is an advantage in situations where a reasonable value for the size of the array is not known at the time it is created.

Strings can be compared for lexicographic order using the compareTo instance method in the String class. We can find the smallest string as follows:

String smallest = strlst.get(0);
for (int i = 1; i < strlist.size(); i++) {
   String nextString = strlst.get(i);
   if ( nextString.compareTo(smallest) < 0 ) 
       smallest = nextString;
}
System.out.println("The smallest string lexicographically is " + smallest);

If strlst were declared to be of type ArrayList, then the return type of strlst.get(i) would be Object instead of String, and a type-cast would be necessary to convert the returned value to type String:

String smallest = (String)strlst.get(0);
for (int i = 1; i < strlist.size(); i++) {
   String nextString = (String)strlst.get(i);
   if ( nextString.compareTo(smallest) < 0 ) 
       smallest = nextString;
}
System.out.println("The smallest string lexicographically is " + smallest);

Furthermore, it now has to be assumed that every item in the list is in fact a string, since objects of any type could now be legally stored in strlst.

The purpose of the subroutine is to chain all the strings in an array of strings into one long string. If the array parameter is null, then there are no strings, and the empty string is returned. Otherwise, the value returned is the string made up of all the strings from the array. For example, if stringList is an array declared as

String[] stringList = { "Put 'em ",  "all", " together" };

then the value of concat(stringList) is "Put 'em all together".

The output consists of six lines, with each line containing six characters. In the first line, i is 0, so all the characters are *'s. In the last line, i is 5, so all the characters are *'s. In each of the four lines in the middle, one of the characters is a * and the rest are periods. The output is

******
.*....
..*...
...*..
....*.
******

It might help to look at the array items that are printed on each line. Note that pic[row][col] is '*' if row is 0 or if row is 5 or if row and col are equal.

pic[0][0] pic[0][1] pic[0][2] pic[0][3] pic[0][4] pic[0][5] 
pic[1][0] pic[1][1] pic[1][2] pic[1][3] pic[1][4] pic[1][5] 
pic[2][0] pic[2][1] pic[2][2] pic[2][3] pic[2][4] pic[2][5] 
pic[3][0] pic[3][1] pic[3][2] pic[3][3] pic[3][4] pic[3][5] 
pic[4][0] pic[4][1] pic[4][2] pic[4][3] pic[4][4] pic[4][5] 
pic[5][0] pic[5][1] pic[5][2] pic[5][3] pic[5][4] pic[5][5]

One possible answer is:

public static int getMax(int[] list) {
   
   int max = list[0];  // This is the largest item seen so far.
   
   for (int i = 1; i < list.length; i++) {
         // Look at each item in the array.  If the item is
         // bigger than max, then set max equal to the item.
       if (list[i] > max)
          max = list[i];
   }
   
   // At this point, max is the largest item in the whole array.
   
   return max;
   
} // end subroutine getMax

A pseudocode outline of the answer is

For each city {
   Add up all the temperatures for that city
   Divide the total by 365 and print the answer
}

Adding up all the temperatures for a given city itself requires a for loop, so the code segment looks like this:

for (int city = 0; city < 100; city++) {
    int total = 0;  // total of temperatures for this city
    for (int day = 0; day < 365; day++)
       total = total + temps[city][day];
    double avg = total / 365.0;  // average temp for this city
    System.out.println("Average temp for city number " 
             + city + " is " + avg);
}

(The data for the i-th employee is stored in an object that can be referred to as employeeData[i]. The four pieces of data about that employee are members of this object and can be referred to as:

• employeeData[i].firstName
• employeeData[i].lastName
• employeeData[i].hourlyWage
• employeeData[i].yearsWithCompany

The code segment uses a for loop to consider each employee in the array.)

for (int i=0; i < 100; i++) {
    if ( employeeData[i].yearsWithCompany >= 20 )
        System.out.println(employeeData[i].firstName + " " +
                      employeeData[i].lastName + ": " +
                      employeeData[i].hourlyWage);
}

(There is one problem with this problem. What happens if all the entries in the array A are zero? In that case, the number of non-zero entries is zero, and the average of non-zero entries is undefined. In my answer, I assign the "undefined" value, Double.NaN, to the average in this case, but this is somewhat arbitrary.)

int nonzeroCt = 0; // The number of non-zero entries in the array.
double total = 0;  // The total of all the grades in the array.
double average;    // The average of the non-zero entries in the array.

for (int i = 0; i < 20; i++) {
   if (A[i] != 0) {       // Process this non-zero entry.
       total += A[i]; // Add it to the total.
       nonzeroCt++;   // Count it.
   }
}

if (nonzeroCt > 0)
   average = total / nonzeroCt;
else   // (The average is undefined in this case)
   average = Double.NaN;