Design top-K trending topics

Python 3.14 · main.py

from math import sqrt

FLOOR = 200  # mentions a topic needs in the window to be eligible at all
TOPICS = [  # topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
    ("weather", 18015, 4504),
    ("football", 15897, 4154),
    ("elections", 13084, 3261),
    ("movies", 10397, 2774),
    ("music", 9631, 2323),
    ("recipes", 6111, 1439),
    ("solar-storm", 847, 2983),
    ("chess-final", 2461, 1609),
    ("new-phone", 3974, 1280),
    ("local-quiz", 19, 52),
]


def expected(baseline: int) -> float:
    return baseline / 20 * 5  # the window's 5 minutes at the topic's usual rate


def surprise(baseline: int, window: int) -> float:
    """Rough standard deviations above the usual rate, smoothed for small counts."""
    return (window - expected(baseline)) / sqrt(expected(baseline) + 50)


by_volume = sorted(TOPICS, key=lambda t: -t[2])
by_surprise = sorted(TOPICS, key=lambda t: -surprise(t[1], t[2]))
floored = [t for t in by_surprise if t[2] >= FLOOR]
for title, ranked in [
    ("volume", by_volume),
    ("surprise", by_surprise),
    ("floor", floored),
]:
    print(f"top 5 by {title:<9} {' '.join(t[0] for t in ranked[:5])}")
print("\ntopic        window expected surprise")
for topic, base, window in by_surprise[:5]:
    print(
        f"{topic:<12} {window:>6} {expected(base):>8.0f} {surprise(base, window):>8.1f}"
    )

In Python: sorted() with a key of -surprise sorts from the highest, and a list comprehension keeps the topics above the floor.

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

const FLOOR = 200; // mentions a topic needs in the window to be eligible at all
const TOPICS = [
  // topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
  ["weather", 18015, 4504],
  ["football", 15897, 4154],
  ["elections", 13084, 3261],
  ["movies", 10397, 2774],
  ["music", 9631, 2323],
  ["recipes", 6111, 1439],
  ["solar-storm", 847, 2983],
  ["chess-final", 2461, 1609],
  ["new-phone", 3974, 1280],
  ["local-quiz", 19, 52],
];

// the window's 5 minutes at the topic's usual rate
const expected = (baseline) => (baseline / 20) * 5;

/** Rough standard deviations above the usual rate, smoothed for small counts. */
const surprise = (baseline, window) =>
  (window - expected(baseline)) / Math.sqrt(expected(baseline) + 50);

const byVolume = [...TOPICS].sort((a, b) => b[2] - a[2]);
const bySurprise = [...TOPICS].sort((a, b) => surprise(b[1], b[2]) - surprise(a[1], a[2]));
const floored = bySurprise.filter((t) => t[2] >= FLOOR);
for (const [title, ranked] of [
  ["volume", byVolume],
  ["surprise", bySurprise],
  ["floor", floored],
]) {
  console.log(
    `top 5 by ${title.padEnd(9)} ${ranked
      .slice(0, 5)
      .map((t) => t[0])
      .join(" ")}`,
  );
}
console.log("\ntopic        window expected surprise");
for (const [topic, base, window] of bySurprise.slice(0, 5)) {
  const numbers = [
    expected(base).toFixed(0).padStart(8),
    surprise(base, window).toFixed(1).padStart(8),
  ];
  console.log(`${topic.padEnd(12)} ${String(window).padStart(6)} ${numbers.join(" ")}`);
}

In JavaScript: sort takes a comparator, so b minus a sorts from the highest, and [...TOPICS] sorts a copy and keeps the original order.

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.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;

public class Main {
  static final int FLOOR = 200; // mentions a topic needs in the window to be eligible at all

  // topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
  record Topic(String name, int baseline, int window) {
    double expected() {
      return baseline / 20.0 * 5; // the window's 5 minutes at the topic's usual rate
    }

    /** Rough standard deviations above the usual rate, smoothed for small counts. */
    double surprise() {
      return (window - expected()) / Math.sqrt(expected() + 50);
    }
  }

