米の量と炊き上がり・人数

<?php
declare(strict_types=1);

/**
 * 米の量と炊き上がり・人数。
 * v2: 値を float に読まず、10進の数字の列（値 = 数字の列 ÷ 10^小数の桁数）のまま扱い、
 * 各項目を「数字の列 × 小さな整数 ÷ (小さな整数 × 10^桁数)」の正確な比として、0.5 ちょうどは大きい方へ四捨五入する。
 * float だと 375 × 2.3 が 862.4999… になって 5g 単位で 860g に落ち、Python などの偶数丸めは 157.5 ÷ 5 = 31.5 を 31 にする。
 * 桁数に上限を置かないため、途中の掛け算・足し算・割り算は数字の列の筆算で行う（bcmath・gmp は使わない）。
 */
const DECIMAL = '/^[0-9]+(\.[0-9]+)?$/';

/** 数字の列 × 小さな整数（筆算） */
function mulSmall(string $a, int $k): string
{
    $out = '';
    $carry = 0;
    for ($i = strlen($a) - 1; $i >= 0; $i--) {
        $p = (int) $a[$i] * $k + $carry;
        $out = ($p % 10) . $out;
        $carry = intdiv($p, 10);
    }
    return ltrim(($carry ? (string) $carry : '') . $out, '0') ?: '0';
}

/** 数字の列どうしの足し算（筆算） */
function addDigits(string $a, string $b): string
{
    $n = max(strlen($a), strlen($b));
    $a = str_pad($a, $n, '0', STR_PAD_LEFT);
    $b = str_pad($b, $n, '0', STR_PAD_LEFT);
    $out = '';
    $carry = 0;
    for ($i = $n - 1; $i >= 0; $i--) {
        $s = (int) $a[$i] + (int) $b[$i] + $carry;
        $out = ($s % 10) . $out;
        $carry = intdiv($s, 10);
    }
    return ltrim(($carry ? '1' : '') . $out, '0') ?: '0';
}

/** 数字の列 ÷ 小さな整数 の切り捨て（筆算） */
function divSmall(string $a, int $k): string
{
    $out = '';
    $r = 0;
    for ($i = 0, $n = strlen($a); $i < $n; $i++) {
        $r = $r * 10 + (int) $a[$i];
        $out .= intdiv($r, $k);
        $r %= $k;
    }
    return ltrim($out, '0') ?: '0';
}

/**
 * (digits ÷ 10^scale) × mul ÷ div を整数に四捨五入（0 以上なので 0.5 ちょうどは大きい方へ）。
 * = floor((2 × digits × mul + div × 10^scale) ÷ (2 × div × 10^scale))。10^scale で割るのは下の桁を落とすだけ
 */
function roundRatio(string $digits, int $scale, int $mul, int $div): int
{
    $a = addDigits(mulSmall($digits, 2 * $mul), $div . str_repeat('0', $scale));
    $a = strlen($a) > $scale ? substr($a, 0, strlen($a) - $scale) : '0';
    return (int) divSmall($a, 2 * $div);
}

/** 0.1合単位の整数を "3"・"2.5"・"0.2" の形にする */
function gouText(int $tenths): string
{
    return $tenths % 10 === 0 ? (string) intdiv($tenths, 10) : intdiv($tenths, 10) . '.' . $tenths % 10;
}

/** @param array{mode: string, value: string} $in */
function riceAmount(array $in): array
{
    $mode = $in['mode'];
    $value = $in['value'];
    if (!is_string($value) || !preg_match(DECIMAL, $value) || trim($value, '0.') === ''
        || !in_array($mode, ['gou', 'servings', 'grams'], true)) {
        return ['error' => 'invalid_input'];
    }
    [$int, $frac] = explode('.', $value . '.');
    $n = ltrim($int . $frac, '0');  // 値 = $n ÷ 10^$s
    $s = strlen($frac);
    if ($mode === 'servings') {
        // 合 = 杯数 × 150 ÷ (150 × 2.2) = 杯数 × 10 ÷ 22。0.5合単位 = (合 × 2) を四捨五入した半合の数
        $halves = max(roundRatio($n, $s, 10, 11), 1);
        $tenths = $halves * 5;
        [$g, $gs] = [(string) ($halves * 75), 0];  // 生米 = 半合 × 75g
    } elseif ($mode === 'grams') {
        $tenths = roundRatio($n, $s, 1, 15);  // g ÷ 150 × 10
        [$g, $gs] = [$n, $s];
    } else {
        $tenths = roundRatio($n, $s, 10, 1);
        [$g, $gs] = [mulSmall($n, 150), $s];
    }
    return [
        'gou' => gouText($tenths),
        'rice_g' => roundRatio($g, $gs, 1, 1),
        'ml' => roundRatio($g, $gs, 6, 5),                  // g ÷ 150 × 180
        'cooked_low' => roundRatio($g, $gs, 21, 50) * 5,    // g × 2.1 ÷ 5
        'cooked_high' => roundRatio($g, $gs, 23, 50) * 5,   // g × 2.3 ÷ 5
        'bowls' => roundRatio($g, $gs, 11, 750),            // g × 2.2 ÷ 150
        'onigiri' => roundRatio($g, $gs, 11, 525),          // g × 2.2 ÷ 105
    ];
}

<?php
declare(strict_types=1);

/**
 * 米の量と炊き上がり・人数。
 * v1: 元ツールと同じく値を float に読み、掛け算・割り算を float のまま行って、round() で丸める素直な書き方。
 * 5g 単位は round(x / 5) * 5、0.5合単位は round(x * 2) / 2、合の表示は round(x * 10) / 10 を整数なら整数で書く。
 */
const G_PER_GOU = 150;
const ML_PER_GOU = 180;
const COOK_LO = 2.1;
const COOK_MID = 2.2;
const COOK_HI = 2.3;
const BOWL_G = 150;
const ONIGIRI_G = 105;

function round5(float $x): int
{
    return (int) round($x / 5) * 5;
}

function gouText(float $g): string
{
    $r = round($g * 10) / 10;
    return $r == floor($r) ? (string) (int) $r : (string) $r;
}

/** @param array{mode: string, value: string} $in */
function riceAmount(array $in): array
{
    if (!is_numeric($in['value']) || !in_array($in['mode'], ['gou', 'servings', 'grams'], true)) {
        return ['error' => 'invalid_input'];
    }
    $v = (float) $in['value'];
    if ($v <= 0) {
        return ['error' => 'invalid_input'];
    }
    if ($in['mode'] === 'servings') {
        $gou = round($v * BOWL_G / (G_PER_GOU * COOK_MID) * 2) / 2; // 0.5合単位
        if ($gou < 0.5) {
            $gou = 0.5;
        }
        $g = $gou * G_PER_GOU;
    } elseif ($in['mode'] === 'grams') {
        $g = $v;
        $gou = $g / G_PER_GOU;
    } else {
        $gou = $v;
        $g = $gou * G_PER_GOU;
    }
    return [
        'gou' => gouText($gou),
        'rice_g' => (int) round($g),
        'ml' => (int) round($g / G_PER_GOU * ML_PER_GOU),
        'cooked_low' => round5($g * COOK_LO),
        'cooked_high' => round5($g * COOK_HI),
        'bowls' => (int) round($g * COOK_MID / BOWL_G),
        'onigiri' => (int) round($g * COOK_MID / ONIGIRI_G),
    ];
}

