Run-length encode the input as count/byte pairs

// Run-length encode the 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.
//
// Outer loop steps run-by-run: pick up the current byte, walk forward
// while it matches, then emit `<count> <byte_decimal>\n`. Inner scan
// uses the explicit-flag pattern (no `&&` short-circuit available in
// Zero 0.1.2). Two inline decimal renderers per run because the MVP
// subset cannot factor them into a function that writes back into the
// outer output buffer (no MutSpan parameters).
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 out_buf: [8192]u8 = [0_u8; 8192]
    let mut written: usize = 0

    let mut i: usize = 0
    while i < n {
        let cur_byte: u8 = bytes[i]
        let mut cur_count: u32 = 1_u32
        i = i + 1
        let mut scanning: Bool = true
        while scanning {
            if i >= n {
                scanning = false
            } else {
                if bytes[i] == cur_byte {
                    cur_count = cur_count + 1_u32
                    i = i + 1
                } else {
                    scanning = false
                }
            }
        }

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

        let b_val: u32 = cur_byte as u32
        if b_val == 0_u32 {
            out_buf[written] = 48_u8
            written = written + 1
        } else {
            let mut tmp2: [4]u8 = [0_u8; 4]
            let mut tn2: usize = 0
            let mut v2: u32 = b_val
            while v2 > 0_u32 {
                tmp2[tn2] = (48_u32 + (v2 % 10_u32)) as u8
                tn2 = tn2 + 1
                v2 = v2 / 10_u32
            }
            let mut j2: usize = 0
            while j2 < tn2 {
                out_buf[written] = tmp2[tn2 - 1 - j2]
                written = written + 1
                j2 = j2 + 1
            }
        }
        out_buf[written] = 10_u8
        written = written + 1
    }

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

// Run-length encode the input, TypeScript reference.

import { readFileSync } from "node:fs";

function main(): void {
  const data = readFileSync(0);
  if (data.length === 0) return;
  const out: string[] = [];
  let curByte = data[0];
  let curCount = 1;
  for (let i = 1; i < data.length; i++) {
    const b = data[i];
    if (b === curByte) {
      curCount++;
    } else {
      out.push(`${curCount} ${curByte}\n`);
      curByte = b;
      curCount = 1;
    }
  }
  out.push(`${curCount} ${curByte}\n`);
  process.stdout.write(out.join(""));
}

main();

// Run-length encode the 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");
    if data.is_empty() {
        return;
    }
    let stdout = io::stdout();
    let mut stdout = stdout.lock();
    let mut cur_byte: u8 = data[0];
    let mut cur_count: u32 = 1;
    for &b in &data[1..] {
        if b == cur_byte {
            cur_count += 1;
        } else {
            writeln!(stdout, "{} {}", cur_count, cur_byte).expect("write");
            cur_byte = b;
            cur_count = 1;
        }
    }
    writeln!(stdout, "{} {}", cur_count, cur_byte).expect("write");
}

// Run-length encode the input, Go reference.

package main

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

func main() {
	data, err := io.ReadAll(os.Stdin)
	if err != nil {
		os.Exit(1)
	}
	if len(data) == 0 {
		return
	}
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	curByte := data[0]
	curCount := 1
	for i := 1; i < len(data); i++ {
		b := data[i]
		if b == curByte {
			curCount++
		} else {
			fmt.Fprintf(w, "%d %d\n", curCount, curByte)
			curByte = b
			curCount = 1
		}
	}
	fmt.Fprintf(w, "%d %d\n", curCount, curByte)
}

#!/usr/bin/env python3
"""Run-length encode the input, Python reference."""

import sys


def main() -> None:
    data = sys.stdin.buffer.read()
    if not data:
        return
    parts = []
    cur_byte = data[0]
    cur_count = 1
    for b in data[1:]:
        if b == cur_byte:
            cur_count += 1
        else:
            parts.append(f"{cur_count} {cur_byte}\n")
            cur_byte = b
            cur_count = 1
    parts.append(f"{cur_count} {cur_byte}\n")
    sys.stdout.write("".join(parts))


if __name__ == "__main__":
    main()