  static String names(List<Topic> ranked) {
    return ranked.stream().limit(5).map(Topic::name).collect(Collectors.joining(" "));
  }

  public static void main(String[] args) {
    Locale.setDefault(Locale.ROOT);
    List<Topic> topics =
        List.of(
            new Topic("weather", 18015, 4504),
            new Topic("football", 15897, 4154),
            new Topic("elections", 13084, 3261),
            new Topic("movies", 10397, 2774),
            new Topic("music", 9631, 2323),
            new Topic("recipes", 6111, 1439),
            new Topic("solar-storm", 847, 2983),
            new Topic("chess-final", 2461, 1609),
            new Topic("new-phone", 3974, 1280),
            new Topic("local-quiz", 19, 52));
    List<Topic> byVolume =
        topics.stream().sorted(Comparator.comparingInt(Topic::window).reversed()).toList();
    List<Topic> bySurprise =
        topics.stream().sorted(Comparator.comparingDouble(Topic::surprise).reversed()).toList();
    List<Topic> floored = bySurprise.stream().filter(t -> t.window() >= FLOOR).toList();
    System.out.println("top 5 by volume    " + names(byVolume));
    System.out.println("top 5 by surprise  " + names(bySurprise));
    System.out.println("top 5 by floor     " + names(floored));
    System.out.println("\ntopic        window expected surprise");
    for (Topic t : bySurprise.subList(0, 5)) {
      System.out.printf(
          "%-12s %6d %8.0f %8.1f%n", t.name(), t.window(), t.expected(), t.surprise());
    }
  }
}

In Java: The record computes expected() and surprise() as methods, and Comparator.comparingDouble(Topic::surprise).reversed() sorts from the highest.

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 <cmath>
#include <print>
#include <string>
#include <vector>

// mentions a topic needs in the window to be eligible at all
constexpr int FLOOR = 200;

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute
// window
struct Topic {
  std::string name;
  int baseline, window;
  // the window's 5 minutes at the topic's usual rate
  double expected() const { return baseline / 20.0 * 5; }
  // Rough standard deviations above the usual rate, smoothed for small counts.
  double surprise() const {
    return (window - expected()) / std::sqrt(expected() + 50);
  }
};

void print_top(const char *title, const std::vector<Topic> &ranked) {
  std::print("top 5 by {:<9}", title);
  for (size_t i = 0; i < 5; i++)
    std::print(" {}", ranked[i].name);
  std::println();
}

int main() {
  const std::vector<Topic> topics = {
      {"weather", 18015, 4504},   {"football", 15897, 4154},
      {"elections", 13084, 3261}, {"movies", 10397, 2774},
      {"music", 9631, 2323},      {"recipes", 6111, 1439},
      {"solar-storm", 847, 2983}, {"chess-final", 2461, 1609},
      {"new-phone", 3974, 1280},  {"local-quiz", 19, 52}};
  auto by_volume = topics, by_surprise = topics;
  std::ranges::sort(by_volume, std::greater{}, &Topic::window);
  std::ranges::sort(by_surprise, std::greater{}, &Topic::surprise);
  std::vector<Topic> floored;
  std::ranges::copy_if(by_surprise, std::back_inserter(floored),
                       [](const Topic &t) { return t.window >= FLOOR; });
  print_top("volume", by_volume);
  print_top("surprise", by_surprise);
  print_top("floor", floored);
  std::println("\ntopic        window expected surprise");
  for (size_t i = 0; i < 5; i++) {
    const auto &t = by_surprise[i];
    std::println("{:<12} {:>6} {:>8.0f} {:>8.1f}", t.name, t.window,
                 t.expected(), t.surprise());
  }
}

In C++: std::ranges::sort takes a projection, &Topic::surprise, so std::greater{} sorts from the highest, and copy_if keeps the topics above the floor.

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

using static System.FormattableString;

const int Floor = 200; // mentions a topic needs in the window to be eligible at all

