Smallest difference between a single and an average

Coincidence

Within a single ao5 round, a solver's best (single) is always ≤ their average (because the average is the trimmed mean of the middle 3 of 5 attempts). So diff = average − best is always ≥ 0.

This stat picks out the rounds with the smallest such diff. The extreme case is diff = 0 (the 3 counting solves happen to equal the single); the next is diff = 0.01 (one centisecond). Often these come from low-time solvers spamming near-identical times, or from big-cube events (777, 666) where the whole set moves together.

By the numbers

`avg − best`

Definition

average minus single from the same round

top 10

Rows per event

Top 10 by diff ascending

剔除 333fm

`333fm` excluded

FMC integer moves — `diff = 0` is trivial and noisy

tiebreak

Three-key sort

diff → avg → single, deterministic ordering

Data source

results joined with persons (sub_id = 1) and competitions. SQL SELECTs best, average, and identity fields; diff is computed in TS. Filters: event_id != '333fm' (FMC integer values make diff = 0 trivial), average > 0 (drops DNF averages and unattempted).

sql

SELECT
  event_id,
  best AS single,
  average,
  person.name,
  person.wca_id,
  competition.cell_name,
  competition.id AS competition_id
FROM results
JOIN persons person ON person.wca_id = person_id AND sub_id = 1
JOIN competitions competition ON competition.id = competition_id
WHERE event_id != '333fm' AND average > 0;

-- TS: diff = average - single
--   sort by (diff ASC, average ASC, single ASC)
--   slice 0..10 per event

Algorithm / pipeline

Pair (single, average)

For each ao5 round in results, pull best and average. WCA dump convention: best column = the round's best attempt (i.e. the "single"), average = the ao5 / mo3 mean.

Apply filters

event_id != '333fm' — FMC integer-move semantics make diff = 0 too common to be meaningful. average > 0 drops DNF averages (value -1) and unattempted (0).

Compute diff

diff = Number(average) − Number(single), units are centiseconds (always ≥ 0 in theory — single is the round's best). For display: (diff / 100).toFixed(2) to seconds; internal sort stays on integer centiseconds to avoid float jitter.

Three-key sort

diff ASC → average ASC → single ASC — among ties on diff, prefer rounds with lower average (harder), then lower single. This deterministic tiebreak orders the (often many) diff = 0 rows.

Per-event top 10

EVENTS_ENTRIES.map, one section per event (FMC excluded), top 10 each. SolveTime(eventId, type, v).clockFormat() formats centiseconds for display.

Key formulae

Diff

diff = average − single, diff ≥ 0

WCA ao5 rule: drop fastest and slowest of 5 attempts, average the middle 3. Therefore single ≤ any of the middle 3 ≤ average (ignoring DNF edge cases).

Caveats & edges

333fm is excluded as a whole — integer move counts make 28 / 28 / 28 / 30 / 29 → single=28, mean=28.67 trivially common; if not excluded it would swamp every other event.
Of the BLD family, only 333bf / 444bf / 555bf have averages (mo3); 333mbf has none. BLD mo3 does not trim head/tail, but single ≤ mo3 still holds (different semantics).
Internally diff is integer centiseconds; the display rounds to 2 decimals — diff = 0.00 and diff = 0.01 happily coexist on the board.
This is within a single round, not "most similar single and average across history" — two coincidentally-equal values in different rounds are not eligible.