傷病手当金（1日あたりの金額と総額）

<?php
declare(strict_types=1);

/**
 * 傷病手当金（1日あたりの金額と総額）。
 * v2: 平均を float にせず、合計（分子）と個数（分母）の int のまま持つ。上限との比較も 合計 > 上限 × 個数 で比べる。
 * 10円未満の四捨五入は 分子 ÷ (分母 × 300) を、1円未満は standard_daily × 2 ÷ 3 を、
 * intdiv(2 × 分子 + 分母, 2 × 分母) の整数の割り算で丸める（ちょうど半分は大きい方へ）。
 * 日付は preg_match で形を確かめてから checkdate。
 * v1（平均は array_sum / count、round($x / 10) * 10）でも23件中23件だった。PHP の round は 0.5 を0から遠い方へ丸め、
 * 1002.5 も float で正確に表せるため。平均が float で割り切れない値になると誤差が入りうるので整数にした。
 */

/** $num / $den（0 以上）を四捨五入した整数。ちょうど半分は大きい方へ */
function roundHalfUp(int $num, int $den): int
{
    return intdiv(2 * $num + $den, 2 * $den);
}

const CAPS = [
    ['2024-04-01', '2025-03-31', 300000],
    ['2025-04-01', '2026-03-31', 320000],
    ['2026-04-01', '2027-03-31', 320000],
];
const MONTH_MAX = 1390000;
const DAYS_MAX = 549;

function calcAllowance(array $in): array
{
    $months = $in['months'];
    $start = $in['start'];
    $days = $in['days'];
    if (!is_array($months) || count($months) < 1 || count($months) > 12) {
        return ['error' => 'invalid_input'];
    }
    foreach ($months as $m) {
        if (!is_int($m) || $m < 1) {
            return ['error' => 'invalid_input'];
        }
    }
    if (!is_string($start) || !preg_match('/^(\d{4})-(\d{2})-(\d{2})$/D', $start, $mm)
        || !checkdate((int)$mm[2], (int)$mm[3], (int)$mm[1])) {
        return ['error' => 'invalid_input'];
    }
    if (!is_int($days) || $days < 0) {
        return ['error' => 'invalid_input'];
    }

    $cap = null;
    foreach (CAPS as [$lo, $hi, $c]) {
        if ($lo <= $start && $start <= $hi) {
            $cap = $c;
        }
    }
    if ($cap === null || max($months) > MONTH_MAX || $days > DAYS_MAX) {
        return ['error' => 'out_of_range'];
    }

    $total = array_sum($months);
    $n = count($months);
    $capped = $n < 12 && $total > $cap * $n;
    [$num, $den] = $capped ? [$cap, 1] : [$total, $n];
    $standardDaily = roundHalfUp($num, $den * 300) * 10;
    $daily = roundHalfUp($standardDaily * 2, 3);
    return ['standard_daily' => $standardDaily, 'daily' => $daily, 'total' => $daily * $days, 'capped' => $capped];
}

<?php
declare(strict_types=1);

/**
 * 傷病手当金（1日あたりの金額と総額）。
 * v1: 平均は float（array_sum / count）、10円単位は round($x / 10) * 10、1円単位は round($x)。
 * 日付は preg_match で形を確かめてから checkdate。
 */
const CAPS = [
    ['2024-04-01', '2025-03-31', 300000],
    ['2025-04-01', '2026-03-31', 320000],
    ['2026-04-01', '2027-03-31', 320000],
];
const MONTH_MAX = 1390000;
const DAYS_MAX = 549;

function calcAllowance(array $in): array
{
    $months = $in['months'];
    $start = $in['start'];
    $days = $in['days'];
    if (!is_array($months) || count($months) < 1 || count($months) > 12) {
        return ['error' => 'invalid_input'];
    }
    foreach ($months as $m) {
        if (!is_int($m) || $m < 1) {
            return ['error' => 'invalid_input'];
        }
    }
    if (!is_string($start) || !preg_match('/^(\d{4})-(\d{2})-(\d{2})$/D', $start, $mm)
        || !checkdate((int)$mm[2], (int)$mm[3], (int)$mm[1])) {
        return ['error' => 'invalid_input'];
    }
    if (!is_int($days) || $days < 0) {
        return ['error' => 'invalid_input'];
    }

    $cap = null;
    foreach (CAPS as [$lo, $hi, $c]) {
        if ($lo <= $start && $start <= $hi) {
            $cap = $c;
        }
    }
    if ($cap === null || max($months) > MONTH_MAX || $days > DAYS_MAX) {
        return ['error' => 'out_of_range'];
    }

    $avg = array_sum($months) / count($months);
    $capped = count($months) < 12 && $avg > $cap;
    $base = $capped ? $cap : $avg;
    $standardDaily = (int)(round($base / 30 / 10) * 10);
    $daily = (int)round($standardDaily * 2 / 3);
    return ['standard_daily' => $standardDaily, 'daily' => $daily, 'total' => $daily * $days, 'capped' => $capped];
}

"""傷病手当金（1日あたりの金額と総額）。

v2: 平均を float にせず、合計（分子）と個数（分母）の整数のまま持つ。上限との比較も 合計 > 上限 × 個数 で比べる。
10円未満の四捨五入は 分子 ÷ (分母 × 300) を、1円未満は standard_daily × 2 ÷ 3 を、
「(2 × 分子 + 分母) // (2 × 分母)」の整数の割り算で丸める（ちょうど半分は大きい方へ）。日付は date.fromisoformat で読む。
v1（平均は sum / len、round(x / 10) * 10）では、Python の round が偶数へ丸めるため、
平均 300,750 ÷ 30 ÷ 10 = 1002.5 が 1002 になり、c002・c012 の standard_daily が 10,020 に落ちた（23件中21件）。
"""
from datetime import date

CAPS = [
    (date(2024, 4, 1), date(2025, 3, 31), 300000),
    (date(2025, 4, 1), date(2026, 3, 31), 320000),
    (date(2026, 4, 1), date(2027, 3, 31), 320000),
]
MONTH_MAX = 1390000
DAYS_MAX = 549


def round_half_up(num, den):
    """num / den（0 以上）を四捨五入した整数。ちょうど半分は大きい方へ"""
    return (2 * num + den) // (2 * den)


def calc(months, start, days):
    if not isinstance(months, list) or not 1 <= len(months) <= 12:
        return {"error": "invalid_input"}
    if any(not isinstance(m, int) or m < 1 for m in months):
        return {"error": "invalid_input"}
    try:
        d = date.fromisoformat(start)
    except (TypeError, ValueError):
        return {"error": "invalid_input"}
    if not isinstance(days, int) or days < 0:
        return {"error": "invalid_input"}

    cap = next((c for lo, hi, c in CAPS if lo <= d <= hi), None)
    if cap is None or any(m > MONTH_MAX for m in months) or days > DAYS_MAX:
        return {"error": "out_of_range"}

    total, n = sum(months), len(months)
    capped = n < 12 and total > cap * n
    num, den = (cap, 1) if capped else (total, n)
    standard_daily = round_half_up(num, den * 300) * 10
    daily = round_half_up(standard_daily * 2, 3)
    return {"standard_daily": standard_daily, "daily": daily, "total": daily * days, "capped": capped}

"""傷病手当金（1日あたりの金額と総額）。

v1: 平均は float（sum / len）、10円単位は round(x / 10) * 10、1円単位は round(x)。日付は date.fromisoformat で読む。
"""
from datetime import date