Topic[] topics =
[
    new("weather", 18015, 4504),
    new("football", 15897, 4154),
    new("elections", 13084, 3261),
    new("movies", 10397, 2774),
    new("music", 9631, 2323),
    new("recipes", 6111, 1439),
    new("solar-storm", 847, 2983),
    new("chess-final", 2461, 1609),
    new("new-phone", 3974, 1280),
    new("local-quiz", 19, 52),
];
var byVolume = topics.OrderByDescending(t => t.Window).ToList();
var bySurprise = topics.OrderByDescending(t => t.Surprise).ToList();
var floored = bySurprise.Where(t => t.Window >= Floor).ToList();
(string Title, List<Topic> Ranked)[] rankings =
    [("volume", byVolume), ("surprise", bySurprise), ("floor", floored)];
foreach (var (title, ranked) in rankings)
{
    string names = string.Join(" ", ranked.Take(5).Select(t => t.Name));
    Console.WriteLine($"top 5 by {title,-9} {names}");
}
Console.WriteLine("\ntopic        window expected surprise");
foreach (var t in bySurprise.Take(5))
{
    Console.WriteLine(Invariant($"{t.Name,-12} {t.Window,6} {t.Expected,8:F0} {t.Surprise,8:F1}"));
}

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
record Topic(string Name, int Baseline, int Window)
{
    // the window's 5 minutes at the topic's usual rate
    public double Expected => Baseline / 20.0 * 5;

    // Rough standard deviations above the usual rate, smoothed for small counts.
    public double Surprise => (Window - Expected) / Math.Sqrt(Expected + 50);
}

In C#: Expected and Surprise are computed properties of the record, OrderByDescending sorts by them, and Invariant formats the numbers the same way in every culture.

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 <math.h>
#include <stdio.h>
#include <stdlib.h>

// FLOOR: mentions a topic needs in the window to be eligible at all
enum { FLOOR = 200, N = 10 };

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute
// window
typedef struct {
  const char *name;
  int baseline, window;
} Topic;

// the window's 5 minutes at the topic's usual rate
static double expected(const Topic *t) { return t->baseline / 20.0 * 5; }

// Rough standard deviations above the usual rate, smoothed for small counts.
static double surprise(const Topic *t) {
  return (t->window - expected(t)) / sqrt(expected(t) + 50);
}

static int by_volume(const void *x, const void *y) {
  return ((const Topic *)y)->window - ((const Topic *)x)->window;
}

static int by_surprise(const void *x, const void *y) {
  const double a = surprise(x), b = surprise(y);
  return (a < b) - (a > b);
}

int main(void) {
  Topic t[N] = {{"weather", 18015, 4504},   {"football", 15897, 4154},
                {"elections", 13084, 3261}, {"movies", 10397, 2774},
                {"music", 9631, 2323},      {"recipes", 6111, 1439},
                {"solar-storm", 847, 2983}, {"chess-final", 2461, 1609},
                {"new-phone", 3974, 1280},  {"local-quiz", 19, 52}};
  qsort(t, N, sizeof t[0], by_volume);
  printf("top 5 by volume   ");
  for (int i = 0; i < 5; i++)
    printf(" %s", t[i].name);
  qsort(t, N, sizeof t[0], by_surprise);
  printf("\ntop 5 by surprise ");
  for (int i = 0; i < 5; i++)
    printf(" %s", t[i].name);
  printf("\ntop 5 by floor    ");
  for (int i = 0, shown = 0; i < N && shown < 5; i++)
    if (t[i].window >= FLOOR) {
      printf(" %s", t[i].name);
      shown++;
    }
  printf("\n\ntopic        window expected surprise\n");
  for (int i = 0; i < 5; i++)
    printf("%-12s %6d %8.0f %8.1f\n", t[i].name, t[i].window, expected(&t[i]),
           surprise(&t[i]));
  return 0;
}

In C: qsort sorts in place, so the volume ranking is printed before the array is sorted again by surprise; the comparator turns two doubles into -1, 0 or 1.

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);

