Practice: a playlist manager

int totalSeconds(ArrayList<Integer> seconds) {
    int total = 0;
    for (int length : seconds) {
        total += length;
    }
    return total;
}

void main() {
    ArrayList<Integer> seconds = new ArrayList<>(List.of(210, 185, 240));
    IO.println(totalSeconds(seconds));
}

An accumulator over the list. The empty case falls out for free, because the total starts at 0 and the loop never runs.

double averageSeconds(ArrayList<Integer> seconds) {
    int total = 0;
    for (int length : seconds) {
        total += length;
    }
    return Math.round((double) total / seconds.size() * 10) / 10.0;
}

void main() {
    ArrayList<Integer> seconds = new ArrayList<>(List.of(210, 185, 240));
    IO.println(averageSeconds(seconds));
}

Divide by size(), not by the number of songs you happen to be testing with, and cast first, so the division keeps its fraction. Then Chapter 3's rounding: times 10, Math.round, divided by 10.0.

String longestTitle(ArrayList<String> titles) {
    String best = titles.get(0);
    for (String title : titles) {
        if (title.length() > best.length()) {
            best = title;
        }
    }
    return best;
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ghost Town", "Ribbons", "Anvil"));
    IO.println(longestTitle(titles));
}

The largest-so-far loop, comparing lengths. Starting from the first title, not from an empty string, means the answer is always a real title.

ArrayList<String> playlistWith(ArrayList<String> titles, String title) {
    ArrayList<String> longer = new ArrayList<>(titles);
    longer.add(title);
    return longer;
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ghost Town", "Ribbons", "Anvil"));
    IO.println(playlistWith(titles, "Lanterns"));
    IO.println(titles);
}

Copy first, so the caller's playlist is left alone: main prints the original afterward, and it still has three songs. titles.add(title) would have changed the caller's list, since titles holds the same object the caller passed in.

ArrayList<String> firstThree(ArrayList<String> titles) {
    if (titles.size() <= 3) {
        return new ArrayList<>(titles);
    }
    return new ArrayList<>(titles.subList(0, 3));
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ghost Town", "Ribbons", "Anvil"));
    titles.add("Lanterns");
    IO.println(firstThree(titles));
}

subList(0, 3) stops the program with an exception when the list is shorter than three, so a short playlist is copied whole before it gets there. Each return hands back a new list, never the caller's.

boolean hasSong(ArrayList<String> titles, String title) {
    return titles.contains(title);
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ghost Town", "Ribbons", "Anvil"));
    IO.println(hasSong(titles, "Anvil"));
    IO.println(hasSong(titles, "Lanterns"));
}

contains asks whether the list holds the title, and its answer is already the true or false the method returns.

ArrayList<Integer> positions(ArrayList<String> titles, String title) {
    ArrayList<Integer> found = new ArrayList<>();
    for (int i = 0; i < titles.size(); i++) {
        if (titles.get(i).equals(title)) {
            found.add(i);
        }
    }
    return found;
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ribbons", "Anvil", "Ribbons"));
    IO.println(positions(titles, "Ribbons"));
}

A counting loop gives the index and the title together, and the filtering pattern keeps the indexes that match. Titles are text, so they are compared with .equals. The last case makes its title at run time, with strip(), so it is a separate String object with the same letters: .equals matches it, and == would not.

ArrayList<String> byLength(ArrayList<String> titles, ArrayList<Integer> seconds) {
    ArrayList<String> titlesLeft = new ArrayList<>(titles);
    ArrayList<Integer> secondsLeft = new ArrayList<>(seconds);
    ArrayList<String> ordered = new ArrayList<>();

    while (!secondsLeft.isEmpty()) {
        int shortest = 0;
        for (int i = 1; i < secondsLeft.size(); i++) {
            if (secondsLeft.get(i) < secondsLeft.get(shortest)) {
                shortest = i;
            }
        }
        ordered.add(titlesLeft.get(shortest));
        titlesLeft.remove(shortest);
        secondsLeft.remove(shortest);
    }
    return ordered;
}

void main() {
    ArrayList<String> titles = new ArrayList<>(List.of("Ghost Town", "Ribbons", "Anvil"));
    ArrayList<Integer> seconds = new ArrayList<>(List.of(210, 185, 240));
    IO.println(byLength(titles, seconds));
}

Each pass of the while finds the index of the shortest length left, moves that song's title to the answer, and removes the pair from both copies at the same index, so the copies stay parallel. shortest is an int, so remove takes it as an index, which is what is wanted here. <, not <=, keeps the first of two equal lengths, so ties stay in playlist order.