CAPS = [
    (date(2024, 4, 1), date(2025, 3, 31), 300000),
    (date(2025, 4, 1), date(2026, 3, 31), 320000),
    (date(2026, 4, 1), date(2027, 3, 31), 320000),
]
MONTH_MAX = 1390000
DAYS_MAX = 549


def calc(months, start, days):
    if not isinstance(months, list) or not 1 <= len(months) <= 12:
        return {"error": "invalid_input"}
    if any(not isinstance(m, int) or m < 1 for m in months):
        return {"error": "invalid_input"}
    try:
        d = date.fromisoformat(start)
    except (TypeError, ValueError):
        return {"error": "invalid_input"}
    if not isinstance(days, int) or days < 0:
        return {"error": "invalid_input"}

    cap = next((c for lo, hi, c in CAPS if lo <= d <= hi), None)
    if cap is None or any(m > MONTH_MAX for m in months) or days > DAYS_MAX:
        return {"error": "out_of_range"}

    avg = sum(months) / len(months)
    capped = len(months) < 12 and avg > cap
    base = cap if capped else avg
    standard_daily = round(base / 30 / 10) * 10
    daily = round(standard_daily * 2 / 3)
    return {"standard_daily": standard_daily, "daily": daily, "total": daily * days, "capped": capped}

package main

import (
	"regexp"
	"time"
)

// 傷病手当金（1日あたりの金額と総額）。
// v2: 平均を float64 にせず、合計 S と月数 n の整数で持つ。標準報酬日額 = (S ÷ n ÷ 30) を10円単位に四捨五入
// = floor((S + 150n) ÷ 300n) × 10、日額 = floor((4 × 標準報酬日額 + 3) ÷ 6)（どちらも 0.5 ちょうどは大きい方へ）。
// 上限との比較も S > 上限 × n の整数で比べる。支給開始日は形を正規表現で確かめてから time.Parse で読む（実在しない日付は Parse が弾く）。
// v1（float64 の sum/len と math.Round）も23件中23件だった。300,750 ÷ 30 ÷ 10 = 1002.5 が float64 でも正確に表せ、
// math.Round は 0.5 を0から遠い方へ丸めるので、5円ちょうどの c002・c012 も 10,030 になる。

const monthMax = 1390000
const daysMax = 549

type capRange struct {
	from, to string // "YYYY-MM-DD" は文字列のままで日付の順に並ぶ
	cap      int64
}

var caps = []capRange{
	{"2024-04-01", "2025-03-31", 300000},
	{"2025-04-01", "2026-03-31", 320000},
	{"2026-04-01", "2027-03-31", 320000},
}

var dateForm = regexp.MustCompile(`^[0-9]{4}-[0-9]{2}-[0-9]{2}$`)

func errOut(code string) map[string]any { return map[string]any{"error": code} }

func Allowance(months []int, start string, days int) map[string]any {
	if len(months) < 1 || len(months) > 12 || days < 0 || !dateForm.MatchString(start) {
		return errOut("invalid_input")
	}
	if _, err := time.Parse("2006-01-02", start); err != nil {
		return errOut("invalid_input")
	}
	for _, m := range months {
		if m < 1 {
			return errOut("invalid_input")
		}
	}
	limit := int64(-1)
	for _, c := range caps {
		if c.from <= start && start <= c.to {
			limit = c.cap
		}
	}
	if limit < 0 || days > daysMax {
		return errOut("out_of_range")
	}
	var sum int64
	for _, m := range months {
		if m > monthMax {
			return errOut("out_of_range")
		}
		sum += int64(m)
	}
	n := int64(len(months))
	capped := n < 12 && sum > limit*n
	if capped {
		sum, n = limit, 1
	}
	std := (sum + 150*n) / (300 * n) * 10
	daily := (4*std + 3) / 6
	return map[string]any{
		"standard_daily": std,
		"daily":          daily,
		"total":          daily * int64(days),
		"capped":         capped,
	}
}

package main

import (
	"math"
	"time"
)

// 傷病手当金（1日あたりの金額と総額）。
// v1: 平均を float64 の sum/len で出し、÷30 の10円未満は math.Round(x/10)*10、× 2/3 は math.Round で四捨五入する。
// 支給開始日は time.Parse("2006-01-02") で読み、上限の期間は time.Time で比べる。

const monthMax = 1390000
const daysMax = 549

type capRange struct {
	from, to string
	cap      float64
}

var caps = []capRange{
	{"2024-04-01", "2025-03-31", 300000},
	{"2025-04-01", "2026-03-31", 320000},
	{"2026-04-01", "2027-03-31", 320000},
}

func errOut(code string) map[string]any { return map[string]any{"error": code} }

func Allowance(months []int, start string, days int) map[string]any {
	d, err := time.Parse("2006-01-02", start)
	if len(months) < 1 || len(months) > 12 || err != nil || days < 0 {
		return errOut("invalid_input")
	}
	for _, m := range months {
		if m < 1 {
			return errOut("invalid_input")
		}
	}
	limit := -1.0
	for _, c := range caps {
		from, _ := time.Parse("2006-01-02", c.from)
		to, _ := time.Parse("2006-01-02", c.to)
		if !d.Before(from) && !d.After(to) {
			limit = c.cap
		}
	}
	if limit < 0 || days > daysMax {
		return errOut("out_of_range")
	}
	sum := 0
	for _, m := range months {
		if m > monthMax {
			return errOut("out_of_range")
		}
		sum += m
	}
	avg := float64(sum) / float64(len(months))
	capped := len(months) < 12 && avg > limit
	if capped {
		avg = limit
	}
	std := math.Round(avg/30/10) * 10
	daily := math.Round(std * 2 / 3)
	return map[string]any{
		"standard_daily": int(std),
		"daily":          int(daily),
		"total":          int(daily) * days,
		"capped":         capped,
	}
}

// 傷病手当金（1日あたりの金額と総額）。
// v2: 平均を割り算せず、合計（分子）と個数（分母）の整数のまま持つ。上限との比較も 合計 > 上限 × 個数 で比べる。
// 10円未満の四捨五入は 分子 ÷ (分母 × 300) を、1円未満は standard_daily × 2 ÷ 3 を、
// Math.floor((2 × 分子 + 分母) / (2 × 分母)) で丸める（ちょうど半分は大きい方へ）。値は最大でも約 3,400万で、
// 2^53 より十分小さいので Number の整数として正確（割り算の結果は floor の前に整数部が狂わない）。
// 日付は正規表現で形を確かめ、Date.UTC で作って年・月・日が戻るかで実在を確かめる。
// v1（平均は 合計 / 個数、Math.round(x / 10) * 10）でも23件中23件だった。Math.round は 0.5 を大きい方へ丸め、
// 1002.5 も Number で正確に表せるため。平均が割り切れない値になると誤差が入りうるので整数にした。

/** num / den（0 以上の整数）を四捨五入した整数。ちょうど半分は大きい方へ */
const roundHalfUp = (num, den) => Math.floor((2 * num + den) / (2 * den));

const CAPS = [
  ["2024-04-01", "2025-03-31", 300000],
  ["2025-04-01", "2026-03-31", 320000],
  ["2026-04-01", "2027-03-31", 320000],
];
const MONTH_MAX = 1390000;
const DAYS_MAX = 549;

function validDate(s) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
  if (!m) return false;
  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
  const t = new Date(Date.UTC(y, mo - 1, d));
  return t.getUTCFullYear() === y && t.getUTCMonth() === mo - 1 && t.getUTCDate() === d;
}

