Run-length encode a lowercase ASCII string, or error on bad input

// src/main.0
// Run-length encoder for AgentLang Index slot 019.
//
// Zero 0.1.2 has no exposed stdin, so plaintext comes from argv[1].
// Lib exports is_lowercase_letter, digit_byte, decimal_length.
//
// Failure modes collapse to "error\n":
//   - argv[1] missing
//   - plaintext is empty
//   - any plaintext byte is outside [a-z]
//
// Output: for each maximal run of consecutive identical bytes, emit
// the byte followed by the run length in decimal. Final newline.
// Examples: "aaabbc" -> "a3b2c1\n", "abcdef" -> "a1b1c1d1e1f1\n",
//           "aaaaaaaaaaaaa" -> "a13\n".

use lib

pub fun main(world: World) -> Void raises {
    let maybe_text = std.args.get(1)
    if maybe_text.has == false {
        check world.out.write("error\n")
        return
    }
    let text_in = std.mem.span(maybe_text.value)

    let t_len = std.mem.len(text_in)
    if t_len == 0 {
        check world.out.write("error\n")
        return
    }

    // Validate all bytes in [a-z] first.
    let mut text_ok: Bool = true
    let mut v_i: usize = 0
    while v_i < t_len {
        let b = text_in[v_i]
        if is_lowercase_letter(b) == false {
            text_ok = false
            v_i = t_len
        } else {
            v_i = v_i + 1
        }
    }
    if text_ok == false {
        check world.out.write("error\n")
        return
    }

    // Walk maximal runs and emit byte + decimal count.
    // Output buffer: each input byte expands to at most 1 + 10 bytes
    // (letter + up to 10 decimal digits for u32 max). Plus newline.
    let mut out: [16384]u8 = [0_u8; 16384]
    let mut out_n: usize = 0

    let mut run_start: usize = 0
    while run_start < t_len {
        let run_byte = text_in[run_start]
        let mut run_len: usize = 1
        let mut probe: usize = run_start + 1
        let mut scanning: Bool = true
        while scanning {
            if probe >= t_len {
                scanning = false
            } else {
                if text_in[probe] == run_byte {
                    run_len = run_len + 1
                    probe = probe + 1
                } else {
                    scanning = false
                }
            }
        }

        let run_len_u32: u32 = run_len as u32
        let digit_count = decimal_length(run_len_u32)

        // Emit the byte.
        out[out_n] = run_byte
        out_n = out_n + 1

        // Emit decimal digits left-to-right by iterating positions.
        let mut emit_i: u32 = digit_count
        while emit_i > 0_u32 {
            let pos = emit_i - 1_u32
            let mut divisor: u32 = 1_u32
            let mut p: u32 = 0_u32
            while p < pos {
                divisor = divisor * 10_u32
                p = p + 1_u32
            }
            let d8: u8 = ((run_len_u32 / divisor) % 10_u32) as u8
            out[out_n] = digit_byte(d8)
            out_n = out_n + 1
            emit_i = emit_i - 1_u32
        }

        run_start = run_start + run_len
    }

    out[out_n] = 10_u8
    out_n = out_n + 1
    check world.out.write(out[0..out_n])
    return
}


// src/lib.0
// Run-length encoder helpers. Pure scalar exports keeping the
// seventh codegen quirk happy at the module boundary.

pub fun is_lowercase_letter(b: u8) -> Bool {
    if b < 97_u8 {
        return false
    }
    if b > 122_u8 {
        return false
    }
    return true
}

pub fun digit_byte(d: u8) -> u8 {
    // Caller passes d in 0..=9. Returns the ASCII byte for that digit.
    return 48_u8 + d
}

pub fun decimal_length(n: u32) -> u32 {
    // Number of decimal digits needed to render n. Always at least 1.
    if n < 10_u32 {
        return 1_u32
    }
    if n < 100_u32 {
        return 2_u32
    }
    if n < 1000_u32 {
        return 3_u32
    }
    if n < 10000_u32 {
        return 4_u32
    }
    if n < 100000_u32 {
        return 5_u32
    }
    if n < 1000000_u32 {
        return 6_u32
    }
    if n < 10000000_u32 {
        return 7_u32
    }
    if n < 100000000_u32 {
        return 8_u32
    }
    if n < 1000000000_u32 {
        return 9_u32
    }
    return 10_u32
}

function isLowercaseLetter(b: number): boolean {
    return b >= 97 && b <= 122;
}

async function readAll(): Promise<string> {
    const chunks: Buffer[] = [];
    for await (const chunk of process.stdin) {
        chunks.push(chunk as Buffer);
    }
    return Buffer.concat(chunks).toString("utf8");
}

