Square integer matrix multiply

No reference implementation in this language.

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