"""米の量と炊き上がり・人数。

v2: 値を fractions.Fraction で10進のまま読み、掛け算・割り算を正確な分数で行って、0.5 ちょうどは大きい方へ四捨五入する。
float だと 375 × 2.3 が 862.4999… になって 5g 単位で 860g に落ち、round() は偶数丸めなので
157.5 ÷ 5 = 31.5 を 31（155g）に、46.5g を 46g にする。
"""
import re
from fractions import Fraction

DECIMAL = re.compile(r"[0-9]+(\.[0-9]+)?")
G_PER_GOU, ML_PER_GOU = 150, 180
COOK_LO, COOK_MID, COOK_HI = Fraction("2.1"), Fraction("2.2"), Fraction("2.3")
BOWL_G, ONIGIRI_G = 150, 105


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 half_up(x):
    """0 以上の x を整数に四捨五入（0.5 ちょうどは大きい方へ）。正の数なので floor で足りる"""
    return (x + Fraction(1, 2)).__floor__()


def round5(x):
    return half_up(x / 5) * 5


def gou_text(g):
    """合を小数第1位に四捨五入。小数第1位が 0 なら整数で書く"""
    t = half_up(g * 10)
    return str(t // 10) if t % 10 == 0 else f"{t // 10}.{t % 10}"


def rice(mode, value):
    v = read_value(value)
    if v is None or v <= 0 or mode not in ("gou", "servings", "grams"):
        return {"error": "invalid_input"}
    if mode == "servings":
        gou = Fraction(half_up(v * BOWL_G / (G_PER_GOU * COOK_MID) * 2), 2)  # 0.5合単位
        gou = max(gou, Fraction(1, 2))
        g = gou * G_PER_GOU
    elif mode == "grams":
        g = v
        gou = g / G_PER_GOU
    else:
        gou = v
        g = gou * G_PER_GOU
    return {
        "gou": gou_text(gou),
        "rice_g": half_up(g),
        "ml": half_up(g / G_PER_GOU * ML_PER_GOU),
        "cooked_low": round5(g * COOK_LO),
        "cooked_high": round5(g * COOK_HI),
        "bowls": half_up(g * COOK_MID / BOWL_G),
        "onigiri": half_up(g * COOK_MID / ONIGIRI_G),
    }

"""米の量と炊き上がり・人数。

v1: 元ツールと同じく値を float に読み、掛け算・割り算を float のまま行って、round() で丸める素直な書き方。
5g 単位は round(x / 5) * 5、0.5合単位は round(x * 2) / 2、合の表示は round(x * 10) / 10 を整数なら整数で書く。
"""
G_PER_GOU, ML_PER_GOU = 150, 180
COOK_LO, COOK_MID, COOK_HI = 2.1, 2.2, 2.3
BOWL_G, ONIGIRI_G = 150, 105


def round5(x):
    return round(x / 5) * 5


def gou_text(g):
    r = round(g * 10) / 10
    return str(int(r)) if r.is_integer() else str(r)


def rice(mode, value):
    try:
        v = float(value)
    except ValueError:
        return {"error": "invalid_input"}
    if v <= 0 or mode not in ("gou", "servings", "grams"):
        return {"error": "invalid_input"}
    if mode == "servings":
        gou = round(v * BOWL_G / (G_PER_GOU * COOK_MID) * 2) / 2  # 0.5合単位
        if gou < 0.5:
            gou = 0.5
        g = gou * G_PER_GOU
    elif mode == "grams":
        g = v
        gou = g / G_PER_GOU
    else:
        gou = v
        g = gou * G_PER_GOU
    return {
        "gou": gou_text(gou),
        "rice_g": round(g),
        "ml": round(g / G_PER_GOU * ML_PER_GOU),
        "cooked_low": round5(g * COOK_LO),
        "cooked_high": round5(g * COOK_HI),
        "bowls": round(g * COOK_MID / BOWL_G),
        "onigiri": round(g * COOK_MID / ONIGIRI_G),
    }

package main

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

// v2: 値を big.Rat（正確な分数）で10進のまま読み、掛け算・割り算を正確に行って、0.5 ちょうどは大きい方へ四捨五入する。
// float64 だと 375 × 2.3 が 862.4999… になり、math.Round(x/5)*5 が 860g に落ちる（元ツールと同じ食い違い）。

// big.Rat の SetString は "1e3"・"1/2" も読むので、先に形を確かめる。
var decimal = regexp.MustCompile(`^[0-9]+(\.[0-9]+)?$`)

func rat(a, b int64) *big.Rat { return big.NewRat(a, b) }

var (
	gPerGou  = rat(150, 1)
	mlPerGou = rat(180, 1)
	cookLo   = rat(21, 10)
	cookMid  = rat(22, 10)
	cookHi   = rat(23, 10)
	bowlG    = rat(150, 1)
	onigiriG = rat(105, 1)
)

// calc は x × y ÷ z を新しい big.Rat で返す（z が nil なら割らない）。
func calc(x, y, z *big.Rat) *big.Rat {
	r := new(big.Rat).Mul(x, y)
	if z != nil {
		r.Quo(r, z)
	}
	return r
}

// halfUp は 0 以上の x を整数に四捨五入する（0.5 ちょうどは大きい方へ）。x + 1/2 を切り捨てる。
func halfUp(x *big.Rat) *big.Int {
	t := new(big.Rat).Add(x, rat(1, 2))
	return new(big.Int).Quo(t.Num(), t.Denom()) // 正の数なので Quo の切り捨てで足りる
}

// round5 は 5g 単位に四捨五入する。
func round5(x *big.Rat) *big.Int {
	n := halfUp(new(big.Rat).Quo(x, rat(5, 1)))
	return n.Mul(n, big.NewInt(5))
}

// gouText は合を小数第1位に四捨五入し、小数第1位が 0 なら整数で書く。
func gouText(g *big.Rat) string {
	t := halfUp(calc(g, rat(10, 1), nil))
	q, r := new(big.Int).QuoRem(t, big.NewInt(10), new(big.Int))
	if r.Sign() == 0 {
		return q.String()
	}
	return fmt.Sprintf("%s.%s", q, r)
}

// 出力の整数は *big.Int のまま返す（encoding/json は big.Int を JSON の整数として書く）。
func Rice(mode, value string) map[string]any {
	if !decimal.MatchString(value) || (mode != "gou" && mode != "servings" && mode != "grams") {
		return map[string]any{"error": "invalid_input"}
	}
	v, ok := new(big.Rat).SetString(value)
	if !ok || v.Sign() <= 0 {
		return map[string]any{"error": "invalid_input"}
	}
	var gou, g *big.Rat
	switch mode {
	case "servings":
		raw := calc(calc(v, bowlG, calc(gPerGou, cookMid, nil)), rat(2, 1), nil)
		gou = new(big.Rat).SetFrac(halfUp(raw), big.NewInt(2)) // 0.5合単位
		if gou.Cmp(rat(1, 2)) < 0 {
			gou = rat(1, 2)
		}
		g = calc(gou, gPerGou, nil)
	case "grams":
		g = v
		gou = new(big.Rat).Quo(g, gPerGou)
	default:
		gou = v
		g = calc(gou, gPerGou, nil)
	}
	return map[string]any{
		"gou":         gouText(gou),
		"rice_g":      halfUp(g),
		"ml":          halfUp(calc(new(big.Rat).Quo(g, gPerGou), mlPerGou, nil)),
		"cooked_low":  round5(calc(g, cookLo, nil)),
		"cooked_high": round5(calc(g, cookHi, nil)),
		"bowls":       halfUp(calc(g, cookMid, bowlG)),
		"onigiri":     halfUp(calc(g, cookMid, onigiriG)),
	}
}

package main

import (
	"math"
	"strconv"
)

// v1: 元ツールと同じく値を float64 に読み、掛け算・割り算を float64 のまま行って、math.Round で丸める素直な書き方。
// 5g 単位は math.Round(x/5)*5、0.5合単位は math.Round(x*2)/2、合の表示は math.Round(x*10)/10 を整数なら整数で書く。

const (
	gPerGou  = 150.0
	mlPerGou = 180.0
	cookLo   = 2.1
	cookMid  = 2.2
	cookHi   = 2.3
	bowlG    = 150.0
	onigiriG = 105.0
)

func round5(x float64) int {
	return int(math.Round(x/5) * 5)
}

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

func Rice(mode, value string) map[string]any {
	v, err := strconv.ParseFloat(value, 64)
	if err != nil || v <= 0 || (mode != "gou" && mode != "servings" && mode != "grams") {
		return map[string]any{"error": "invalid_input"}
	}
	var gou, g float64
	switch mode {
	case "servings":
		gou = math.Round(v*bowlG/(gPerGou*cookMid)*2) / 2 // 0.5合単位
		if gou < 0.5 {
			gou = 0.5
		}
		g = gou * gPerGou
	case "grams":
		g = v
		gou = g / gPerGou
	default:
		gou = v
		g = gou * gPerGou
	}
	return map[string]any{
		"gou":         gouText(gou),
		"rice_g":      int(math.Round(g)),
		"ml":          int(math.Round(g / gPerGou * mlPerGou)),
		"cooked_low":  round5(g * cookLo),
		"cooked_high": round5(g * cookHi),
		"bowls":       int(math.Round(g * cookMid / bowlG)),
		"onigiri":     int(math.Round(g * cookMid / onigiriG)),
	}
}

// 米の量と炊き上がり・人数。
// v2: 値を Number に読まず、10^桁数 倍した BigInt（整数）として10進のまま読む。各項目を
// 「値 × 小さな整数 ÷ 小さな整数」の正確な比として、0.5 ちょうどは大きい方へ四捨五入する。
// Number だと 375 × 2.3 が 862.4999… になり、Math.round(x / 5) * 5 が 860g に落ちる（元ツールの食い違い）。

const DECIMAL = /^[0-9]+(\.[0-9]+)?$/;

/** "2.5" → { n: 25n, unit: 10n }（値 = n ÷ unit）。読めなければ null */
function readValue(s) {
  if (typeof s !== "string" || !DECIMAL.test(s)) return null;
  const [int, frac = ""] = s.split(".");
  return { n: BigInt(int + frac), unit: 10n ** BigInt(frac.length) };
}

/**
 * (x.n ÷ x.unit) × mul ÷ div を整数に四捨五入（0 以上なので 0.5 ちょうどは大きい方へ）。
 * = floor((2 × n × mul + div × unit) ÷ (2 × div × unit))。BigInt の割り算は正の数なら切り捨て
 */
function roundRatio(x, mul, div) {
  return (2n * x.n * mul + div * x.unit) / (2n * div * x.unit);
}

/** 0.1合単位の整数を "3"・"2.5"・"0.2" の形にする */
function gouText(tenths) {
  return tenths % 10n === 0n ? `${tenths / 10n}` : `${tenths / 10n}.${tenths % 10n}`;
}

export function rice({ mode, value }) {
  const v = readValue(value);
  if (v === null || v.n === 0n || !["gou", "servings", "grams"].includes(mode)) return { error: "invalid_input" };
  let tenths, g; // g = 生米のグラム（{ n, unit }）
  if (mode === "servings") {
    // 合 = 杯数 × 150 ÷ (150 × 2.2) = 杯数 × 10 ÷ 22。0.5合単位 = (合 × 2) を四捨五入した半合の数
    let halves = roundRatio(v, 10n, 11n);
    if (halves < 1n) halves = 1n;
    tenths = halves * 5n;
    g = { n: halves * 75n, unit: 1n }; // 生米 = 半合 × 75g
  } else if (mode === "grams") {
    tenths = roundRatio(v, 1n, 15n); // g ÷ 150 × 10
    g = v;
  } else {
    tenths = roundRatio(v, 10n, 1n);
    g = { n: v.n * 150n, unit: v.unit };
  }
  // 出力の整数は Number に直す（2^53 を超える量は扱わない）
  return {
    gou: gouText(tenths),
    rice_g: Number(roundRatio(g, 1n, 1n)),
    ml: Number(roundRatio(g, 6n, 5n)), // g ÷ 150 × 180
    cooked_low: Number(roundRatio(g, 21n, 50n) * 5n), // g × 2.1 ÷ 5
    cooked_high: Number(roundRatio(g, 23n, 50n) * 5n), // g × 2.3 ÷ 5
    bowls: Number(roundRatio(g, 11n, 750n)), // g × 2.2 ÷ 150
    onigiri: Number(roundRatio(g, 11n, 525n)), // g × 2.2 ÷ 105
  };
}

// 米の量と炊き上がり・人数。
// v1: 元ツールと同じく値を parseFloat で読み、掛け算・割り算を Number のまま行って、Math.round で丸める素直な書き方。
// 5g 単位は Math.round(x / 5) * 5、0.5合単位は Math.round(x * 2) / 2、合の表示は Math.round(x * 10) / 10 を整数なら整数で書く。

const G_PER_GOU = 150;
const ML_PER_GOU = 180;
const COOK_LO = 2.1;
const COOK_MID = 2.2;
const COOK_HI = 2.3;
const BOWL_G = 150;
const ONIGIRI_G = 105;

const round5 = (x) => Math.round(x / 5) * 5;

function gouText(g) {
  const r = Math.round(g * 10) / 10;
  return r === Math.round(r) ? String(Math.round(r)) : String(r);
}

export function rice({ mode, value }) {
  const v = parseFloat(value);
  if (!isFinite(v) || v <= 0 || !["gou", "servings", "grams"].includes(mode)) return { error: "invalid_input" };
  let gou, g;
  if (mode === "servings") {
    gou = Math.round(((v * BOWL_G) / (G_PER_GOU * COOK_MID)) * 2) / 2; // 0.5合単位
    if (gou < 0.5) gou = 0.5;
    g = gou * G_PER_GOU;
  } else if (mode === "grams") {
    g = v;
    gou = g / G_PER_GOU;
  } else {
    gou = v;
    g = gou * G_PER_GOU;
  }
  return {
    gou: gouText(gou),
    rice_g: Math.round(g),
    ml: Math.round((g / G_PER_GOU) * ML_PER_GOU),
    cooked_low: round5(g * COOK_LO),
    cooked_high: round5(g * COOK_HI),
    bowls: Math.round((g * COOK_MID) / BOWL_G),
    onigiri: Math.round((g * COOK_MID) / ONIGIRI_G),
  };
}

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

/**
 * 米の量と炊き上がり・人数。
 * v2: 入力の文字列を BigDecimal（10進のまま）で読み、掛け算は正確に、割り算は divide(…, 桁, RoundingMode.HALF_UP)
 * （正確な商を 0.5 ちょうどは大きい方へ丸める）で行う。
 * v1 は double で 375 × 2.3 が 862.4999…になり、Math.round(172.4999…) で 5g 単位の上限が 860g（正しくは 865g）になっていた。
 * Double.parseDouble は "1e2"・"NaN"・前後の空白も読むので、入力は 10進の数の形かを先に確かめる。
 */
public final class Rice {
    private Rice() {}

    private static final Pattern DECIMAL = Pattern.compile("[0-9]+(\\.[0-9]+)?");
    private static final BigDecimal G_PER_GOU = BigDecimal.valueOf(150); // 生米1合のグラム
    private static final BigDecimal ML_PER_GOU = BigDecimal.valueOf(180); // 生米1合の ml
    private static final BigDecimal COOK_LO = new BigDecimal("2.1"); // 炊き上がり倍率（下限）
    private static final BigDecimal COOK_MID = new BigDecimal("2.2"); // 炊き上がり倍率（中央）
    private static final BigDecimal COOK_HI = new BigDecimal("2.3"); // 炊き上がり倍率（上限）
    private static final BigDecimal BOWL_G = BigDecimal.valueOf(150); // 茶碗1杯
    private static final BigDecimal ONIGIRI_G = BigDecimal.valueOf(105); // おにぎり1個
    private static final BigDecimal TWO = BigDecimal.valueOf(2);
    private static final BigDecimal FIVE = BigDecimal.valueOf(5);
    private static final BigDecimal HALF = new BigDecimal("0.5");

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

    /** a ÷ b の正確な値を整数に四捨五入（0.5 ちょうどは大きい方へ） */
    static BigInteger roundDiv(BigDecimal a, BigDecimal b) {
        return a.divide(b, 0, RoundingMode.HALF_UP).toBigIntegerExact();
    }

    /** 5g 単位に丸める */
    static BigInteger round5(BigDecimal x) {
        return roundDiv(x, FIVE).multiply(BigInteger.valueOf(5));
    }

    /** a ÷ b の正確な値を小数第1位に四捨五入し、小数第1位が 0 なら整数で書く */
    static String gouText(BigDecimal a, BigDecimal b) {
        return a.divide(b, 1, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString();
    }

    public static Map<String, Object> calc(String mode, String value) {
        if (value == null || !DECIMAL.matcher(value).matches()) return error();
        BigDecimal v = new BigDecimal(value);
        if (v.signum() == 0) return error();

        BigDecimal riceG;
        String gouShown;
        switch (mode) {
            case "servings" -> {
                // 必要な合 = 杯数 × 150 ÷ (150 × 2.2) を 0.5合単位に（2倍して整数に丸め、2 で割る）
                BigInteger halves = roundDiv(v.multiply(BOWL_G).multiply(TWO), G_PER_GOU.multiply(COOK_MID));
                BigDecimal gou = new BigDecimal(halves).divide(TWO).max(HALF); // ÷ 2 は割り切れる
                gouShown = gouText(gou, BigDecimal.ONE);
                riceG = gou.multiply(G_PER_GOU);
            }
            case "grams" -> {
                riceG = v;
                gouShown = gouText(riceG, G_PER_GOU);
            }
            case "gou" -> {
                gouShown = gouText(v, BigDecimal.ONE);
                riceG = v.multiply(G_PER_GOU);
            }
            default -> {
                return error();
            }
        }

        BigDecimal cookedMid = riceG.multiply(COOK_MID);
        Map<String, Object> out = new LinkedHashMap<>();
        out.put("gou", gouShown);
        out.put("rice_g", roundDiv(riceG, BigDecimal.ONE));
        out.put("ml", roundDiv(riceG.multiply(ML_PER_GOU), G_PER_GOU));
        out.put("cooked_low", round5(riceG.multiply(COOK_LO)));
        out.put("cooked_high", round5(riceG.multiply(COOK_HI)));
        out.put("bowls", roundDiv(cookedMid, BOWL_G));
        out.put("onigiri", roundDiv(cookedMid, ONIGIRI_G));
        return out;
    }
}

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

/**
 * 米の量と炊き上がり・人数。
 * v1: 元ツール（app.js）と同じ考え方を、Java でいちばん普通に書いた形。double で掛け算・割り算し、Math.round で丸める。
 */
public final class Rice {
    private Rice() {}

    static final double G_PER_GOU = 150; // 生米1合のグラム
    static final double ML_PER_GOU = 180; // 生米1合の ml
    static final double COOK_LO = 2.1; // 炊き上がり倍率（下限）
    static final double COOK_MID = 2.2; // 炊き上がり倍率（中央）
    static final double COOK_HI = 2.3; // 炊き上がり倍率（上限）
    static final double BOWL_G = 150; // 茶碗1杯
    static final double ONIGIRI_G = 105; // おにぎり1個

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

    /** 5g 単位に丸める */
    static long round5(double x) {
        return Math.round(x / 5) * 5;
    }

    /** 合数の表示（小数第1位まで。整数ならそのまま） */
    static String fmtGou(double g) {
        double r = Math.round(g * 10) / 10.0;
        return r == Math.round(r) ? String.valueOf(Math.round(r)) : String.valueOf(r);
    }

    public static Map<String, Object> calc(String mode, String value) {
        double v;
        try {
            v = Double.parseDouble(value);
        } catch (NumberFormatException e) {
            return error();
        }
        if (v <= 0) return error();

        double riceG, gou;
        switch (mode) {
            case "servings" -> {
                double rawGou = v * BOWL_G / (G_PER_GOU * COOK_MID);
                gou = Math.round(rawGou * 2) / 2.0; // 0.5合単位
                if (gou < 0.5) gou = 0.5;
                riceG = gou * G_PER_GOU;
            }
            case "grams" -> {
                riceG = v;
                gou = riceG / G_PER_GOU;
            }
            case "gou" -> {
                gou = v;
                riceG = gou * G_PER_GOU;
            }
            default -> {
                return error();
            }
        }

        double cookedMid = riceG * COOK_MID;
        Map<String, Object> out = new LinkedHashMap<>();
        out.put("gou", fmtGou(gou));
        out.put("rice_g", Math.round(riceG));
        out.put("ml", Math.round(riceG / G_PER_GOU * ML_PER_GOU));
        out.put("cooked_low", round5(riceG * COOK_LO));
        out.put("cooked_high", round5(riceG * COOK_HI));
        out.put("bowls", Math.round(cookedMid / BOWL_G));
        out.put("onigiri", Math.round(cookedMid / ONIGIRI_G));
        return out;
    }
}

// 米の量と炊き上がり・人数。
// v2: 入力の文字列を decimal（10進の小数）で読み、Math.Round(x, MidpointRounding.AwayFromZero)（0.5 ちょうどは 0 から遠い方へ）で丸める。
// 掛け算と ÷ 5 は decimal で正確。÷ 150・÷ 105 は割り切れないことがあるが、その商は 0.5 ちょうどにはならず、
// decimal の 28〜29 桁の精度なら 0.5 との差（入力の小数の桁が少ない限り十分大きい）を取り違えない。
// v1 は double で 375 × 2.3 が 862.4999…になって 5g 単位の上限が 860g（正しくは 865g）になり、
// Math.Round の既定（偶数丸め）で 0.31合 = 46.5g → 46g、172.5g → 170g になっていた。
// 読み書きはカルチャに左右されないよう InvariantCulture。double.TryParse は "1e2"・"NaN"・空白も読むので、形を先に確かめる。
using System.Globalization;
using System.Text.RegularExpressions;

public static class Rice
{
    static readonly Regex DecimalForm = new(@"^[0-9]+(\.[0-9]+)?\z");

    const decimal GPerGou = 150m; // 生米1合のグラム
    const decimal MlPerGou = 180m; // 生米1合の ml
    const decimal CookLo = 2.1m; // 炊き上がり倍率（下限）
    const decimal CookMid = 2.2m; // 炊き上がり倍率（中央）
    const decimal CookHi = 2.3m; // 炊き上がり倍率（上限）
    const decimal BowlG = 150m; // 茶碗1杯
    const decimal OnigiriG = 105m; // おにぎり1個

    /// 整数に四捨五入（0.5 ちょうどは大きい方へ）
    static long R(decimal x) => (long)Math.Round(x, MidpointRounding.AwayFromZero); // long に収まらなければ OverflowException

    /// 5g 単位に丸める
    static long Round5(decimal x) => R(x / 5) * 5;

    /// 合数の表示（小数第1位に四捨五入。小数第1位が 0 なら整数で書く）
    static string FmtGou(decimal g) => Math.Round(g, 1, MidpointRounding.AwayFromZero).ToString("0.#", CultureInfo.InvariantCulture);

    public static Dictionary<string, object?> Calc(string mode, string value)
    {
        if (!DecimalForm.IsMatch(value))
            return new() { ["error"] = "invalid_input" };
        // 桁が decimal に収まらなければ OverflowException（そのケースだけ error になる）
        decimal v = decimal.Parse(value, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
        if (v == 0)
            return new() { ["error"] = "invalid_input" };

        decimal gou, riceG;
        switch (mode)
        {
            case "servings":
                // 必要な合 = 杯数 × 150 ÷ (150 × 2.2) を 0.5合単位に（2倍して整数に丸め、2 で割る）
                decimal halves = Math.Round(v * BowlG * 2 / (GPerGou * CookMid), MidpointRounding.AwayFromZero);
                gou = Math.Max(halves / 2, 0.5m);
                riceG = gou * GPerGou;
                break;
            case "grams":
                riceG = v;
                gou = riceG / GPerGou;
                break;
            case "gou":
                gou = v;
                riceG = gou * GPerGou;
                break;
            default:
                return new() { ["error"] = "invalid_input" };
        }

        decimal cookedMid = riceG * CookMid;
        return new()
        {
            ["gou"] = FmtGou(gou),
            ["rice_g"] = R(riceG),
            ["ml"] = R(riceG * MlPerGou / GPerGou),
            ["cooked_low"] = Round5(riceG * CookLo),
            ["cooked_high"] = Round5(riceG * CookHi),
            ["bowls"] = R(cookedMid / BowlG),
            ["onigiri"] = R(cookedMid / OnigiriG),
        };
    }
}

// 米の量と炊き上がり・人数。
// v1: 元ツール（app.js）と同じ考え方を、C# でいちばん普通に書いた形。double で掛け算・割り算し、Math.Round で丸める。
using System.Globalization;

public static class Rice
{
    const double GPerGou = 150; // 生米1合のグラム
    const double MlPerGou = 180; // 生米1合の ml
    const double CookLo = 2.1; // 炊き上がり倍率（下限）
    const double CookMid = 2.2; // 炊き上がり倍率（中央）
    const double CookHi = 2.3; // 炊き上がり倍率（上限）
    const double BowlG = 150; // 茶碗1杯
    const double OnigiriG = 105; // おにぎり1個

    /// 5g 単位に丸める
    static long Round5(double x) => (long)Math.Round(x / 5) * 5;

    /// 合数の表示（小数第1位まで。整数ならそのまま）
    static string FmtGou(double g)
    {
        double r = Math.Round(g * 10) / 10;
        return r == Math.Round(r) ? ((long)r).ToString(CultureInfo.InvariantCulture) : r.ToString(CultureInfo.InvariantCulture);
    }

    public static Dictionary<string, object?> Calc(string mode, string value)
    {
        if (!double.TryParse(value, CultureInfo.InvariantCulture, out double v) || v <= 0)
            return new() { ["error"] = "invalid_input" };

        double gou, riceG;
        switch (mode)
        {
            case "servings":
                double rawGou = v * BowlG / (GPerGou * CookMid);
                gou = Math.Round(rawGou * 2) / 2; // 0.5合単位
                if (gou < 0.5) gou = 0.5;
                riceG = gou * GPerGou;
                break;
            case "grams":
                riceG = v;
                gou = riceG / GPerGou;
                break;
            case "gou":
                gou = v;
                riceG = gou * GPerGou;
                break;
            default:
                return new() { ["error"] = "invalid_input" };
        }

        double cookedMid = riceG * CookMid;
        return new()
        {
            ["gou"] = FmtGou(gou),
            ["rice_g"] = (long)Math.Round(riceG),
            ["ml"] = (long)Math.Round(riceG / GPerGou * MlPerGou),
            ["cooked_low"] = Round5(riceG * CookLo),
            ["cooked_high"] = Round5(riceG * CookHi),
            ["bowls"] = (long)Math.Round(cookedMid / BowlG),
            ["onigiri"] = (long)Math.Round(cookedMid / OnigiriG),
        };
    }
}

//! 米の量と炊き上がり・人数。
//! v2: 小数を f64 で扱わない。入力の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、生米のグラム数を
//! 分数 p / q（整数）で持つ。各項目は「整数 a ÷ 整数 b」の形に直してから、余りが半分以上なら繰り上げる
//! （0.5 ちょうどは大きい方へ）。倍率 2.1・2.2・2.3 も 21/10・22/10・23/10 の分数で掛ける。
//! v1 は f64 で 375 × 2.3 が 862.4999…になり、(172.4999…).round() で 5g 単位の上限が 860g（正しくは 865g）になっていた。
//! parse::<f64>() は "1e2"・"inf"・"NaN" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。

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

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

/// 10進の数の文字列を (整数, 小数の桁数) に。形が違えば None。桁が u128 に収まらなければ Err
fn dec(text: &str) -> Result<Option<(u128, u32)>, 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)?;
    }
    Ok(Some((v, frac.len() as u32)))
}

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

/// a ÷ b（a ≥ 0・b > 0）を整数に四捨五入（余り × 2 ≥ b なら繰り上げ。× 2 であふれないよう引き算で比べる）
fn half_up(a: u128, b: u128) -> u128 {
    let (q, r) = (a / b, a % b);
    if r >= b - r { q + 1 } else { q }
}

pub fn calc(mode: &str, value: &str) -> Result<Value, String> {
    let invalid = || Ok(obj(vec![("error", s("invalid_input"))]));
    let Some((v, k)) = dec(value)? else { return invalid() };
    if v == 0 {
        return invalid();
    }
    let ten_k = 10u128.checked_pow(k).ok_or(OVERFLOW)?; // 入力 = v ÷ 10^k

    // 生米のグラム数 = p ÷ q
    let (p, q) = match mode {
        // 必要な合 = 杯数 × 150 ÷ (150 × 22/10) = 杯数 × 10/22。0.5合単位 = (杯数 × 20/22) を整数に丸めて ÷ 2
        "servings" => {
            let halves = half_up(mul(v, 20)?, mul(ten_k, 22)?).max(1); // 0.5合より少なければ 0.5合
            (mul(halves, 75)?, 1) // 0.5合 = 75g
        }
        "grams" => (v, ten_k),
        "gou" => (mul(v, 150)?, ten_k),
        _ => return invalid(),
    };

    // 合 × 10 = g ÷ 150 × 10 = p ÷ (15q)
    let tenths = half_up(p, mul(q, 15)?);
    let gou = if tenths % 10 == 0 { format!("{}", tenths / 10) } else { format!("{}.{}", tenths / 10, tenths % 10) };
    Ok(obj(vec![
        ("gou", s(gou)),
        ("rice_g", n(half_up(p, q))),
        ("ml", n(half_up(mul(p, 180)?, mul(q, 150)?))),
        // g × 21/10 ÷ 5 = 21p ÷ 50q
        ("cooked_low", n(mul(half_up(mul(p, 21)?, mul(q, 50)?), 5)?)),
        ("cooked_high", n(mul(half_up(mul(p, 23)?, mul(q, 50)?), 5)?)),
        // g × 22/10 ÷ 150、÷ 105
        ("bowls", n(half_up(mul(p, 22)?, mul(q, 1500)?))),
        ("onigiri", n(half_up(mul(p, 22)?, mul(q, 1050)?))),
    ]))
}

//! 米の量と炊き上がり・人数。
//! v1: 元ツール（app.js）と同じ考え方を、Rust でいちばん普通に書いた形。f64 で掛け算・割り算し、.round() で丸める。

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

const G_PER_GOU: f64 = 150.0; // 生米1合のグラム
const ML_PER_GOU: f64 = 180.0; // 生米1合の ml
const COOK_LO: f64 = 2.1; // 炊き上がり倍率（下限）
const COOK_MID: f64 = 2.2; // 炊き上がり倍率（中央）
const COOK_HI: f64 = 2.3; // 炊き上がり倍率（上限）
const BOWL_G: f64 = 150.0; // 茶碗1杯
const ONIGIRI_G: f64 = 105.0; // おにぎり1個

/// 5g 単位に丸める
fn round5(x: f64) -> i64 {
    (x / 5.0).round() as i64 * 5
}

/// 合数の表示（小数第1位まで。整数ならそのまま）
fn fmt_gou(g: f64) -> String {
    let r = (g * 10.0).round() / 10.0;
    if r == r.round() { format!("{}", r as i64) } else { r.to_string() }
}

pub fn calc(mode: &str, value: &str) -> Result<Value, String> {
    let invalid = || Ok(obj(vec![("error", s("invalid_input"))]));
    let v: f64 = match value.parse() {
        Ok(v) => v,
        Err(_) => return invalid(),
    };
    if v <= 0.0 {
        return invalid();
    }

    let (gou, rice_g) = match mode {
        "servings" => {
            let raw_gou = v * BOWL_G / (G_PER_GOU * COOK_MID);
            let gou = ((raw_gou * 2.0).round() / 2.0).max(0.5); // 0.5合単位
            (gou, gou * G_PER_GOU)
        }
        "grams" => (v / G_PER_GOU, v),
        "gou" => (v, v * G_PER_GOU),
        _ => return invalid(),
    };

    let cooked_mid = rice_g * COOK_MID;
    Ok(obj(vec![
        ("gou", s(fmt_gou(gou))),
        ("rice_g", n(rice_g.round() as i64)),
        ("ml", n((rice_g / G_PER_GOU * ML_PER_GOU).round() as i64)),
        ("cooked_low", n(round5(rice_g * COOK_LO))),
        ("cooked_high", n(round5(rice_g * COOK_HI))),
        ("bowls", n((cooked_mid / BOWL_G).round() as i64)),
        ("onigiri", n((cooked_mid / ONIGIRI_G).round() as i64)),
    ]))
}

# 米の量と炊き上がり・人数。
# v2: 値を Rational（正確な分数）で10進のまま読み、掛け算・割り算を正確に行って、0.5 ちょうどは大きい方へ四捨五入する。
# v1 の Float では 375 × 2.3 が 862.4999… になって 5g 単位で 860g に落ちた（元ツールと同じ食い違い）。

module Rice
  module_function

  DECIMAL = /\A[0-9]+(\.[0-9]+)?\z/
  G_PER_GOU = 150
  ML_PER_GOU = 180
  COOK_LO = Rational("2.1")
  COOK_MID = Rational("2.2")
  COOK_HI = Rational("2.3")
  BOWL_G = 150
  ONIGIRI_G = 105

  # Rational() は "1e3"・"1/2"・"1_000" も読むので、先に形を確かめる
  def read_value(s)
    s.is_a?(String) && DECIMAL.match?(s) ? Rational(s) : nil
  end

  # 0 以上の x を整数に四捨五入（0.5 ちょうどは大きい方へ）
  def half_up(x)
    (x + Rational(1, 2)).floor
  end

  def round5(x)
    half_up(x / 5) * 5
  end

  # 合を小数第1位に四捨五入し、小数第1位が 0 なら整数で書く
  def gou_text(g)
    t = half_up(g * 10)
    (t % 10).zero? ? (t / 10).to_s : "#{t / 10}.#{t % 10}"
  end

  def rice(mode:, value:)
    v = read_value(value)
    return { "error" => "invalid_input" } if v.nil? || v <= 0 || !%w[gou servings grams].include?(mode)

    case mode
    when "servings"
      gou = Rational(half_up(v * BOWL_G / (G_PER_GOU * COOK_MID) * 2), 2) # 0.5合単位
      gou = Rational(1, 2) if gou < Rational(1, 2)
      g = gou * G_PER_GOU
    when "grams"
      g = v
      gou = g / G_PER_GOU
    else
      gou = v
      g = gou * G_PER_GOU
    end
    {
      "gou" => gou_text(gou),
      "rice_g" => half_up(g),
      "ml" => half_up(g / G_PER_GOU * ML_PER_GOU),
      "cooked_low" => round5(g * COOK_LO),
      "cooked_high" => round5(g * COOK_HI),
      "bowls" => half_up(g * COOK_MID / BOWL_G),
      "onigiri" => half_up(g * COOK_MID / ONIGIRI_G)
    }
  end
end

# 米の量と炊き上がり・人数。
# v1: 元ツールと同じく値を Float() で読み、掛け算・割り算を Float のまま行って、round で丸める素直な書き方。
# 5g 単位は (x / 5).round * 5、0.5合単位は (x * 2).round / 2.0、合の表示は (x * 10).round / 10.0 を整数なら整数で書く。

module Rice
  module_function

  G_PER_GOU = 150
  ML_PER_GOU = 180
  COOK_LO = 2.1
  COOK_MID = 2.2
  COOK_HI = 2.3
  BOWL_G = 150
  ONIGIRI_G = 105

  def round5(x)
    (x / 5).round * 5
  end

  def gou_text(g)
    r = (g * 10).round / 10.0
    r == r.to_i ? r.to_i.to_s : r.to_s
  end

  def rice(mode:, value:)
    v = Float(value)
    return { "error" => "invalid_input" } if v <= 0 || !%w[gou servings grams].include?(mode)

    case mode
    when "servings"
      gou = (v * BOWL_G / (G_PER_GOU * COOK_MID) * 2).round / 2.0 # 0.5合単位
      gou = 0.5 if gou < 0.5
      g = gou * G_PER_GOU
    when "grams"
      g = v
      gou = g / G_PER_GOU
    else
      gou = v
      g = gou * G_PER_GOU
    end
    {
      "gou" => gou_text(gou),
      "rice_g" => g.round,
      "ml" => (g / G_PER_GOU * ML_PER_GOU).round,
      "cooked_low" => round5(g * COOK_LO),
      "cooked_high" => round5(g * COOK_HI),
      "bowls" => (g * COOK_MID / BOWL_G).round,
      "onigiri" => (g * COOK_MID / ONIGIRI_G).round
    }
  rescue ArgumentError, TypeError
    { "error" => "invalid_input" }
  end