const FLOOR = 200; // mentions a topic needs in the window to be eligible at all
// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
const TOPICS = [
    ['weather', 18015, 4504],
    ['football', 15897, 4154],
    ['elections', 13084, 3261],
    ['movies', 10397, 2774],
    ['music', 9631, 2323],
    ['recipes', 6111, 1439],
    ['solar-storm', 847, 2983],
    ['chess-final', 2461, 1609],
    ['new-phone', 3974, 1280],
    ['local-quiz', 19, 52],
];

function expected(int $baseline): float
{
    return $baseline / 20 * 5; // the window's 5 minutes at the topic's usual rate
}

/** Rough standard deviations above the usual rate, smoothed for small counts. */
function surprise(int $baseline, int $window): float
{
    return ($window - expected($baseline)) / sqrt(expected($baseline) + 50);
}

$byVolume = TOPICS;
usort($byVolume, fn(array $a, array $b): int => $b[2] <=> $a[2]);
$bySurprise = TOPICS;
$scoreOf = fn(array $t): float => surprise($t[1], $t[2]);
usort($bySurprise, fn(array $a, array $b): int => $scoreOf($b) <=> $scoreOf($a));
$floored = array_values(array_filter($bySurprise, fn(array $t): bool => $t[2] >= FLOOR));
$rankings = ['volume' => $byVolume, 'surprise' => $bySurprise, 'floor' => $floored];
foreach ($rankings as $title => $ranked) {
    printf("top 5 by %-9s %s\n", $title, implode(' ', array_column(array_slice($ranked, 0, 5), 0)));
}
echo "\ntopic        window expected surprise\n";
foreach (array_slice($bySurprise, 0, 5) as [$topic, $base, $window]) {
    printf("%-12s %6d %8.0f %8.1f\n", $topic, $window, expected($base), surprise($base, $window));
}

In PHP: usort sorts a copy of the constant array, because arrays are values, and <=> compares two surprises from the highest when its operands are swapped.

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

const FLOOR: u32 = 200; // mentions a topic needs in the window to be eligible at all

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
const TOPICS: [(&str, u32, u32); 10] = [
    ("weather", 18015, 4504),
    ("football", 15897, 4154),
    ("elections", 13084, 3261),
    ("movies", 10397, 2774),
    ("music", 9631, 2323),
    ("recipes", 6111, 1439),
    ("solar-storm", 847, 2983),
    ("chess-final", 2461, 1609),
    ("new-phone", 3974, 1280),
    ("local-quiz", 19, 52),
];

/// The window's 5 minutes at the topic's usual rate.
fn expected(baseline: u32) -> f64 {
    f64::from(baseline) / 20.0 * 5.0
}

/// Rough standard deviations above the usual rate, smoothed for small counts.
fn surprise(baseline: u32, window: u32) -> f64 {
    (f64::from(window) - expected(baseline)) / (expected(baseline) + 50.0).sqrt()
}

fn main() {
    let mut by_volume = TOPICS.to_vec();
    by_volume.sort_by_key(|t| std::cmp::Reverse(t.2));
    let mut by_surprise = TOPICS.to_vec();
    by_surprise.sort_by(|a, b| surprise(b.1, b.2).total_cmp(&surprise(a.1, a.2)));
    let floored: Vec<_> = by_surprise
        .iter()
        .copied()
        .filter(|t| t.2 >= FLOOR)
        .collect();
    for (title, ranked) in [
        ("volume", &by_volume),
        ("surprise", &by_surprise),
        ("floor", &floored),
    ] {
        let names: Vec<&str> = ranked.iter().take(5).map(|t| t.0).collect();
        println!("top 5 by {title:<9} {}", names.join(" "));
    }
    println!("\ntopic        window expected surprise");
    for &(topic, base, window) in &by_surprise[..5] {
        let (e, s) = (expected(base), surprise(base, window));
        println!("{topic:<12} {window:>6} {e:>8.0} {s:>8.1}");
    }
}

In Rust: f64 has no total order of its own, so total_cmp sorts the surprises, and std::cmp::Reverse sorts the volumes from the highest.

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

type Topic = [name: string, baseline: number, window: number];

