Count whitespace-separated tokens in input

// Count whitespace-separated tokens in input, Zero 0.1.2 direct backend.
//
// argv[1] is the input bytes (Zero 0.1.2 has no exposed stdin capability).
// All logic stays inside `pub fun main` to avoid Span/MutSpan parameter
// restrictions.
//
// One-pass state machine: track `in_word`. Each transition from
// whitespace to non-whitespace increments the count. Whitespace bytes
// are 0x20, 0x09, 0x0A, 0x0D.
//
// Decimal renderer uses small-divisor u32 divmod (avoids the 2^32-
// divisor SIGFPE narrowing-cast bug surfaced in earlier corpus work).
pub fun main(world: World) -> Void raises {
    let line_opt = std.args.get(1)
    let mut bytes: Span<u8> = std.mem.span("")
    if line_opt.has {
        bytes = std.mem.span(line_opt.value)
    }
    let n: usize = std.mem.len(bytes)

    let mut count: u32 = 0_u32
    let mut in_word: Bool = false
    let mut i: usize = 0
    while i < n {
        let b: u8 = bytes[i]
        let mut is_ws: Bool = false
        if b == 32_u8 {
            is_ws = true
        }
        if b == 9_u8 {
            is_ws = true
        }
        if b == 10_u8 {
            is_ws = true
        }
        if b == 13_u8 {
            is_ws = true
        }
        if is_ws {
            in_word = false
        } else {
            if in_word == false {
                count = count + 1_u32
                in_word = true
            }
        }
        i = i + 1
    }

    let mut out_buf: [16]u8 = [0_u8; 16]
    let mut written: usize = 0
    if count == 0_u32 {
        out_buf[0] = 48_u8
        written = 1
    } else {
        let mut tmp: [16]u8 = [0_u8; 16]
        let mut tn: usize = 0
        let mut c: u32 = count
        while c > 0_u32 {
            let d: u32 = c % 10_u32
            tmp[tn] = (48_u32 + d) as u8
            tn = tn + 1
            c = c / 10_u32
        }
        let mut j: usize = 0
        while j < tn {
            out_buf[j] = tmp[tn - 1 - j]
            j = j + 1
        }
        written = tn
    }
    out_buf[written] = 10_u8
    written = written + 1

    let out: Span<u8> = out_buf[0..written]
    check world.out.write(out)
    return
}

// 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()