Fewest bookings to cancel so none overlap

def min_removals(bookings):
    cancelled = 0
    last_end = float('-inf')
    for s, e in sorted(bookings, key=lambda b: b[1]):   # by end time
        if s >= last_end:          # fits after the last kept booking: keep it
            last_end = e
        else:                      # clashes: cancel it
            cancelled += 1
    return cancelled

#include <vector>
#include <algorithm>
#include <climits>

int solve(std::vector<std::vector<int>> b) {
    std::sort(b.begin(), b.end(), [](const std::vector<int>& p, const std::vector<int>& q) { return p[1] < q[1]; });
    int cancelled = 0;
    long long lastEnd = LLONG_MIN;
    for (const auto& x : b) {
        if (x[0] >= lastEnd) lastEnd = x[1];   // fits: keep it
        else ++cancelled;                      // clashes: cancel it
    }
    return cancelled;
}

class Solution {
    public int minRemovals(int[][] bookings) {
        int[][] b = bookings.clone();
        java.util.Arrays.sort(b, (p, q) -> Integer.compare(p[1], q[1]));   // by end time
        int cancelled = 0;
        long lastEnd = Long.MIN_VALUE;
        for (int[] x : b) {
            if (x[0] >= lastEnd) lastEnd = x[1];   // fits: keep it
            else cancelled++;                      // clashes: cancel it
        }
        return cancelled;
    }
}

function minRemovals(bookings) {
  const b = bookings.map(x => x.slice()).sort((p, q) => p[1] - q[1]);   // by end time
  let cancelled = 0, lastEnd = -Infinity;
  for (const [s, e] of b) {
    if (s >= lastEnd) lastEnd = e;   // fits: keep it
    else cancelled++;                // clashes: cancel it
  }
  return cancelled;
}

fn solve(bookings: &[[i64; 2]]) -> i64 {
    let mut b = bookings.to_vec();
    b.sort_by_key(|x| x[1]);                       // by end time
    let mut cancelled = 0;
    let mut last_end = i64::MIN;
    for &[s, e] in &b {
        if s >= last_end {
            last_end = e;                          // fits: keep it
        } else {
            cancelled += 1;                        // clashes: cancel it
        }
    }
    cancelled
}

import Data.List (sortOn)

-- Sort by end time; keep whatever fits after the last kept booking, count the rest.
solve :: [[Int]] -> Int
solve bookings = go minBound (sortOn (!! 1) bookings)
  where
    go _ [] = 0
    go lastEnd ([s, e] : rest)
      | s >= lastEnd = go e rest
      | otherwise    = 1 + go lastEnd rest