const FLOOR = 200; // mentions a topic needs in the window to be eligible at all
const TOPICS: Topic[] = [
  // topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
  ["weather", 18015, 4504],
  ["football", 15897, 4154],
  ["elections", 13084, 3261],
  ["movies", 10397, 2774],
  ["music", 9631, 2323],
  ["recipes", 6111, 1439],
  ["solar-storm", 847, 2983],
  ["chess-final", 2461, 1609],
  ["new-phone", 3974, 1280],
  ["local-quiz", 19, 52],
];

// the window's 5 minutes at the topic's usual rate
const expected = (baseline: number): number => (baseline / 20) * 5;

/** Rough standard deviations above the usual rate, smoothed for small counts. */
const surprise = (baseline: number, window: number): number =>
  (window - expected(baseline)) / Math.sqrt(expected(baseline) + 50);

const byVolume = [...TOPICS].sort((a, b) => b[2] - a[2]);
const bySurprise = [...TOPICS].sort((a, b) => surprise(b[1], b[2]) - surprise(a[1], a[2]));
const floored = bySurprise.filter((t) => t[2] >= FLOOR);
const rankings: [string, Topic[]][] = [
  ["volume", byVolume],
  ["surprise", bySurprise],
  ["floor", floored],
];
for (const [title, ranked] of rankings) {
  console.log(
    `top 5 by ${title.padEnd(9)} ${ranked
      .slice(0, 5)
      .map((t) => t[0])
      .join(" ")}`,
  );
}
console.log("\ntopic        window expected surprise");
for (const [topic, base, window] of bySurprise.slice(0, 5)) {
  const numbers = [
    expected(base).toFixed(0).padStart(8),
    surprise(base, window).toFixed(1).padStart(8),
  ];
  console.log(`${topic.padEnd(12)} ${String(window).padStart(6)} ${numbers.join(" ")}`);
}

In TypeScript: The labelled tuple type Topic names the three fields, and rankings is typed as pairs of a title and a ranked list.

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 (
	"cmp"
	"fmt"
	"math"
	"slices"
	"strings"
)

const floor = 200 // mentions a topic needs in the window to be eligible at all

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
type topic struct {
	name             string
	baseline, window int
}

// expected is the window's 5 minutes at the topic's usual rate.
func (t topic) expected() float64 { return float64(t.baseline) / 20 * 5 }

// surprise is roughly how many standard deviations above the usual rate, smoothed for small counts.
func (t topic) surprise() float64 {
	return (float64(t.window) - t.expected()) / math.Sqrt(t.expected()+50)
}

func top5(ranked []topic) string {
	names := []string{}
	for _, t := range ranked[:5] {
		names = append(names, t.name)
	}
	return strings.Join(names, " ")
}

func main() {
	topics := []topic{
		{"weather", 18015, 4504}, {"football", 15897, 4154}, {"elections", 13084, 3261},
		{"movies", 10397, 2774}, {"music", 9631, 2323}, {"recipes", 6111, 1439},
		{"solar-storm", 847, 2983}, {"chess-final", 2461, 1609}, {"new-phone", 3974, 1280},
		{"local-quiz", 19, 52},
	}
	byVolume, bySurprise := slices.Clone(topics), slices.Clone(topics)
	slices.SortFunc(byVolume, func(a, b topic) int { return cmp.Compare(b.window, a.window) })
	slices.SortFunc(bySurprise, func(a, b topic) int {
		return cmp.Compare(b.surprise(), a.surprise())
	})
	var floored []topic
	for _, t := range bySurprise {
		if t.window >= floor {
			floored = append(floored, t)
		}
	}
	fmt.Println("top 5 by volume    " + top5(byVolume))
	fmt.Println("top 5 by surprise  " + top5(bySurprise))
	fmt.Println("top 5 by floor     " + top5(floored))
	fmt.Println("\ntopic        window expected surprise")
	for _, t := range bySurprise[:5] {
		fmt.Printf("%-12s %6d %8.0f %8.1f\n", t.name, t.window, t.expected(), t.surprise())
	}
}

