Practice: a bus timetable

record Service(String route, int departs, String destination) {}

String routeOf(Service service) {
    String route = service.route();
    int departs = service.departs();
    String destination = service.destination();
    return route;
}

void main() {
    Service service = new Service("47", 415, "Harbor");
    IO.println(routeOf(service));
}

The three lines name every part of a service, so whoever reads routeOf next sees at once what a service holds, and the method gives back the one it was asked for.

String clock(int minutes) {
    return String.format("%02d:%02d", minutes / 60, minutes % 60);
}

void main() {
    IO.println(clock(380));
    IO.println(clock(0));
}

%02d pads to two digits with a zero. Without it, five past ten prints as 10:5 and the timetable stops lining up.

record Service(String route, int departs, String destination) {}

ArrayList<String> destinations(ArrayList<Service> services) {
    Set<String> places = new TreeSet<>();
    for (Service service : services) {
        places.add(service.destination());
    }
    return new ArrayList<>(places);
}

void main() {
    ArrayList<Service> services = new ArrayList<>(List.of(
            new Service("12", 380, "Museum"),
            new Service("47", 415, "Harbor"),
            new Service("47", 500, "Harbor")));
    IO.println(destinations(services));
}

Two services run to the Harbor, so without the set it would appear twice. A TreeSet holds each destination once and keeps them sorted, and a new ArrayList hands them back as a list.

record Service(String route, int departs, String destination) {}

Service nextAfter(ArrayList<Service> services, int minute) {
    ArrayList<Service> sorted = new ArrayList<>(services);
    sorted.sort(Comparator.comparing(service -> service.departs()));
    for (Service service : sorted) {
        if (service.departs() > minute) {
            return service;
        }
    }
    return null;
}

void main() {
    ArrayList<Service> services = new ArrayList<>(List.of(
            new Service("12", 380, "Museum"),
            new Service("47", 415, "Harbor"),
            new Service("47", 500, "Harbor")));
    IO.println(nextAfter(services, 400));
    IO.println(nextAfter(services, 600));
}

Strictly after, so the bus leaving at exactly that minute is the one you just missed. Sorting a copy first means the first match found is the earliest, and null after the loop says that no bus is left.

record Service(String route, int departs, String destination) {}

ArrayList<Service> byTime(ArrayList<Service> services) {
    ArrayList<Service> sorted = new ArrayList<>(services);
    sorted.sort(Comparator.comparing(service -> service.departs()));
    return sorted;
}

void main() {
    ArrayList<Service> services = new ArrayList<>(List.of(
            new Service("47", 500, "Harbor"),
            new Service("12", 380, "Museum"),
            new Service("47", 415, "Harbor")));
    IO.println(byTime(services));
}

The comparator says which part to sort on, the departure. Sorting a copy leaves the list it is handed as it was.

record Service(String route, int departs, String destination) {}

Map<String, Integer> countByRoute(ArrayList<Service> services) {
    Map<String, Integer> counts = new LinkedHashMap<>();
    for (Service service : services) {
        String route = service.route();
        if (!counts.containsKey(route)) {
            counts.put(route, 0);
        }
        counts.put(route, counts.get(route) + 1);
    }
    return counts;
}

void main() {
    ArrayList<Service> services = new ArrayList<>(List.of(
            new Service("12", 380, "Museum"),
            new Service("47", 415, "Harbor"),
            new Service("47", 500, "Harbor")));
    IO.println(countByRoute(services));
}

The if puts a 0 there only when nothing is there yet, so the line after it can always add one. Route 47 runs twice, which is what catches a version that puts 1.

String label(int minute) {
    return (minute >= 420 && minute < 560) || (minute >= 960 && minute < 1140)
            ? "peak"
            : "off-peak";
}

void main() {
    IO.println(label(415));
    IO.println(label(500));
}

Up to but not including, so 560 is already off-peak. The cases sit on the boundaries because that is the only place this can be wrong.

record Service(String route, int departs, String destination) {}

String clock(int minutes) {
    return String.format("%02d:%02d", minutes / 60, minutes % 60);
}

ArrayList<Service> byTime(ArrayList<Service> services) {
    ArrayList<Service> sorted = new ArrayList<>(services);
    sorted.sort(Comparator.comparing(service -> service.departs()));
    return sorted;
}

ArrayList<String> timetableLines(ArrayList<Service> services) {
    ArrayList<String> lines = new ArrayList<>();
    for (Service service : byTime(services)) {
        lines.add(service.route() + " " + clock(service.departs()) + " "
                + service.destination());
    }
    return lines;
}

void main() {
    ArrayList<Service> services = new ArrayList<>(List.of(
            new Service("47", 500, "Harbor"),
            new Service("12", 380, "Museum"),
            new Service("47", 415, "Harbor")));
    for (String line : timetableLines(services)) {
        IO.println(line);
    }
}

Two methods you already wrote, used rather than repeated. The check passes the services out of order on purpose.