洗濯洗剤・柔軟剤の量

<?php
declare(strict_types=1);

/**
 * 洗濯洗剤・柔軟剤の量。
 * v2: 値を float に読まず、10^桁数 倍した整数（分子）と 10^桁数（分母）の組として10進のまま読む。
 * 水量 ÷ 基準の水量 × 基準の量 を分子・分母の整数の掛け算で正確な比にして、小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
 * float だと 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、v1 の round($x, 1) は 8.2 を返した（PHP 8.4.4）。
 * 整数が PHP_INT_MAX を超えると float になるが、strict_types なので int の引数に渡したところで TypeError になり、黙って誤差の入った値は返さない。
 */
const DECIMAL = '/\A[0-9]+(\.[0-9]+)?\z/';
const WATER_PER_KG = ['top' => 10, 'drum' => 6];

/** "2.5" → [25, 10]（値 = 分子 ÷ 分母）。読めなければ null */
function readValue(mixed $s): ?array
{
    if (!is_string($s) || !preg_match(DECIMAL, $s)) {
        return null;
    }
    [$int, $frac] = array_pad(explode('.', $s), 2, '');
    $n = ltrim($int . $frac, '0');
    if (strlen($n) > 18 || strlen($frac) > 18) {
        throw new RangeException('too many digits'); // int（64ビット）に入りきらない
    }
    return [(int) $n, 10 ** strlen($frac)];
}

/** 分子 ÷ 分母（どちらも 0 以上・分母は正）を小数第1位に四捨五入して "8.3"・"15" の形にする */
function fmt1(int $num, int $den): string
{
    $tenths = intdiv(2 * 10 * $num + $den, 2 * $den); // floor(num × 10 ÷ den + 1/2)
    return $tenths % 10 === 0 ? (string) intdiv($tenths, 10) : intdiv($tenths, 10) . '.' . $tenths % 10;
}

/** @param array{int, int} $water */
function amount(array $water, mixed $refWater, mixed $refAmount): ?string
{
    $rw = readValue($refWater);
    $ra = readValue($refAmount);
    if ($rw === null || $ra === null || $rw[0] === 0) {
        return null; // 基準が読めない・0 以下 → 量は出さない
    }
    // (w.n / w.d) ÷ (rw.n / rw.d) × (ra.n / ra.d)
    return fmt1($water[0] * $rw[1] * $ra[0], $water[1] * $rw[0] * $ra[1]);
}

/** @param array{basis: string, value: string, ref_water: string, ref_amount: string, machine?: string, soft_water?: string, soft_amount?: string} $in */
function laundry(array $in): array
{
    $machine = $in['machine'] ?? 'top';
    $v = readValue($in['value'] ?? null);
    if ($v === null || $v[0] === 0 || !in_array($in['basis'] ?? null, ['water', 'weight'], true) || !isset(WATER_PER_KG[$machine])) {
        return ['error' => 'invalid_input'];
    }
    $water = $in['basis'] === 'water' ? $v : [$v[0] * WATER_PER_KG[$machine], $v[1]];
    $softener = isset($in['soft_water']) ? amount($water, $in['soft_water'], $in['soft_amount'] ?? null) : null;
    return [
        'water_l' => fmt1($water[0], $water[1]),
        'detergent' => amount($water, $in['ref_water'] ?? null, $in['ref_amount'] ?? null),
        'softener' => $softener,
    ];
}

<?php
declare(strict_types=1);

/**
 * 洗濯洗剤・柔軟剤の量。
 * v1: 元ツールと同じく値を float に読み、水量 ÷ 基準の水量 × 基準の量 を float のまま計算して、round($x, 1) で丸める素直な書き方。
 * 小数第1位が 0 なら整数で書く。
 */
const WATER_PER_KG = ['top' => 10, 'drum' => 6];

function fmt1(float $x): string
{
    $r = round($x, 1);
    return $r == floor($r) ? (string) (int) $r : (string) $r;
}

function amount(float $water, mixed $refWater, mixed $refAmount): ?string
{
    if (!is_numeric($refWater) || !is_numeric($refAmount) || (float) $refWater <= 0) {
        return null; // 基準が読めない・0 以下 → 量は出さない
    }
    return fmt1($water / (float) $refWater * (float) $refAmount);
}

/** @param array{basis: string, value: string, ref_water: string, ref_amount: string, machine?: string, soft_water?: string, soft_amount?: string} $in */
function laundry(array $in): array
{
    $machine = $in['machine'] ?? 'top';
    if (!is_numeric($in['value']) || !in_array($in['basis'], ['water', 'weight'], true) || !isset(WATER_PER_KG[$machine])) {
        return ['error' => 'invalid_input'];
    }
    $v = (float) $in['value'];
    if ($v <= 0) {
        return ['error' => 'invalid_input'];
    }
    $water = $in['basis'] === 'water' ? $v : $v * WATER_PER_KG[$machine];
    $softener = isset($in['soft_water']) ? amount($water, $in['soft_water'], $in['soft_amount'] ?? null) : null;
    return ['water_l' => fmt1($water), 'detergent' => amount($water, $in['ref_water'], $in['ref_amount']), 'softener' => $softener];
}

"""洗濯洗剤・柔軟剤の量。

v2: 値を fractions.Fraction で10進のまま読み、水量 ÷ 基準の水量 × 基準の量 を正確な分数で計算して、
小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
float だと 13.2 ÷ 40 × 25 が 8.2499999999999982 になって 8.2 に落ち、round(x, 1) は偶数丸めなので
2進数で正確に入る 1.25・6.25 も 1.2・6.2 にする。
"""
import re
from fractions import Fraction

DECIMAL = re.compile(r"[0-9]+(\.[0-9]+)?")
WATER_PER_KG = {"top": 10, "drum": 6}


def read_value(s):
    """10進の数の文字列を正確な分数に。読めなければ None（float() と違い "1e3"・" 4"・"nan"・"-1" も読まない）"""
    if not isinstance(s, str) or not DECIMAL.fullmatch(s):
        return None
    return Fraction(s)


def fmt1(x):
    """0 以上の x を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）。小数第1位が 0 なら整数で書く"""
    t = (x * 10 + Fraction(1, 2)).__floor__()
    return str(t // 10) if t % 10 == 0 else f"{t // 10}.{t % 10}"


def amount(water, ref_water, ref_amount):
    rw, ra = read_value(ref_water), read_value(ref_amount)
    if rw is None or ra is None or rw <= 0:
        return None  # 基準が読めない・0 以下 → 量は出さない
    return fmt1(water / rw * ra)


def laundry(basis, value, ref_water, ref_amount, machine="top", soft_water=None, soft_amount=None):
    v = read_value(value)
    if v is None or v <= 0 or basis not in ("water", "weight") or machine not in WATER_PER_KG:
        return {"error": "invalid_input"}
    water = v if basis == "water" else v * WATER_PER_KG[machine]
    softener = amount(water, soft_water, soft_amount) if soft_water is not None else None
    return {"water_l": fmt1(water), "detergent": amount(water, ref_water, ref_amount), "softener": softener}

"""洗濯洗剤・柔軟剤の量。

v1: 元ツールと同じく値を float に読み、水量 ÷ 基準の水量 × 基準の量 を float のまま計算して、round(x, 1) で丸める素直な書き方。
小数第1位が 0 なら整数で書く。
"""
WATER_PER_KG = {"top": 10, "drum": 6}


def to_float(s):
    try:
        return float(s)
    except (TypeError, ValueError):
        return None


def fmt1(x):
    r = round(x, 1)
    return str(int(r)) if r.is_integer() else str(r)


def amount(water, ref_water, ref_amount):
    rw, ra = to_float(ref_water), to_float(ref_amount)
    if rw is None or ra is None or rw <= 0:
        return None  # 基準が読めない・0 以下 → 量は出さない
    return fmt1(water / rw * ra)


def laundry(basis, value, ref_water, ref_amount, machine="top", soft_water=None, soft_amount=None):
    v = to_float(value)
    if v is None or v <= 0 or basis not in ("water", "weight") or machine not in WATER_PER_KG:
        return {"error": "invalid_input"}
    water = v if basis == "water" else v * WATER_PER_KG[machine]
    softener = amount(water, soft_water, soft_amount) if soft_water is not None else None
    return {"water_l": fmt1(water), "detergent": amount(water, ref_water, ref_amount), "softener": softener}

package main

import (
	"fmt"
	"math/big"
	"regexp"
)

// v2: 値を float64 に読まず、big.Rat（正確な分数）で10進のまま読む。水量 ÷ 基準の水量 × 基準の量 を分数のまま計算して、
// 小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
// float64 だと 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、math.Round(x*10)/10 で 8.2 に落ちる。
// big.Rat の SetString は "1e3"・"1/2" も読むので、先に10進の数の形かを確かめる。

var decimal = regexp.MustCompile(`^[0-9]+(\.[0-9]+)?$`)

var waterPerKg = map[string]int64{"top": 10, "drum": 6}

// readValue は10進の数の文字列を正確な分数にする。読めなければ nil。
func readValue(s *string) *big.Rat {
	if s == nil || !decimal.MatchString(*s) {
		return nil
	}
	r, ok := new(big.Rat).SetString(*s)
	if !ok {
		return nil
	}
	return r
}

// fmt1 は 0 以上の x を小数第1位に四捨五入して "8.3"・"15" の形にする。
// 0.1 単位の数 = floor((2 × 分子 × 10 + 分母) ÷ (2 × 分母))。どちらも正なので Quo（0 の方への切り捨て）で足りる。
func fmt1(x *big.Rat) string {
	num := new(big.Int).Mul(x.Num(), big.NewInt(20))
	num.Add(num, x.Denom())
	den := new(big.Int).Mul(x.Denom(), big.NewInt(2))
	tenths := new(big.Int).Quo(num, den)
	q, r := new(big.Int).QuoRem(tenths, big.NewInt(10), new(big.Int))
	if r.Sign() == 0 {
		return q.String()
	}
	return fmt.Sprintf("%s.%s", q, r)
}

// amount は基準が読めない・基準の水量が 0 以下なら nil（JSON の null）を返す。
func amount(water *big.Rat, refWater, refAmount *string) any {
	rw, ra := readValue(refWater), readValue(refAmount)
	if rw == nil || ra == nil || rw.Sign() <= 0 {
		return nil
	}
	x := new(big.Rat).Quo(water, rw)
	return fmt1(x.Mul(x, ra))
}

func Laundry(basis string, value *string, machine string, refWater, refAmount, softWater, softAmount *string) map[string]any {
	if machine == "" {
		machine = "top"
	}
	perKg, ok := waterPerKg[machine]
	v := readValue(value)
	if v == nil || v.Sign() <= 0 || (basis != "water" && basis != "weight") || !ok {
		return map[string]any{"error": "invalid_input"}
	}
	water := v
	if basis == "weight" {
		water = new(big.Rat).Mul(v, new(big.Rat).SetInt64(perKg))
	}
	var softener any
	if softWater != nil {
		softener = amount(water, softWater, softAmount)
	}
	return map[string]any{"water_l": fmt1(water), "detergent": amount(water, refWater, refAmount), "softener": softener}
}

package main

import (
	"math"
	"strconv"
)

// v1: 元ツールと同じく値を float64 に読み、水量 ÷ 基準の水量 × 基準の量 を float64 のまま計算して、
// math.Round(x*10)/10 で丸める素直な書き方。小数第1位が 0 なら整数で書く。

var waterPerKg = map[string]float64{"top": 10, "drum": 6}

func fmt1(x float64) string {
	return strconv.FormatFloat(math.Round(x*10)/10, 'f', -1, 64)
}

// amount は基準が読めない・基準の水量が 0 以下なら nil（JSON の null）を返す。
func amount(water float64, refWater, refAmount *string) any {
	if refWater == nil || refAmount == nil {
		return nil
	}
	rw, err1 := strconv.ParseFloat(*refWater, 64)
	ra, err2 := strconv.ParseFloat(*refAmount, 64)
	if err1 != nil || err2 != nil || rw <= 0 {
		return nil
	}
	return fmt1(water / rw * ra)
}

func Laundry(basis, value, machine string, refWater, refAmount, softWater, softAmount *string) map[string]any {
	if machine == "" {
		machine = "top"
	}
	perKg, ok := waterPerKg[machine]
	v, err := strconv.ParseFloat(value, 64)
	if err != nil || v <= 0 || (basis != "water" && basis != "weight") || !ok {
		return map[string]any{"error": "invalid_input"}
	}
	water := v
	if basis == "weight" {
		water = v * perKg
	}
	var softener any
	if softWater != nil {
		softener = amount(water, softWater, softAmount)
	}
	return map[string]any{"water_l": fmt1(water), "detergent": amount(water, refWater, refAmount), "softener": softener}
}

// 洗濯洗剤・柔軟剤の量。
// v2: 値を Number に読まず、10^桁数 倍した BigInt（分子）と 10^桁数（分母）の組として10進のまま読む。
// 水量 ÷ 基準の水量 × 基準の量 を BigInt の掛け算で正確な比にして、小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
// Number だと 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、Math.round(x * 10) / 10 で 8.2 に落ちる。

const DECIMAL = /^[0-9]+(\.[0-9]+)?$/;
const WATER_PER_KG = { top: 10n, drum: 6n };

/** "2.5" → { n: 25n, d: 10n }（値 = n ÷ d）。読めなければ null（parseFloat と違い "4abc"・"1e3"・"-1" も読まない） */
function readValue(s) {
  if (typeof s !== "string" || !DECIMAL.test(s)) return null;
  const [int, frac = ""] = s.split(".");
  return { n: BigInt(int + frac), d: 10n ** BigInt(frac.length) };
}

/**
 * n ÷ d（0 以上・d は正）を小数第1位に四捨五入して "8.3"・"15" の形にする。
 * 0.1 単位の数 = floor((20 × n + d) ÷ (2 × d))。BigInt の割り算は正の数なら切り捨て
 */
function fmt1({ n, d }) {
  const tenths = (20n * n + d) / (2n * d);
  return tenths % 10n === 0n ? `${tenths / 10n}` : `${tenths / 10n}.${tenths % 10n}`;
}

function amount(water, refWater, refAmount) {
  const rw = readValue(refWater);
  const ra = readValue(refAmount);
  if (rw === null || ra === null || rw.n === 0n) return null; // 基準が読めない・0 以下 → 量は出さない
  // (w.n / w.d) ÷ (rw.n / rw.d) × (ra.n / ra.d)
  return fmt1({ n: water.n * rw.d * ra.n, d: water.d * rw.n * ra.d });
}

export function laundry({ basis, value, machine = "top", ref_water, ref_amount, soft_water, soft_amount }) {
  const v = readValue(value);
  if (v === null || v.n === 0n || !["water", "weight"].includes(basis) || !Object.hasOwn(WATER_PER_KG, machine)) {
    return { error: "invalid_input" };
  }
  const water = basis === "water" ? v : { n: v.n * WATER_PER_KG[machine], d: v.d };
  const softener = soft_water !== undefined && soft_water !== null ? amount(water, soft_water, soft_amount) : null;
  return { water_l: fmt1(water), detergent: amount(water, ref_water, ref_amount), softener };
}

// 洗濯洗剤・柔軟剤の量。
// v1: 元ツールと同じく値を parseFloat で Number に読み、水量 ÷ 基準の水量 × 基準の量 を Number のまま計算して、
// Math.round(x * 10) / 10 で丸める素直な書き方。String() は小数第1位が 0 なら整数で書く。

const WATER_PER_KG = { top: 10, drum: 6 };

const fmt1 = (x) => String(Math.round(x * 10) / 10);

function amount(water, refWater, refAmount) {
  const rw = parseFloat(refWater);
  const ra = parseFloat(refAmount);
  if (isNaN(rw) || isNaN(ra) || !(rw > 0)) return null; // 基準が読めない・0 以下 → 量は出さない
  return fmt1((water / rw) * ra);
}

export function laundry({ basis, value, machine = "top", ref_water, ref_amount, soft_water, soft_amount }) {
  const v = parseFloat(value);
  if (isNaN(v) || !(v > 0) || !["water", "weight"].includes(basis) || !(machine in WATER_PER_KG)) return { error: "invalid_input" };
  const water = basis === "water" ? v : v * WATER_PER_KG[machine];
  const softener = soft_water !== undefined ? amount(water, soft_water, soft_amount) : null;
  return { water_l: fmt1(water), detergent: amount(water, ref_water, ref_amount), softener };
}

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * 洗濯洗剤・柔軟剤の量。
 * v2: double を使わない。入力の10進の文字列を BigDecimal で正確に読み、水量 × 基準の量 ÷ 基準の水量 を
 * divide(…, 1, HALF_UP) で「正確な商」から小数第1位に四捨五入する（0.5 ちょうどは大きい方へ）。
 * v1 は double で 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、Math.round(x * 10) / 10.0 で 8.3 が 8.2 になっていた（11.6L の 7.25 も同じ）。
 * Double.parseDouble は "1e2"・"NaN"・" 45" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
 */
public final class Laundry {
    private Laundry() {}

    static final Map<String, BigDecimal> WATER_PER_KG = Map.of("top", BigDecimal.TEN, "drum", BigDecimal.valueOf(6)); // 1kg あたりの水（L）
    static final Pattern DECIMAL = Pattern.compile("[0-9]+(\\.[0-9]+)?");

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

    /** 10進の数の文字列を正確に読む。形が違えば null */
    static BigDecimal dec(String s) {
        return s != null && DECIMAL.matcher(s).matches() ? new BigDecimal(s) : null;
    }

    /** 小数第1位に丸めた値を書く（小数第1位が 0 なら整数で） */
    static String fmt(BigDecimal rounded) {
        return rounded.stripTrailingZeros().toPlainString();
    }

    /** 必要量 = 水量 × 基準の量 ÷ 基準の水量（基準が読めない・基準の水量が 0 以下なら null） */
    static String amount(BigDecimal water, String refWater, String refAmount) {
        BigDecimal rw = dec(refWater), ra = dec(refAmount);
        if (rw == null || ra == null || rw.signum() <= 0) return null;
        return fmt(water.multiply(ra).divide(rw, 1, RoundingMode.HALF_UP));
    }

    public static Map<String, Object> calc(String basis, String value, String machine, String refWater, String refAmount,
                                           String softWater, String softAmount) {
        BigDecimal v = dec(value);
        if (v == null || v.signum() <= 0) return error();
        BigDecimal perKg = WATER_PER_KG.get(machine == null ? "top" : machine);
        if (perKg == null) return error();

        BigDecimal water;
        switch (basis) {
            case "water" -> water = v;
            case "weight" -> water = v.multiply(perKg);
            default -> {
                return error();
            }
        }

        Map<String, Object> out = new LinkedHashMap<>();
        out.put("water_l", fmt(water.setScale(1, RoundingMode.HALF_UP)));
        out.put("detergent", amount(water, refWater, refAmount));
        out.put("softener", softWater == null ? null : amount(water, softWater, softAmount));
        return out;
    }
}

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 洗濯洗剤・柔軟剤の量。
 * v1: 元ツール（app.js）と同じ考え方を、Java でいちばん普通に書いた形。double に読み、水量 ÷ 基準の水量 × 基準の量 を計算し、
 * Math.round(x * 10) / 10.0 で小数第1位に丸める。
 */
public final class Laundry {
    private Laundry() {}

    static final Map<String, Double> WATER_PER_KG = Map.of("top", 10.0, "drum", 6.0); // 1kg あたりの水（L）

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

    /** 小数第1位まで（小数第1位が 0 なら整数で） */
    static String fmt(double x) {
        double r = Math.round(x * 10) / 10.0;
        return r == Math.floor(r) ? String.valueOf((long) r) : String.valueOf(r);
    }

    /** 必要量 = 水量 ÷ 基準の水量 × 基準の量（基準が読めない・基準の水量が 0 以下なら null） */
    static String amount(double water, String refWater, String refAmount) {
        if (refWater == null || refAmount == null) return null;
        double rw, ra;
        try {
            rw = Double.parseDouble(refWater);
            ra = Double.parseDouble(refAmount);
        } catch (NumberFormatException e) {
            return null;
        }
        if (rw <= 0) return null;
        return fmt(water / rw * ra);
    }

    public static Map<String, Object> calc(String basis, String value, String machine, String refWater, String refAmount,
                                           String softWater, String softAmount) {
        double v;
        try {
            v = Double.parseDouble(value);
        } catch (NumberFormatException e) {
            return error();
        }
        if (v <= 0) return error();
        Double perKg = WATER_PER_KG.get(machine == null ? "top" : machine);
        if (perKg == null) return error();

        double water;
        switch (basis) {
            case "water" -> water = v;
            case "weight" -> water = v * perKg;
            default -> {
                return error();
            }
        }

        Map<String, Object> out = new LinkedHashMap<>();
        out.put("water_l", fmt(water));
        out.put("detergent", amount(water, refWater, refAmount));
        out.put("softener", softWater == null ? null : amount(water, softWater, softAmount));
        return out;
    }
}

// 洗濯洗剤・柔軟剤の量。
// v2: double を使わない。入力の10進の文字列を decimal で正確に読み、水量 × 基準の量（正確）を基準の水量で割って
// 小数第1位に四捨五入する（0.5 ちょうどは大きい方へ＝MidpointRounding.AwayFromZero と同じ）。
// decimal の割り算は商を有効数字28〜29桁に丸めるので、その丸めで境目をまたがないよう、0.1 単位の商を整数で出し、
// 余りを基準の水量の半分と比べて繰り上げる（余りの計算は掛け算と引き算だけで、decimal の中で正確）。
// v1 は double で 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、さらに Math.Round(x, 1) の既定は偶数丸めなので 1.25 → 1.2、6.25 → 6.2 になっていた。
// double.TryParse は "1e2"・"NaN"・" 45" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
using System.Globalization;
using System.Text.RegularExpressions;

public static class Laundry
{
    static readonly Dictionary<string, decimal> WaterPerKg = new() { ["top"] = 10m, ["drum"] = 6m }; // 1kg あたりの水（L）
    static readonly Regex Decimal = new(@"^[0-9]+(\.[0-9]+)?\z", RegexOptions.CultureInvariant);

    static Dictionary<string, object?> Invalid() => new() { ["error"] = "invalid_input" };

    // 10進の数の文字列を正確に読む。形が違えば null。decimal に正確に入らない桁数（28桁超）は黙って丸めず例外にする
    static decimal? Dec(string? s)
    {
        if (s == null || !Decimal.IsMatch(s)) return null;
        if (s.Count(char.IsAsciiDigit) > 28) throw new OverflowException($"桁が多すぎます: {s}");
        return decimal.Parse(s, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
    }

    // a ÷ b（a ≥ 0・b > 0）を 0.1 単位に四捨五入し、0.1 を 1 とした整数で返す
    static decimal TenthsHalfUp(decimal a, decimal b)
    {
        decimal num = a * 10; // 正確（あふれれば OverflowException）
        decimal q = Math.Floor(num / b);
        decimal r = num - q * b; // 商の丸めで q が 1 ずれていても r で直す
        while (r < 0) { q -= 1; r += b; }
        while (r >= b) { q += 1; r -= b; }
        return r * 2 >= b ? q + 1 : q;
    }

    // 0.1 を 1 とした整数を書く（小数第1位が 0 なら整数で）
    static string Fmt(decimal tenths)
    {
        decimal i = Math.Floor(tenths / 10), f = tenths - i * 10;
        return f == 0 ? i.ToString(CultureInfo.InvariantCulture) : $"{i.ToString(CultureInfo.InvariantCulture)}.{f.ToString(CultureInfo.InvariantCulture)}";
    }

    // 必要量 = 水量 × 基準の量 ÷ 基準の水量（基準が読めない・基準の水量が 0 以下なら null）
    static string? Amount(decimal water, string? refWater, string? refAmount)
    {
        if (Dec(refWater) is not decimal rw || Dec(refAmount) is not decimal ra || rw <= 0) return null;
        return Fmt(TenthsHalfUp(water * ra, rw));
    }

    public static Dictionary<string, object?> Calc(string basis, string value, string? machine, string? refWater, string? refAmount,
        string? softWater, string? softAmount)
    {
        if (Dec(value) is not decimal v || v <= 0) return Invalid();
        if (!WaterPerKg.TryGetValue(machine ?? "top", out var perKg)) return Invalid();
        decimal water;
        switch (basis)
        {
            case "water": water = v; break;
            case "weight": water = v * perKg; break;
            default: return Invalid();
        }
        return new()
        {
            ["water_l"] = Fmt(TenthsHalfUp(water, 1)),
            ["detergent"] = Amount(water, refWater, refAmount),
            ["softener"] = softWater == null ? null : Amount(water, softWater, softAmount),
        };
    }
}

// 洗濯洗剤・柔軟剤の量。
// v1: 元ツール（app.js）と同じ考え方を、C# でいちばん普通に書いた形。double に読み、水量 ÷ 基準の水量 × 基準の量 を計算し、
// Math.Round(x, 1) で小数第1位に丸める。

public static class Laundry
{
    static readonly Dictionary<string, double> WaterPerKg = new() { ["top"] = 10, ["drum"] = 6 }; // 1kg あたりの水（L）

    static Dictionary<string, object?> Invalid() => new() { ["error"] = "invalid_input" };

    // 小数第1位まで（小数第1位が 0 なら整数で。double.ToString() は 15 を "15" と書く）
    static string Fmt(double x) => Math.Round(x, 1).ToString();

    // 必要量 = 水量 ÷ 基準の水量 × 基準の量（基準が読めない・基準の水量が 0 以下なら null）
    static string? Amount(double water, string? refWater, string? refAmount)
    {
        if (!double.TryParse(refWater, out var rw) || !double.TryParse(refAmount, out var ra)) return null;
        if (rw <= 0) return null;
        return Fmt(water / rw * ra);
    }

    public static Dictionary<string, object?> Calc(string basis, string value, string? machine, string? refWater, string? refAmount,
        string? softWater, string? softAmount)
    {
        if (!double.TryParse(value, out var v) || v <= 0) return Invalid();
        if (!WaterPerKg.TryGetValue(machine ?? "top", out var perKg)) return Invalid();
        double water;
        switch (basis)
        {
            case "water": water = v; break;
            case "weight": water = v * perKg; break;
            default: return Invalid();
        }
        return new()
        {
            ["water_l"] = Fmt(water),
            ["detergent"] = Amount(water, refWater, refAmount),
            ["softener"] = softWater == null ? null : Amount(water, softWater, softAmount),
        };
    }
}

//! 洗濯洗剤・柔軟剤の量。
//! v2: f64 を使わない。入力の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、水量・必要量を分数 p / q（整数）で持つ。
//! 小数第1位への四捨五入は p × 10 ÷ q の余りが半分以上なら繰り上げる（0.5 ちょうどは大きい方へ）。
//! v1 は f64 で 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、(x * 10.0).round() で 8.3 が 8.2 になっていた（11.6L の 7.25 も同じ）。
//! parse::<f64>() は "1e2"・"inf"・"NaN" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。

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

const OVERFLOW: &str = "桁あふれ";

/// 1kg あたりの水（L）
fn water_per_kg(machine: &str) -> Option<u128> {
    match machine {
        "top" => Some(10),
        "drum" => Some(6),
        _ => None,
    }
}

/// 10進の数の文字列を (整数, 10^小数の桁数) に。形が違えば None。桁が u128 に収まらなければ Err
fn dec(text: &str) -> Result<Option<(u128, u128)>, String> {
    let (int_part, frac_part) = match text.split_once('.') { Some((i, f)) => (i, Some(f)), None => (text, None) };
    let digits = |p: &str| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit());
    if !digits(int_part) || frac_part.is_some_and(|f| !digits(f)) {
        return Ok(None);
    }
    let frac = frac_part.unwrap_or("");
    let mut v: u128 = 0;
    for b in int_part.bytes().chain(frac.bytes()) {
        v = v.checked_mul(10).and_then(|x| x.checked_add((b - b'0') as u128)).ok_or(OVERFLOW)?;
    }
    let scale = 10u128.checked_pow(frac.len() as u32).ok_or(OVERFLOW)?;
    Ok(Some((v, scale)))
}

fn mul(a: u128, b: u128) -> Result<u128, String> {
    a.checked_mul(b).ok_or(OVERFLOW.into())
}

/// p ÷ q（p ≥ 0・q > 0）を小数第1位に四捨五入して書く（小数第1位が 0 なら整数で）
fn fmt1(p: u128, q: u128) -> Result<String, String> {
    let a = mul(p, 10)?;
    let (t, r) = (a / q, a % q);
    let tenths = if r >= q - r { t + 1 } else { t }; // 余り × 2 ≥ q（× 2 であふれないよう引き算で比べる）
    Ok(if tenths % 10 == 0 { format!("{}", tenths / 10) } else { format!("{}.{}", tenths / 10, tenths % 10) })
}

/// 必要量 = 水量 × 基準の量 ÷ 基準の水量（基準が読めない・基準の水量が 0 以下なら null）
fn amount((wp, wq): (u128, u128), ref_water: Option<&str>, ref_amount: Option<&str>) -> Result<Value, String> {
    let (Some(rw), Some(ra)) = (ref_water, ref_amount) else { return Ok(Value::Null) };
    let (Some((rwv, rws)), Some((rav, ras))) = (dec(rw)?, dec(ra)?) else { return Ok(Value::Null) };
    if rwv == 0 {
        return Ok(Value::Null);
    }
    // (wp/wq) × (rav/ras) ÷ (rwv/rws) = wp·rav·rws ÷ (wq·ras·rwv)
    Ok(s(fmt1(mul(mul(wp, rav)?, rws)?, mul(mul(wq, ras)?, rwv)?)?))
}

pub fn calc(
    basis: &str,
    value: &str,
    machine: Option<&str>,
    ref_water: Option<&str>,
    ref_amount: Option<&str>,
    soft_water: Option<&str>,
    soft_amount: Option<&str>,
) -> Result<Value, String> {
    let invalid = || Ok(obj(vec![("error", s("invalid_input"))]));
    let Some((v, scale)) = dec(value)? else { return invalid() };
    if v == 0 {
        return invalid();
    }
    let Some(per_kg) = water_per_kg(machine.unwrap_or("top")) else { return invalid() };
    let water = match basis {
        "water" => (v, scale),
        "weight" => (mul(v, per_kg)?, scale),
        _ => return invalid(),
    };
    let softener = if soft_water.is_some() { amount(water, soft_water, soft_amount)? } else { Value::Null };
    Ok(obj(vec![
        ("water_l", s(fmt1(water.0, water.1)?)),
        ("detergent", amount(water, ref_water, ref_amount)?),
        ("softener", softener),
    ]))
}

//! 洗濯洗剤・柔軟剤の量。
//! v1: 元ツール（app.js）と同じ考え方を、Rust でいちばん普通に書いた形。f64 に読み、水量 ÷ 基準の水量 × 基準の量 を計算し、
//! (x * 10.0).round() / 10.0 で小数第1位に丸める。

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

/// 1kg あたりの水（L）
fn water_per_kg(machine: &str) -> Option<f64> {
    match machine {
        "top" => Some(10.0),
        "drum" => Some(6.0),
        _ => None,
    }
}

/// 小数第1位まで（小数第1位が 0 なら整数で。f64 の Display は 15.0 を "15" と書く）
fn fmt(x: f64) -> String {
    format!("{}", (x * 10.0).round() / 10.0)
}

/// 必要量 = 水量 ÷ 基準の水量 × 基準の量（基準が読めない・基準の水量が 0 以下なら null）
fn amount(water: f64, ref_water: Option<&str>, ref_amount: Option<&str>) -> Value {
    let (Some(Ok(rw)), Some(Ok(ra))) = (ref_water.map(str::parse::<f64>), ref_amount.map(str::parse::<f64>)) else {
        return Value::Null;
    };
    if rw <= 0.0 {
        return Value::Null;
    }
    s(fmt(water / rw * ra))
}

pub fn calc(
    basis: &str,
    value: &str,
    machine: Option<&str>,
    ref_water: Option<&str>,
    ref_amount: Option<&str>,
    soft_water: Option<&str>,
    soft_amount: Option<&str>,
) -> Value {
    let invalid = || obj(vec![("error", s("invalid_input"))]);
    let Ok(v) = value.parse::<f64>() else { return invalid() };
    if v <= 0.0 {
        return invalid();
    }
    let Some(per_kg) = water_per_kg(machine.unwrap_or("top")) else { return invalid() };
    let water = match basis {
        "water" => v,
        "weight" => v * per_kg,
        _ => return invalid(),
    };
    let softener = if soft_water.is_some() { amount(water, soft_water, soft_amount) } else { Value::Null };
    obj(vec![("water_l", s(fmt(water))), ("detergent", amount(water, ref_water, ref_amount)), ("softener", softener)])
}

# 洗濯洗剤・柔軟剤の量。
# v2: 値を Rational（正確な分数）で10進のまま読み、水量 ÷ 基準の水量 × 基準の量 を分数のまま計算して、
# 小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
# v1 の Float では 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、round(1) で 8.2 になった（1.25・6.25 のように
# 2進数で正確に表せる 0.5 ちょうどは、Ruby の round が 0 から遠い方へ丸めるので v1 でも合っていた）。

module Laundry
  module_function

  DECIMAL = /\A[0-9]+(\.[0-9]+)?\z/
  WATER_PER_KG = { "top" => 10, "drum" => 6 }.freeze

  # 10進の数の文字列を正確な分数に。読めなければ nil（Float() と違い "1e3"・"0x1A"・"-1" も読まない）
  def read_value(s)
    return nil unless s.is_a?(String) && DECIMAL.match?(s)

    Rational(s)
  end

  # 0 以上の x を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）。小数第1位が 0 なら整数で書く
  def fmt1(x)
    tenths = (x * 10 + Rational(1, 2)).floor
    (tenths % 10).zero? ? (tenths / 10).to_s : "#{tenths / 10}.#{tenths % 10}"
  end

  def amount(water, ref_water, ref_amount)
    rw = read_value(ref_water)
    ra = read_value(ref_amount)
    return nil if rw.nil? || ra.nil? || rw <= 0 # 基準が読めない・0 以下 → 量は出さない

    fmt1(water / rw * ra)
  end

  def laundry(basis:, value:, ref_water:, ref_amount:, machine: "top", soft_water: nil, soft_amount: nil)
    v = read_value(value)
    if v.nil? || v <= 0 || !%w[water weight].include?(basis) || !WATER_PER_KG.key?(machine)
      return { "error" => "invalid_input" }
    end

    water = basis == "water" ? v : v * WATER_PER_KG[machine]
    softener = soft_water.nil? ? nil : amount(water, soft_water, soft_amount)
    { "water_l" => fmt1(water), "detergent" => amount(water, ref_water, ref_amount), "softener" => softener }
  end
end

# 洗濯洗剤・柔軟剤の量。
# v1: 元ツールと同じく値を Float() で読み、水量 ÷ 基準の水量 × 基準の量 を Float のまま計算して、round(1) で丸める素直な書き方。
# 小数第1位が 0 なら整数で書く。

module Laundry
  module_function

  WATER_PER_KG = { "top" => 10, "drum" => 6 }.freeze

  def to_float(s)
    Float(s)
  rescue ArgumentError, TypeError
    nil
  end

  def fmt1(x)
    r = x.round(1)
    r == r.to_i ? r.to_i.to_s : r.to_s
  end

  def amount(water, ref_water, ref_amount)
    rw = to_float(ref_water)
    ra = to_float(ref_amount)
    return nil if rw.nil? || ra.nil? || rw <= 0 # 基準が読めない・0 以下 → 量は出さない

    fmt1(water / rw * ra)
  end

  def laundry(basis:, value:, ref_water:, ref_amount:, machine: "top", soft_water: nil, soft_amount: nil)
    v = to_float(value)
    if v.nil? || v <= 0 || !%w[water weight].include?(basis) || !WATER_PER_KG.key?(machine)
      return { "error" => "invalid_input" }
    end

    water = basis == "water" ? v : v * WATER_PER_KG[machine]
    softener = soft_water.nil? ? nil : amount(water, soft_water, soft_amount)
    { "water_l" => fmt1(water), "detergent" => amount(water, ref_water, ref_amount), "softener" => softener }
  end
end

// 洗濯洗剤・柔軟剤の量。
// v2: Double を使わない。入力の10進の文字列を BigDecimal で正確に読み、水量 × 基準の量 ÷ 基準の水量 を
// divide(…, 1, HALF_UP) で「正確な商」から小数第1位に四捨五入する（0.5 ちょうどは大きい方へ）。
// v1 は Double で 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、(x * 10).roundToLong() / 10.0 で 8.3 が 8.2 になっていた（11.6L の 7.25 も同じ）。
// toDoubleOrNull は "1e2"・"NaN" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
import java.math.BigDecimal
import java.math.RoundingMode

val WATER_PER_KG = mapOf("top" to BigDecimal.TEN, "drum" to BigDecimal.valueOf(6)) // 1kg あたりの水（L）
private val DECIMAL = Regex("[0-9]+(\\.[0-9]+)?")

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

/** 10進の数の文字列を正確に読む。形が違えば null */
fun dec(s: String?): BigDecimal? = if (s != null && DECIMAL.matches(s)) BigDecimal(s) else null

/** 小数第1位に丸めた値を書く（小数第1位が 0 なら整数で） */
fun fmt(rounded: BigDecimal): String = rounded.stripTrailingZeros().toPlainString()

/** 必要量 = 水量 × 基準の量 ÷ 基準の水量（基準が読めない・基準の水量が 0 以下なら null） */
fun amount(water: BigDecimal, refWater: String?, refAmount: String?): String? {
    val rw = dec(refWater) ?: return null
    val ra = dec(refAmount) ?: return null
    if (rw.signum() <= 0) return null
    return fmt(water.multiply(ra).divide(rw, 1, RoundingMode.HALF_UP))
}

fun laundry(
    basis: String, value: String, machine: String?, refWater: String?, refAmount: String?,
    softWater: String?, softAmount: String?,
): Map<String, Any?> {
    val v = dec(value) ?: return invalid()
    if (v.signum() <= 0) return invalid()
    val perKg = WATER_PER_KG[machine ?: "top"] ?: return invalid()
    val water = when (basis) {
        "water" -> v
        "weight" -> v.multiply(perKg)
        else -> return invalid()
    }
    return linkedMapOf(
        "water_l" to fmt(water.setScale(1, RoundingMode.HALF_UP)),
        "detergent" to amount(water, refWater, refAmount),
        "softener" to if (softWater == null) null else amount(water, softWater, softAmount),
    )
}

// 洗濯洗剤・柔軟剤の量。
// v1: 元ツール（app.js）と同じ考え方を、Kotlin でいちばん普通に書いた形。Double に読み、水量 ÷ 基準の水量 × 基準の量 を計算し、
// (x * 10).roundToLong() / 10.0 で小数第1位に丸める。
import kotlin.math.floor
import kotlin.math.roundToLong

val WATER_PER_KG = mapOf("top" to 10.0, "drum" to 6.0) // 1kg あたりの水（L）

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

/** 小数第1位まで（小数第1位が 0 なら整数で） */
fun fmt(x: Double): String {
    val r = (x * 10).roundToLong() / 10.0
    return if (r == floor(r)) r.toLong().toString() else r.toString()
}

/** 必要量 = 水量 ÷ 基準の水量 × 基準の量（基準が読めない・基準の水量が 0 以下なら null） */
fun amount(water: Double, refWater: String?, refAmount: String?): String? {
    val rw = refWater?.toDoubleOrNull() ?: return null
    val ra = refAmount?.toDoubleOrNull() ?: return null
    if (rw <= 0) return null
    return fmt(water / rw * ra)
}

fun laundry(
    basis: String, value: String, machine: String?, refWater: String?, refAmount: String?,
    softWater: String?, softAmount: String?,
): Map<String, Any?> {
    val v = value.toDoubleOrNull() ?: return invalid()
    if (v <= 0) return invalid()
    val perKg = WATER_PER_KG[machine ?: "top"] ?: return invalid()
    val water = when (basis) {
        "water" -> v
        "weight" -> v * perKg
        else -> return invalid()
    }
    return linkedMapOf(
        "water_l" to fmt(water),
        "detergent" to amount(water, refWater, refAmount),
        "softener" to if (softWater == null) null else amount(water, softWater, softAmount),
    )
}

// 洗濯洗剤・柔軟剤の量。
// v2: Double を使わない。入力の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、水量・必要量を分数 p / q（整数）で持つ。
// 小数第1位への四捨五入は p × 10 ÷ q の余りが半分以上なら繰り上げる（0.5 ちょうどは大きい方へ）。
// v1 は Double で 13.2 ÷ 40 × 25 が 8.2499999999999982 になり、(x * 10).rounded() で 8.3 が 8.2 になっていた（11.6L の 7.25 も同じ）。
// Double(_:) は "1e2"・"inf"・"nan" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
// 桁あふれは trap にせず Failure を投げる（そのケースだけ error になる）。

private let waterPerKg: [String: Int] = ["top": 10, "drum": 6] // 1kg あたりの水（L）

private func mul(_ a: Int, _ b: Int) throws -> Int {
    let (r, overflow) = a.multipliedReportingOverflow(by: b)
    if overflow { throw Failure("桁あふれ") }
    return r
}

/// 10進の数の文字列を (整数, 10^小数の桁数) に。形が違えば nil
private func dec(_ text: String?) throws -> (Int, Int)? {
    guard let text else { return nil }
    let parts = text.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let isDigits = { (p: Substring) in !p.isEmpty && p.utf8.allSatisfy { $0 >= 0x30 && $0 <= 0x39 } }
    guard parts.allSatisfy(isDigits) else { return nil }
    var v = 0
    for b in parts.joined().utf8 { v = try addChecked(try mul(v, 10), Int(b - 0x30)) }
    var scale = 1
    for _ in 0..<(parts.count == 2 ? parts[1].utf8.count : 0) { scale = try mul(scale, 10) }
    return (v, scale)
}

private func addChecked(_ a: Int, _ b: Int) throws -> Int {
    let (r, overflow) = a.addingReportingOverflow(b)
    if overflow { throw Failure("桁あふれ") }
    return r
}

/// p ÷ q（p ≥ 0・q > 0）を小数第1位に四捨五入して書く（小数第1位が 0 なら整数で）
private func fmt1(_ p: Int, _ q: Int) throws -> String {
    let a = try mul(p, 10)
    let (t, r) = a.quotientAndRemainder(dividingBy: q)
    let tenths = r >= q - r ? t + 1 : t // 余り × 2 ≥ q（× 2 であふれないよう引き算で比べる）
    return tenths % 10 == 0 ? "\(tenths / 10)" : "\(tenths / 10).\(tenths % 10)"
}

/// 必要量 = 水量 × 基準の量 ÷ 基準の水量（基準が読めない・基準の水量が 0 以下なら nil）
private func amount(_ water: (Int, Int), _ refWater: String?, _ refAmount: String?) throws -> String? {
    guard let (rwv, rws) = try dec(refWater), let (rav, ras) = try dec(refAmount), rwv > 0 else { return nil }
    // (wp/wq) × (rav/ras) ÷ (rwv/rws) = wp·rav·rws ÷ (wq·ras·rwv)
    return try fmt1(try mul(try mul(water.0, rav), rws), try mul(try mul(water.1, ras), rwv))
}

func laundry(basis: String, value: String, machine: String?, refWater: String?, refAmount: String?,
             softWater: String?, softAmount: String?) throws -> [String: Any] {
    guard let (v, scale) = try dec(value), v > 0 else { return ["error": "invalid_input"] }
    guard let perKg = waterPerKg[machine ?? "top"] else { return ["error": "invalid_input"] }
    let water: (Int, Int)
    switch basis {
    case "water": water = (v, scale)
    case "weight": water = (try mul(v, perKg), scale)
    default: return ["error": "invalid_input"]
    }
    return [
        "water_l": try fmt1(water.0, water.1),
        "detergent": orNull(try amount(water, refWater, refAmount)),
        "softener": orNull(softWater == nil ? nil : try amount(water, softWater, softAmount)),
    ]
}

// ランナー規約（標準入力の 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))
}