In Go: expected and surprise are methods of the topic struct, and cmp.Compare with its arguments swapped sorts from the highest.

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

let floor = 200  // mentions a topic needs in the window to be eligible at all

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
struct Topic {
  let name: String
  let baseline: Int
  let window: Int

  /// The window's 5 minutes at the topic's usual rate.
  var expected: Double { Double(baseline) / 20 * 5 }

  /// Rough standard deviations above the usual rate, smoothed for small counts.
  var surprise: Double { (Double(window) - expected) / (expected + 50).squareRoot() }
}

let topics = [
  ("weather", 18015, 4504), ("football", 15897, 4154), ("elections", 13084, 3261),
  ("movies", 10397, 2774), ("music", 9631, 2323), ("recipes", 6111, 1439),
  ("solar-storm", 847, 2983), ("chess-final", 2461, 1609), ("new-phone", 3974, 1280),
  ("local-quiz", 19, 52),
].map { Topic(name: $0.0, baseline: $0.1, window: $0.2) }

func pad(_ text: String, _ width: Int, left: Bool = false) -> String {
  let spaces = String(repeating: " ", count: max(0, width - text.count))
  return left ? text + spaces : spaces + text
}

/// x rounded to one digit after the point
func oneDecimal(_ x: Double) -> String {
  let n = Int((x * 10).rounded())
  return "\(n / 10).\(n % 10)"
}

let byVolume = topics.sorted { $0.window > $1.window }
let bySurprise = topics.sorted { $0.surprise > $1.surprise }
let floored = bySurprise.filter { $0.window >= floor }
for (title, ranked) in [("volume", byVolume), ("surprise", bySurprise), ("floor", floored)] {
  print(
    "top 5 by " + pad(title, 9, left: true) + " "
      + ranked.prefix(5).map(\.name).joined(separator: " "))
}
print("\ntopic        window expected surprise")
for t in bySurprise.prefix(5) {
  let numbers = pad(String(t.window), 6) + pad(String(Int(t.expected.rounded())), 9)
  print(pad(t.name, 12, left: true) + " " + numbers + pad(oneDecimal(t.surprise), 9))
}

In Swift: expected and surprise are computed properties of the struct; without Foundation the standard library has no number format, so oneDecimal and pad lay out the table.

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

FLOOR = 200 # mentions a topic needs in the window to be eligible at all

# topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
Topic = Data.define(:name, :baseline, :window) do
  # the window's 5 minutes at the topic's usual rate
  def expected = baseline / 20.0 * 5

  # Rough standard deviations above the usual rate, smoothed for small counts.
  def surprise = (window - expected) / Math.sqrt(expected + 50)
end

TOPICS = [
  ['weather', 18_015, 4504], ['football', 15_897, 4154], ['elections', 13_084, 3261],
  ['movies', 10_397, 2774], ['music', 9631, 2323], ['recipes', 6111, 1439],
  ['solar-storm', 847, 2983], ['chess-final', 2461, 1609], ['new-phone', 3974, 1280],
  ['local-quiz', 19, 52]
].map { |name, baseline, window| Topic.new(name, baseline, window) }.freeze

by_surprise = TOPICS.sort_by { |t| -t.surprise }
rankings = { 'volume' => TOPICS.sort_by { |t| -t.window }, 'surprise' => by_surprise,
             'floor' => by_surprise.select { |t| t.window >= FLOOR } }
rankings.each do |title, ranked|
  puts "top 5 by #{title.ljust(9)} #{ranked.first(5).map(&:name).join(' ')}"
end
puts "\ntopic        window expected surprise"
by_surprise.first(5).each do |t|
  numbers = "#{t.window.to_s.rjust(6)} #{format('%.0f', t.expected).rjust(8)}"
  puts "#{t.name.ljust(12)} #{numbers} #{format('%.1f', t.surprise).rjust(8)}"
end

In Ruby: Data.define gives each topic its fields and its two methods, and sort_by with a negated surprise sorts from the highest.

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

import kotlin.math.roundToLong
import kotlin.math.sqrt