async function main(): Promise<void> {
    const data = await readAll();
    const lines = data.split("\n");
    if (lines.length < 1) {
        process.stdout.write("error\n");
        return;
    }
    const text = lines[0];
    if (text.length === 0) {
        process.stdout.write("error\n");
        return;
    }
    const bytes = Buffer.from(text, "utf8");
    for (let i = 0; i < bytes.length; i++) {
        if (!isLowercaseLetter(bytes[i])) {
            process.stdout.write("error\n");
            return;
        }
    }
    const out: string[] = [];
    let i = 0;
    while (i < bytes.length) {
        const runByte = bytes[i];
        let runLen = 1;
        let j = i + 1;
        while (j < bytes.length && bytes[j] === runByte) {
            runLen++;
            j++;
        }
        out.push(String.fromCharCode(runByte));
        out.push(String(runLen));
        i = j;
    }
    process.stdout.write(out.join("") + "\n");
}

main();

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

fn is_lowercase_letter(b: u8) -> bool {
    (b'a'..=b'z').contains(&b)
}

fn main() {
    let mut input = String::new();
    if io::stdin().read_to_string(&mut input).is_err() {
        let _ = io::stdout().write_all(b"error\n");
        return;
    }
    let mut lines = input.split('\n');
    let line_text = lines.next();
    let Some(lt) = line_text else {
        let _ = io::stdout().write_all(b"error\n");
        return;
    };
    let text_bytes = lt.as_bytes();
    if text_bytes.is_empty() {
        let _ = io::stdout().write_all(b"error\n");
        return;
    }
    for &b in text_bytes {
        if !is_lowercase_letter(b) {
            let _ = io::stdout().write_all(b"error\n");
            return;
        }
    }
    let mut out: Vec<u8> = Vec::with_capacity(text_bytes.len() * 2 + 1);
    let mut i = 0usize;
    while i < text_bytes.len() {
        let run_byte = text_bytes[i];
        let mut run_len = 1usize;
        let mut j = i + 1;
        while j < text_bytes.len() && text_bytes[j] == run_byte {
            run_len += 1;
            j += 1;
        }
        out.push(run_byte);
        out.extend_from_slice(run_len.to_string().as_bytes());
        i = j;
    }
    out.push(b'\n');
    let _ = io::stdout().write_all(&out);
}

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func isLowercaseLetter(b byte) bool {
	return b >= 'a' && b <= 'z'
}

func readAll(r *bufio.Reader) string {
	var sb strings.Builder
	buf := make([]byte, 4096)
	for {
		n, err := r.Read(buf)
		if n > 0 {
			sb.Write(buf[:n])
		}
		if err != nil {
			break
		}
	}
	return sb.String()
}

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	r := bufio.NewReader(os.Stdin)
	data := readAll(r)
	lines := strings.SplitN(data, "\n", 2)
	if len(lines) < 1 {
		fmt.Fprint(w, "error\n")
		return
	}
	text := lines[0]
	if len(text) == 0 {
		fmt.Fprint(w, "error\n")
		return
	}
	for i := 0; i < len(text); i++ {
		if !isLowercaseLetter(text[i]) {
			fmt.Fprint(w, "error\n")
			return
		}
	}
	out := make([]byte, 0, len(text)*2+1)
	i := 0
	for i < len(text) {
		runByte := text[i]
		runLen := 1
		j := i + 1
		for j < len(text) && text[j] == runByte {
			runLen++
			j++
		}
		out = append(out, runByte)
		out = append(out, strconv.Itoa(runLen)...)
		i = j
	}
	out = append(out, '\n')
	w.Write(out)
}

#!/usr/bin/env python3
import sys


def is_lowercase_letter(b: int) -> bool:
    return 97 <= b <= 122


def main() -> None:
    data = sys.stdin.read()
    lines = data.split("\n")
    if len(lines) < 1:
        sys.stdout.write("error\n")
        return
    text = lines[0]
    if not text:
        sys.stdout.write("error\n")
        return
    text_bytes = text.encode("utf-8")
    for b in text_bytes:
        if not is_lowercase_letter(b):
            sys.stdout.write("error\n")
            return
    out = []
    i = 0
    n = len(text_bytes)
    while i < n:
        run_byte = text_bytes[i]
        run_len = 1
        j = i + 1
        while j < n and text_bytes[j] == run_byte:
            run_len += 1
            j += 1
        out.append(bytes([run_byte]).decode("ascii"))
        out.append(str(run_len))
        i = j
    sys.stdout.write("".join(out) + "\n")


if __name__ == "__main__":
    main()