Stream processing: windows, event time, watermarks

Python 3.14 · main.py

# Ten clicks from four phones: when each happened and when it reached the job, in seconds
# after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
CLICKS = [
    (5, 6, "A"),
    (20, 21, "B"),
    (31, 150, "C"),
    (42, 150, "C"),
    (55, 56, "A"),
    (70, 71, "B"),
    (88, 205, "D"),
    (101, 102, "A"),
    (130, 131, "B"),
    (170, 171, "A"),
]
MINUTES = 4


def per_minute(times: list[int]) -> list[int]:
    counts = [0] * MINUTES  # one-minute tumbling windows, 12:00 to 12:03
    for t in times:
        counts[t // 60] += 1
    return counts


by_event = per_minute([happened for happened, _, _ in CLICKS])
by_arrival = per_minute([arrived for _, arrived, _ in CLICKS])
print("minute    by event time   by processing time")
for m in range(MINUTES):
    print(f"12:0{m}     {by_event[m]:>13}   {by_arrival[m]:>18}")
late = [phone for happened, arrived, phone in CLICKS if arrived // 60 != happened // 60]
phones = ", ".join(late)
print(
    f"{len(late)} of {len(CLICKS)} clicks were counted in a later minute, from phones {phones}"
)
latest = max(arrived - happened for happened, arrived, _ in CLICKS)
print(f"the latest arrived {latest} s after it happened")

In Python: t // 60 is the minute of a time in seconds, and a list of four counts stands for the one-minute windows from 12:00 to 12:03.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
const CLICKS = [
  [5, 6, "A"],
  [20, 21, "B"],
  [31, 150, "C"],
  [42, 150, "C"],
  [55, 56, "A"],
  [70, 71, "B"],
  [88, 205, "D"],
  [101, 102, "A"],
  [130, 131, "B"],
  [170, 171, "A"],
];
const MINUTES = 4;

function perMinute(times) {
  // one-minute tumbling windows, 12:00 to 12:03
  const counts = new Array(MINUTES).fill(0);
  for (const t of times) {
    counts[Math.floor(t / 60)] += 1;
  }
  return counts;
}

const byEvent = perMinute(CLICKS.map(([happened]) => happened));
const byArrival = perMinute(CLICKS.map(([, arrived]) => arrived));
console.log("minute    by event time   by processing time");
for (let m = 0; m < MINUTES; m++) {
  console.log(
    `12:0${m}     ${String(byEvent[m]).padStart(13)}   ${String(byArrival[m]).padStart(18)}`,
  );
}
const late = CLICKS.filter(([h, a]) => Math.floor(a / 60) !== Math.floor(h / 60)).map((c) => c[2]);
const phones = late.join(", ");
console.log(
  `${late.length} of ${CLICKS.length} clicks were counted in a later minute, from phones ${phones}`,
);
const latest = Math.max(...CLICKS.map(([happened, arrived]) => arrived - happened));
console.log(`the latest arrived ${latest} s after it happened`);

In JavaScript: JavaScript has no integer division, so Math.floor(t / 60) gives the minute, and padStart lines up the columns.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class Main {
  // Ten clicks from four phones: when each happened and when it reached the job, in seconds
  // after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
  record Click(int happened, int arrived, String phone) {}

  static final List<Click> CLICKS =
      List.of(
          new Click(5, 6, "A"),
          new Click(20, 21, "B"),
          new Click(31, 150, "C"),
          new Click(42, 150, "C"),
          new Click(55, 56, "A"),
          new Click(70, 71, "B"),
          new Click(88, 205, "D"),
          new Click(101, 102, "A"),
          new Click(130, 131, "B"),
          new Click(170, 171, "A"));
  static final int MINUTES = 4;

  public static void main(String[] args) {
    Locale.setDefault(Locale.ROOT);
    int[] byEvent = new int[MINUTES]; // one-minute tumbling windows, 12:00 to 12:03
    int[] byArrival = new int[MINUTES];
    List<String> late = new ArrayList<>();
    int latest = 0;
    for (Click c : CLICKS) {
      byEvent[c.happened() / 60]++;
      byArrival[c.arrived() / 60]++;
      if (c.arrived() / 60 != c.happened() / 60) {
        late.add(c.phone());
      }
      latest = Math.max(latest, c.arrived() - c.happened());
    }
    System.out.println("minute    by event time   by processing time");
    for (int m = 0; m < MINUTES; m++) {
      System.out.printf("12:0%d     %13d   %18d%n", m, byEvent[m], byArrival[m]);
    }
    System.out.printf(
        "%d of %d clicks were counted in a later minute, from phones %s%n",
        late.size(), CLICKS.size(), String.join(", ", late));
    System.out.printf("the latest arrived %d s after it happened%n", latest);
  }
}

In Java: Integer division drops the remainder, so t / 60 is the minute. printf's %13d pads each count to its column, and main sets Locale.ROOT first, so that every locale prints the same digits.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <algorithm>
#include <array>
#include <print>
#include <string>
#include <vector>

// Ten clicks from four phones: when each happened and when it reached the job,
// in seconds after 12:00:00. Phones C and D were offline for a while and sent
// their clicks late.
struct Click {
  int happened, arrived;
  char phone;
};

constexpr std::array<Click, 10> clicks{{
    {5, 6, 'A'},
    {20, 21, 'B'},
    {31, 150, 'C'},
    {42, 150, 'C'},
    {55, 56, 'A'},
    {70, 71, 'B'},
    {88, 205, 'D'},
    {101, 102, 'A'},
    {130, 131, 'B'},
    {170, 171, 'A'},
}};
constexpr int minutes = 4;

int main() {
  // one-minute tumbling windows, 12:00 to 12:03
  std::array<int, minutes> by_event{};
  std::array<int, minutes> by_arrival{};
  std::vector<std::string> late;
  int latest = 0;
  for (const auto &[happened, arrived, phone] : clicks) {
    by_event[happened / 60]++;
    by_arrival[arrived / 60]++;
    if (arrived / 60 != happened / 60) {
      late.emplace_back(1, phone);
    }
    latest = std::max(latest, arrived - happened);
  }
  std::println("minute    by event time   by processing time");
  for (int m = 0; m < minutes; m++) {
    std::println("12:0{}     {:>13}   {:>18}", m, by_event[m], by_arrival[m]);
  }
  std::string phones;
  for (const auto &phone : late) {
    phones += (phones.empty() ? "" : ", ") + phone;
  }
  std::println("{} of {} clicks were counted in a later minute, from phones {}",
               late.size(), clicks.size(), phones);
  std::println("the latest arrived {} s after it happened", latest);
}

In C++: Structured bindings unpack each click in the range-for loop, and std::println's {:>13} right-aligns the counts.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
(int Happened, int Arrived, string Phone)[] clicks =
[
    (5, 6, "A"), (20, 21, "B"), (31, 150, "C"), (42, 150, "C"), (55, 56, "A"),
    (70, 71, "B"), (88, 205, "D"), (101, 102, "A"), (130, 131, "B"), (170, 171, "A"),
];
const int Minutes = 4;

int[] byEvent = PerMinute(clicks.Select(c => c.Happened));
int[] byArrival = PerMinute(clicks.Select(c => c.Arrived));
Console.WriteLine("minute    by event time   by processing time");
for (int m = 0; m < Minutes; m++)
{
    Console.WriteLine($"12:0{m}     {byEvent[m],13}   {byArrival[m],18}");
}
var late = clicks.Where(c => c.Arrived / 60 != c.Happened / 60).Select(c => c.Phone).ToList();
string phones = string.Join(", ", late);
Console.WriteLine(
    $"{late.Count} of {clicks.Length} clicks were counted in a later minute, from phones {phones}");
int latest = clicks.Max(c => c.Arrived - c.Happened);
Console.WriteLine($"the latest arrived {latest} s after it happened");

static int[] PerMinute(IEnumerable<int> times)
{
    var counts = new int[Minutes]; // one-minute tumbling windows, 12:00 to 12:03
    foreach (int t in times)
    {
        counts[t / 60]++;
    }
    return counts;
}

In C#: The clicks are named tuples that LINQ's Select, Where and Max read, and {byEvent[m],13} pads a count to 13 characters.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stddef.h>
#include <stdio.h>

// Ten clicks from four phones: when each happened and when it reached the job,
// in seconds after 12:00:00. Phones C and D were offline for a while and sent
// their clicks late.
typedef struct {
  int happened, arrived;
  char phone;
} Click;

static const Click CLICKS[] = {
    {5, 6, 'A'},     {20, 21, 'B'},   {31, 150, 'C'}, {42, 150, 'C'},
    {55, 56, 'A'},   {70, 71, 'B'},   {88, 205, 'D'}, {101, 102, 'A'},
    {130, 131, 'B'}, {170, 171, 'A'},
};
enum { COUNT = sizeof CLICKS / sizeof CLICKS[0], MINUTES = 4 };

int main(void) {
  int by_event[MINUTES] = {0}; // one-minute tumbling windows, 12:00 to 12:03
  int by_arrival[MINUTES] = {0};
  char late[COUNT * 2] = {0};
  int late_count = 0, latest = 0;
  for (size_t i = 0; i < COUNT; i++) {
    const Click *c = &CLICKS[i];
    by_event[c->happened / 60]++;
    by_arrival[c->arrived / 60]++;
    if (c->arrived / 60 != c->happened / 60) {
      late[late_count++] = c->phone;
    }
    if (c->arrived - c->happened > latest) {
      latest = c->arrived - c->happened;
    }
  }
  puts("minute    by event time   by processing time");
  for (int m = 0; m < MINUTES; m++) {
    printf("12:0%d     %13d   %18d\n", m, by_event[m], by_arrival[m]);
  }
  printf("%d of %d clicks were counted in a later minute, from phones",
         late_count, (int)COUNT);
  for (int i = 0; i < late_count; i++) {
    printf("%s %c", i > 0 ? "," : "", late[i]);
  }
  printf("\nthe latest arrived %d s after it happened\n", latest);
  return 0;
}

In C: C has no join, so the late phones, single characters, are printed one by one with a comma before every one after the first.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
const CLICKS = [
    [5, 6, 'A'], [20, 21, 'B'], [31, 150, 'C'], [42, 150, 'C'], [55, 56, 'A'],
    [70, 71, 'B'], [88, 205, 'D'], [101, 102, 'A'], [130, 131, 'B'], [170, 171, 'A'],
];
const MINUTES = 4;

/** @param list<int> $times @return list<int> */
function perMinute(array $times): array
{
    $counts = array_fill(0, MINUTES, 0); // one-minute tumbling windows, 12:00 to 12:03
    foreach ($times as $t) {
        $counts[intdiv($t, 60)]++;
    }
    return $counts;
}

$byEvent = perMinute(array_column(CLICKS, 0));
$byArrival = perMinute(array_column(CLICKS, 1));
echo "minute    by event time   by processing time\n";
for ($m = 0; $m < MINUTES; $m++) {
    printf("12:0%d     %13d   %18d\n", $m, $byEvent[$m], $byArrival[$m]);
}
$late = [];
$latest = 0;
foreach (CLICKS as [$happened, $arrived, $phone]) {
    if (intdiv($arrived, 60) !== intdiv($happened, 60)) {
        $late[] = $phone;
    }
    $latest = max($latest, $arrived - $happened);
}
printf(
    "%d of %d clicks were counted in a later minute, from phones %s\n",
    count($late),
    count(CLICKS),
    implode(', ', $late),
);
printf("the latest arrived %d s after it happened\n", $latest);

In PHP: array_column picks the happened and the arrived times out of the rows, and intdiv divides whole numbers.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
const CLICKS: [(usize, usize, &str); 10] = [
    (5, 6, "A"),
    (20, 21, "B"),
    (31, 150, "C"),
    (42, 150, "C"),
    (55, 56, "A"),
    (70, 71, "B"),
    (88, 205, "D"),
    (101, 102, "A"),
    (130, 131, "B"),
    (170, 171, "A"),
];
const MINUTES: usize = 4;

fn per_minute(times: impl Iterator<Item = usize>) -> [usize; MINUTES] {
    let mut counts = [0; MINUTES]; // one-minute tumbling windows, 12:00 to 12:03
    for t in times {
        counts[t / 60] += 1;
    }
    counts
}

fn main() {
    let by_event = per_minute(CLICKS.iter().map(|&(happened, _, _)| happened));
    let by_arrival = per_minute(CLICKS.iter().map(|&(_, arrived, _)| arrived));
    println!("minute    by event time   by processing time");
    for m in 0..MINUTES {
        println!("12:0{m}     {:>13}   {:>18}", by_event[m], by_arrival[m]);
    }
    let late: Vec<&str> = CLICKS
        .iter()
        .filter(|&&(happened, arrived, _)| arrived / 60 != happened / 60)
        .map(|&(_, _, phone)| phone)
        .collect();
    println!(
        "{} of {} clicks were counted in a later minute, from phones {}",
        late.len(),
        CLICKS.len(),
        late.join(", ")
    );
    let latest = CLICKS.iter().map(|&(h, a, _)| a - h).max().unwrap_or(0);
    println!("the latest arrived {latest} s after it happened");
}

In Rust: per_minute takes any iterator of times, so both calls pass a map over the same array without building a list.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
const CLICKS: [number, number, string][] = [
  [5, 6, "A"],
  [20, 21, "B"],
  [31, 150, "C"],
  [42, 150, "C"],
  [55, 56, "A"],
  [70, 71, "B"],
  [88, 205, "D"],
  [101, 102, "A"],
  [130, 131, "B"],
  [170, 171, "A"],
];
const MINUTES = 4;

function perMinute(times: number[]): number[] {
  // one-minute tumbling windows, 12:00 to 12:03
  const counts: number[] = new Array(MINUTES).fill(0);
  for (const t of times) {
    counts[Math.floor(t / 60)] += 1;
  }
  return counts;
}

const byEvent = perMinute(CLICKS.map(([happened]) => happened));
const byArrival = perMinute(CLICKS.map(([, arrived]) => arrived));
console.log("minute    by event time   by processing time");
for (let m = 0; m < MINUTES; m++) {
  console.log(
    `12:0${m}     ${String(byEvent[m]).padStart(13)}   ${String(byArrival[m]).padStart(18)}`,
  );
}
const late = CLICKS.filter(([h, a]) => Math.floor(a / 60) !== Math.floor(h / 60)).map((c) => c[2]);
const phones = late.join(", ");
console.log(
  `${late.length} of ${CLICKS.length} clicks were counted in a later minute, from phones ${phones}`,
);
const latest = Math.max(...CLICKS.map(([happened, arrived]) => arrived - happened));
console.log(`the latest arrived ${latest} s after it happened`);

In TypeScript: Each click is typed as a tuple of two numbers and a string, so a row of the wrong shape does not compile.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strings"
)

// Click is one of ten clicks from four phones: when it happened and when it reached the job,
// in seconds after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
type Click struct {
	Happened, Arrived int
	Phone             string
}

var clicks = []Click{
	{5, 6, "A"}, {20, 21, "B"}, {31, 150, "C"}, {42, 150, "C"}, {55, 56, "A"},
	{70, 71, "B"}, {88, 205, "D"}, {101, 102, "A"}, {130, 131, "B"}, {170, 171, "A"},
}

const minutes = 4

func main() {
	var byEvent, byArrival [minutes]int // one-minute tumbling windows, 12:00 to 12:03
	var late []string
	latest := 0
	for _, c := range clicks {
		byEvent[c.Happened/60]++
		byArrival[c.Arrived/60]++
		if c.Arrived/60 != c.Happened/60 {
			late = append(late, c.Phone)
		}
		latest = max(latest, c.Arrived-c.Happened)
	}
	fmt.Println("minute    by event time   by processing time")
	for m := range minutes {
		fmt.Printf("12:0%d     %13d   %18d\n", m, byEvent[m], byArrival[m])
	}
	fmt.Printf("%d of %d clicks were counted in a later minute, from phones %s\n",
		len(late), len(clicks), strings.Join(late, ", "))
	fmt.Printf("the latest arrived %d s after it happened\n", latest)
}

In Go: The counts are arrays of fixed size, [minutes]int, that start at zero, and range over the constant counts from 0 to 3.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
let clicks: [(happened: Int, arrived: Int, phone: String)] = [
  (5, 6, "A"), (20, 21, "B"), (31, 150, "C"), (42, 150, "C"), (55, 56, "A"),
  (70, 71, "B"), (88, 205, "D"), (101, 102, "A"), (130, 131, "B"), (170, 171, "A"),
]
let minutes = 4

func perMinute(_ times: [Int]) -> [Int] {
  var counts = [Int](repeating: 0, count: minutes)  // one-minute tumbling windows, 12:00 to 12:03
  for t in times {
    counts[t / 60] += 1
  }
  return counts
}

func pad(_ n: Int, to width: Int) -> String {
  let digits = String(n)
  return String(repeating: " ", count: max(0, width - digits.count)) + digits
}

let byEvent = perMinute(clicks.map { $0.happened })
let byArrival = perMinute(clicks.map { $0.arrived })
print("minute    by event time   by processing time")
for m in 0..<minutes {
  print("12:0\(m)     \(pad(byEvent[m], to: 13))   \(pad(byArrival[m], to: 18))")
}
let late = clicks.filter { $0.arrived / 60 != $0.happened / 60 }.map { $0.phone }
print(
  "\(late.count) of \(clicks.count) clicks were counted in a later minute,"
    + " from phones \(late.joined(separator: ", "))")
let latest = clicks.map { $0.arrived - $0.happened }.max() ?? 0
print("the latest arrived \(latest) s after it happened")

In Swift: The clicks are tuples with labels, so $0.happened reads a field, and pad lines up the columns without Foundation.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

# Ten clicks from four phones: when each happened and when it reached the job, in seconds
# after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
CLICKS = [
  [5, 6, 'A'], [20, 21, 'B'], [31, 150, 'C'], [42, 150, 'C'], [55, 56, 'A'],
  [70, 71, 'B'], [88, 205, 'D'], [101, 102, 'A'], [130, 131, 'B'], [170, 171, 'A']
].freeze
MINUTES = 4

def per_minute(times)
  counts = Array.new(MINUTES, 0) # one-minute tumbling windows, 12:00 to 12:03
  times.each { |time| counts[time / 60] += 1 }
  counts
end

by_event = per_minute(CLICKS.map(&:first))
by_arrival = per_minute(CLICKS.map { |click| click[1] })
puts 'minute    by event time   by processing time'
MINUTES.times do |minute|
  puts "12:0#{minute}     #{by_event[minute].to_s.rjust(13)}   " \
       "#{by_arrival[minute].to_s.rjust(18)}"
end
late = CLICKS.reject { |happened, arrived, _| arrived / 60 == happened / 60 }.map(&:last)
puts "#{late.size} of #{CLICKS.size} clicks were counted in a later minute, " \
     "from phones #{late.join(', ')}"
latest = CLICKS.map { |happened, arrived, _| arrived - happened }.max
puts "the latest arrived #{latest} s after it happened"

In Ruby: map(&:first) takes the first field of each row, and reject keeps the clicks whose minute changed on the way.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

// Ten clicks from four phones: when each happened and when it reached the job, in seconds
// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
data class Click(
    val happened: Int,
    val arrived: Int,
    val phone: String,
)

val clicks =
    listOf(
        Click(5, 6, "A"),
        Click(20, 21, "B"),
        Click(31, 150, "C"),
        Click(42, 150, "C"),
        Click(55, 56, "A"),
        Click(70, 71, "B"),
        Click(88, 205, "D"),
        Click(101, 102, "A"),
        Click(130, 131, "B"),
        Click(170, 171, "A"),
    )
const val MINUTES = 4

fun perMinute(times: List<Int>): IntArray {
    val counts = IntArray(MINUTES) // one-minute tumbling windows, 12:00 to 12:03
    for (t in times) counts[t / 60]++
    return counts
}

fun main() {
    val byEvent = perMinute(clicks.map { it.happened })
    val byArrival = perMinute(clicks.map { it.arrived })
    println("minute    by event time   by processing time")
    for (m in 0 until MINUTES) {
        val event = byEvent[m].toString().padStart(13)
        val arrival = byArrival[m].toString().padStart(18)
        println("12:0$m     $event   $arrival")
    }
    val late = clicks.filter { it.arrived / 60 != it.happened / 60 }.map { it.phone }
    println(
        "${late.size} of ${clicks.size} clicks were counted in a later minute, " +
            "from phones ${late.joinToString(", ")}",
    )
    println("the latest arrived ${clicks.maxOf { it.arrived - it.happened }} s after it happened")
}

In Kotlin: IntArray(MINUTES) starts at zero, and maxOf with a lambda finds the longest delay in one call.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

/// Ten clicks from four phones: when each happened and when it reached the job, in seconds
/// after 12:00:00. Phones C and D were offline for a while and sent their clicks late.
const clicks = [
  (happened: 5, arrived: 6, phone: 'A'),
  (happened: 20, arrived: 21, phone: 'B'),
  (happened: 31, arrived: 150, phone: 'C'),
  (happened: 42, arrived: 150, phone: 'C'),
  (happened: 55, arrived: 56, phone: 'A'),
  (happened: 70, arrived: 71, phone: 'B'),
  (happened: 88, arrived: 205, phone: 'D'),
  (happened: 101, arrived: 102, phone: 'A'),
  (happened: 130, arrived: 131, phone: 'B'),
  (happened: 170, arrived: 171, phone: 'A'),
];
const minutes = 4;

List<int> perMinute(Iterable<int> times) {
  // one-minute tumbling windows, 12:00 to 12:03
  final counts = List.filled(minutes, 0);
  for (final t in times) {
    counts[t ~/ 60]++;
  }
  return counts;
}

void main() {
  final byEvent = perMinute(clicks.map((c) => c.happened));
  final byArrival = perMinute(clicks.map((c) => c.arrived));
  print('minute    by event time   by processing time');
  for (var m = 0; m < minutes; m++) {
    print(
      '12:0$m     ${byEvent[m].toString().padLeft(13)}   '
      '${byArrival[m].toString().padLeft(18)}',
    );
  }
  final late = [
    for (final c in clicks)
      if (c.arrived ~/ 60 != c.happened ~/ 60) c.phone,
  ];
  print(
    '${late.length} of ${clicks.length} clicks were counted in a later minute, '
    'from phones ${late.join(', ')}',
  );
  final latest = clicks
      .map((c) => c.arrived - c.happened)
      .reduce((a, b) => a > b ? a : b);
  print('the latest arrived $latest s after it happened');
}

In Dart: Each click is a record with named fields, and a collection for with an if gathers the late phones.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart