Non-overlapping substring count

// Non-overlapping substring count, Zero 0.1.2 direct backend.
//
// Same input convention as 001-005: arguments come from argv because
// Zero 0.1.2 has no exposed stdin capability. argv[1] is the pattern P
// and argv[2] is the text T. All logic stays inside `pub fun main`
// to avoid Span/MutSpan parameter restrictions.
//
// Greedy non-overlapping scan: once a match starts at index i, the
// next candidate starts at i + m. The count is rendered with the
// small-divisor u32 divmod renderer (avoids the 2^32-divisor SIGFPE).
pub fun main(world: World) -> Void raises {
    let p_opt = std.args.get(1)
    let t_opt = std.args.get(2)
    let mut p_bytes: Span<u8> = std.mem.span("")
    let mut t_bytes: Span<u8> = std.mem.span("")
    if p_opt.has {
        p_bytes = std.mem.span(p_opt.value)
    }
    if t_opt.has {
        t_bytes = std.mem.span(t_opt.value)
    }
    let m: usize = std.mem.len(p_bytes)
    let n: usize = std.mem.len(t_bytes)

    let mut count: u32 = 0_u32
    if m > 0 && m <= n {
        let mut i: usize = 0
        while i + m <= n {
            let mut k: usize = 0
            let mut equal: Bool = true
            while k < m {
                if t_bytes[i + k] != p_bytes[k] {
                    equal = false
                    k = m
                } else {
                    k = k + 1
                }
            }
            if equal {
                count = count + 1_u32
                i = i + m
            } else {
                i = i + 1
            }
        }
    }

    let mut out_buf: [16]u8 = [0_u8; 16]
    let mut written: usize = 0
    if count == 0_u32 {
        out_buf[0] = 48_u8
        written = 1
    } else {
        let mut digits: [16]u8 = [0_u8; 16]
        let mut rem: u32 = count
        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
        }
    }
    out_buf[written] = 10_u8
    written = written + 1

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

// Non-overlapping substring count, TypeScript reference.
// Reads pattern P from line 1 of stdin and text T from line 2.

import { readFileSync } from "node:fs";

function main(): void {
  const raw = readFileSync(0, "utf8");
  const lines = raw.split("\n");
  const p = lines[0] ?? "";
  const t = lines[1] ?? "";
  let count = 0;
  if (p.length > 0) {
    let i = 0;
    const n = t.length;
    const m = p.length;
    while (i + m <= n) {
      if (t.substring(i, i + m) === p) {
        count++;
        i += m;
      } else {
        i++;
      }
    }
  }
  process.stdout.write(`${count}\n`);
}

main();

// Non-overlapping substring count, Rust reference.
// Reads pattern P from line 1 of stdin and text T from line 2.

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

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let mut lines = input.split('\n');
    let p = lines.next().unwrap_or("");
    let t = lines.next().unwrap_or("");
    let mut count: u64 = 0;
    if !p.is_empty() {
        let pb = p.as_bytes();
        let tb = t.as_bytes();
        let m = pb.len();
        let n = tb.len();
        if m <= n {
            let mut i = 0;
            while i + m <= n {
                if &tb[i..i + m] == pb {
                    count += 1;
                    i += m;
                } else {
                    i += 1;
                }
            }
        }
    }
    let out = io::stdout();
    let mut h = out.lock();
    writeln!(h, "{}", count).unwrap();
}

// Non-overlapping substring count, Go reference.
// Reads pattern P from line 1 of stdin and text T from line 2.

package main

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

func main() {
	raw, _ := io.ReadAll(bufio.NewReader(os.Stdin))
	parts := strings.SplitN(string(raw), "\n", 3)
	var p, t string
	if len(parts) >= 1 {
		p = parts[0]
	}
	if len(parts) >= 2 {
		t = parts[1]
	}
	count := 0
	if len(p) > 0 {
		m := len(p)
		n := len(t)
		i := 0
		for i+m <= n {
			if t[i:i+m] == p {
				count++
				i += m
			} else {
				i++
			}
		}
	}
	fmt.Printf("%d\n", count)
}

"""Non-overlapping substring count, Python reference.

Reads pattern P from line 1 of stdin and text T from line 2. Counts greedy
non-overlapping occurrences and writes the decimal count followed by \\n.
"""
import sys


def main() -> None:
    raw = sys.stdin.read().split("\n", 2)
    p = raw[0] if len(raw) >= 1 else ""
    t = raw[1] if len(raw) >= 2 else ""
    count = 0
    if p:
        i = 0
        n = len(t)
        m = len(p)
        while i + m <= n:
            if t[i:i + m] == p:
                count += 1
                i += m
            else:
                i += 1
    sys.stdout.write(f"{count}\n")


if __name__ == "__main__":
    main()