export function calc({ months, start, days }) {
  if (!Array.isArray(months) || months.length < 1 || months.length > 12) return { error: "invalid_input" };
  if (months.some((m) => !Number.isInteger(m) || m < 1)) return { error: "invalid_input" };
  if (typeof start !== "string" || !validDate(start)) return { error: "invalid_input" };
  if (!Number.isInteger(days) || days < 0) return { error: "invalid_input" };

  const hit = CAPS.find(([lo, hi]) => lo <= start && start <= hi);
  if (!hit || months.some((m) => m > MONTH_MAX) || days > DAYS_MAX) return { error: "out_of_range" };
  const cap = hit[2];

  const total = months.reduce((a, b) => a + b, 0);
  const n = months.length;
  const capped = n < 12 && total > cap * n;
  const [num, den] = capped ? [cap, 1] : [total, n];
  const standardDaily = roundHalfUp(num, den * 300) * 10;
  const daily = roundHalfUp(standardDaily * 2, 3);
  return { standard_daily: standardDaily, daily, total: daily * days, capped };
}

// 傷病手当金（1日あたりの金額と総額）。
// v1: 平均は Number（合計 / 個数）、10円単位は Math.round(x / 10) * 10、1円単位は Math.round(x)。
// 日付は正規表現で形を確かめ、Date.UTC で作って年・月・日が戻るかで実在を確かめる。

const CAPS = [
  ["2024-04-01", "2025-03-31", 300000],
  ["2025-04-01", "2026-03-31", 320000],
  ["2026-04-01", "2027-03-31", 320000],
];
const MONTH_MAX = 1390000;
const DAYS_MAX = 549;

function validDate(s) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
  if (!m) return false;
  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
  const t = new Date(Date.UTC(y, mo - 1, d));
  return t.getUTCFullYear() === y && t.getUTCMonth() === mo - 1 && t.getUTCDate() === d;
}

export function calc({ months, start, days }) {
  if (!Array.isArray(months) || months.length < 1 || months.length > 12) return { error: "invalid_input" };
  if (months.some((m) => !Number.isInteger(m) || m < 1)) return { error: "invalid_input" };
  if (typeof start !== "string" || !validDate(start)) return { error: "invalid_input" };
  if (!Number.isInteger(days) || days < 0) return { error: "invalid_input" };

  const hit = CAPS.find(([lo, hi]) => lo <= start && start <= hi);
  if (!hit || months.some((m) => m > MONTH_MAX) || days > DAYS_MAX) return { error: "out_of_range" };
  const cap = hit[2];

  const avg = months.reduce((a, b) => a + b, 0) / months.length;
  const capped = months.length < 12 && avg > cap;
  const base = capped ? cap : avg;
  const standardDaily = Math.round(base / 30 / 10) * 10;
  const daily = Math.round((standardDaily * 2) / 3);
  return { standard_daily: standardDaily, daily, total: daily * days, capped };
}

import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 傷病手当金（1日あたりの金額と総額）。
 * v2: 平均を「合計 ÷ 個数」の分数（long の分子・分母）のまま持ち、上限との比較も 合計 > 上限 × 個数 の整数で行う。
 * ÷30 の10円単位は 分子 ÷ (分母 × 300) を floor((2 × 分子 + D) ÷ (2 × D)) で四捨五入（半分は大きい方へ）して × 10、
 * × 2/3 も floor((4 × 日額 + 3) ÷ 6)。日付は LocalDate.parse（ISO_LOCAL_DATE・実在しない日は例外）で読む。
 * v1（double の平均・Math.round）も23件中23件だった。Math.round は 0.5 を大きい方へ丸め、5円ちょうど（c002 の
 * 10,025 ÷ 10 = 1002.5）は double でも正確に表せるので、たまたま通る。偶然に頼らないよう整数にした。
 */
public final class Sickness {
    private Sickness() {}

    static Map<String, Object> err(String code) {
        Map<String, Object> m = new LinkedHashMap<>();
        m.put("error", code);
        return m;
    }

    /** 支給開始日の年度の上限。期間外なら -1 */
    static long cap(LocalDate d) {
        if (d.isBefore(LocalDate.of(2024, 4, 1)) || d.isAfter(LocalDate.of(2027, 3, 31))) return -1;
        if (d.isBefore(LocalDate.of(2025, 4, 1))) return 300000;
        return 320000;
    }

    /** num ÷ den（どちらも 0 以上・den &gt; 0）を四捨五入。ちょうど半分は大きい方へ */
    static long roundHalfUp(long num, long den) {
        return (2 * num + den) / (2 * den);
    }

    public static Map<String, Object> calc(long[] months, String start, long days) {
        if (months.length == 0 || months.length > 12 || days < 0) return err("invalid_input");
        for (long m : months) if (m < 1) return err("invalid_input");
        LocalDate d;
        try {
            d = LocalDate.parse(start);
        } catch (DateTimeParseException e) {
            return err("invalid_input");
        }
        long limit = cap(d);
        if (limit < 0 || days > 549) return err("out_of_range");
        for (long m : months) if (m > 1390000) return err("out_of_range");

        long sum = 0;
        for (long m : months) sum += m;
        boolean capped = months.length < 12 && sum > limit * months.length;
        long num = capped ? limit : sum; // 基準の月額 B = num ÷ den
        long den = capped ? 1 : months.length;
        long standardDaily = roundHalfUp(num, den * 300) * 10; // B ÷ 30 を10円単位に
        long daily = roundHalfUp(standardDaily * 2, 3);

        Map<String, Object> out = new LinkedHashMap<>();
        out.put("standard_daily", standardDaily);
        out.put("daily", daily);
        out.put("total", daily * days);
        out.put("capped", capped);
        return out;
    }
}

import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 傷病手当金（1日あたりの金額と総額）。
 * v1: 平均を double（合計 ÷ 個数）で出し、÷30 の10円単位は Math.round(x / 10) * 10、× 2/3 は Math.round(x * 2 / 3.0)。
 * 日付は LocalDate.parse（ISO_LOCAL_DATE）で読む。
 */
public final class Sickness {
    private Sickness() {}

    static Map<String, Object> err(String code) {
        Map<String, Object> m = new LinkedHashMap<>();
        m.put("error", code);
        return m;
    }

    /** 支給開始日の年度の上限。期間外なら -1 */
    static long cap(LocalDate d) {
        if (d.isBefore(LocalDate.of(2024, 4, 1)) || d.isAfter(LocalDate.of(2027, 3, 31))) return -1;
        if (d.isBefore(LocalDate.of(2025, 4, 1))) return 300000;
        return 320000;
    }

    public static Map<String, Object> calc(long[] months, String start, long days) {
        if (months.length == 0 || months.length > 12 || days < 0) return err("invalid_input");
        for (long m : months) if (m < 1) return err("invalid_input");
        LocalDate d;
        try {
            d = LocalDate.parse(start);
        } catch (DateTimeParseException e) {
            return err("invalid_input");
        }
        long limit = cap(d);
        if (limit < 0 || days > 549) return err("out_of_range");
        for (long m : months) if (m > 1390000) return err("out_of_range");

        long sum = 0;
        for (long m : months) sum += m;
        double avg = (double) sum / months.length;
        boolean capped = months.length < 12 && avg > limit;
        double base = capped ? limit : avg;
        long standardDaily = Math.round(base / 30 / 10) * 10;
        long daily = Math.round(standardDaily * 2 / 3.0);

        Map<String, Object> out = new LinkedHashMap<>();
        out.put("standard_daily", standardDaily);
        out.put("daily", daily);
        out.put("total", daily * days);
        out.put("capped", capped);
        return out;
    }
}

