Count whitespace-separated tokens in input

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 009 — word-count

## Problem

Read all bytes from standard input. A **word** is a maximal run of
non-whitespace bytes. The whitespace bytes are:

- space (0x20)
- tab (0x09)
- newline (0x0A)
- carriage return (0x0D)

Write the total word count as a decimal integer to standard output,
followed by exactly one newline. Exit with status 0.

## Edge cases

- Empty input → write `0\n`.
- All-whitespace input → write `0\n`.
- Single word with no trailing whitespace → write `1\n`.
- Words separated by any mix of whitespace bytes count by maximal
  non-whitespace runs only; consecutive whitespace bytes never produce
  an empty word.

## Acceptance

The stdout produced by your program must match the expected bytes
exactly for every test case (public and hidden). 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

1200 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

8 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:3:17 PAR100: expected '{' before block

3. gpt-4o-mini Go wrong output

   (no diagnostic captured)

4. gpt-4o-mini Python wrong output

   (no diagnostic captured)

5. gpt-5 Zero compile

   ref.zero:3:9 PAR100: expected '{' before block

6. opus Zero compile

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

7. opus Rust wrong output

   (no diagnostic captured)

8. 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

// Count whitespace-separated tokens in input, TypeScript reference.

import { readFileSync } from "node:fs";

function main(): void {
  const data = readFileSync(0);
  let count = 0;
  let inWord = false;
  for (let i = 0; i < data.length; i++) {
    const b = data[i];
    const isWS = b === 32 || b === 9 || b === 10 || b === 13;
    if (isWS) {
      inWord = false;
    } else if (!inWord) {
      count++;
      inWord = true;
    }
  }
  process.stdout.write(`${count}\n`);
}

main();

// Count whitespace-separated tokens in input, 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 count: u32 = 0;
    let mut in_word = false;
    for &b in &data {
        let is_ws = b == 32 || b == 9 || b == 10 || b == 13;
        if is_ws {
            in_word = false;
        } else if !in_word {
            count += 1;
            in_word = true;
        }
    }
    let mut stdout = io::stdout();
    writeln!(stdout, "{}", count).expect("write stdout");
}

// Count whitespace-separated tokens in input, Go reference.

package main

import (
	"io"
	"os"
	"strconv"
)

func main() {
	data, err := io.ReadAll(os.Stdin)
	if err != nil {
		os.Exit(1)
	}
	count := 0
	inWord := false
	for _, b := range data {
		isWS := b == 32 || b == 9 || b == 10 || b == 13
		if isWS {
			inWord = false
		} else if !inWord {
			count++
			inWord = true
		}
	}
	os.Stdout.WriteString(strconv.Itoa(count) + "\n")
}

#!/usr/bin/env python3
"""Count whitespace-separated tokens in input, Python reference."""

import sys


def main() -> None:
    data = sys.stdin.buffer.read()
    count = 0
    in_word = False
    for b in data:
        is_ws = b == 32 or b == 9 or b == 10 or b == 13
        if is_ws:
            in_word = False
        elif not in_word:
            count += 1
            in_word = True
    sys.stdout.write(f"{count}\n")


if __name__ == "__main__":
    main()

Design notes

Algorithm, failure modes, cross-language parity, and where Zero needed a workaround. From corpus/009-word-count/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 · 009-word-count · run captured 2026-06-27