だし（出汁）の割合計算

<?php
declare(strict_types=1);

/**
 * だし（出汁）の割合計算。
 * v2: 0.1g を単位にした整数で計算する。水の量 × 割合 ÷ 100 を 0.1g 単位で四捨五入 = intdiv(水 × 割合 × 10 + 50, 100)。
 * float だと 45 × 0.03 が 1.3499999999999999 になり、round で 1.3 に落ちる。
 */
const TYPES = [
    'ichiban' => [['昆布', 1], ['かつお節', 2]],
    'katsuo' => [['かつお節', 3]],
    'konbu' => [['昆布', 2]],
    'niboshi' => [['煮干し', 3]],
    'karyu' => [['顆粒だし', 1]],
];

/** @param array{water_ml: int, type: string} $in */
function calcDashi(array $in): array
{
    $water = $in['water_ml'];
    if ($water <= 0) {
        return ['error' => 'invalid_input'];
    }
    $materials = [];
    foreach (TYPES[$in['type']] as [$name, $pct]) {
        $tenths = intdiv($water * $pct * 10 + 50, 100);
        $materials[] = ['name' => $name, 'grams' => $tenths % 10 === 0 ? (string) intdiv($tenths, 10) : intdiv($tenths, 10) . '.' . $tenths % 10];
    }
    return ['materials' => $materials];
}

<?php
declare(strict_types=1);

/**
 * だし（出汁）の割合計算。
 * v1: 水の量 × (割合 ÷ 100) を float で計算し、round($n, 1) で小数第1位に丸める素直な書き方。
 */
const TYPES = [
    'ichiban' => [['昆布', 1], ['かつお節', 2]],
    'katsuo' => [['かつお節', 3]],
    'konbu' => [['昆布', 2]],
    'niboshi' => [['煮干し', 3]],
    'karyu' => [['顆粒だし', 1]],
];

/** @param array{water_ml: int, type: string} $in */
function calcDashi(array $in): array
{
    $water = $in['water_ml'];
    if ($water <= 0) {
        return ['error' => 'invalid_input'];
    }
    $materials = [];
    foreach (TYPES[$in['type']] as [$name, $pct]) {
        $materials[] = ['name' => $name, 'grams' => (string) round($water * ($pct / 100), 1)];
    }
    return ['materials' => $materials];
}

"""だし（出汁）の割合計算。

v2: 0.1g を単位にした整数で計算する。水の量 × 割合 ÷ 100 を 0.1g 単位で四捨五入 = (水 × 割合 × 10 + 50) // 100。
round(n, 1) は2進数で実際に入っている値を丸めるので、0.15（中身は 0.1499…）を 0.1 に、1.25 を偶数丸めで 1.2 にする。
"""
TYPES = {
    "ichiban": [("昆布", 1), ("かつお節", 2)],
    "katsuo": [("かつお節", 3)],
    "konbu": [("昆布", 2)],
    "niboshi": [("煮干し", 3)],
    "karyu": [("顆粒だし", 1)],
}


