Per-byte frequency table sorted by byte value

Prompt

This is the natural-language brief given to every model, verbatim. The harness prefixes a language-specific calling-convention block and suffixes a "return only the source code" instruction. Nothing else.

# Task 010 — byte-frequency

## Problem

Read all bytes from standard input. Count how often each byte value
(0 through 255) appears. For every byte value with a non-zero count,
write one line of the form `<byte_decimal> <count>\n` to standard
output. The lines must be in ascending byte-value order. Exit with
status 0.

## Output format

- Each line is `<byte_decimal>` (the byte value 0..255 rendered in
  decimal, no padding), one ASCII space (0x20), `<count>` (the
  occurrence count in decimal, no padding), one newline (0x0A).
- No header, no trailing extra newline beyond the per-record one.

## Edge cases

- Empty input → empty output (no header, no `0\n`, nothing).
- Single byte input → one line.
- Repeated identical bytes → one line with the matching count.
- High-bit bytes (0x80..0xFF) appear with their decimal value
  (128..255) just like ASCII bytes.

## Acceptance

The stdout produced by your program must match the expected bytes
exactly for every test case. Stderr must be empty and the process
must exit 0.

## Input convention

- **stdin** (TypeScript, Rust, Go, Python): read all bytes until EOF.
- **argv[1]** (Zero 0.1.2 has no exposed stdin capability): read the
  bytes from the first command-line argument.

## Token budget

1600 tokens.

Acceptance

A task counts as passed only when every public and hidden test case agrees on these fields. No fuzzy matching, no "off by one trailing newline is fine."

Results

Each cell is one attempt. Pass means stdout matched byte-exact on every test case, stderr empty, exit zero. Hover a failure to see the captured first line of the diagnostic.

Failure excerpts

7 of 25 attempts failed. Each card is one attempt, with the captured first line of the diagnostic.

1. gpt-4o Zero compile

   ref.zero:6:8 PAR100: expected '{' before block

2. gpt-4o-mini Zero compile

   ref.zero:1:15 PAR100: expected expression

3. gpt-4o-mini Rust wrong output

   (no diagnostic captured)

4. gpt-4o-mini Python wrong output

   (no diagnostic captured)

5. gpt-5 Zero compile

   ref.zero:1:1 IMP001: unknown package-local import 'std'

6. opus Zero compile

   ref.zero:1:8 PAR100: expected '{' before block

7. sonnet Zero wrong output

   (no diagnostic captured)

Reference implementations

The hand-written reference each language ships with. Every reference passes the same public and hidden test suite under the pinned toolchain before any model touches the task.

Click a language to expand

// Per-byte frequency table, TypeScript reference.

import { readFileSync } from "node:fs";

function main(): void {
  const data = readFileSync(0);
  const counts = new Uint32Array(256);
  for (let i = 0; i < data.length; i++) {
    counts[data[i]]++;
  }
  const out: string[] = [];
  for (let b = 0; b < 256; b++) {
    const c = counts[b];
    if (c > 0) {
      out.push(`${b} ${c}\n`);
    }
  }
  process.stdout.write(out.join(""));
}

main();

// Per-byte frequency table, Rust reference.

use std::io::{self, Read, Write};

fn main() {
    let mut data = Vec::new();
    io::stdin().read_to_end(&mut data).expect("read stdin");
    let mut counts = [0u32; 256];
    for &b in &data {
        counts[b as usize] += 1;
    }
    let stdout = io::stdout();
    let mut stdout = stdout.lock();
    for (b, &c) in counts.iter().enumerate() {
        if c > 0 {
            writeln!(stdout, "{} {}", b, c).expect("write stdout");
        }
    }
}

// Per-byte frequency table, Go reference.

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	data, err := io.ReadAll(os.Stdin)
	if err != nil {
		os.Exit(1)
	}
	var counts [256]uint32
	for _, b := range data {
		counts[b]++
	}
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for b := 0; b < 256; b++ {
		if counts[b] > 0 {
			fmt.Fprintf(w, "%d %d\n", b, counts[b])
		}
	}
}

#!/usr/bin/env python3
"""Per-byte frequency table, Python reference."""

import sys


def main() -> None:
    data = sys.stdin.buffer.read()
    counts = [0] * 256
    for b in data:
        counts[b] += 1
    out_parts = []
    for b in range(256):
        c = counts[b]
        if c > 0:
            out_parts.append(f"{b} {c}\n")
    sys.stdout.write("".join(out_parts))


if __name__ == "__main__":
    main()

Design notes

Algorithm, failure modes, cross-language parity, and where Zero needed a workaround. From corpus/010-byte-frequency/notes.md.

Cost

Tokens and API ms are summed across the five languages this model attempted for this task.

Compare

Model deep-dives: gpt-4o · gpt-4o-mini · gpt-5 · opus · sonnet . Back to the leaderboard and methodology.

Truffle · 010-byte-frequency · run captured 2026-06-27