// 傷病手当金（1日あたりの金額と総額）。
// v2: 平均を「合計 ÷ 個数」の分数（long の分子・分母）のまま持ち、上限との比較も 合計 > 上限 × 個数 の整数で行う。
// ÷30 の10円単位は 分子 ÷ (分母 × 300) を (2 × 分子 + D) / (2 × D) で四捨五入（半分は大きい方へ）して × 10、
// × 2/3 も (4 × 日額 + 3) / 6。日付は DateTime.TryParseExact（"yyyy-MM-dd"・InvariantCulture）で読む。
// v1（months.Average() の double・Math.Round）は23件中21件。Math.Round は既定で偶数への丸め（MidpointRounding.ToEven）なので、
// 5円ちょうどの c002・c012（10,025 ÷ 10 = 1002.5）が 1002 になり、standard_daily 10,020・daily 6,680（正しくは 10,030・6,687）と出た。
using System.Globalization;

public static class Sickness
{
    static Dictionary<string, object?> Err(string code) => new() { ["error"] = code };

    /// 支給開始日の年度の上限。期間外なら null
    static long? Cap(DateTime d)
    {
        if (d < new DateTime(2024, 4, 1) || d > new DateTime(2027, 3, 31)) return null;
        if (d < new DateTime(2025, 4, 1)) return 300000;
        return 320000;
    }

    /// num ÷ den（どちらも 0 以上・den > 0）を四捨五入。ちょうど半分は大きい方へ
    static long RoundHalfUp(long num, long den) => (2 * num + den) / (2 * den);

    public static Dictionary<string, object?> Calc(long[] months, string start, long days)
    {
        if (months.Length == 0 || months.Length > 12 || days < 0) return Err("invalid_input");
        if (months.Any(m => m < 1)) return Err("invalid_input");
        if (!DateTime.TryParseExact(start, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var d))
            return Err("invalid_input");
        var limit = Cap(d);
        if (limit is null || days > 549 || months.Any(m => m > 1390000)) return Err("out_of_range");

        long sum = months.Sum();
        bool capped = months.Length < 12 && sum > limit.Value * months.Length;
        long num = capped ? limit.Value : sum; // 基準の月額 B = num ÷ den
        long den = capped ? 1 : months.Length;
        long standardDaily = RoundHalfUp(num, den * 300) * 10; // B ÷ 30 を10円単位に
        long daily = RoundHalfUp(standardDaily * 2, 3);
        return new()
        {
            ["standard_daily"] = standardDaily,
            ["daily"] = daily,
            ["total"] = daily * days,
            ["capped"] = capped,
        };
    }
}

// 傷病手当金（1日あたりの金額と総額）。
// v1: 平均を double（months.Average()）で出し、÷30 の10円単位は Math.Round(x / 10) * 10、× 2/3 は Math.Round(x * 2 / 3.0)。
// 日付は DateTime.TryParseExact（"yyyy-MM-dd"・InvariantCulture）で読む。
using System.Globalization;

public static class Sickness
{
    static Dictionary<string, object?> Err(string code) => new() { ["error"] = code };

    /// 支給開始日の年度の上限。期間外なら null
    static long? Cap(DateTime d)
    {
        if (d < new DateTime(2024, 4, 1) || d > new DateTime(2027, 3, 31)) return null;
        if (d < new DateTime(2025, 4, 1)) return 300000;
        return 320000;
    }

    public static Dictionary<string, object?> Calc(long[] months, string start, long days)
    {
        if (months.Length == 0 || months.Length > 12 || days < 0) return Err("invalid_input");
        if (months.Any(m => m < 1)) return Err("invalid_input");
        if (!DateTime.TryParseExact(start, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var d))
            return Err("invalid_input");
        var limit = Cap(d);
        if (limit is null || days > 549 || months.Any(m => m > 1390000)) return Err("out_of_range");

        double avg = months.Average();
        bool capped = months.Length < 12 && avg > limit.Value;
        double baseAmount = capped ? limit.Value : avg;
        long standardDaily = (long)Math.Round(baseAmount / 30 / 10) * 10;
        long daily = (long)Math.Round(standardDaily * 2 / 3.0);
        return new()
        {
            ["standard_daily"] = standardDaily,
            ["daily"] = daily,
            ["total"] = daily * days,
            ["capped"] = capped,
        };
    }
}

//! 傷病手当金（1日あたりの金額と総額）。
//! v2: 平均を f64 にせず、合計 S と月数 n の整数で持つ。標準報酬日額 = (S ÷ n ÷ 30) を10円単位に四捨五入
//! = floor((S + 150n) ÷ 300n) × 10、日額 = floor((4 × 標準報酬日額 + 3) ÷ 6)（どちらも 0.5 ちょうどは大きい方へ）。
//! 上限との比較も S > 上限 × n の整数で比べる。支給開始日は数字4・2・2桁の形を確かめ、月 1〜12・日 1〜その月の日数（うるう年を含む）で確かめる。
//! v1 は日を 1〜31 でしか確かめず、c016 の 2025-02-29 を invalid_input にせず計算した（23件中22件。標準ライブラリに日付の検証が無い）。
//! 計算は f64 でも合っていた（300,750 ÷ 30 ÷ 10 = 1002.5 は f64 で正確に表せ、f64::round は 0.5 を0から遠い方へ丸める）。

use crate::json::{n, obj, s, Value};

const MONTH_MAX: i64 = 1_390_000;
const DAYS_MAX: i64 = 549;
const CAPS: [((i64, i64, i64), (i64, i64, i64), i64); 3] = [
    ((2024, 4, 1), (2025, 3, 31), 300_000),
    ((2025, 4, 1), (2026, 3, 31), 320_000),
    ((2026, 4, 1), (2027, 3, 31), 320_000),
];

fn err(code: &str) -> Value {
    obj(vec![("error", s(code))])
}

fn is_leap(y: i64) -> bool {
    y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)
}

fn days_in_month(y: i64, m: i64) -> i64 {
    match m {
        2 if is_leap(y) => 29,
        2 => 28,
        4 | 6 | 9 | 11 => 30,
        _ => 31,
    }
}

/// "YYYY-MM-DD" を数字の桁数まで確かめて読み、実在する日付なら (年, 月, 日)
fn parse_date(t: &str) -> Option<(i64, i64, i64)> {
    let p: Vec<&str> = t.split('-').collect();
    if p.len() != 3 || p.iter().zip([4, 2, 2]).any(|(x, w)| x.len() != w || !x.bytes().all(|b| b.is_ascii_digit())) {
        return None;
    }
    let (y, m, d) = (p[0].parse().ok()?, p[1].parse().ok()?, p[2].parse().ok()?);
    if !(1..=12).contains(&m) || d < 1 || d > days_in_month(y, m) {
        return None;
    }
    Some((y, m, d))
}

pub fn calc(months: &[i64], start: &str, days: i64) -> Value {
    let date = parse_date(start);
    if months.is_empty() || months.len() > 12 || months.iter().any(|&m| m < 1) || date.is_none() || days < 0 {
        return err("invalid_input");
    }
    let date = date.unwrap();
    let limit = CAPS.iter().find(|(from, to, _)| *from <= date && date <= *to).map(|c| c.2);
    let Some(limit) = limit else { return err("out_of_range") };
    if months.iter().any(|&m| m > MONTH_MAX) || days > DAYS_MAX {
        return err("out_of_range");
    }
    let (mut sum, mut cnt) = (months.iter().sum::<i64>(), months.len() as i64);
    let capped = cnt < 12 && sum > limit * cnt;
    if capped {
        (sum, cnt) = (limit, 1);
    }
    let std = (sum + 150 * cnt) / (300 * cnt) * 10;
    let daily = (4 * std + 3) / 6;
    obj(vec![
        ("standard_daily", n(std)),
        ("daily", n(daily)),
        ("total", n(daily * days)),
        ("capped", Value::Bool(capped)),
    ])
}

//! 傷病手当金（1日あたりの金額と総額）。
//! v1: 平均を f64 の sum / len で出し、÷30 の10円未満は (x / 10.0).round() * 10.0、× 2/3 は f64::round で四捨五入する。
//! 標準ライブラリに日付の型が無いので、支給開始日は長さ10を確かめて '-' で分けて数にし、月 1〜12・日 1〜31 を確かめる。
//! 上限の期間は (年, 月, 日) の組で比べる。

use crate::json::{n, obj, s, Value};

const MONTH_MAX: i64 = 1_390_000;
const DAYS_MAX: i64 = 549;
const CAPS: [((u32, u32, u32), (u32, u32, u32), f64); 3] = [
    ((2024, 4, 1), (2025, 3, 31), 300_000.0),
    ((2025, 4, 1), (2026, 3, 31), 320_000.0),
    ((2026, 4, 1), (2027, 3, 31), 320_000.0),
];

fn err(code: &str) -> Value {
    obj(vec![("error", s(code))])
}

fn parse_date(t: &str) -> Option<(u32, u32, u32)> {
    if t.len() != 10 {
        return None;
    }
    let p: Vec<&str> = t.split('-').collect();
    if p.len() != 3 {
        return None;
    }
    let y = p[0].parse().ok()?;
    let m = p[1].parse().ok()?;
    let d = p[2].parse().ok()?;
    if !(1..=12).contains(&m) || !(1..=31).contains(&d) {
        return None;
    }
    Some((y, m, d))
}

pub fn calc(months: &[i64], start: &str, days: i64) -> Value {
    let date = parse_date(start);
    if months.is_empty() || months.len() > 12 || months.iter().any(|&m| m < 1) || date.is_none() || days < 0 {
        return err("invalid_input");
    }
    let date = date.unwrap();
    let limit = CAPS.iter().find(|(from, to, _)| *from <= date && date <= *to).map(|c| c.2);
    let Some(limit) = limit else { return err("out_of_range") };
    if months.iter().any(|&m| m > MONTH_MAX) || days > DAYS_MAX {
        return err("out_of_range");
    }
    let mut avg = months.iter().sum::<i64>() as f64 / months.len() as f64;
    let capped = months.len() < 12 && avg > limit;
    if capped {
        avg = limit;
    }
    let std = (avg / 30.0 / 10.0).round() * 10.0;
    let daily = (std * 2.0 / 3.0).round();
    obj(vec![
        ("standard_daily", n(std as i64)),
        ("daily", n(daily as i64)),
        ("total", n(daily as i64 * days)),
        ("capped", Value::Bool(capped)),
    ])
}

# 傷病手当金（1日あたりの金額と総額）。
# v2: 平均を Float にせず、合計（分子）と個数（分母）の Integer のまま持つ。上限との比較も 合計 > 上限 × 個数 で比べる。
# 10円未満の四捨五入は 分子 ÷ (分母 × 300) を、1円未満は standard_daily × 2 ÷ 3 を、
# (2 × 分子 + 分母) / (2 × 分母) の整数の割り算で丸める（ちょうど半分は大きい方へ）。
# 日付は /\A\d{4}-\d{2}-\d{2}\z/ で形を確かめてから Date.valid_date? で実在を確かめる。
# v1 の Date.strptime(start, "%Y-%m-%d") は "2025-6-1" も 2025-06-01 として読むので、c017 が invalid_input にならず
# 計算まで進んでいた（23件中22件）。丸めは v1 の Float と round（0.5 は0から遠い方へ）でも通っていた。

require "date"

module Allowance
  module_function

  CAPS = [
    [Date.new(2024, 4, 1), Date.new(2025, 3, 31), 300_000],
    [Date.new(2025, 4, 1), Date.new(2026, 3, 31), 320_000],
    [Date.new(2026, 4, 1), Date.new(2027, 3, 31), 320_000],
  ].freeze
  MONTH_MAX = 1_390_000
  DAYS_MAX = 549
  DATE = /\A(\d{4})-(\d{2})-(\d{2})\z/

  # num / den（0 以上の整数）を四捨五入した整数。ちょうど半分は大きい方へ
  def round_half_up(num, den)
    (2 * num + den) / (2 * den)
  end

  def calc(months:, start:, days:)
    return { "error" => "invalid_input" } unless months.is_a?(Array) && months.size.between?(1, 12)
    return { "error" => "invalid_input" } if months.any? { |m| !m.is_a?(Integer) || m < 1 }
    m = start.is_a?(String) && DATE.match(start)
    return { "error" => "invalid_input" } unless m
    y, mo, dd = m.captures.map(&:to_i)
    return { "error" => "invalid_input" } unless Date.valid_date?(y, mo, dd)
    d = Date.new(y, mo, dd)
    return { "error" => "invalid_input" } unless days.is_a?(Integer) && days >= 0

    hit = CAPS.find { |lo, hi, _| d.between?(lo, hi) }
    return { "error" => "out_of_range" } if hit.nil? || months.any? { |m| m > MONTH_MAX } || days > DAYS_MAX
    cap = hit[2]

    total = months.sum
    n = months.size
    capped = n < 12 && total > cap * n
    num, den = capped ? [cap, 1] : [total, n]
    standard_daily = round_half_up(num, den * 300) * 10
    daily = round_half_up(standard_daily * 2, 3)
    { "standard_daily" => standard_daily, "daily" => daily, "total" => daily * days, "capped" => capped }
  end
end

# 傷病手当金（1日あたりの金額と総額）。
# v1: 平均は Float（sum.to_f / size）、10円単位は (x / 10).round * 10、1円単位は x.round。
# 日付は Date.strptime(start, "%Y-%m-%d") で読み、読めなければ invalid_input。

require "date"

module Allowance
  module_function

  CAPS = [
    [Date.new(2024, 4, 1), Date.new(2025, 3, 31), 300_000],
    [Date.new(2025, 4, 1), Date.new(2026, 3, 31), 320_000],
    [Date.new(2026, 4, 1), Date.new(2027, 3, 31), 320_000],
  ].freeze
  MONTH_MAX = 1_390_000
  DAYS_MAX = 549

  def calc(months:, start:, days:)
    return { "error" => "invalid_input" } unless months.is_a?(Array) && months.size.between?(1, 12)
    return { "error" => "invalid_input" } if months.any? { |m| !m.is_a?(Integer) || m < 1 }
    d = begin
      Date.strptime(start, "%Y-%m-%d")
    rescue ArgumentError, TypeError
      nil
    end
    return { "error" => "invalid_input" } if d.nil?
    return { "error" => "invalid_input" } unless days.is_a?(Integer) && days >= 0

    hit = CAPS.find { |lo, hi, _| d.between?(lo, hi) }
    return { "error" => "out_of_range" } if hit.nil? || months.any? { |m| m > MONTH_MAX } || days > DAYS_MAX
    cap = hit[2]

    avg = months.sum.to_f / months.size
    capped = months.size < 12 && avg > cap
    base = capped ? cap : avg
    standard_daily = (base / 30.0 / 10).round * 10
    daily = (standard_daily * 2 / 3.0).round
    { "standard_daily" => standard_daily, "daily" => daily, "total" => daily * days, "capped" => capped }
  end
end

import java.time.LocalDate
import java.time.format.DateTimeParseException

// 傷病手当金（1日あたりの金額と総額）。
// v2: 平均を「合計 ÷ 個数」の分数（Long の分子・分母）のまま持ち、上限との比較も 合計 > 上限 × 個数 の整数で行う。
// ÷30 の10円単位は 分子 ÷ (分母 × 300) を (2 × 分子 + D) / (2 × D) で四捨五入（半分は大きい方へ）して × 10、
// × 2/3 も (4 × 日額 + 3) / 6。日付は LocalDate.parse（ISO_LOCAL_DATE・実在しない日は例外）で読む。
// v1（months.average() の Double・roundToLong）も23件中23件だった。roundToLong は 0.5 を大きい方へ丸め、
// 5円ちょうど（c002 の 10,025 ÷ 10 = 1002.5）は Double でも正確に表せるので、たまたま通る。偶然に頼らないよう整数にした。

private fun err(code: String): Map<String, Any?> = linkedMapOf("error" to code)

/** 支給開始日の年度の上限。期間外なら null */
private fun capFor(d: LocalDate): Long? = when {
    d < LocalDate.of(2024, 4, 1) || d > LocalDate.of(2027, 3, 31) -> null
    d < LocalDate.of(2025, 4, 1) -> 300000L
    else -> 320000L
}

/** num ÷ den（どちらも 0 以上・den > 0）を四捨五入。ちょうど半分は大きい方へ */
private fun roundHalfUp(num: Long, den: Long): Long = (2 * num + den) / (2 * den)

fun sicknessAllowance(months: List<Long>, start: String, days: Long): Map<String, Any?> {
    if (months.isEmpty() || months.size > 12 || days < 0) return err("invalid_input")
    if (months.any { it < 1 }) return err("invalid_input")
    val d = try {
        LocalDate.parse(start)
    } catch (e: DateTimeParseException) {
        return err("invalid_input")
    }
    val limit = capFor(d) ?: return err("out_of_range")
    if (days > 549 || months.any { it > 1390000 }) return err("out_of_range")

    val sum = months.sum()
    val capped = months.size < 12 && sum > limit * months.size
    val num = if (capped) limit else sum // 基準の月額 B = num ÷ den
    val den = if (capped) 1L else months.size.toLong()
    val standardDaily = roundHalfUp(num, den * 300) * 10 // B ÷ 30 を10円単位に
    val daily = roundHalfUp(standardDaily * 2, 3)
    return linkedMapOf(
        "standard_daily" to standardDaily,
        "daily" to daily,
        "total" to daily * days,
        "capped" to capped,
    )
}

import java.time.LocalDate
import java.time.format.DateTimeParseException
import kotlin.math.roundToLong

// 傷病手当金（1日あたりの金額と総額）。
// v1: 平均を Double（months.average()）で出し、÷30 の10円単位は (x / 10).roundToLong() * 10、× 2/3 は (x * 2 / 3.0).roundToLong()。
// 日付は LocalDate.parse（ISO_LOCAL_DATE）で読む。

private fun err(code: String): Map<String, Any?> = linkedMapOf("error" to code)

/** 支給開始日の年度の上限。期間外なら null */
private fun capFor(d: LocalDate): Long? = when {
    d < LocalDate.of(2024, 4, 1) || d > LocalDate.of(2027, 3, 31) -> null
    d < LocalDate.of(2025, 4, 1) -> 300000L
    else -> 320000L
}

fun sicknessAllowance(months: List<Long>, start: String, days: Long): Map<String, Any?> {
    if (months.isEmpty() || months.size > 12 || days < 0) return err("invalid_input")
    if (months.any { it < 1 }) return err("invalid_input")
    val d = try {
        LocalDate.parse(start)
    } catch (e: DateTimeParseException) {
        return err("invalid_input")
    }
    val limit = capFor(d) ?: return err("out_of_range")
    if (days > 549 || months.any { it > 1390000 }) return err("out_of_range")

    val avg = months.average()
    val capped = months.size < 12 && avg > limit
    val base = if (capped) limit.toDouble() else avg
    val standardDaily = (base / 30 / 10).roundToLong() * 10
    val daily = (standardDaily * 2 / 3.0).roundToLong()
    return linkedMapOf(
        "standard_daily" to standardDaily,
        "daily" to daily,
        "total" to daily * days,
        "capped" to capped,
    )
}

// 傷病手当金（1日あたりの金額と総額）。
// v2: 平均を Double にせず、合計 S と月数 n の整数で持つ。標準報酬日額 = (S ÷ n ÷ 30) を10円単位に四捨五入
// = floor((S + 150n) ÷ 300n) × 10、日額 = floor((4 × 標準報酬日額 + 3) ÷ 6)（どちらも 0.5 ちょうどは大きい方へ）。
// 上限との比較も S > 上限 × n の整数で比べる。支給開始日は Date にせず、数字4・2・2桁の形と、月 1〜12・日 1〜その月の日数
// （うるう年を含む）を確かめ、上限の期間は "YYYY-MM-DD" の文字列のまま比べる（この形なら文字列の順が日付の順）。
// v1 は DateFormatter（"yyyy-MM-dd"）が c017 の "2025-6-1" を 1桁の月・日のまま読んでしまい、invalid_input にならなかった（23件中22件）。
// 計算は Double でも合っていた（300,750 ÷ 30 ÷ 10 = 1002.5 は Double で正確に表せ、rounded() は 0.5 を0から遠い方へ丸める）。

private let monthMax = 1_390_000
private let daysMax = 549
private let caps: [(from: String, to: String, cap: Int)] = [
    ("2024-04-01", "2025-03-31", 300_000),
    ("2025-04-01", "2026-03-31", 320_000),
    ("2026-04-01", "2027-03-31", 320_000),
]

private func isLeap(_ y: Int) -> Bool { y % 4 == 0 && (y % 100 != 0 || y % 400 == 0) }

private func daysInMonth(_ y: Int, _ m: Int) -> Int {
    switch m {
    case 2: return isLeap(y) ? 29 : 28
    case 4, 6, 9, 11: return 30
    default: return 31
    }
}

/// "YYYY-MM-DD" の形で、実在する日付なら true
private func isValidDate(_ s: String) -> Bool {
    let p = s.split(separator: "-", omittingEmptySubsequences: false)
    guard p.count == 3, zip(p, [4, 2, 2]).allSatisfy({ part, w in
        part.count == w && part.allSatisfy { $0.isASCII && $0.isNumber }
    }) else { return false }
    let (y, m, d) = (Int(p[0])!, Int(p[1])!, Int(p[2])!)
    return (1...12).contains(m) && d >= 1 && d <= daysInMonth(y, m)
}

func allowance(months: [Int], start: String, days: Int) -> [String: Any] {
    if months.isEmpty || months.count > 12 || months.contains(where: { $0 < 1 }) || !isValidDate(start) || days < 0 {
        return ["error": "invalid_input"]
    }
    guard let limit = caps.first(where: { $0.from <= start && start <= $0.to })?.cap else {
        return ["error": "out_of_range"]
    }
    if months.contains(where: { $0 > monthMax }) || days > daysMax {
        return ["error": "out_of_range"]
    }
    var (sum, n) = (months.reduce(0, +), months.count)
    let capped = n < 12 && sum > limit * n
    if capped {
        (sum, n) = (limit, 1)
    }
    let std = (sum + 150 * n) / (300 * n) * 10
    let daily = (4 * std + 3) / 6
    return [
        "standard_daily": std,
        "daily": daily,
        "total": daily * days,
        "capped": capped,
    ]
}

