Greedy Scheduling in Python, Java and TypeScript

def most_meetings(meetings: list[tuple[int, int]]) -> list[tuple[int, int]]:
    kept: list[tuple[int, int]] = []
    for start, end in sorted(meetings, key=lambda meeting: meeting[1]):
        if not kept or start >= kept[-1][1]:
            kept.append((start, end))
    return kept


def least_lateness(jobs: dict[str, tuple[int, int]]) -> tuple[list[str], int]:
    order = sorted(jobs, key=lambda name: jobs[name][1])
    time, worst = 0, 0
    for name in order:
        duration, deadline = jobs[name]
        time += duration
        worst = max(worst, time - deadline)
    return order, worst


meetings = [(1, 3), (2, 5), (4, 7), (6, 8), (5, 9), (8, 10)]
print("meetings kept:", " ".join(f"({start}, {end})" for start, end in most_meetings(meetings)))
order, worst = least_lateness({"A": (3, 3), "B": (1, 6), "C": (2, 8), "D": (4, 9)})
print(f"jobs by deadline: {' '.join(order)}, worst lateness {worst}")

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class GreedyCode {
    record Meeting(int start, int end) {}

    record Job(int duration, int deadline) {}

    static List<Meeting> mostMeetings(List<Meeting> meetings) {
        List<Meeting> sorted = new ArrayList<>(meetings);
        sorted.sort(Comparator.comparingInt(Meeting::end));
        List<Meeting> kept = new ArrayList<>();
        for (Meeting meeting : sorted) {
            if (kept.isEmpty() || meeting.start() >= kept.get(kept.size() - 1).end()) {
                kept.add(meeting);
            }
        }
        return kept;
    }

    static int leastLateness(Map<String, Job> jobs, List<String> order) {
        order.addAll(jobs.keySet());
        order.sort(Comparator.comparingInt(name -> jobs.get(name).deadline()));
        int time = 0;
        int worst = 0;
        for (String name : order) {
            time += jobs.get(name).duration();
            worst = Math.max(worst, time - jobs.get(name).deadline());
        }
        return worst;
    }

    public static void main(String[] args) {
        List<Meeting> meetings = List.of(new Meeting(1, 3), new Meeting(2, 5), new Meeting(4, 7),
                new Meeting(6, 8), new Meeting(5, 9), new Meeting(8, 10));
        System.out.println("meetings kept: " + mostMeetings(meetings).stream()
                .map(m -> "(" + m.start() + ", " + m.end() + ")").collect(Collectors.joining(" ")));
        Map<String, Job> jobs = new LinkedHashMap<>();
        jobs.put("A", new Job(3, 3));
        jobs.put("B", new Job(1, 6));
        jobs.put("C", new Job(2, 8));
        jobs.put("D", new Job(4, 9));
        List<String> order = new ArrayList<>();
        int worst = leastLateness(jobs, order);
        System.out.println("jobs by deadline: " + String.join(" ", order) + ", worst lateness " + worst);
    }
}

type Meeting = [start: number, end: number];

function mostMeetings(meetings: Meeting[]): Meeting[] {
  const kept: Meeting[] = [];
  for (const [start, end] of [...meetings].sort((a, b) => a[1] - b[1])) {
    if (kept.length === 0 || start >= kept[kept.length - 1][1]) {
      kept.push([start, end]);
    }
  }
  return kept;
}

function leastLateness(jobs: Record<string, [duration: number, deadline: number]>): [string[], number] {
  const order = Object.keys(jobs).sort((a, b) => jobs[a][1] - jobs[b][1]);
  let time = 0;
  let worst = 0;
  for (const name of order) {
    const [duration, deadline] = jobs[name];
    time += duration;
    worst = Math.max(worst, time - deadline);
  }
  return [order, worst];
}

const meetings: Meeting[] = [[1, 3], [2, 5], [4, 7], [6, 8], [5, 9], [8, 10]];
console.log(`meetings kept: ${mostMeetings(meetings).map(([s, e]) => `(${s}, ${e})`).join(" ")}`);
const [order, worst] = leastLateness({ A: [3, 3], B: [1, 6], C: [2, 8], D: [4, 9] });
console.log(`jobs by deadline: ${order.join(" ")}, worst lateness ${worst}`);