Lab 14.1 — Almost a Vector (AlmostAVector) Approval

Create an array and populate it with integers read in from the file numbers.text, then print out various items of information about the array (see below). You should assume a maximum of 100 numbers.

Sample Test Run

For example if the file numbers.text contains:

12.3
2.5
9.4
3.14
22.15
17
54.3
7.6

the program should produce the following output:

The array: {12.3, 2.5, 9.4, 3.14, 22.15, 17.0, 54.3, 7.6} contains 100 elements of which 8 elements are being used
The first element of the array is 12.3
The last element of the array is 7.6 and is at position 7
The middle element of the array is 3.14 and is at position 3
There are 92 empty elements in the array

Notes:

• Notice the data file does not contain a header value, thus you do not know the numbers of value in the file (and thus the exact size of the array) before you read in the numbers.
  • This is why the instructions specify that no more than 100 numbers will be read in
  • Specifying the maximum number of values allows you to create an array of that size
  • The only problem is that if the file contains 5 numbers, when you print out the array, the last 95 numbers printed will be garbage (even if they contain 0, those are not values we read in and for all practical purposes, are of no interest to us).
  • In this context, arr.length is not very useful; what we are really interested in are the number of values actually read in
• Another point: processing a file using eof uses a while loop (its condition-based, i.e., while there's more data);
  • Because we're using a while, there's no index variable to use as the subscript, as would be the case for a for loop (BTW, the same is true for reading in with a trailer value, which also uses a while loop)
  • We thus have to keep track of where to put the next element read in (this is usually done using the index variable of the for loop); this varibale also will tell us the number of elements we've placed into the array
  • We introduce an integer variable (I usually call it size), initialized to 0 — which is both the initial number of elements actually placed into the array, as well as the location/index of the next element to be filled
  • Within the read loop we assign the next number read in to the element at loction size and then increment size
    • The first number read in therefore is assigned to location 0 of the array, nd the size is incremented to 1, which is both the number of elements currently in the array, as well as the next location in which an element is to be placed.
• All processing of the elements of the array now uses size (instead of arr.length) since it is only the elements from 0 … size-1 that are of interest to us.
  • Unlike the length field which is carried along with the array, size is not part of the array
    • This means that your print method for this exercise must have a second parameter — size
• One good thing about all of this — if you use arr.length instead of size. yo'll very quickly see your mistake (there will be a ton of elements with value 0 printed).
• In lecture 14, the technique Reading in an array of known maximum size using a trailer value or eof presents the basic code discussed above.

Lab 14.2 — A Partially Populated Array (PartiallyPopulated Array) Approval

The file flight_manifest contains names of passengers preceded by the class they are flying (first, business or econom — see below for the exact format). Write a program that reads in the data — a line at a time (using nextLine — and prints out the passengers by class. You should assume a maximum of 100 passengers.

Sample Test Run

For example if the file flight_manifest contains:

Business class: Bill Gates
Economy: Gerald Weiss
Economy: David Arnow
First class: Warren Buffet
Business class: Paula Whitlock 
First class: Jim Cox
Economy: Dina Sokol

the program should produce the following output:

First class: Warren Buffet
First class: Jim Cox

Business class: Bill Gates
Business class: Paula Whitlock 

Economy: Gerald Weiss
Economy: David Arnow
Economy: Dina Sokol

Notes:

• The data should be read in a line at a time (using nextLine)
• Since we can't begin printing until all the data has been read in (i.e., the last passenger in the file may be in first class), we require an array (of String) for the data
• We are not quite sorting the data yet, but categorizing it (by class) into three categories
  • Each class (i.e., category) requires a fresh pass over the array; this anticipates what we will be doing when we begin sorting arrays
• The String class contains a method named startWith (look it up in the API for practice) that accepts another String as an argument and returns true/false whethe the original String begins with the passed argument. For example, if we have:

  String s = "Hello world";
  			

  then the call s.beginsWith("Hello") returns true, while s.beginsWith("ell") returns false.
  • You might be asking yourself If there's a startsWith method, is there a … method ???. While you're at the API looking up startsWith, see what other methods there are and if any of them make 'sense' to you.

Lab 14.3 — Parallel Arrays (ParallelArrays)

For the purpose of this exercise, we introduce the notion of aligning pairs of numbers (this is not a standard term, I made it up for this exercise). Given a sequence of pairs of numbers, 'aligning' consists of making all the pairs of numbers go in the same direction, i.e., either all the pairs have the first number less than the second or vice-versa. Write a program to read in pairs of numbers from the file numbers.text, and aligns them (my term) before writing them out to the file aligned_pairs.text. If the pairs read in contains more pairs in which the first number is less than the second, then the pairs should aligned with first < second; otherwise they should be paired using first > second.

Sample Test Run #1

If the file numbers.text contains:

1  	4
10 	5
12	14
22	27
25	10

then after program execution, the file aligned_pairs.text should contain the following:

1 4
5 10
12 14
22 27
10 25

since there are 3 pairs ((1, 4), (12, 14), and (22, 27)) in which the first number is less than the second, while there are only two pairs ((10, 5) and (25, 10)) in which the first number is greater than the second number.

Sample Test Run #2

If the file numbers.text contains:

3	2
6	7
9	6

then after program execution, the file aligned_pairs.text should contain the following:

3 2
7 6
9 6

since there are 2 pairs ((3, 2) and (9, 6)) in which the first number is greater than the second, while there is only one pair ((6, 7)) in which the first number is less than the second number. Notes:

• Which way to align — first < second or first > second — depends on how many pairs are of the first variety of second variety; i.e., one cannot determine which way to align until all pairs have been read in;
  • Thus all the pairs must be kept around, requiring two (parallel) arrays: for the first and second number of each pair
    • The i'th elements of the two arrays form the i'th pair.

Lab 14.4 — Printing Subarrays (Subarray)

The file numbers.text contains a header value followed by the corresponding number of integers. Read the values int an array and print out the a sequence of subarrays, with the first subarray consisting of the entire array, the second consisting of the second to next to last element, the third consisiting of the thitd to third from last element, and so on, until a subarray of size one or two is printed.

Sample Test Run

For example if the file numbers.text contains:

7
12
41
26
77
11
19
44

the program should produce the following output:

{12, 41, 26, 77, 11, 19, 44}
{... 41, 26, 77, 11, 19 ...}
{... 26, 77, 11 ...}
{... 77 ...}

Notes:

• Define a method print(int [] arr, int first, int last) to print out the subarray
  • Alternatively, you can defined the print method to take a length (number of elements instead of the last parameter).
• Note the format of the printed subarray … if the first element of the subarray is not the first element of the array, a ellipsis (…) is printed after the opening { to indicate there are elements preceding the subarray in the array. Similary for subarrays in which the last element of the subarray is not the last element of the array.
• You will need a for loop to print out the various subarrays (since the number of the elements can vary depending on the contents of the file).

Lab 14.5 — Printing Subarrays — Take 2 (Subarrays) (Optional)

The same basic specs as Lab 14.4, but with additional subarray patterns printed out:

• A subarray consisting of the entire array
• Subarrays of increasing size, all starting at the first element of the array
• Subarrays of increasing size, all ending at the first element of the array
• Subarrays of size 1, working through the entire array
• Subarrays of size 2, working through the entire array >
• …
• Subarrays size of arr.length-1, working through the entire array
• A single subarray of the entire array
• The subarray sequence of Lab 14.4

Sample Test Run

For example if the file numbers.text contains:

7
12
41
26
77
11
19
44

the program should produce the following output:

{12, 41, 26, 77, 11, 19, 44}

{12 ...}
{12, 41 ...}
{12, 41, 26 ...}
{12, 41, 26, 77 ...}
{12, 41, 26, 77, 11 ...}
{12, 41, 26, 77, 11, 19 ...}
{12, 41, 26, 77, 11, 19, 44}

{... 44}
{... 19, 44}
{... 11, 19, 44}
{... 77, 11, 19, 44}
{... 26, 77, 11, 19, 44}
{... 41, 26, 77, 11, 19, 44}
{12, 41, 26, 77, 11, 19, 44}

{12 ...}
{... 41 ...}
{... 26 ...}
{... 77 ...}
{... 11 ...}
{... 19 ...}
{... 44}

{12, 41 ...}
{... 41, 26 ...}
{... 26, 77 ...}
{... 77, 11 ...}
{... 11, 19 ...}
{... 19, 44}

{12, 41, 26 ...}
{... 41, 26, 77 ...}
{... 26, 77, 11 ...}
{... 77, 11, 19 ...}
{... 11, 19, 44}

{12, 41, 26, 77 ...}
{... 41, 26, 77, 11 ...}
{... 26, 77, 11, 19 ...}
{... 77, 11, 19, 44}

{12, 41, 26, 77, 11 ...}
{... 41, 26, 77, 11, 19 ...}
{... 26, 77, 11, 19, 44}

{12, 41, 26, 77, 11, 19 ...}
{... 41, 26, 77, 11, 19, 44}

{12, 41, 26, 77, 11, 19, 44}

{12, 41, 26, 77, 11, 19, 44}
{... 41, 26, 77, 11, 19 ...}
{... 26, 77, 11 ...}
{... 77 ...}

Notes:

• Same formatting rules as before
• Use a for loop for each of the pattern sets (except for the first entire-array-as-subarray; the challenege is to figure out the formulas in the header to produce the desired subarray sequence.