Fewest meeting rooms for a day of meetings

def min_meeting_rooms(meetings):
    starts = sorted(s for s, _ in meetings)
    ends = sorted(e for _, e in meetings)
    rooms = j = 0
    for s in starts:
        if ends[j] <= s:          # a meeting has finished: reuse its room
            j += 1
        else:                     # every room is busy: open another
            rooms += 1
    return rooms

#include <vector>
#include <algorithm>

int solve(const std::vector<std::vector<int>>& meetings) {
    std::vector<int> starts, ends;
    for (const auto& m : meetings) { starts.push_back(m[0]); ends.push_back(m[1]); }
    std::sort(starts.begin(), starts.end());
    std::sort(ends.begin(), ends.end());
    int rooms = 0;
    size_t j = 0;
    for (int s : starts) {
        if (ends[j] <= s) ++j;    // a meeting has finished: reuse its room
        else ++rooms;             // every room is busy: open another
    }
    return rooms;
}

class Solution {
    public int minMeetingRooms(int[][] meetings) {
        int n = meetings.length;
        int[] starts = new int[n], ends = new int[n];
        for (int i = 0; i < n; i++) { starts[i] = meetings[i][0]; ends[i] = meetings[i][1]; }
        java.util.Arrays.sort(starts);
        java.util.Arrays.sort(ends);
        int rooms = 0, j = 0;
        for (int s : starts) {
            if (ends[j] <= s) j++;    // a meeting has finished: reuse its room
            else rooms++;             // every room is busy: open another
        }
        return rooms;
    }
}

function minMeetingRooms(meetings) {
  const starts = meetings.map(m => m[0]).sort((a, b) => a - b);
  const ends = meetings.map(m => m[1]).sort((a, b) => a - b);
  let rooms = 0, j = 0;
  for (const s of starts) {
    if (ends[j] <= s) j++;        // a meeting has finished: reuse its room
    else rooms++;                 // every room is busy: open another
  }
  return rooms;
}

fn solve(meetings: &[[i64; 2]]) -> i64 {
    let mut starts: Vec<i64> = meetings.iter().map(|m| m[0]).collect();
    let mut ends: Vec<i64> = meetings.iter().map(|m| m[1]).collect();
    starts.sort();
    ends.sort();
    let (mut rooms, mut j) = (0, 0);
    for s in starts {
        if ends[j] <= s {
            j += 1;               // a meeting has finished: reuse its room
        } else {
            rooms += 1;           // every room is busy: open another
        }
    }
    rooms
}

import Data.List (sort)

-- Walk the sorted starts; reuse a room when the earliest unclaimed end has passed.
solve :: [[Int]] -> Int
solve meetings = go (sort [s | [s, _] <- meetings]) (sort [e | [_, e] <- meetings])
  where
    go [] _ = 0
    go (s : ss) ends@(e : es)
      | e <= s    = go ss es
      | otherwise = 1 + go ss ends
    go _ [] = 0