end

import java.math.BigDecimal
import java.math.BigInteger
import java.math.RoundingMode

// 米の量と炊き上がり・人数。
// v2: 入力の文字列を BigDecimal（10進のまま）で読み、掛け算は正確に、割り算は divide(…, 桁, RoundingMode.HALF_UP)
// （正確な商を 0.5 ちょうどは大きい方へ丸める）で行う。
// v1 は Double で 375 × 2.3 が 862.4999…になり、roundToLong(172.4999…) で 5g 単位の上限が 860g（正しくは 865g）になっていた。
// toDoubleOrNull は "1e2"・"NaN" も読むので、入力は 10進の数の形かを先に確かめる。

private val DECIMAL = Regex("[0-9]+(\\.[0-9]+)?")
private val G_PER_GOU = BigDecimal(150) // 生米1合のグラム
private val ML_PER_GOU = BigDecimal(180) // 生米1合の ml
private val COOK_LO = BigDecimal("2.1") // 炊き上がり倍率（下限）
private val COOK_MID = BigDecimal("2.2") // 炊き上がり倍率（中央）
private val COOK_HI = BigDecimal("2.3") // 炊き上がり倍率（上限）
private val BOWL_G = BigDecimal(150) // 茶碗1杯
private val ONIGIRI_G = BigDecimal(105) // おにぎり1個
private val TWO = BigDecimal(2)
private val FIVE = BigDecimal(5)
private val HALF = BigDecimal("0.5")

/** a ÷ b の正確な値を整数に四捨五入（0.5 ちょうどは大きい方へ） */
private fun roundDiv(a: BigDecimal, b: BigDecimal): BigInteger = a.divide(b, 0, RoundingMode.HALF_UP).toBigIntegerExact()

/** 5g 単位に丸める */
private fun round5(x: BigDecimal): BigInteger = roundDiv(x, FIVE) * BigInteger.valueOf(5)

