Square integer matrix multiply

// Square integer matrix multiply, Zero 0.1.2 direct backend.
//
// Same input convention as 001-003: arguments come from argv because
// Zero 0.1.2 has no exposed stdin capability. argv[1] is N; the next
// N*N args are A row-major; the next N*N args are B row-major. All
// logic stays inside `pub fun main` to avoid the Span/MutSpan
// parameter restriction.
//
// Matrices are stored as flat [25]i32 buffers (the spec caps N at 5
// so 5*5 = 25 fixes both upper bound and stack size). Element type
// i32 because entries are in [-99, 99] and worst-case product sum is
// 5 * 99 * 99 = 49005, comfortably inside i32 range. The decimal
// renderer handles negative values and emits N lines of space-
// separated decimals terminated by \n.
pub fun main(world: World) -> Void raises {
    let n_opt = std.args.get(1)
    if n_opt.has == false {
        check world.err.write("usage: pass N as argv[1] and the matrix entries as argv[2..]\n")
        return
    }
    let n_bytes: Span<u8> = std.mem.span(n_opt.value)
    let n_str_len: usize = std.mem.len(n_bytes)
    if n_str_len == 0 {
        check world.err.write("N must be in [1, 5]\n")
        return
    }
    let mut np: usize = 0
    let mut n_val: u32 = 0_u32
    while np < n_str_len {
        let ch: u8 = n_bytes[np]
        if ch < 48_u8 || ch > 57_u8 {
            check world.err.write("N must be in [1, 5]\n")
            return
        }
        n_val = n_val * 10_u32 + ((ch - 48_u8) as u32)
        np = np + 1
    }
    if n_val < 1_u32 || n_val > 5_u32 {
        check world.err.write("N must be in [1, 5]\n")
        return
    }
    let n: usize = n_val as usize
    let nn: usize = n * n

    let mut a: [25]i32 = [0_i32; 25]
    let mut b: [25]i32 = [0_i32; 25]

    let mut idx: usize = 0
    while idx < nn {
        let arg = std.args.get(2_usize + idx)
        if arg.has == false {
            check world.err.write("missing matrix entry\n")
            return
        }
        let bytes: Span<u8> = std.mem.span(arg.value)
        let bl: usize = std.mem.len(bytes)
        if bl == 0 {
            check world.err.write("empty matrix entry\n")
            return
        }
        let mut p: usize = 0
        let mut neg: Bool = false
        if bytes[0] == 45_u8 {
            neg = true
            p = 1
        }
        if p >= bl {
            check world.err.write("invalid matrix entry\n")
            return
        }
        let mut v: i32 = 0_i32
        while p < bl {
            let c: u8 = bytes[p]
            if c < 48_u8 || c > 57_u8 {
                check world.err.write("invalid matrix entry\n")
                return
            }
            v = v * 10_i32 + ((c - 48_u8) as i32)
            p = p + 1
        }
        if neg {
            v = 0_i32 - v
        }
        a[idx] = v
        idx = idx + 1
    }

    let mut jdx: usize = 0
    while jdx < nn {
        let arg = std.args.get(2_usize + nn + jdx)
        if arg.has == false {
            check world.err.write("missing matrix entry\n")
            return
        }
        let bytes: Span<u8> = std.mem.span(arg.value)
        let bl: usize = std.mem.len(bytes)
        if bl == 0 {
            check world.err.write("empty matrix entry\n")
            return
        }
        let mut p: usize = 0
        let mut neg: Bool = false
        if bytes[0] == 45_u8 {
            neg = true
            p = 1
        }
        if p >= bl {
            check world.err.write("invalid matrix entry\n")
            return
        }
        let mut v: i32 = 0_i32
        while p < bl {
            let c: u8 = bytes[p]
            if c < 48_u8 || c > 57_u8 {
                check world.err.write("invalid matrix entry\n")
                return
            }
            v = v * 10_i32 + ((c - 48_u8) as i32)
            p = p + 1
        }
        if neg {
            v = 0_i32 - v
        }
        b[jdx] = v
        jdx = jdx + 1
    }

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

    let mut i: usize = 0
    while i < n {
        let mut j: usize = 0
        while j < n {
            let mut s: i32 = 0_i32
            let mut k: usize = 0
            while k < n {
                s = s + a[i * n + k] * b[k * n + j]
                k = k + 1
            }
            // Render s into the buffer.
            if j > 0 {
                out_buf[written] = 32_u8
                written = written + 1
            }
            let mut is_neg: Bool = false
            let mut u: u32 = 0_u32
            if s < 0_i32 {
                is_neg = true
                u = (0_i32 - s) as u32
            } else {
                u = s as u32
            }
            if is_neg {
                out_buf[written] = 45_u8
                written = written + 1
            }
            if u == 0_u32 {
                out_buf[written] = 48_u8
                written = written + 1
            } else {
                let mut digits: [16]u8 = [0_u8; 16]
                let mut rem: u32 = u
                let mut dc: usize = 0
                while rem > 0_u32 {
                    let dq: u32 = rem / 10_u32
                    let dr: u32 = rem % 10_u32
                    digits[dc] = (dr as u8) + 48_u8
                    rem = dq
                    dc = dc + 1
                }
                let mut o: usize = 0
                while o < dc {
                    out_buf[written] = digits[dc - 1 - o]
                    written = written + 1
                    o = o + 1
                }
            }
            j = j + 1
        }
        out_buf[written] = 10_u8
        written = written + 1
        i = i + 1
    }

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

// Square integer matrix multiply, TypeScript reference.
// Reads N, then N rows of A, then N rows of B, prints rows of C = A * B.
import { readFileSync } from "node:fs";

const raw = readFileSync(0, "utf8");
const tokens = raw.split(/\s+/).filter((t) => t.length > 0);
let pos = 0;
const n = Number.parseInt(tokens[pos++], 10);
if (!Number.isInteger(n) || n < 1 || n > 5) {
  process.stderr.write("N must be in [1, 5]\n");
  process.exit(1);
}

const a: number[][] = [];
const b: number[][] = [];
for (let i = 0; i < n; i++) {
  const row: number[] = [];
  for (let j = 0; j < n; j++) row.push(Number.parseInt(tokens[pos++], 10));
  a.push(row);
}
for (let i = 0; i < n; i++) {
  const row: number[] = [];
  for (let j = 0; j < n; j++) row.push(Number.parseInt(tokens[pos++], 10));
  b.push(row);
}

const rows: string[] = [];
for (let i = 0; i < n; i++) {
  const cells: string[] = [];
  for (let j = 0; j < n; j++) {
    let s = 0;
    for (let k = 0; k < n; k++) s += a[i][k] * b[k][j];
    cells.push(String(s));
  }
  rows.push(cells.join(" "));
}
process.stdout.write(rows.join("\n") + "\n");

// Square integer matrix multiply, Rust reference.
// Reads N, then N rows of A, then N rows of B, prints C = A * B.
use std::io::{self, Read, Write};
use std::process::ExitCode;

fn main() -> ExitCode {
    let mut input = String::new();
    if io::stdin().read_to_string(&mut input).is_err() {
        let _ = writeln!(io::stderr(), "failed to read stdin");
        return ExitCode::from(1);
    }
    let mut iter = input.split_ascii_whitespace();
    let n: i64 = match iter.next().and_then(|t| t.parse().ok()) {
        Some(v) if (1..=5).contains(&v) => v,
        _ => {
            let _ = writeln!(io::stderr(), "N must be in [1, 5]");
            return ExitCode::from(1);
        }
    };
    let n = n as usize;
    let read_matrix = |it: &mut std::str::SplitAsciiWhitespace| -> Option<Vec<Vec<i32>>> {
        let mut m = vec![vec![0i32; n]; n];
        for i in 0..n {
            for j in 0..n {
                let v: i32 = it.next()?.parse().ok()?;
                m[i][j] = v;
            }
        }
        Some(m)
    };
    let a = match read_matrix(&mut iter) {
        Some(m) => m,
        None => {
            let _ = writeln!(io::stderr(), "failed to read A");
            return ExitCode::from(1);
        }
    };
    let b = match read_matrix(&mut iter) {
        Some(m) => m,
        None => {
            let _ = writeln!(io::stderr(), "failed to read B");
            return ExitCode::from(1);
        }
    };
    let mut out = String::new();
    for i in 0..n {
        for j in 0..n {
            let mut s: i32 = 0;
            for k in 0..n {
                s += a[i][k] * b[k][j];
            }
            if j > 0 {
                out.push(' ');
            }
            out.push_str(&s.to_string());
        }
        out.push('\n');
    }
    let _ = io::stdout().write_all(out.as_bytes());
    ExitCode::SUCCESS
}

// Square integer matrix multiply, Go reference.
// Reads N, then N rows of A, then N rows of B, prints C = A * B.
package main

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

func main() {
	raw, err := io.ReadAll(bufio.NewReader(os.Stdin))
	if err != nil {
		fmt.Fprintln(os.Stderr, "failed to read stdin")
		os.Exit(1)
	}
	tokens := strings.Fields(string(raw))
	pos := 0
	if len(tokens) == 0 {
		fmt.Fprintln(os.Stderr, "missing input")
		os.Exit(1)
	}
	n, err := strconv.Atoi(tokens[pos])
	if err != nil || n < 1 || n > 5 {
		fmt.Fprintln(os.Stderr, "N must be in [1, 5]")
		os.Exit(1)
	}
	pos++
	a := make([][]int, n)
	b := make([][]int, n)
	for i := 0; i < n; i++ {
		a[i] = make([]int, n)
		for j := 0; j < n; j++ {
			a[i][j], err = strconv.Atoi(tokens[pos])
			if err != nil {
				fmt.Fprintln(os.Stderr, "failed to read A")
				os.Exit(1)
			}
			pos++
		}
	}
	for i := 0; i < n; i++ {
		b[i] = make([]int, n)
		for j := 0; j < n; j++ {
			b[i][j], err = strconv.Atoi(tokens[pos])
			if err != nil {
				fmt.Fprintln(os.Stderr, "failed to read B")
				os.Exit(1)
			}
			pos++
		}
	}
	var sb strings.Builder
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			s := 0
			for k := 0; k < n; k++ {
				s += a[i][k] * b[k][j]
			}
			if j > 0 {
				sb.WriteByte(' ')
			}
			sb.WriteString(strconv.Itoa(s))
		}
		sb.WriteByte('\n')
	}
	fmt.Print(sb.String())
}

"""Square integer matrix multiply, Python reference.

Reads N, then N rows of A, then N rows of B. Writes the N rows of C = A * B,
each row as space-separated decimal integers terminated by a single newline.
"""
import sys


def main() -> None:
    tokens = sys.stdin.read().split()
    pos = 0
    n = int(tokens[pos]); pos += 1
    if n < 1 or n > 5:
        sys.stderr.write("N must be in [1, 5]\n")
        sys.exit(1)
    a = [[0] * n for _ in range(n)]
    b = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            a[i][j] = int(tokens[pos]); pos += 1
    for i in range(n):
        for j in range(n):
            b[i][j] = int(tokens[pos]); pos += 1
    out_rows: list[str] = []
    for i in range(n):
        row_vals = []
        for j in range(n):
            s = 0
            for k in range(n):
                s += a[i][k] * b[k][j]
            row_vals.append(str(s))
        out_rows.append(" ".join(row_vals))
    sys.stdout.write("\n".join(out_rows) + "\n")


if __name__ == "__main__":
    main()