// ランナー規約（標準入力の JSON → 標準出力の JSON）の共通部分。どの spec でも同じ内容。
// ロジックは別ファイル。spec ごとの「入力を読んで呼ぶ」部分は main.swift に書く。
//
// Swift は Int のあふれ・配列の範囲外・強制アンラップの失敗でプロセスごと止まり（trap）、
// 言語の中では受け止められない。1件の失敗で全体を落とさないため、ケースは子プロセス
// （自分自身を --child で起動）で回し、子が止まったらそのケースを error にして残りを続ける。
import Foundation

struct Failure: Error, CustomStringConvertible {
    let description: String
    init(_ message: String) { description = message }
}

typealias Input = [String: Any]

extension Dictionary where Key == String, Value == Any {
    func str(_ key: String) throws -> String {
        guard let v = self[key] as? String else { throw Failure("\(key) がありません（文字列）") }
        return v
    }

    func int(_ key: String) throws -> Int {
        // JSONSerialization の数は NSNumber。as? Int は整数で表せるときだけ成功する（1.5 は nil）
        guard let v = self[key] as? Int else {
            throw Failure("\(key) がありません（整数）")
        }
        return v
    }
}

/// Swift の nil を JSON の null にする
func orNull(_ v: Any?) -> Any { v ?? NSNull() }

// コンパイラの版（#if swift(...) は言語モードの版で、swiftc の既定では Swift 5 になるので使わない）
private let runtimeName: String = {
    #if compiler(>=6.5)
    return "Swift 6.5+"
    #elseif compiler(>=6.4)
    return "Swift 6.4"
    #elseif compiler(>=6.3)
    return "Swift 6.3"
    #elseif compiler(>=6.2)
    return "Swift 6.2"
    #elseif compiler(>=6.1)
    return "Swift 6.1"
    #elseif compiler(>=6.0)
    return "Swift 6.0"
    #else
    return "Swift 5"
    #endif
}()

private func toJSON(_ v: Any) throws -> Data {
    try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes])
}

private func fail(_ message: String) -> Never {
    FileHandle.standardError.write(Data((message + "\n").utf8))
    exit(1)
}

/// 子プロセス: cases を順に回し、1件ごとに1行の JSON を書いてすぐ flush する
private func runChild(_ cases: [Input], _ calc: (Input) throws -> [String: Any]) {
    for c in cases {
        let id = c["id"] ?? NSNull()
        var r: [String: Any] = ["id": id]
        do {
            r["output"] = try calc(c["input"] as? Input ?? [:])
        } catch {
            r["error"] = "\(error)"
        }
        guard let line = try? toJSON(r) else { fail("結果を JSON にできません: \(id)") }
        FileHandle.standardOutput.write(line + Data("\n".utf8))
    }
}

private func signalName(_ s: Int32) -> String {
    switch s {
    case SIGTRAP, SIGILL: return "signal \(s)（trap。整数のあふれ・配列の範囲外・nil の強制アンラップなど）"
    case SIGABRT: return "signal \(s)（abort）"
    case SIGSEGV, SIGBUS: return "signal \(s)（不正なメモリ参照）"
    default: return "signal \(s)"
    }
}

/// 親プロセス:子に cases を渡し、子が途中で止まったら、止まったケースを error にして続きから回す
private func runParent(_ cases: [Input]) -> [Any] {
    let exe = URL(fileURLWithPath: CommandLine.arguments[0])
    var results: [Any] = []
    var rest = cases[...]
    while !rest.isEmpty {
        let p = Process()
        p.executableURL = exe
        p.arguments = ["--child"]
        let (inPipe, outPipe, errPipe) = (Pipe(), Pipe(), Pipe())
        p.standardInput = inPipe
        p.standardOutput = outPipe
        p.standardError = errPipe
        do { try p.run() } catch { fail("子プロセスを起動できません: \(error)") }

        var errData = Data()
        let group = DispatchGroup()
        group.enter()
        DispatchQueue.global().async {
            errData = errPipe.fileHandleForReading.readDataToEndOfFile()
            group.leave()
        }
        guard let payload = try? toJSON(["cases": Array(rest)]) else { fail("cases を JSON にできません") }
        inPipe.fileHandleForWriting.write(payload)
        try? inPipe.fileHandleForWriting.close()
        let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
        group.wait()
        p.waitUntilExit()

        let lines = outData.split(separator: UInt8(ascii: "\n"))
        for line in lines {
            guard let r = try? JSONSerialization.jsonObject(with: Data(line)) else { fail("子の出力を読めません") }
            results.append(r)
        }
        rest = rest.dropFirst(lines.count)
        if p.terminationReason == .exit && p.terminationStatus == 0 {
            if !rest.isEmpty { fail("子プロセスが途中で終わりました") }
            break
        }
        // 子が止まった: 次のケースが原因
        guard let crashed = rest.first else { fail("子プロセスが異常終了しました") }
        let stderrText = String(decoding: errData, as: UTF8.self)
        // -O ではあふれの trap はメッセージを出さず signal で止まる
        let reason = stderrText.split(separator: "\n").first { $0.contains("Fatal error") }
            .map(String.init)
            ?? (p.terminationReason == .uncaughtSignal ? signalName(p.terminationStatus) : "exit \(p.terminationStatus)")
        results.append(["id": crashed["id"] ?? NSNull(), "error": "クラッシュ（プロセスが停止）: \(reason)"])
        rest = rest.dropFirst()
    }
    return results
}

/// 標準入力の JSON を読み、cases をすべて calc に通して、標準出力に JSON を書く
func runCases(_ calc: (Input) throws -> [String: Any]) {
    let src = FileHandle.standardInput.readDataToEndOfFile()
    guard let req = (try? JSONSerialization.jsonObject(with: src)) as? Input,
          let cases = req["cases"] as? [Input] else { fail("入力の JSON を読めません") }
    if CommandLine.arguments.dropFirst().first == "--child" {
        runChild(cases, calc)
        return
    }
    let out: [String: Any] = [
        "spec": req["spec"] ?? NSNull(),
        "lang": "swift",
        "runtime": runtimeName,
        "results": runParent(cases),
    ]
    guard let data = try? toJSON(out) else { fail("結果を JSON にできません") }
    FileHandle.standardOutput.write(data + Data("\n".utf8))
}

// 傷病手当金（1日あたりの金額と総額）。
// v1: 平均を Double の sum / count で出し、÷30 の10円未満は (x / 10).rounded() * 10、× 2/3 は rounded() で四捨五入する。
// 支給開始日は DateFormatter（"yyyy-MM-dd"）で Date に読み、上限の期間も同じ DateFormatter で作った Date と比べる。
import Foundation

private let monthMax = 1_390_000
private let daysMax = 549
private let caps: [(from: String, to: String, cap: Double)] = [
    ("2024-04-01", "2025-03-31", 300_000),
    ("2025-04-01", "2026-03-31", 320_000),
    ("2026-04-01", "2027-03-31", 320_000),
]

private let formatter: DateFormatter = {
    let f = DateFormatter()
    f.dateFormat = "yyyy-MM-dd"
    f.locale = Locale(identifier: "en_US_POSIX")
    return f
}()

