Prime count via Sieve of Eratosthenes

// Prime count via Sieve of Eratosthenes, Zero 0.1.2 direct backend.
//
// Same input convention as task 001: N is read from argv[1] because
// Zero 0.1.2 has no exposed stdin capability. All logic stays inside
// `pub fun main` to avoid the Span/MutSpan-as-parameter restriction.
//
// The composite-flag table is fixed-size [10001]u8 so the spec cap
// of N <= 10000 is enforced at the type level. Element type is u8
// to stay inside the direct backend's allowed local-array element
// types (u8, u32, i32).
pub fun main(world: World) -> Void raises {
    let arg = std.args.get(1)
    if arg.has == false {
        check world.err.write("usage: pass N as argv[1] (Zero 0.1.2 has no stdin capability)\n")
        return
    }

    let arg_bytes: Span<u8> = std.mem.span(arg.value)
    let arg_len: usize = std.mem.len(arg_bytes)
    if arg_len == 0 {
        check world.err.write("N must be a non-negative integer\n")
        return
    }
    let mut parse_i: usize = 0
    let mut n: u32 = 0_u32
    while parse_i < arg_len {
        let ch: u8 = arg_bytes[parse_i]
        if ch < 48_u8 || ch > 57_u8 {
            check world.err.write("N must be a non-negative integer\n")
            return
        }
        n = n * 10_u32 + ((ch - 48_u8) as u32)
        parse_i = parse_i + 1
    }
    if n > 10000_u32 {
        check world.err.write("N must be <= 10000\n")
        return
    }

    let mut count: u32 = 0_u32
    if n >= 2_u32 {
        let mut composite: [10001]u8 = [0_u8; 10001]
        let mut i: u32 = 2_u32
        while i * i <= n {
            if composite[i as usize] == 0_u8 {
                let mut j: u32 = i * i
                while j <= n {
                    composite[j as usize] = 1_u8
                    j = j + i
                }
            }
            i = i + 1_u32
        }
        let mut k: u32 = 2_u32
        while k <= n {
            if composite[k as usize] == 0_u8 {
                count = count + 1_u32
            }
            k = k + 1_u32
        }
    }

    let mut buf: [16]u8 = [0_u8; 16]
    let mut written: usize = 0
    if count == 0_u32 {
        buf[0] = 48_u8
        buf[1] = 10_u8
        written = 2
    } else {
        let mut digits: [16]u8 = [0_u8; 16]
        let mut rem: u32 = count
        let mut digit_count: usize = 0
        while rem > 0_u32 {
            let dq: u32 = rem / 10_u32
            let dr: u32 = rem % 10_u32
            digits[digit_count] = (dr as u8) + 48_u8
            rem = dq
            digit_count = digit_count + 1
        }
        let mut o: usize = 0
        while o < digit_count {
            buf[o] = digits[digit_count - 1 - o]
            o = o + 1
        }
        buf[digit_count] = 10_u8
        written = digit_count + 1
    }
    let out: Span<u8> = buf[0..written]
    check world.out.write(out)
    return
}

// Prime count via Sieve of Eratosthenes, TypeScript reference.
// Reads N from stdin, runs a byte-flag sieve, counts unmarked [2, N].
import { readFileSync } from "node:fs";

const input = readFileSync(0, "utf8").trim();
const n = Number.parseInt(input, 10);
if (!Number.isInteger(n) || n < 0) {
  process.stderr.write("N must be a non-negative integer\n");
  process.exit(1);
}

if (n < 2) {
  process.stdout.write("0\n");
} else {
  const composite = new Uint8Array(n + 1);
  for (let i = 2; i * i <= n; i++) {
    if (composite[i] === 0) {
      for (let j = i * i; j <= n; j += i) {
        composite[j] = 1;
      }
    }
  }
  let count = 0;
  for (let k = 2; k <= n; k++) {
    if (composite[k] === 0) count++;
  }
  process.stdout.write(`${count}\n`);
}

// Prime count via Sieve of Eratosthenes, Rust reference.
// Reads N from stdin, runs a byte-flag sieve, counts unmarked [2, N].
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 n: i64 = match input.trim().parse() {
        Ok(v) if v >= 0 => v,
        _ => {
            let _ = writeln!(io::stderr(), "N must be a non-negative integer");
            return ExitCode::from(1);
        }
    };
    let n_usize = n as usize;
    let count = if n < 2 {
        0
    } else {
        let mut composite = vec![0u8; n_usize + 1];
        let mut i: usize = 2;
        while i * i <= n_usize {
            if composite[i] == 0 {
                let mut j = i * i;
                while j <= n_usize {
                    composite[j] = 1;
                    j += i;
                }
            }
            i += 1;
        }
        (2..=n_usize).filter(|&k| composite[k] == 0).count()
    };
    let _ = writeln!(io::stdout(), "{}", count);
    ExitCode::SUCCESS
}

// Prime count via Sieve of Eratosthenes, Go reference.
// Reads N from stdin, runs a byte-flag sieve, counts unmarked [2, N].
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	line, _ := reader.ReadString('\n')
	n, err := strconv.Atoi(strings.TrimSpace(line))
	if err != nil || n < 0 {
		fmt.Fprintln(os.Stderr, "N must be a non-negative integer")
		os.Exit(1)
	}
	if n < 2 {
		fmt.Print("0\n")
		return
	}
	composite := make([]byte, n+1)
	for i := 2; i*i <= n; i++ {
		if composite[i] == 0 {
			for j := i * i; j <= n; j += i {
				composite[j] = 1
			}
		}
	}
	count := 0
	for k := 2; k <= n; k++ {
		if composite[k] == 0 {
			count++
		}
	}
	fmt.Print(count, "\n")
}

"""Prime count via Sieve of Eratosthenes, Python reference.

Reads N from stdin, runs a standard byte-flag sieve over [0, N], counts
unmarked indices in [2, N]. N is bounded by 10000 by the task spec but
nothing here would change for a larger N apart from the allocation.
"""
import sys


def main() -> None:
    n = int(sys.stdin.readline().strip())
    if n < 0:
        sys.stderr.write("N must be a non-negative integer\n")
        sys.exit(1)
    if n < 2:
        sys.stdout.write("0\n")
        return
    composite = bytearray(n + 1)
    i = 2
    while i * i <= n:
        if composite[i] == 0:
            j = i * i
            while j <= n:
                composite[j] = 1
                j += i
        i += 1
    count = sum(1 for k in range(2, n + 1) if composite[k] == 0)
    sys.stdout.write(f"{count}\n")


if __name__ == "__main__":
    main()