Reverse the order of words on a line

// Reverse the order of words on a line, Zero 0.1.2 direct backend.
//
// argv[1] is the line (Zero 0.1.2 has no exposed stdin capability).
// All logic stays inside `pub fun main` to avoid Span/MutSpan parameter
// restrictions.
//
// Two-pass design: first pass scans the input and records each word's
// (start, length) into two parallel [500]u32 arrays. Second pass walks
// from last word to first, appending bytes to an output buffer with
// single-space separators and a trailing newline. If zero words were
// found, nothing is written.
//
// Zero's `&&` is not assumed to short-circuit, so the inner loops are
// split into a `while true` with an explicit early-exit setting the
// loop index to n.
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 starts: [500]u32 = [0_u32; 500]
    let mut lens: [500]u32 = [0_u32; 500]
    let mut nw: usize = 0

    let mut i: usize = 0
    while i < n {
        // Skip spaces. Inner loop avoids relying on && short-circuit.
        let mut skipping: Bool = true
        while skipping {
            if i >= n {
                skipping = false
            } else {
                if bytes[i] == 32_u8 {
                    i = i + 1
                } else {
                    skipping = false
                }
            }
        }
        if i < n {
            let start: usize = i
            let mut scanning: Bool = true
            while scanning {
                if i >= n {
                    scanning = false
                } else {
                    if bytes[i] != 32_u8 {
                        i = i + 1
                    } else {
                        scanning = false
                    }
                }
            }
            let len: usize = i - start
            starts[nw] = start as u32
            lens[nw] = len as u32
            nw = nw + 1
        }
    }

    if nw == 0 {
        return
    }

    let mut out_buf: [1024]u8 = [0_u8; 1024]
    let mut written: usize = 0

    let mut w: usize = nw
    while w > 0 {
        w = w - 1
        if written > 0 {
            out_buf[written] = 32_u8
            written = written + 1
        }
        let s: usize = starts[w] as usize
        let l: usize = lens[w] as usize
        let mut k: usize = 0
        while k < l {
            out_buf[written] = bytes[s + k]
            written = written + 1
            k = k + 1
        }
    }
    out_buf[written] = 10_u8
    written = written + 1

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

// Reverse the order of words on a line, TypeScript reference.

import { readFileSync } from "node:fs";

function main(): void {
  let line = readFileSync(0, "utf8");
  if (line.endsWith("\n")) line = line.slice(0, -1);
  const words = line.split(" ").filter((w) => w.length > 0);
  if (words.length === 0) return;
  words.reverse();
  process.stdout.write(words.join(" ") + "\n");
}

main();

// Reverse the order of words on a line, Rust reference.

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

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    if input.ends_with('\n') {
        input.pop();
    }
    let words: Vec<&str> = input.split(' ').filter(|w| !w.is_empty()).collect();
    if words.is_empty() {
        return;
    }
    let mut out = String::with_capacity(input.len() + 1);
    for (i, w) in words.iter().rev().enumerate() {
        if i > 0 {
            out.push(' ');
        }
        out.push_str(w);
    }
    out.push('\n');
    let stdout = io::stdout();
    let mut h = stdout.lock();
    h.write_all(out.as_bytes()).unwrap();
}

// Reverse the order of words on a line, Go reference.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	line = strings.TrimRight(line, "\n")
	parts := strings.Split(line, " ")
	words := parts[:0]
	for _, w := range parts {
		if w != "" {
			words = append(words, w)
		}
	}
	if len(words) == 0 {
		return
	}
	var b strings.Builder
	for i := len(words) - 1; i >= 0; i-- {
		if i != len(words)-1 {
			b.WriteByte(' ')
		}
		b.WriteString(words[i])
	}
	b.WriteByte('\n')
	os.Stdout.WriteString(b.String())
}

"""Reverse the order of words on a line, Python reference."""
import sys


def main() -> None:
    line = sys.stdin.readline()
    if line.endswith("\n"):
        line = line[:-1]
    words = line.split(" ")
    words = [w for w in words if w != ""]
    if not words:
        return
    words.reverse()
    sys.stdout.write(" ".join(words) + "\n")


if __name__ == "__main__":
    main()