func allowance(months: [Int], start: String, days: Int) -> [String: Any] {
    let date = formatter.date(from: start)
    if months.isEmpty || months.count > 12 || months.contains(where: { $0 < 1 }) || date == nil || days < 0 {
        return ["error": "invalid_input"]
    }
    let limit = caps.first { c in
        formatter.date(from: c.from)! <= date! && date! <= formatter.date(from: c.to)!
    }?.cap
    guard let limit else { return ["error": "out_of_range"] }
    if months.contains(where: { $0 > monthMax }) || days > daysMax {
        return ["error": "out_of_range"]
    }
    var avg = Double(months.reduce(0, +)) / Double(months.count)
    let capped = months.count < 12 && avg > limit
    if capped {
        avg = limit
    }
    let std = (avg / 30 / 10).rounded() * 10
    let daily = (std * 2 / 3).rounded()
    return [
        "standard_daily": Int(std),
        "daily": Int(daily),
        "total": Int(daily) * days,
        "capped": capped,
    ]
}

// ランナー規約（標準入力の JSON → 標準出力の JSON）の共通部分。どの spec でも同じ内容。
// ロジックは別ファイル。spec ごとの「入力を読んで呼ぶ」部分は main.swift に書く。
//
// Swift は Int のあふれ・配列の範囲外・強制アンラップの失敗でプロセスごと止まり（trap）、
// 言語の中では受け止められない。1件の失敗で全体を落とさないため、ケースは子プロセス
// （自分自身を --child で起動）で回し、子が止まったらそのケースを error にして残りを続ける。
import Foundation

struct Failure: Error, CustomStringConvertible {
    let description: String
    init(_ message: String) { description = message }
}

typealias Input = [String: Any]

extension Dictionary where Key == String, Value == Any {
    func str(_ key: String) throws -> String {
        guard let v = self[key] as? String else { throw Failure("\(key) がありません（文字列）") }
        return v
    }

    func int(_ key: String) throws -> Int {
        // JSONSerialization の数は NSNumber。as? Int は整数で表せるときだけ成功する（1.5 は nil）
        guard let v = self[key] as? Int else {
            throw Failure("\(key) がありません（整数）")
        }
        return v
    }
}

/// Swift の nil を JSON の null にする
func orNull(_ v: Any?) -> Any { v ?? NSNull() }

// コンパイラの版（#if swift(...) は言語モードの版で、swiftc の既定では Swift 5 になるので使わない）
private let runtimeName: String = {
    #if compiler(>=6.5)
    return "Swift 6.5+"
    #elseif compiler(>=6.4)
    return "Swift 6.4"
    #elseif compiler(>=6.3)
    return "Swift 6.3"
    #elseif compiler(>=6.2)
    return "Swift 6.2"
    #elseif compiler(>=6.1)
    return "Swift 6.1"
    #elseif compiler(>=6.0)
    return "Swift 6.0"
    #else
    return "Swift 5"
    #endif
}()

private func toJSON(_ v: Any) throws -> Data {
    try JSONSerialization.data(withJSONObject: v, options: [.withoutEscapingSlashes])
}

private func fail(_ message: String) -> Never {
    FileHandle.standardError.write(Data((message + "\n").utf8))
    exit(1)
}

/// 子プロセス: cases を順に回し、1件ごとに1行の JSON を書いてすぐ flush する
private func runChild(_ cases: [Input], _ calc: (Input) throws -> [String: Any]) {
    for c in cases {
        let id = c["id"] ?? NSNull()
        var r: [String: Any] = ["id": id]
        do {
            r["output"] = try calc(c["input"] as? Input ?? [:])
        } catch {
            r["error"] = "\(error)"
        }
        guard let line = try? toJSON(r) else { fail("結果を JSON にできません: \(id)") }
        FileHandle.standardOutput.write(line + Data("\n".utf8))
    }
}

private func signalName(_ s: Int32) -> String {
    switch s {
    case SIGTRAP, SIGILL: return "signal \(s)（trap。整数のあふれ・配列の範囲外・nil の強制アンラップなど）"
    case SIGABRT: return "signal \(s)（abort）"
    case SIGSEGV, SIGBUS: return "signal \(s)（不正なメモリ参照）"
    default: return "signal \(s)"
    }
}

/// 親プロセス:子に cases を渡し、子が途中で止まったら、止まったケースを error にして続きから回す
private func runParent(_ cases: [Input]) -> [Any] {
    let exe = URL(fileURLWithPath: CommandLine.arguments[0])
    var results: [Any] = []
    var rest = cases[...]
    while !rest.isEmpty {
        let p = Process()
        p.executableURL = exe
        p.arguments = ["--child"]
        let (inPipe, outPipe, errPipe) = (Pipe(), Pipe(), Pipe())
        p.standardInput = inPipe
        p.standardOutput = outPipe
        p.standardError = errPipe
        do { try p.run() } catch { fail("子プロセスを起動できません: \(error)") }

        var errData = Data()
        let group = DispatchGroup()
        group.enter()
        DispatchQueue.global().async {
            errData = errPipe.fileHandleForReading.readDataToEndOfFile()
            group.leave()
        }
        guard let payload = try? toJSON(["cases": Array(rest)]) else { fail("cases を JSON にできません") }
        inPipe.fileHandleForWriting.write(payload)
        try? inPipe.fileHandleForWriting.close()
        let outData = outPipe.fileHandleForReading.readDataToEndOfFile()
        group.wait()
        p.waitUntilExit()

        let lines = outData.split(separator: UInt8(ascii: "\n"))
        for line in lines {
            guard let r = try? JSONSerialization.jsonObject(with: Data(line)) else { fail("子の出力を読めません") }
            results.append(r)
        }
        rest = rest.dropFirst(lines.count)
        if p.terminationReason == .exit && p.terminationStatus == 0 {
            if !rest.isEmpty { fail("子プロセスが途中で終わりました") }
            break
        }
        // 子が止まった: 次のケースが原因
        guard let crashed = rest.first else { fail("子プロセスが異常終了しました") }
        let stderrText = String(decoding: errData, as: UTF8.self)
        // -O ではあふれの trap はメッセージを出さず signal で止まる
        let reason = stderrText.split(separator: "\n").first { $0.contains("Fatal error") }
            .map(String.init)
            ?? (p.terminationReason == .uncaughtSignal ? signalName(p.terminationStatus) : "exit \(p.terminationStatus)")
        results.append(["id": crashed["id"] ?? NSNull(), "error": "クラッシュ（プロセスが停止）: \(reason)"])
        rest = rest.dropFirst()
    }
    return results
}

/// 標準入力の JSON を読み、cases をすべて calc に通して、標準出力に JSON を書く
func runCases(_ calc: (Input) throws -> [String: Any]) {
    let src = FileHandle.standardInput.readDataToEndOfFile()
    guard let req = (try? JSONSerialization.jsonObject(with: src)) as? Input,
          let cases = req["cases"] as? [Input] else { fail("入力の JSON を読めません") }
    if CommandLine.arguments.dropFirst().first == "--child" {
        runChild(cases, calc)
        return
    }
    let out: [String: Any] = [
        "spec": req["spec"] ?? NSNull(),
        "lang": "swift",
        "runtime": runtimeName,
        "results": runParent(cases),
    ]
    guard let data = try? toJSON(out) else { fail("結果を JSON にできません") }
    FileHandle.standardOutput.write(data + Data("\n".utf8))
}