Intervals

intervals.sort()                       # by start
merged = []
for s, e in intervals:
    if merged and s <= merged[-1][1]:      # overlaps the current block
        merged[-1][1] = max(merged[-1][1], e)
    else:                                  # a gap: start a new block
        merged.append([s, e])

std::sort(iv.begin(), iv.end());          // by start
std::vector<std::vector<int>> merged;
for (const auto& x : iv) {
    if (!merged.empty() && x[0] <= merged.back()[1])
        merged.back()[1] = std::max(merged.back()[1], x[1]);   // overlaps: extend
    else
        merged.push_back(x);                                    // a gap: new block
}

Arrays.sort(iv, (a, b) -> Integer.compare(a[0], b[0]));   // by start
List<int[]> merged = new ArrayList<>();
for (int[] x : iv) {
    int[] last = merged.isEmpty() ? null : merged.get(merged.size() - 1);
    if (last != null && x[0] <= last[1]) last[1] = Math.max(last[1], x[1]);   // overlaps: extend
    else merged.add(new int[]{x[0], x[1]});                                   // a gap: new block
}

intervals.sort((a, b) => a[0] - b[0]);   // by start
const merged = [];
for (const [s, e] of intervals) {
  const last = merged[merged.length - 1];
  if (last && s <= last[1]) last[1] = Math.max(last[1], e);   // overlaps: extend
  else merged.push([s, e]);                                   // a gap: new block
}

iv.sort();                                // by start
let mut merged: Vec<[i64; 2]> = Vec::new();
for &[s, e] in &iv {
    match merged.last_mut() {
        Some(last) if s <= last[1] => last[1] = last[1].max(e),   // overlaps: extend
        _ => merged.push([s, e]),                                  // a gap: new block
    }
}

import Data.List (sort)
-- Sort by start; fold each range into the last block or start a new one.
merge :: [(Int, Int)] -> [(Int, Int)]
merge = reverse . foldl step [] . sort
  where
    step ((s0, e0) : acc) (s, e) | s <= e0 = (s0, max e0 e) : acc
    step acc x = x : acc