const val FLOOR = 200 // mentions a topic needs in the window to be eligible at all

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
data class Topic(
    val name: String,
    val baseline: Int,
    val window: Int,
) {
    val expected get() = baseline / 20.0 * 5 // the window's 5 minutes at the topic's usual rate

    /** Rough standard deviations above the usual rate, smoothed for small counts. */
    val surprise get() = (window - expected) / sqrt(expected + 50)
}

// the common library has no number format: one digit after the point
fun Double.oneDecimal(): String {
    val n = (this * 10).roundToLong()
    return "${n / 10}.${n % 10}"
}

fun main() {
    val topics =
        listOf(
            Topic("weather", 18015, 4504),
            Topic("football", 15897, 4154),
            Topic("elections", 13084, 3261),
            Topic("movies", 10397, 2774),
            Topic("music", 9631, 2323),
            Topic("recipes", 6111, 1439),
            Topic("solar-storm", 847, 2983),
            Topic("chess-final", 2461, 1609),
            Topic("new-phone", 3974, 1280),
            Topic("local-quiz", 19, 52),
        )
    val bySurprise = topics.sortedByDescending { it.surprise }
    val rankings =
        listOf(
            "volume" to topics.sortedByDescending { it.window },
            "surprise" to bySurprise,
            "floor" to bySurprise.filter { it.window >= FLOOR },
        )
    for ((title, ranked) in rankings) {
        println("top 5 by ${title.padEnd(9)} " + ranked.take(5).joinToString(" ") { it.name })
    }
    println("\ntopic        window expected surprise")
    for (t in bySurprise.take(5)) {
        val numbers =
            t.window.toString().padStart(6) +
                t.expected
                    .roundToLong()
                    .toString()
                    .padStart(9)
        println(t.name.padEnd(12) + " " + numbers + t.surprise.oneDecimal().padStart(9))
    }
}

In Kotlin: expected and surprise are properties of the data class, sortedByDescending sorts a copy, and oneDecimal formats a number, which the common library cannot.

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

import 'dart:math';

const floor = 200; // mentions a topic needs in the window to be eligible at all

// topic, mentions in the 20 minutes before the window, mentions in the 5-minute window
const topics = [
  ('weather', 18015, 4504),
  ('football', 15897, 4154),
  ('elections', 13084, 3261),
  ('movies', 10397, 2774),
  ('music', 9631, 2323),
  ('recipes', 6111, 1439),
  ('solar-storm', 847, 2983),
  ('chess-final', 2461, 1609),
  ('new-phone', 3974, 1280),
  ('local-quiz', 19, 52),
];

/// The window's 5 minutes at the topic's usual rate.
double expected(int baseline) => baseline / 20 * 5;

/// Rough standard deviations above the usual rate, smoothed for small counts.
double surprise(int baseline, int window) =>
    (window - expected(baseline)) / sqrt(expected(baseline) + 50);

void main() {
  final byVolume = [...topics]..sort((a, b) => b.$3.compareTo(a.$3));
  final bySurprise = [...topics]
    ..sort((a, b) => surprise(b.$2, b.$3).compareTo(surprise(a.$2, a.$3)));
  final floored = bySurprise.where((t) => t.$3 >= floor).toList();
  for (final (title, ranked) in [
    ('volume', byVolume),
    ('surprise', bySurprise),
    ('floor', floored),
  ]) {
    print(
      'top 5 by ${title.padRight(9)} ${ranked.take(5).map((t) => t.$1).join(' ')}',
    );
  }
  print('\ntopic        window expected surprise');
  for (final (topic, base, window) in bySurprise.take(5)) {
    final numbers =
        '${'$window'.padLeft(6)} ${expected(base).toStringAsFixed(0).padLeft(8)}';
    print(
      '${topic.padRight(12)} $numbers ${surprise(base, window).toStringAsFixed(1).padLeft(8)}',
    );
  }
}

In Dart: Each topic is a record, read as t.$1 to t.$3, and the cascade ..sort sorts a copy of the constant list in place.

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