def gram(tenths):
    """0.1g 単位の整数を "1.4"・"20" の形にする"""
    return str(tenths // 10) if tenths % 10 == 0 else f"{tenths // 10}.{tenths % 10}"


def calc_dashi(water_ml, type):
    if water_ml <= 0:
        return {"error": "invalid_input"}
    return {"materials": [{"name": name, "grams": gram((water_ml * pct * 10 + 50) // 100)} for name, pct in TYPES[type]]}

"""だし（出汁）の割合計算。

v1: 水の量 × (割合 ÷ 100) を float で計算し、round(n, 1) で小数第1位に丸める素直な書き方。
"""
TYPES = {
    "ichiban": [("昆布", 1), ("かつお節", 2)],
    "katsuo": [("かつお節", 3)],
    "konbu": [("昆布", 2)],
    "niboshi": [("煮干し", 3)],
    "karyu": [("顆粒だし", 1)],
}


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


def calc_dashi(water_ml, type):
    if water_ml <= 0:
        return {"error": "invalid_input"}
    return {"materials": [{"name": name, "grams": gram(water_ml * (pct / 100))} for name, pct in TYPES[type]]}

package main

import (
	"fmt"
	"strconv"
)

// v2: 0.1g を単位にした整数で計算する。水の量 × 割合 ÷ 100 を 0.1g 単位で四捨五入 = (水 × 割合 × 10 + 50) / 100（整数の割り算）。
// float64 だと 45 × 0.03 が 1.3499999999999999 になり、四捨五入で 1.3 に落ちる。

type material struct {
	name string
	pct  int
}

var types = map[string][]material{
	"ichiban": {{"昆布", 1}, {"かつお節", 2}},
	"katsuo":  {{"かつお節", 3}},
	"konbu":   {{"昆布", 2}},
	"niboshi": {{"煮干し", 3}},
	"karyu":   {{"顆粒だし", 1}},
}

// gram は 0.1g 単位の整数を "1.4"・"20" の形にする。
func gram(tenths int) string {
	if tenths%10 == 0 {
		return strconv.Itoa(tenths / 10)
	}
	return fmt.Sprintf("%d.%d", tenths/10, tenths%10)
}

func CalcDashi(waterMl int, typ string) map[string]any {
	if waterMl <= 0 {
		return map[string]any{"error": "invalid_input"}
	}
	materials := []map[string]string{}
	for _, m := range types[typ] {
		materials = append(materials, map[string]string{"name": m.name, "grams": gram((waterMl*m.pct*10 + 50) / 100)})
	}
	return map[string]any{"materials": materials}
}

package main

import (
	"math"
	"strconv"
)

// v1: 水の量 × (割合 ÷ 100) を float64 で計算し、math.Round(n*10)/10 で小数第1位に丸める素直な書き方。

type material struct {
	name string
	pct  float64
}

var types = map[string][]material{
	"ichiban": {{"昆布", 1}, {"かつお節", 2}},
	"katsuo":  {{"かつお節", 3}},
	"konbu":   {{"昆布", 2}},
	"niboshi": {{"煮干し", 3}},
	"karyu":   {{"顆粒だし", 1}},
}

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

func CalcDashi(waterMl int, typ string) map[string]any {
	if waterMl <= 0 {
		return map[string]any{"error": "invalid_input"}
	}
	materials := []map[string]string{}
	for _, m := range types[typ] {
		materials = append(materials, map[string]string{"name": m.name, "grams": gram(float64(waterMl) * (m.pct / 100))})
	}
	return map[string]any{"materials": materials}
}

// だし（出汁）の割合計算。
// v2: 0.1g を単位にした整数で計算する。水の量 × 割合 ÷ 100 を 0.1g 単位で四捨五入 = (水 × 割合 × 10 + 50) ÷ 100 の切り捨て。
// Number だと 45 × 0.03 が 1.3499999999999999 になり、四捨五入で 1.3 に落ちる。

const TYPES = {
  ichiban: [["昆布", 1], ["かつお節", 2]],
  katsuo: [["かつお節", 3]],
  konbu: [["昆布", 2]],
  niboshi: [["煮干し", 3]],
  karyu: [["顆粒だし", 1]],
};

/** 0.1g 単位の整数を "1.4"・"20" の形にする */
const gram = (tenths) => (tenths % 10 === 0 ? String(tenths / 10) : `${Math.floor(tenths / 10)}.${tenths % 10}`);

export function calcDashi({ water_ml, type }) {
  if (!(water_ml > 0)) return { error: "invalid_input" };
  return { materials: TYPES[type].map(([name, pct]) => ({ name, grams: gram(Math.floor((water_ml * pct * 10 + 50) / 100)) })) };
}

// だし（出汁）の割合計算。
// v1: 水の量 × (割合 ÷ 100) を Number で計算し、Math.round(n * 10) / 10 で小数第1位に丸める素直な書き方。

const TYPES = {
  ichiban: [["昆布", 1], ["かつお節", 2]],
  katsuo: [["かつお節", 3]],
  konbu: [["昆布", 2]],
  niboshi: [["煮干し", 3]],
  karyu: [["顆粒だし", 1]],
};

const gram = (n) => String(Math.round(n * 10) / 10);

export function calcDashi({ water_ml, type }) {
  if (!(water_ml > 0)) return { error: "invalid_input" };
  return { materials: TYPES[type].map(([name, pct]) => ({ name, grams: gram(water_ml * (pct / 100)) })) };
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * だし（出汁）の割合計算。
 * v2: 割合を整数（%）のまま持ち、水の量 × 割合 を 0.1g 単位の整数に四捨五入する（(水 × 割合 × 10 + 50) ÷ 100 の整数の割り算）。
 * double だと 45 × 0.03 が 1.3499999999999999 になり、Math.round(n * 10) / 10.0 で 1.4g が 1.3g になっていた。
 */
public final class Dashi {
    private Dashi() {}

    record Material(String name, long pct) {}

    static final Map<String, List<Material>> TYPES = Map.of(
            "ichiban", List.of(new Material("昆布", 1), new Material("かつお節", 2)),
            "katsuo", List.of(new Material("かつお節", 3)),
            "konbu", List.of(new Material("昆布", 2)),
            "niboshi", List.of(new Material("煮干し", 3)),
            "karyu", List.of(new Material("顆粒だし", 1)));

    static String gram(long waterMl, long pct) {
        long tenths = Math.addExact(Math.multiplyExact(Math.multiplyExact(waterMl, pct), 10), 50) / 100; // 0.1g 単位に四捨五入（すべて 0 以上）
        return tenths % 10 == 0 ? Long.toString(tenths / 10) : (tenths / 10) + "." + (tenths % 10);
    }

    public static Map<String, Object> calc(long waterMl, String type) {
        Map<String, Object> out = new LinkedHashMap<>();
        if (waterMl <= 0) {
            out.put("error", "invalid_input");
            return out;
        }
        List<Object> materials = new ArrayList<>();
        for (Material m : TYPES.get(type)) {
            Map<String, Object> e = new LinkedHashMap<>();
            e.put("name", m.name());
            e.put("grams", gram(waterMl, m.pct()));
            materials.add(e);
        }
        out.put("materials", materials);
        return out;
    }
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/** だし（出汁）の割合計算。v1: 水の量 × (割合 ÷ 100) を double で計算し、Math.round(n * 10) / 10.0 で小数第1位に丸める素直な書き方。 */
public final class Dashi {
    private Dashi() {}

    record Material(String name, double pct) {}

    static final Map<String, List<Material>> TYPES = Map.of(
            "ichiban", List.of(new Material("昆布", 1), new Material("かつお節", 2)),
            "katsuo", List.of(new Material("かつお節", 3)),
            "konbu", List.of(new Material("昆布", 2)),
            "niboshi", List.of(new Material("煮干し", 3)),
            "karyu", List.of(new Material("顆粒だし", 1)));

    static String gram(double n) {
        double g = Math.round(n * 10) / 10.0;
        return g == Math.floor(g) ? String.valueOf((long) g) : String.valueOf(g);
    }

    public static Map<String, Object> calc(long waterMl, String type) {
        Map<String, Object> out = new LinkedHashMap<>();
        if (waterMl <= 0) {
            out.put("error", "invalid_input");
            return out;
        }
        List<Object> materials = new ArrayList<>();
        for (Material m : TYPES.get(type)) {
            Map<String, Object> e = new LinkedHashMap<>();
            e.put("name", m.name());
            e.put("grams", gram(waterMl * (m.pct() / 100)));
            materials.add(e);
        }
        out.put("materials", materials);
        return out;
    }
}

// だし（出汁）の割合計算。
// v2: 0.1g 単位の整数（水 × 割合 × 10 ÷ 100 を、50 を足して切り捨て＝四捨五入）で計算し、double を使わない。
// v1 は 45 × 0.03 が 1.3499999999999999 になって 0.1g 少なくなり、Math.Round の既定（偶数丸め）で 0.05 → 0、1.25 → 1.2 になっていた。

public static class Dashi
{
    static readonly Dictionary<string, (string Name, long Pct)[]> Types = new()
    {
        ["ichiban"] = [("昆布", 1), ("かつお節", 2)],
        ["katsuo"] = [("かつお節", 3)],
        ["konbu"] = [("昆布", 2)],
        ["niboshi"] = [("煮干し", 3)],
        ["karyu"] = [("顆粒だし", 1)],
    };

    static string Gram(long waterMl, long pct)
    {
        long tenths = (waterMl * pct * 10 + 50) / 100; // 0.1g 単位に四捨五入（すべて 0 以上）
        return tenths % 10 == 0 ? $"{tenths / 10}" : $"{tenths / 10}.{tenths % 10}";
    }

    public static Dictionary<string, object?> Calc(long waterMl, string type)
    {
        if (waterMl <= 0)
            return new() { ["error"] = "invalid_input" };
        var materials = Types[type].Select(m => new Dictionary<string, string> { ["name"] = m.Name, ["grams"] = Gram(waterMl, m.Pct) }).ToList();
        return new() { ["materials"] = materials };
    }
}

// だし（出汁）の割合計算。
// v1: 水の量 × (割合 ÷ 100) を double で計算し、Math.Round(n, 1) で小数第1位に丸める素直な書き方。
// お金ではなく重さ（g）なので、decimal ではなく double を使うのが普通と判断した。
using System.Globalization;

public static class Dashi
{
    static readonly Dictionary<string, (string Name, double Pct)[]> Types = new()
    {
        ["ichiban"] = [("昆布", 1), ("かつお節", 2)],
        ["katsuo"] = [("かつお節", 3)],
        ["konbu"] = [("昆布", 2)],
        ["niboshi"] = [("煮干し", 3)],
        ["karyu"] = [("顆粒だし", 1)],
    };

    static string Gram(double n) => Math.Round(n, 1).ToString(CultureInfo.InvariantCulture);

    public static Dictionary<string, object?> Calc(long waterMl, string type)
    {
        if (waterMl <= 0)
            return new() { ["error"] = "invalid_input" };
        var materials = Types[type].Select(m => new Dictionary<string, string> { ["name"] = m.Name, ["grams"] = Gram(waterMl * (m.Pct / 100)) }).ToList();
        return new() { ["materials"] = materials };
    }
}

//! だし（出汁）の割合計算。
//! v2: 0.1g を単位にした整数（i64）で計算する。水の量 × 割合 ÷ 100 を 0.1g 単位で四捨五入 = (水 × 割合 × 10 + 50) / 100（整数の割り算）。
//! f64 だと 45 × 0.03 が 1.3499999999999999 になり、round で 1.3 に落ちる（f64::round 自体は 0.5 を大きい方へ丸める）。

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

fn materials(kind: &str) -> Option<&'static [(&'static str, i64)]> {
    match kind {
        "ichiban" => Some(&[("昆布", 1), ("かつお節", 2)]),
        "katsuo" => Some(&[("かつお節", 3)]),
        "konbu" => Some(&[("昆布", 2)]),
        "niboshi" => Some(&[("煮干し", 3)]),
        "karyu" => Some(&[("顆粒だし", 1)]),
        _ => None,
    }
}

/// 水 × 割合 ÷ 100 を 0.1g 単位で四捨五入して書く（水は 1 以上）
fn gram(water_ml: i64, pct: i64) -> String {
    let tenths = (water_ml * pct * 10 + 50) / 100;
    if tenths % 10 == 0 { format!("{}", tenths / 10) } else { format!("{}.{}", tenths / 10, tenths % 10) }
}

pub fn calc(water_ml: i64, kind: &str) -> Result<Value, String> {
    if water_ml <= 0 {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let list = materials(kind).ok_or(format!("unknown type: {kind}"))?;
    let out = list.iter().map(|(name, pct)| obj(vec![("name", s(*name)), ("grams", s(gram(water_ml, *pct)))])).collect();
    Ok(obj(vec![("materials", Value::Arr(out))]))
}

//! だし（出汁）の割合計算。
//! v1: 水の量 × (割合 ÷ 100) を f64 で計算し、(n * 10.0).round() / 10.0 で小数第1位に丸める素直な書き方。

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

fn materials(kind: &str) -> Option<&'static [(&'static str, f64)]> {
    match kind {
        "ichiban" => Some(&[("昆布", 1.0), ("かつお節", 2.0)]),
        "katsuo" => Some(&[("かつお節", 3.0)]),
        "konbu" => Some(&[("昆布", 2.0)]),
        "niboshi" => Some(&[("煮干し", 3.0)]),
        "karyu" => Some(&[("顆粒だし", 1.0)]),
        _ => None,
    }
}

fn gram(x: f64) -> String {
    format!("{}", (x * 10.0).round() / 10.0)
}

pub fn calc(water_ml: i64, kind: &str) -> Result<Value, String> {
    if water_ml <= 0 {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let list = materials(kind).ok_or(format!("unknown type: {kind}"))?;
    let out = list
        .iter()
        .map(|(name, pct)| obj(vec![("name", s(*name)), ("grams", s(gram(water_ml as f64 * (pct / 100.0))))]))
        .collect();
    Ok(obj(vec![("materials", Value::Arr(out))]))
}

# だし（出汁）の割合計算。
# v2: 0.1g 単位の整数で計算する（水 × 割合 × 10 に 50 を足して 100 で割る）。
# v1 の Float では 45 × 0.03 が 1.3499999999999999 になり、round(1) で 1.3 になった（1.25 → 1.3 のように
# 2進数で正確に表せる 0.5 ちょうどは、Ruby の round が 0 から遠い方へ丸めるので v1 でも合っていた）。

module Dashi
  module_function

  TYPES = {
    "ichiban" => [["昆布", 1], ["かつお節", 2]],
    "katsuo" => [["かつお節", 3]],
    "konbu" => [["昆布", 2]],
    "niboshi" => [["煮干し", 3]],
    "karyu" => [["顆粒だし", 1]],
  }.freeze

  def gram(water, pct)
    tenths = (water * pct * 10 + 50) / 100 # 0.1g 単位に四捨五入（すべて 0 以上の整数）
    tenths % 10 == 0 ? (tenths / 10).to_s : "#{tenths / 10}.#{tenths % 10}"
  end

  def calc(water_ml:, type:)
    return { "error" => "invalid_input" } if water_ml <= 0

    { "materials" => TYPES.fetch(type).map { |name, pct| { "name" => name, "grams" => gram(water_ml, pct) } } }
  end
end

# だし（出汁）の割合計算。
# v1: 水の量 × (割合 ÷ 100.0) を Float で計算し、round(1) で小数第1位に丸める素直な書き方。

module Dashi
  module_function

  TYPES = {
    "ichiban" => [["昆布", 1], ["かつお節", 2]],
    "katsuo" => [["かつお節", 3]],
    "konbu" => [["昆布", 2]],
    "niboshi" => [["煮干し", 3]],
    "karyu" => [["顆粒だし", 1]],
  }.freeze

  def gram(n)
    r = n.round(1)
    r == r.to_i ? r.to_i.to_s : r.to_s
  end

  def calc(water_ml:, type:)
    return { "error" => "invalid_input" } if water_ml <= 0

    { "materials" => TYPES.fetch(type).map { |name, pct| { "name" => name, "grams" => gram(water_ml * (pct / 100.0)) } } }
  end
end

// だし（出汁）の割合計算。
// v2: 割合を整数（%）のまま持ち、水の量 × 割合 を 0.1g 単位の整数に四捨五入する（(水 × 割合 × 10 + 50) ÷ 100 の整数の割り算）。
// Double だと 45 × 0.03 が 1.3499999999999999 になり、(n * 10).roundToLong() / 10.0 で 1.4g が 1.3g になっていた。

data class Material(val name: String, val pct: Long)

val TYPES = mapOf(
    "ichiban" to listOf(Material("昆布", 1), Material("かつお節", 2)),
    "katsuo" to listOf(Material("かつお節", 3)),
    "konbu" to listOf(Material("昆布", 2)),
    "niboshi" to listOf(Material("煮干し", 3)),
    "karyu" to listOf(Material("顆粒だし", 1)),
)

fun gram(waterMl: Long, pct: Long): String {
    // 0.1g 単位に四捨五入（すべて 0 以上なので / の切り捨てでよい）。桁あふれは例外にする
    val tenths = Math.addExact(Math.multiplyExact(Math.multiplyExact(waterMl, pct), 10L), 50L) / 100
    return if (tenths % 10 == 0L) (tenths / 10).toString() else "${tenths / 10}.${tenths % 10}"
}

fun dashi(waterMl: Long, type: String): Map<String, Any?> {
    if (waterMl <= 0) return linkedMapOf("error" to "invalid_input")
    val materials = TYPES.getValue(type).map { m ->
        linkedMapOf<String, Any?>("name" to m.name, "grams" to gram(waterMl, m.pct))
    }
    return linkedMapOf("materials" to materials)
}

import kotlin.math.floor
import kotlin.math.roundToLong

// だし（出汁）の割合計算。v1: 水の量 × (割合 ÷ 100) を Double で計算し、(n * 10).roundToLong() / 10.0 で小数第1位に丸める素直な書き方。

data class Material(val name: String, val pct: Double)

val TYPES = mapOf(
    "ichiban" to listOf(Material("昆布", 1.0), Material("かつお節", 2.0)),
    "katsuo" to listOf(Material("かつお節", 3.0)),
    "konbu" to listOf(Material("昆布", 2.0)),
    "niboshi" to listOf(Material("煮干し", 3.0)),
    "karyu" to listOf(Material("顆粒だし", 1.0)),
)

fun gram(n: Double): String {
    val g = (n * 10).roundToLong() / 10.0
    return if (g == floor(g)) g.toLong().toString() else g.toString()
}

fun dashi(waterMl: Long, type: String): Map<String, Any?> {
    if (waterMl <= 0) return linkedMapOf("error" to "invalid_input")
    val materials = TYPES.getValue(type).map { m ->
        linkedMapOf<String, Any?>("name" to m.name, "grams" to gram(waterMl * (m.pct / 100)))
    }
    return linkedMapOf("materials" to materials)
}

// だし（出汁）の割合計算。
// v2: 割合を整数（%）のまま持ち、水の量 × 割合 ÷ 100 を 0.1g 単位の整数に四捨五入（0.05 は繰り上げ）してから文字列にする。
// v1 は Double で 45 × 0.03 が 1.3499999999999999 になり、1.35g を 1.3g と丸めた（10.05g・4.65g も同じ）。

private let types: [String: [(String, Int)]] = [
    "ichiban": [("昆布", 1), ("かつお節", 2)],
    "katsuo": [("かつお節", 3)],
    "konbu": [("昆布", 2)],
    "niboshi": [("煮干し", 3)],
    "karyu": [("顆粒だし", 1)],
]

/// water × pct ÷ 100 を小数第1位まで（小数第1位が 0 なら整数で）
private func grams(_ water: Int, _ pct: Int) -> String {
    let tenths = (water * pct * 10 + 50) / 100 // 0.1g 単位に四捨五入（すべて 0 以上）
    return tenths % 10 == 0 ? "\(tenths / 10)" : "\(tenths / 10).\(tenths % 10)"
}

func dashi(waterMl: Int, type: String) throws -> [String: Any] {
    if waterMl <= 0 { return ["error": "invalid_input"] }
    guard let list = types[type] else { throw Failure("unknown type: \(type)") }
    return ["materials": list.map { name, pct in ["name": name, "grams": grams(waterMl, pct)] }]
}

// ランナー規約（標準入力の 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: 素直に書いた版（水の量 × (割合 ÷ 100) を Double で計算し、(x * 10).rounded() / 10 で小数第1位に丸める）。
// Swift の "\(20.0)" は "20.0" になるので、小数部が 0 なら Int にして書く。

private let types: [String: [(String, Double)]] = [
    "ichiban": [("昆布", 1), ("かつお節", 2)],
    "katsuo": [("かつお節", 3)],
    "konbu": [("昆布", 2)],
    "niboshi": [("煮干し", 3)],
    "karyu": [("顆粒だし", 1)],
]

private func gram(_ x: Double) -> String {
    let r = (x * 10).rounded() / 10
    return r == r.rounded() ? String(Int(r)) : String(r)
}

func dashi(waterMl: Int, type: String) throws -> [String: Any] {
    if waterMl <= 0 { return ["error": "invalid_input"] }
    guard let list = types[type] else { throw Failure("unknown type: \(type)") }
    return ["materials": list.map { name, pct in ["name": name, "grams": gram(Double(waterMl) * (pct / 100))] }]
}

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

private let runtimeName: String = {
    #if swift(>=6.5)
    return "Swift 6.5+"
    #elseif swift(>=6.4)
    return "Swift 6.4"
    #elseif swift(>=6.3)
    return "Swift 6.3"
    #elseif swift(>=6.2)
    return "Swift 6.2"
    #elseif swift(>=6.1)
    return "Swift 6.1"
    #elseif swift(>=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))
}