/** a ÷ b の正確な値を小数第1位に四捨五入し、小数第1位が 0 なら整数で書く */
private fun gouText(a: BigDecimal, b: BigDecimal): String =
    a.divide(b, 1, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString()

fun riceAmounts(mode: String, value: String): Map<String, Any?> {
    if (!DECIMAL.matches(value)) return linkedMapOf("error" to "invalid_input")
    val v = BigDecimal(value)
    if (v.signum() == 0) return linkedMapOf("error" to "invalid_input")

    val gouShown: String
    val riceG: BigDecimal
    when (mode) {
        "servings" -> {
            // 必要な合 = 杯数 × 150 ÷ (150 × 2.2) を 0.5合単位に（2倍して整数に丸め、2 で割る）
            val halves = roundDiv(v * BOWL_G * TWO, G_PER_GOU * COOK_MID)
            val gou = BigDecimal(halves).divide(TWO).max(HALF) // ÷ 2 は割り切れる
            gouShown = gouText(gou, BigDecimal.ONE)
            riceG = gou * G_PER_GOU
        }
        "grams" -> {
            riceG = v
            gouShown = gouText(riceG, G_PER_GOU)
        }
        "gou" -> {
            gouShown = gouText(v, BigDecimal.ONE)
            riceG = v * G_PER_GOU
        }
        else -> return linkedMapOf("error" to "invalid_input")
    }

    val cookedMid = riceG * COOK_MID
    return linkedMapOf(
        "gou" to gouShown,
        "rice_g" to roundDiv(riceG, BigDecimal.ONE),
        "ml" to roundDiv(riceG * ML_PER_GOU, G_PER_GOU),
        "cooked_low" to round5(riceG * COOK_LO),
        "cooked_high" to round5(riceG * COOK_HI),
        "bowls" to roundDiv(cookedMid, BOWL_G),
        "onigiri" to roundDiv(cookedMid, ONIGIRI_G),
    )
}

import kotlin.math.roundToLong

// 米の量と炊き上がり・人数。
// v1: 元ツール（app.js）と同じ考え方を、Kotlin でいちばん普通に書いた形。Double で掛け算・割り算し、roundToLong で丸める。

private const val G_PER_GOU = 150.0 // 生米1合のグラム
private const val ML_PER_GOU = 180.0 // 生米1合の ml
private const val COOK_LO = 2.1 // 炊き上がり倍率（下限）
private const val COOK_MID = 2.2 // 炊き上がり倍率（中央）
private const val COOK_HI = 2.3 // 炊き上がり倍率（上限）
private const val BOWL_G = 150.0 // 茶碗1杯
private const val ONIGIRI_G = 105.0 // おにぎり1個

/** 5g 単位に丸める */
private fun round5(x: Double): Long = (x / 5).roundToLong() * 5

/** 合数の表示（小数第1位まで。整数ならそのまま） */
private fun fmtGou(g: Double): String {
    val r = (g * 10).roundToLong() / 10.0
    return if (r == r.roundToLong().toDouble()) r.roundToLong().toString() else r.toString()
}

fun riceAmounts(mode: String, value: String): Map<String, Any?> {
    val v = value.toDoubleOrNull()
    if (v == null || v <= 0) return linkedMapOf("error" to "invalid_input")

    val gou: Double
    val riceG: Double
    when (mode) {
        "servings" -> {
            val rawGou = v * BOWL_G / (G_PER_GOU * COOK_MID)
            gou = maxOf((rawGou * 2).roundToLong() / 2.0, 0.5) // 0.5合単位
            riceG = gou * G_PER_GOU
        }
        "grams" -> {
            riceG = v
            gou = riceG / G_PER_GOU
        }
        "gou" -> {
            gou = v
            riceG = gou * G_PER_GOU
        }
        else -> return linkedMapOf("error" to "invalid_input")
    }

    val cookedMid = riceG * COOK_MID
    return linkedMapOf(
        "gou" to fmtGou(gou),
        "rice_g" to riceG.roundToLong(),
        "ml" to (riceG / G_PER_GOU * ML_PER_GOU).roundToLong(),
        "cooked_low" to round5(riceG * COOK_LO),
        "cooked_high" to round5(riceG * COOK_HI),
        "bowls" to (cookedMid / BOWL_G).roundToLong(),
        "onigiri" to (cookedMid / ONIGIRI_G).roundToLong(),
    )
}

// 米の量と炊き上がり・人数。
// v2: 小数を Double で扱わない。入力の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、生米のグラム数を
// 分数 p / q（整数）で持つ。各項目は「整数 a ÷ 整数 b」の形に直してから、余りが半分以上なら繰り上げる
// （0.5 ちょうどは大きい方へ）。倍率 2.1・2.2・2.3 も 21/10・22/10・23/10 の分数で掛ける。
// v1 は Double で 375 × 2.3 が 862.4999…になり、(172.4999…).rounded() で 5g 単位の上限が 860g（正しくは 865g）になっていた。
// Double(s) は "1e2"・"inf"・"nan" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
// 桁あふれは（Swift の既定の trap でプロセスを止めず）例外にする。

/// 10進の数の文字列を (整数, 小数の桁数) に。形が違えば nil。桁が Int に収まらなければ例外
private func dec(_ text: String) throws -> (n: Int, scale: Int)? {
    let parts = text.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let isDigits = { (p: Substring) in !p.isEmpty && p.unicodeScalars.allSatisfy { $0 >= "0" && $0 <= "9" } }
    guard parts.allSatisfy(isDigits) else { return nil }
    let frac = parts.count == 2 ? parts[1] : ""
    var n = 0
    for u in (parts[0] + frac).unicodeScalars {
        n = try add(try mul(n, 10), Int(u.value - 48))
    }
    return (n, frac.count)
}

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

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

/// a ÷ b（a ≥ 0・b > 0）を整数に四捨五入（余り × 2 ≥ b なら繰り上げ。× 2 であふれないよう引き算で比べる）
private func halfUp(_ a: Int, _ b: Int) -> Int {
    let (q, r) = (a / b, a % b)
    return r >= b - r ? q + 1 : q
}

func riceAmounts(mode: String, value: String) throws -> [String: Any] {
    guard let d = try dec(value), d.n > 0 else { return ["error": "invalid_input"] }
    let (v, k) = (d.n, d.scale)
    var tenK = 1 // 入力 = v ÷ 10^k
    for _ in 0..<k { tenK = try mul(tenK, 10) }

    // 生米のグラム数 = p ÷ q
    let p: Int, q: Int
    switch mode {
    case "servings":
        // 必要な合 = 杯数 × 150 ÷ (150 × 22/10) = 杯数 × 10/22。0.5合単位 = (杯数 × 20/22) を整数に丸めて ÷ 2
        let halves = max(halfUp(try mul(v, 20), try mul(tenK, 22)), 1) // 0.5合より少なければ 0.5合
        (p, q) = (try mul(halves, 75), 1) // 0.5合 = 75g
    case "grams":
        (p, q) = (v, tenK)
    case "gou":
        (p, q) = (try mul(v, 150), tenK)
    default:
        return ["error": "invalid_input"]
    }

    // 合 × 10 = g ÷ 150 × 10 = p ÷ (15q)
    let tenths = halfUp(p, try mul(q, 15))
    let gou = tenths % 10 == 0 ? "\(tenths / 10)" : "\(tenths / 10).\(tenths % 10)"
    return [
        "gou": gou,
        "rice_g": halfUp(p, q),
        "ml": halfUp(try mul(p, 180), try mul(q, 150)),
        // g × 21/10 ÷ 5 = 21p ÷ 50q
        "cooked_low": try mul(halfUp(try mul(p, 21), try mul(q, 50)), 5),
        "cooked_high": try mul(halfUp(try mul(p, 23), try mul(q, 50)), 5),
        // g × 22/10 ÷ 150、÷ 105
        "bowls": halfUp(try mul(p, 22), try mul(q, 1500)),
        "onigiri": halfUp(try mul(p, 22), try mul(q, 1050)),
    ]
}

// ランナー規約（標準入力の 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 で掛け算・割り算し、.rounded() で丸める。

private let gPerGou = 150.0 // 生米1合のグラム
private let mlPerGou = 180.0 // 生米1合の ml
private let cookLo = 2.1 // 炊き上がり倍率（下限）
private let cookMid = 2.2 // 炊き上がり倍率（中央）
private let cookHi = 2.3 // 炊き上がり倍率（上限）
private let bowlG = 150.0 // 茶碗1杯
private let onigiriG = 105.0 // おにぎり1個

/// 5g 単位に丸める
private func round5(_ x: Double) -> Int {
    Int((x / 5).rounded()) * 5
}

/// 合数の表示（小数第1位まで。整数ならそのまま）
private func fmtGou(_ g: Double) -> String {
    let r = (g * 10).rounded() / 10
    return r == r.rounded() ? String(Int(r)) : String(r)
}

func riceAmounts(mode: String, value: String) throws -> [String: Any] {
    guard let v = Double(value), v > 0 else { return ["error": "invalid_input"] }

    let gou: Double
    let riceG: Double
    switch mode {
    case "servings":
        let rawGou = v * bowlG / (gPerGou * cookMid)
        gou = max((rawGou * 2).rounded() / 2, 0.5) // 0.5合単位
        riceG = gou * gPerGou
    case "grams":
        riceG = v
        gou = riceG / gPerGou
    case "gou":
        gou = v
        riceG = gou * gPerGou
    default:
        return ["error": "invalid_input"]
    }

    let cookedMid = riceG * cookMid
    return [
        "gou": fmtGou(gou),
        "rice_g": Int(riceG.rounded()),
        "ml": Int((riceG / gPerGou * mlPerGou).rounded()),
        "cooked_low": round5(riceG * cookLo),
        "cooked_high": round5(riceG * cookHi),
        "bowls": Int((cookedMid / bowlG).rounded()),
        "onigiri": Int((cookedMid / onigiriG).rounded()),
    ]
}

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