// 洗濯洗剤・柔軟剤の量。
// v1: 元ツール（app.js）と同じ考え方を、Swift でいちばん普通に書いた形。Double に読み、水量 ÷ 基準の水量 × 基準の量 を計算し、
// (x * 10).rounded() / 10 で小数第1位に丸める。

private let waterPerKg: [String: Double] = ["top": 10, "drum": 6] // 1kg あたりの水（L）

/// 小数第1位まで（小数第1位が 0 なら整数で）
private func fmt(_ x: Double) -> String {
    let r = (x * 10).rounded() / 10
    return r == r.rounded() ? String(Int(r)) : String(r)
}

/// 必要量 = 水量 ÷ 基準の水量 × 基準の量（基準が読めない・基準の水量が 0 以下なら nil）
private func amount(_ water: Double, _ refWater: String?, _ refAmount: String?) -> String? {
    guard let rw = refWater.flatMap(Double.init), let ra = refAmount.flatMap(Double.init), rw > 0 else { return nil }
    return fmt(water / rw * ra)
}

func laundry(basis: String, value: String, machine: String?, refWater: String?, refAmount: String?,
             softWater: String?, softAmount: String?) throws -> [String: Any] {
    guard let v = Double(value), v > 0 else { return ["error": "invalid_input"] }
    guard let perKg = waterPerKg[machine ?? "top"] else { return ["error": "invalid_input"] }
    let water: Double
    switch basis {
    case "water": water = v
    case "weight": water = v * perKg
    default: return ["error": "invalid_input"]
    }
    return [
        "water_l": fmt(water),
        "detergent": orNull(amount(water, refWater, refAmount)),
        "softener": orNull(softWater == nil ? nil : amount(water, softWater, softAmount)),
    ]
}

// ランナー規約（標準入力の 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))
}