ローレル指数

<?php
declare(strict_types=1);

/**
 * ローレル指数。
 * v2: 身長・体重の文字列を float に読まず、小数点を外した数字の列（10^桁数 倍した整数）として10進のまま読み、
 * 指数を「分子 ÷ 分母」の整数の組で正確に持つ。区分は分子と「境目 × 分母」を比べ、
 * 表示は小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
 * v1 の float では 160cm・59.392kg の指数 145 ちょうどが 144.99999999999997 になって「ふつう（標準）」に落ち、
 * 160cm・12.8kg の 31.25 が 31.249999999999996 になって sprintf('%.1f') で 31.2 に落ちた。
 * 身長の3乗に 10 の累乗を掛けると int の上限（約 9.2 × 10^18）を超えうるので、整数は数字の列のまま筆算する
 * （bcmath・gmp は入っていない環境があるので使わない）。
 */
const DECIMAL = '/^[0-9]+(\.[0-9]+)?$/D'; // D: $ を末尾の改行の前で一致させない
const BANDS = [['100', 'やせ'], ['115', 'やせ気味'], ['145', 'ふつう（標準）'], ['160', '太り気味']];

/** 先頭の 0 を外す（0 は "0"） */
function digitsNorm(string $a): string
{
    $a = ltrim($a, '0');
    return $a === '' ? '0' : $a;
}

/** 0 以上の整数（数字の列）の大小。-1・0・1 */
function digitsCmp(string $a, string $b): int
{
    return strlen($a) <=> strlen($b) ?: strcmp($a, $b) <=> 0;
}

function digitsAdd(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 digitsNorm(($carry ? '1' : '') . $out);
}

/** $a - $b（$a >= $b のとき） */
function digitsSub(string $a, string $b): string
{
    $b = str_pad($b, strlen($a), '0', STR_PAD_LEFT);
    $out = '';
    $borrow = 0;
    for ($i = strlen($a) - 1; $i >= 0; $i--) {
        $d = (int) $a[$i] - (int) $b[$i] - $borrow;
        $borrow = $d < 0 ? 1 : 0;
        $out = ($d + 10 * $borrow) . $out;
    }
    return digitsNorm($out);
}

function digitsMul(string $a, string $b): string
{
    $la = strlen($a);
    $lb = strlen($b);
    $acc = array_fill(0, $la + $lb, 0);
    for ($i = $la - 1; $i >= 0; $i--) {
        for ($j = $lb - 1; $j >= 0; $j--) {
            $acc[$i + $j + 1] += (int) $a[$i] * (int) $b[$j];
        }
    }
    for ($k = $la + $lb - 1; $k > 0; $k--) {
        $acc[$k - 1] += intdiv($acc[$k], 10);
        $acc[$k] %= 10;
    }
    return digitsNorm(implode('', $acc));
}

/** 筆算の割り算。[商, 余り] */
function digitsDivMod(string $a, string $b): array
{
    $q = '';
    $r = '0';
    for ($i = 0, $n = strlen($a); $i < $n; $i++) {
        $r = digitsNorm($r . $a[$i]);
        $d = 0;
        while (digitsCmp($r, $b) >= 0) {
            $r = digitsSub($r, $b);
            $d++;
        }
        $q .= $d;
    }
    return [digitsNorm($q), $r];
}

/** 0 以上の $num ÷ $den を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "31.3" の形にする */
function fmt1(string $num, string $den): string
{
    [$q, $r] = digitsDivMod($num . '0', $den);  // 10 倍して割る
    if (digitsCmp(digitsAdd($r, $r), $den) >= 0) {
        $q = digitsAdd($q, '1');
    }
    $q = str_pad($q, 2, '0', STR_PAD_LEFT);
    return substr($q, 0, -1) . '.' . substr($q, -1);
}

/** "21.97" → ['2197', 2]（値 = 数字の列 ÷ 10^桁数）。読めなければ null */
function readDecimal($s): ?array
{
    if (!is_string($s) || !preg_match(DECIMAL, $s)) {
        return null;
    }
    [$int, $frac] = explode('.', $s . '.');
    return [digitsNorm($int . $frac), strlen($frac)];
}

/** @param array{height_cm: string, weight_kg: string} $in */
function roehrer(array $in): array
{
    $h = readDecimal($in['height_cm'] ?? null);
    $w = readDecimal($in['weight_kg'] ?? null);
    if ($h === null || $w === null || $h[0] === '0' || $w[0] === '0') {
        return ['error' => 'invalid_input'];
    }
    // 身長(m)³ = h³ ÷ 10^(3 × 桁数 + 6)
    $cubeNum = digitsMul(digitsMul($h[0], $h[0]), $h[0]);
    $cubeDen = '1' . str_repeat('0', 3 * $h[1] + 6);
    // 指数 = 体重 ÷ 身長(m)³ × 10 = (w × cubeDen × 10) ÷ (10^桁数 × cubeNum)
    $num = $w[0] . substr($cubeDen, 1) . '0';
    $den = $cubeNum . str_repeat('0', $w[1]);
    $category = '肥満';
    foreach (BANDS as [$bound, $name]) {
        if (digitsCmp($num, digitsMul($bound, $den)) < 0) {
            $category = $name;
            break;
        }
    }
    return [
        'index' => fmt1($num, $den),
        'category' => $category,
        'normal_low' => fmt1(digitsMul('115', $cubeNum), $cubeDen . '0'),
        'normal_high' => fmt1(digitsMul('145', $cubeNum), $cubeDen . '0'),
    ];
}

<?php
declare(strict_types=1);

/**
 * ローレル指数。
 * v1: 身長・体重を float に読み、体重 ÷ (身長 ÷ 100) ** 3 × 10 を計算して、区分は丸める前の指数を < で比べ、
 * 指数とふつうの体重の目安を sprintf('%.1f') で書く素直な書き方。
 */

function roehrerCategory(float $index): string
{
    if ($index < 100) return 'やせ';
    if ($index < 115) return 'やせ気味';
    if ($index < 145) return 'ふつう（標準）';
    if ($index < 160) return '太り気味';
    return '肥満';
}

/** @param array{height_cm: string, weight_kg: string} $in */
function roehrer(array $in): array
{
    if (!is_numeric($in['height_cm']) || !is_numeric($in['weight_kg'])) {
        return ['error' => 'invalid_input'];
    }
    $height = (float) $in['height_cm'];
    $weight = (float) $in['weight_kg'];
    if ($height <= 0 || $weight <= 0) {
        return ['error' => 'invalid_input'];
    }
    $hm = $height / 100;
    $index = $weight / $hm ** 3 * 10;
    return [
        'index' => sprintf('%.1f', $index),
        'category' => roehrerCategory($index),
        'normal_low' => sprintf('%.1f', 115 * $hm ** 3 / 10),
        'normal_high' => sprintf('%.1f', 145 * $hm ** 3 / 10),
    ];
}

"""ローレル指数。

v2: 身長・体重の文字列を fractions.Fraction（正確な分数）で10進のまま読み、体重 ÷ (身長 ÷ 100)³ × 10 を正確に計算する。
区分は正確な指数を境目と比べ、表示は小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
v1 の float では 160cm・59.392kg の指数 145 ちょうどが 144.99999999999997 になって「ふつう（標準）」に落ち、
160cm・12.8kg の 31.25 が 31.249999999999996 になって f"{:.1f}" で 31.2 に落ちた。
"""
import re
from fractions import Fraction

DECIMAL = re.compile(r"[0-9]+(\.[0-9]+)?")
BANDS = [(100, "やせ"), (115, "やせ気味"), (145, "ふつう（標準）"), (160, "太り気味")]


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


def fmt1(x):
    """0 以上の x を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "31.3" の形に"""
    n = int(x * 10 + Fraction(1, 2))  # 正の数なので int は切り捨て
    return f"{n // 10}.{n % 10}"


def roehrer(height_cm, weight_kg):
    height, weight = read_decimal(height_cm), read_decimal(weight_kg)
    if height is None or weight is None or height <= 0 or weight <= 0:
        return {"error": "invalid_input"}
    cube = (height / 100) ** 3
    index = weight / cube * 10
    category = next((name for b, name in BANDS if index < b), "肥満")
    return {"index": fmt1(index), "category": category,
            "normal_low": fmt1(115 * cube / 10), "normal_high": fmt1(145 * cube / 10)}

"""ローレル指数。

v1: 身長・体重を float に読み、体重 ÷ (身長 ÷ 100) ** 3 × 10 を計算して、区分は丸める前の指数を < で比べ、
指数とふつうの体重の目安を f"{:.1f}" で書く素直な書き方。
"""

BANDS = [(100, "やせ"), (115, "やせ気味"), (145, "ふつう（標準）"), (160, "太り気味")]


def roehrer(height_cm, weight_kg):
    try:
        height = float(height_cm)
        weight = float(weight_kg)
    except ValueError:
        return {"error": "invalid_input"}
    if height <= 0 or weight <= 0:
        return {"error": "invalid_input"}
    hm = height / 100
    index = weight / hm ** 3 * 10
    category = next((name for b, name in BANDS if index < b), "肥満")
    return {"index": f"{index:.1f}", "category": category,
            "normal_low": f"{115 * hm ** 3 / 10:.1f}", "normal_high": f"{145 * hm ** 3 / 10:.1f}"}

package main

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

// v2: 身長・体重の文字列を big.Rat（正確な分数）で10進のまま読み、体重 ÷ (身長 ÷ 100)³ × 10 を正確に計算する。
// 区分は正確な指数を境目と比べ、表示は小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
// float64 だと 130cm・21.97kg の指数 100 ちょうどが 99.99999999999997 になって「やせ」に落ち、
// 160cm・12.8kg の 31.25 が 31.249999999999996 になって %.1f で 31.2 に落ちる。

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

var bands = []struct {
	bound int64
	name  string
}{{100, "やせ"}, {115, "やせ気味"}, {145, "ふつう（標準）"}, {160, "太り気味"}}

func readDecimal(s string) (*big.Rat, bool) {
	if !decimal.MatchString(s) {
		return nil, false
	}
	return new(big.Rat).SetString(s)
}

// fmt1 は 0 以上の x を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "31.3" の形にする。
func fmt1(x *big.Rat) string {
	t := new(big.Int).Mul(x.Num(), big.NewInt(10))
	q, r := new(big.Int).QuoRem(t, x.Denom(), new(big.Int)) // 0 以上なので QuoRem は切り捨て
	if r.Lsh(r, 1).Cmp(x.Denom()) >= 0 {
		q.Add(q, big.NewInt(1))
	}
	ten := big.NewInt(10)
	d := new(big.Int)
	q.QuoRem(q, ten, d)
	return fmt.Sprintf("%s.%s", q.String(), d.String())
}

func ratInt(n int64) *big.Rat { return new(big.Rat).SetInt64(n) }

func Roehrer(heightCm, weightKg string) map[string]any {
	height, ok1 := readDecimal(heightCm)
	weight, ok2 := readDecimal(weightKg)
	if !ok1 || !ok2 || height.Sign() <= 0 || weight.Sign() <= 0 {
		return map[string]any{"error": "invalid_input"}
	}
	hm := new(big.Rat).Quo(height, ratInt(100))
	cube := new(big.Rat).Mul(hm, hm)
	cube.Mul(cube, hm)
	index := new(big.Rat).Quo(weight, cube)
	index.Mul(index, ratInt(10))
	category := "肥満"
	for _, b := range bands {
		if index.Cmp(ratInt(b.bound)) < 0 {
			category = b.name
			break
		}
	}
	low := new(big.Rat).Mul(ratInt(115), cube)
	high := new(big.Rat).Mul(ratInt(145), cube)
	return map[string]any{
		"index":       fmt1(index),
		"category":    category,
		"normal_low":  fmt1(low.Quo(low, ratInt(10))),
		"normal_high": fmt1(high.Quo(high, ratInt(10))),
	}
}

package main

import (
	"fmt"
	"math"
	"strconv"
)

// v1: 身長・体重を float64 に読み、体重 ÷ math.Pow(身長 ÷ 100, 3) × 10 を計算して、区分は丸める前の指数を < で比べ、
// 指数とふつうの体重の目安を %.1f で書く素直な書き方。

func category(index float64) string {
	switch {
	case index < 100:
		return "やせ"
	case index < 115:
		return "やせ気味"
	case index < 145:
		return "ふつう（標準）"
	case index < 160:
		return "太り気味"
	}
	return "肥満"
}

func Roehrer(heightCm, weightKg string) map[string]any {
	height, err1 := strconv.ParseFloat(heightCm, 64)
	weight, err2 := strconv.ParseFloat(weightKg, 64)
	if err1 != nil || err2 != nil || height <= 0 || weight <= 0 {
		return map[string]any{"error": "invalid_input"}
	}
	cube := math.Pow(height/100, 3)
	index := weight / cube * 10
	return map[string]any{
		"index":       fmt.Sprintf("%.1f", index),
		"category":    category(index),
		"normal_low":  fmt.Sprintf("%.1f", 115*cube/10),
		"normal_high": fmt.Sprintf("%.1f", 145*cube/10),
	}
}

// ローレル指数。
// v2: 身長・体重の文字列を Number に読まず、10^桁数 倍した BigInt（整数）として10進のまま読み、
// 指数を「分子 ÷ 分母」の BigInt の組で正確に持つ。区分は分子と「境目 × 分母」を比べ、
// 表示は小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
// 元ツール（v1）の Number では 130cm・21.97kg の指数 100 ちょうどが 99.99999999999997 になって「やせ」に落ち、
// 160cm・12.8kg の 31.25 が 31.249999999999996 になって toFixed(1) で 31.2 に落ちる。

const DECIMAL = /^[0-9]+(\.[0-9]+)?$/;
const BANDS = [[100n, "やせ"], [115n, "やせ気味"], [145n, "ふつう（標準）"], [160n, "太り気味"]];

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

/** 0 以上の num ÷ den を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "31.3" の形に */
function fmt1(num, den) {
  // 10 × num ÷ den + 0.5 の切り捨て = (20 × num + den) ÷ (2 × den)。BigInt の割り算は正の数なら切り捨て
  const n = (20n * num + den) / (2n * den);
  return `${n / 10n}.${n % 10n}`;
}

export function roehrer({ height_cm, weight_kg }) {
  const h = readDecimal(height_cm);
  const w = readDecimal(weight_kg);
  if (h === null || w === null || h.n <= 0n || w.n <= 0n) return { error: "invalid_input" };
  // 身長(m)³ = h.n³ ÷ 10^(3 × h.scale + 6)
  const cubeNum = h.n ** 3n;
  const cubeDen = 10n ** BigInt(3 * h.scale + 6);
  // 指数 = 体重 ÷ 身長(m)³ × 10 = (w.n × cubeDen × 10) ÷ (10^w.scale × cubeNum)
  const num = w.n * cubeDen * 10n;
  const den = 10n ** BigInt(w.scale) * cubeNum;
  const band = BANDS.find(([b]) => num < b * den);
  return {
    index: fmt1(num, den),
    category: band ? band[1] : "肥満",
    normal_low: fmt1(115n * cubeNum, cubeDen * 10n),
    normal_high: fmt1(145n * cubeNum, cubeDen * 10n),
  };
}

// ローレル指数。
// v1: 元ツールと同じく、身長・体重を parseFloat で Number に読み、体重 ÷ (身長 ÷ 100 を3回掛けた値) × 10 を計算して、
// 区分は丸める前の指数を < で比べ、指数とふつうの体重の目安を toFixed(1) で書く素直な書き方。

function judge(index) {
  if (index < 100) return "やせ";
  if (index < 115) return "やせ気味";
  if (index < 145) return "ふつう（標準）";
  if (index < 160) return "太り気味";
  return "肥満";
}

function readPositive(s) {
  const v = parseFloat(s);
  return Number.isFinite(v) && v > 0 ? v : null;
}

export function roehrer({ height_cm, weight_kg }) {
  const heightCm = readPositive(height_cm);
  const weightKg = readPositive(weight_kg);
  if (heightCm === null || weightKg === null) return { error: "invalid_input" };
  const heightM = heightCm / 100;
  const index = (weightKg / (heightM * heightM * heightM)) * 10;
  return {
    index: index.toFixed(1),
    category: judge(index),
    normal_low: ((115 * heightM * heightM * heightM) / 10).toFixed(1),
    normal_high: ((145 * heightM * heightM * heightM) / 10).toFixed(1),
  };
}

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

/**
 * ローレル指数。
 * v2: 身長・体重の文字列を BigDecimal（10進のまま）で読み、(身長 ÷ 100)³ を正確に出す。
 * 区分は「指数 < 境目」を「体重 × 10 < 境目 × (身長 ÷ 100)³」に直して正確に比べ、
 * 指数は divide(…, 1, RoundingMode.HALF_UP)（正確な商を 0.5 ちょうどは大きい方へ）で丸める。目安も HALF_UP。
 * v1 は double で 1.3³ などが2進数の小数になり、指数がちょうど 100・115・145・160 になる入力で境目のわずかに下に入って
 * 下の区分になり、31.25 が 31.249999… になって 31.2 と出ていた。
 * Double.parseDouble は "1e2"・"NaN"・前後の空白も読むので、入力は 10進の数の形かを先に確かめる。
 */
public final class Roehrer {
    private Roehrer() {}

    private static final Pattern DECIMAL = Pattern.compile("[0-9]+(\\.[0-9]+)?");
    private static final BigDecimal TEN = BigDecimal.TEN;
    private static final int[] BOUNDS = {100, 115, 145, 160};
    private static final String[] NAMES = {"やせ", "やせ気味", "ふつう（標準）", "太り気味"};

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

    public static Map<String, Object> calc(String heightCm, String weightKg) {
        BigDecimal h = dec(heightCm), w = dec(weightKg);
        Map<String, Object> out = new LinkedHashMap<>();
        if (h == null || w == null || h.signum() <= 0 || w.signum() <= 0) {
            out.put("error", "invalid_input");
            return out;
        }
        BigDecimal hm3 = h.movePointLeft(2).pow(3); // (身長 ÷ 100)³。10進のまま正確
        BigDecimal w10 = w.multiply(TEN);           // 指数 = 体重 × 10 ÷ hm3
        String category = "肥満";
        for (int i = 0; i < BOUNDS.length; i++) {
            if (w10.compareTo(BigDecimal.valueOf(BOUNDS[i]).multiply(hm3)) < 0) { // 指数 < 境目（hm3 > 0）
                category = NAMES[i];
                break;
            }
        }
        out.put("index", w10.divide(hm3, 1, RoundingMode.HALF_UP).toPlainString());
        out.put("category", category);
        out.put("normal_low", BigDecimal.valueOf(115).multiply(hm3).movePointLeft(1).setScale(1, RoundingMode.HALF_UP).toPlainString());
        out.put("normal_high", BigDecimal.valueOf(145).multiply(hm3).movePointLeft(1).setScale(1, RoundingMode.HALF_UP).toPlainString());
        return out;
    }
}

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

/**
 * ローレル指数。
 * v1: 元ツール（app.js）と同じ考え方を、Java でいちばん普通に書いた形。身長・体重を double に読み、
 * 体重 ÷ (身長 ÷ 100)³ × 10 を計算して、区分は丸める前の指数で決め、表示は String.format("%.1f")。
 */
public final class Roehrer {
    private Roehrer() {}

    static String judge(double index) {
        if (index < 100) return "やせ";
        if (index < 115) return "やせ気味";
        if (index < 145) return "ふつう（標準）";
        if (index < 160) return "太り気味";
        return "肥満";
    }

    /** 正の数に読めなければ null */
    static Double readPositive(String s) {
        try {
            double v = Double.parseDouble(s);
            return v > 0 ? v : null;
        } catch (NumberFormatException | NullPointerException e) {
            return null;
        }
    }

    public static Map<String, Object> calc(String heightCm, String weightKg) {
        Double h = readPositive(heightCm), w = readPositive(weightKg);
        Map<String, Object> out = new LinkedHashMap<>();
        if (h == null || w == null) {
            out.put("error", "invalid_input");
            return out;
        }
        double hm = h / 100;
        double index = w / (hm * hm * hm) * 10;
        out.put("index", String.format("%.1f", index));
        out.put("category", judge(index));
        out.put("normal_low", String.format("%.1f", 115 * hm * hm * hm / 10));
        out.put("normal_high", String.format("%.1f", 145 * hm * hm * hm / 10));
        return out;
    }
}

// ローレル指数。
// v2: 身長・体重の文字列を decimal（10進の小数）で読み、(身長 ÷ 100)³ を正確に出す。
// 区分は「指数 < 境目」を「体重 × 10 < 境目 × (身長 ÷ 100)³」に直して正確に比べる。
// 指数は decimal の割り算だと 28桁で一度丸まり（31.2499…9 が 31.25 になる）、そのあと小数第1位に丸めると二重の丸めになるので、
// 体重 × 10 と (身長 ÷ 100)³ を同じ桁だけずらして整数にし、指数 × 10 の整数の商と余りで「余り × 2 ≥ 割る数なら繰り上げ」にする。
// 目安は 115 × (身長 ÷ 100)³ ÷ 10 が割り切れるので、Math.Round(x, 1, MidpointRounding.AwayFromZero)。
// v1 は double で、指数がちょうど 100・115・145・160 になる入力で境目のわずかに下に入って下の区分になり、31.25 が 31.2 と出ていた。
// 読み書きはカルチャに左右されないよう InvariantCulture。double.TryParse は "1e2"・"NaN"・空白も読むので、形を先に確かめる。
// 桁が decimal に収まらなければ OverflowException（そのケースは error になる）。
using System.Globalization;
using System.Text.RegularExpressions;

public static class Roehrer
{
    static readonly Regex DecimalForm = new(@"^[0-9]+(\.[0-9]+)?\z");
    static readonly (decimal Bound, string Name)[] Bands = [(100m, "やせ"), (115m, "やせ気味"), (145m, "ふつう（標準）"), (160m, "太り気味")];

    /// 10進の数の文字列を decimal に。形が違えば null
    static decimal? Dec(string s) =>
        DecimalForm.IsMatch(s) ? decimal.Parse(s, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture) : null;

    static string F1(decimal x) => Math.Round(x, 1, MidpointRounding.AwayFromZero).ToString("F1", CultureInfo.InvariantCulture);

    /// 小数部の桁数
    static int Scale(decimal x) => (decimal.GetBits(x)[3] >> 16) & 0xFF;

    public static Dictionary<string, object?> Calc(string heightCm, string weightKg)
    {
        if (Dec(heightCm) is not decimal h || Dec(weightKg) is not decimal w || h <= 0 || w <= 0)
            return new() { ["error"] = "invalid_input" };
        decimal hm = h / 100;
        decimal hm3 = hm * hm * hm; // (身長 ÷ 100)³。桁が収まる範囲では正確
        decimal w10 = w * 10;       // 指数 = 体重 × 10 ÷ hm3
        string category = "肥満";
        foreach (var (bound, name) in Bands)
        {
            if (w10 < bound * hm3) { category = name; break; } // 指数 < 境目（hm3 > 0）
        }
        // 指数 × 10 = (w10 × 10) ÷ hm3。両方を 10^k 倍して整数にし、商と余りで四捨五入する
        int k = Math.Max(Scale(w10), Scale(hm3));
        decimal p = 1;
        for (int i = 0; i < k; i++) p *= 10;
        decimal num = decimal.Truncate(w10 * 10 * p), den = decimal.Truncate(hm3 * p);
        decimal rem = num % den;
        decimal q = (num - rem) / den; // 割り切れる
        if (rem * 2 >= den) q += 1;
        return new()
        {
            ["index"] = (q / 10).ToString("F1", CultureInfo.InvariantCulture),
            ["category"] = category,
            ["normal_low"] = F1(115 * hm3 / 10),
            ["normal_high"] = F1(145 * hm3 / 10),
        };
    }
}

// ローレル指数。
// v1: 元ツール（app.js）と同じ考え方を、C# でいちばん普通に書いた形。身長・体重を double に読み、
// 体重 ÷ (身長 ÷ 100)³ × 10 を計算して、区分は丸める前の指数で決め、表示は ToString("F1")。

public static class Roehrer
{
    static string Judge(double index)
    {
        if (index < 100) return "やせ";
        if (index < 115) return "やせ気味";
        if (index < 145) return "ふつう（標準）";
        if (index < 160) return "太り気味";
        return "肥満";
    }

    public static Dictionary<string, object?> Calc(string heightCm, string weightKg)
    {
        if (!double.TryParse(heightCm, out var h) || !double.TryParse(weightKg, out var w) || h <= 0 || w <= 0)
            return new() { ["error"] = "invalid_input" };
        double hm = h / 100;
        double index = w / (hm * hm * hm) * 10;
        return new()
        {
            ["index"] = index.ToString("F1"),
            ["category"] = Judge(index),
            ["normal_low"] = (115 * hm * hm * hm / 10).ToString("F1"),
            ["normal_high"] = (145 * hm * hm * hm / 10).ToString("F1"),
        };
    }
}

//! ローレル指数。
//! v2: 小数を f64 で扱わない。身長・体重の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、
//! 指数 = 体重 ÷ (身長 ÷ 100)³ × 10 を整数の分数（分子 ÷ 分母、i128）で正確に表す。
//! 区分は「分子 < 境目 × 分母」で比べ、表示は商と余りで「余り × 2 ≥ 分母なら繰り上げ」（0.5 ちょうどは大きい方へ）。
//! v1 は f64 で 1.3³ などが2進数の小数になり、指数がちょうど 100・115・145・160 になる入力で境目のわずかに下に入って
//! 下の区分になり、31.25 が 31.249999… になって 31.2 と出ていた。
//! parse::<f64>() は "1e2"・"inf"・"NaN" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。

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

const BANDS: [(i128, &str); 4] = [(100, "やせ"), (115, "やせ気味"), (145, "ふつう（標準）"), (160, "太り気味")];

fn overflow() -> String {
    "桁あふれ".into()
}

/// 10進の数の文字列を (整数, 小数の桁数) に。形が違えば None。桁が i128 に収まらなければ Err
fn dec(text: &str) -> Result<Option<(i128, 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 n: i128 = 0;
    for b in int_part.bytes().chain(frac.bytes()) {
        n = n.checked_mul(10).and_then(|x| x.checked_add((b - b'0') as i128)).ok_or_else(overflow)?;
    }
    Ok(Some((n, frac.len() as u32)))
}

fn mul(a: i128, b: i128) -> Result<i128, String> {
    a.checked_mul(b).ok_or_else(overflow)
}

fn pow10(k: u32) -> Result<i128, String> {
    10i128.checked_pow(k).ok_or_else(overflow)
}

/// 0 以上の分数 num ÷ den（den > 0）を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "12.3" の形に
fn fmt1(num: i128, den: i128) -> Result<String, String> {
    let n10 = mul(num, 10)?;
    let (mut q, r) = (n10 / den, n10 % den);
    if r >= den - r {
        q += 1; // 余り × 2 ≥ 分母（× 2 であふれないように引き算で比べる）
    }
    Ok(format!("{}.{}", q / 10, q % 10))
}

pub fn calc(height_cm: &str, weight_kg: &str) -> Result<Value, String> {
    let (Some((h, a)), Some((w, b))) = (dec(height_cm)?, dec(weight_kg)?) else {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    };
    if h <= 0 || w <= 0 {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    // 身長 = h ÷ 10^a、体重 = w ÷ 10^b。(身長 ÷ 100)³ = h³ ÷ 10^(3a+6)
    // 指数 = w × 10^(3a+7) ÷ (10^b × h³)。10 の累乗は分子・分母の片方にまとめる
    let h3 = mul(mul(h, h)?, h)?;
    let e = 3 * a as i64 + 7 - b as i64;
    let (num, den) = if e >= 0 { (mul(w, pow10(e as u32)?)?, h3) } else { (w, mul(h3, pow10((-e) as u32)?)?) };
    let mut category = "肥満";
    for (bound, name) in BANDS {
        if num < mul(bound, den)? {
            category = name;
            break;
        }
    }
    // 目安 = 115 × (身長 ÷ 100)³ ÷ 10 = 115 × h³ ÷ 10^(3a+7)
    let d = pow10(3 * a + 7)?;
    Ok(obj(vec![
        ("index", s(fmt1(num, den)?)),
        ("category", s(category)),
        ("normal_low", s(fmt1(mul(115, h3)?, d)?)),
        ("normal_high", s(fmt1(mul(145, h3)?, d)?)),
    ]))
}

//! ローレル指数。
//! v1: 元ツール（app.js）と同じ考え方を、Rust でいちばん普通に書いた形。身長・体重を f64 に読み、
//! 体重 ÷ (身長 ÷ 100)³ × 10 を計算して（3乗は powi(3)）、区分は丸める前の指数で決め、表示は format!("{:.1}")。

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

fn judge(index: f64) -> &'static str {
    if index < 100.0 {
        "やせ"
    } else if index < 115.0 {
        "やせ気味"
    } else if index < 145.0 {
        "ふつう（標準）"
    } else if index < 160.0 {
        "太り気味"
    } else {
        "肥満"
    }
}

pub fn calc(height_cm: &str, weight_kg: &str) -> Result<Value, String> {
    let (Ok(h), Ok(w)) = (height_cm.parse::<f64>(), weight_kg.parse::<f64>()) else {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    };
    if h <= 0.0 || w <= 0.0 {
        return Ok(obj(vec![("error", s("invalid_input"))]));
    }
    let hm3 = (h / 100.0).powi(3);
    let index = w / hm3 * 10.0;
    Ok(obj(vec![
        ("index", s(format!("{:.1}", index))),
        ("category", s(judge(index))),
        ("normal_low", s(format!("{:.1}", 115.0 * hm3 / 10.0))),
        ("normal_high", s(format!("{:.1}", 145.0 * hm3 / 10.0))),
    ]))
}

# ローレル指数。
# v2: 身長・体重の文字列を Rational（正確な分数）で10進のまま読み、体重 ÷ (身長 ÷ 100)³ × 10 を正確に計算する。
# 区分は正確な指数を境目と比べ、表示は小数第1位に「0.5 ちょうどは大きい方へ」四捨五入する。
# v1 の Float では 160cm・59.392kg の指数 145 ちょうどが 144.99999999999997 になって「ふつう（標準）」に落ち、
# 160cm・12.8kg の 31.25 が 31.249999999999996 になって format("%.1f") で 31.2 に落ちた。

module Roehrer
  module_function

  DECIMAL = /\A[0-9]+(\.[0-9]+)?\z/
  BANDS = [[100, "やせ"], [115, "やせ気味"], [145, "ふつう（標準）"], [160, "太り気味"]].freeze

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

  # 0 以上の x を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "31.3" の形に
  def fmt1(x)
    n = (x * 10 + Rational(1, 2)).floor
    "#{n / 10}.#{n % 10}"
  end

  def calc(height_cm:, weight_kg:)
    height = read_decimal(height_cm)
    weight = read_decimal(weight_kg)
    return { "error" => "invalid_input" } if height.nil? || weight.nil? || height <= 0 || weight <= 0

    cube = (height / 100)**3
    index = weight / cube * 10
    category = BANDS.find { |b, _| index < b }&.last || "肥満"
    { "index" => fmt1(index), "category" => category,
      "normal_low" => fmt1(115 * cube / 10), "normal_high" => fmt1(145 * cube / 10) }
  end
end

# ローレル指数。
# v1: 身長・体重を Float に読み、体重 ÷ (身長 ÷ 100)**3 × 10 を計算して、区分は丸める前の指数を < で比べ、
# 指数とふつうの体重の目安を format("%.1f") で書く素直な書き方。

module Roehrer
  module_function

  BANDS = [[100, "やせ"], [115, "やせ気味"], [145, "ふつう（標準）"], [160, "太り気味"]].freeze

  def calc(height_cm:, weight_kg:)
    height = Float(height_cm)
    weight = Float(weight_kg)
    return { "error" => "invalid_input" } if height <= 0 || weight <= 0

    hm = height / 100
    index = weight / hm**3 * 10
    category = BANDS.find { |b, _| index < b }&.last || "肥満"
    { "index" => format("%.1f", index), "category" => category,
      "normal_low" => format("%.1f", 115 * hm**3 / 10), "normal_high" => format("%.1f", 145 * hm**3 / 10) }
  rescue ArgumentError, TypeError
    { "error" => "invalid_input" }
  end
end

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

// ローレル指数。
// v2: 身長・体重の文字列を BigDecimal（10進のまま）で読み、(身長 ÷ 100)³ を正確に出す。
// 区分は「指数 < 境目」を「体重 × 10 < 境目 × (身長 ÷ 100)³」に直して正確に比べ、
// 指数は divide(…, 1, RoundingMode.HALF_UP)（正確な商を 0.5 ちょうどは大きい方へ）で丸める。目安も HALF_UP。
// v1 は Double で 1.3³ などが2進数の小数になり、指数がちょうど 100・115・145・160 になる入力で境目のわずかに下に入って
// 下の区分になり、31.25 が 31.249999… になって 31.2 と出ていた。
// toDoubleOrNull は "1e2"・"NaN" も読むので、入力は 10進の数の形かを先に確かめる。

private val DECIMAL = Regex("[0-9]+(\\.[0-9]+)?")
private val BANDS = listOf(100 to "やせ", 115 to "やせ気味", 145 to "ふつう（標準）", 160 to "太り気味")

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

/** 0 以上の x を小数第1位に（0.5 ちょうどは大きい方へ） */
private fun fmt1(x: BigDecimal): String = x.setScale(1, RoundingMode.HALF_UP).toPlainString()

fun roehrer(heightCm: String, weightKg: String): Map<String, Any?> {
    val h = dec(heightCm)
    val w = dec(weightKg)
    if (h == null || w == null || h.signum() <= 0 || w.signum() <= 0) return linkedMapOf("error" to "invalid_input")
    val hm3 = h.movePointLeft(2).pow(3) // (身長 ÷ 100)³。10進のまま正確
    val w10 = w * BigDecimal.TEN       // 指数 = 体重 × 10 ÷ hm3
    val category = BANDS.firstOrNull { (b, _) -> w10 < BigDecimal(b) * hm3 }?.second ?: "肥満" // 指数 < 境目（hm3 > 0）
    return linkedMapOf(
        "index" to w10.divide(hm3, 1, RoundingMode.HALF_UP).toPlainString(),
        "category" to category,
        "normal_low" to fmt1((BigDecimal(115) * hm3).movePointLeft(1)),
        "normal_high" to fmt1((BigDecimal(145) * hm3).movePointLeft(1)),
    )
}

// ローレル指数。
// v1: 元ツール（app.js）と同じ考え方を、Kotlin でいちばん普通に書いた形。身長・体重を Double に読み、
// 体重 ÷ (身長 ÷ 100)³ × 10 を計算して、区分は丸める前の指数で決め、表示は "%.1f".format(x)。

private fun judge(index: Double): String = when {
    index < 100 -> "やせ"
    index < 115 -> "やせ気味"
    index < 145 -> "ふつう（標準）"
    index < 160 -> "太り気味"
    else -> "肥満"
}

fun roehrer(heightCm: String, weightKg: String): Map<String, Any?> {
    val h = heightCm.toDoubleOrNull()
    val w = weightKg.toDoubleOrNull()
    if (h == null || w == null || h <= 0 || w <= 0) return linkedMapOf("error" to "invalid_input")
    val hm = h / 100
    val index = w / (hm * hm * hm) * 10
    return linkedMapOf(
        "index" to "%.1f".format(index),
        "category" to judge(index),
        "normal_low" to "%.1f".format(115 * hm * hm * hm / 10),
        "normal_high" to "%.1f".format(145 * hm * hm * hm / 10),
    )
}

// ローレル指数。
// v2: 小数を Double で扱わない。身長・体重の文字列を「整数 ÷ 10^小数の桁数」として10進のまま読み、
// 指数 = 体重 ÷ (身長 ÷ 100)³ × 10 を整数の分数（分子 ÷ 分母、Int128）で正確に表す。
// 区分は「分子 < 境目 × 分母」で比べ、表示は商と余りで「余り × 2 ≥ 分母なら繰り上げ」（0.5 ちょうどは大きい方へ）。
// v1 は Double で 1.3³ などが2進数の小数になり、指数がちょうど 100・115・145・160 になる入力で境目のわずかに下に入って
// 下の区分になり、31.25 が 31.249999… になって 31.2 と出ていた。
// Double(s) は "1e2"・"inf"・"nan" も読むので、入力は 10進の数の形（[0-9]+(\.[0-9]+)?）かを自分で確かめる。
// 桁あふれは（Swift の既定の trap でプロセスを止めず）例外にする。

private let bands: [(Int128, String)] = [(100, "やせ"), (115, "やせ気味"), (145, "ふつう（標準）"), (160, "太り気味")]

/// 10進の数の文字列を (整数, 小数の桁数) に。形が違えば nil。桁が Int128 に収まらなければ例外
private func dec(_ text: String) throws -> (n: Int128, 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: Int128 = 0
    for u in (parts[0] + frac).unicodeScalars {
        n = try add(try mul(n, 10), Int128(u.value - 48))
    }
    return (n, frac.count)
}

/// a × b（あふれたら例外）
private func mul(_ a: Int128, _ b: Int128) throws -> Int128 {
    let (m, o) = a.multipliedReportingOverflow(by: b)
    if o { throw Failure("桁あふれ") }
    return m
}

/// a + b（あふれたら例外）
private func add(_ a: Int128, _ b: Int128) throws -> Int128 {
    let (s, o) = a.addingReportingOverflow(b)
    if o { throw Failure("桁あふれ") }
    return s
}

/// 10^k（あふれたら例外）
private func pow10(_ k: Int) throws -> Int128 {
    var x: Int128 = 1
    for _ in 0..<k { x = try mul(x, 10) }
    return x
}

/// 0 以上の分数 num ÷ den（den > 0）を小数第1位に四捨五入（0.5 ちょうどは大きい方へ）して "12.3" の形に
private func fmt1(_ num: Int128, _ den: Int128) throws -> String {
    let n10 = try mul(num, 10)
    var q = n10 / den
    let r = n10 % den
    if r >= den - r { q += 1 } // 余り × 2 ≥ 分母（× 2 であふれないように引き算で比べる）
    return "\(q / 10).\(q % 10)"
}

func roehrer(heightCm: String, weightKg: String) throws -> [String: Any] {
    guard let hd = try dec(heightCm), let wd = try dec(weightKg), hd.n > 0, wd.n > 0 else {
        return ["error": "invalid_input"]
    }
    let (h, a, w, b) = (hd.n, hd.scale, wd.n, wd.scale)
    // 身長 = h ÷ 10^a、体重 = w ÷ 10^b。(身長 ÷ 100)³ = h³ ÷ 10^(3a+6)
    // 指数 = w × 10^(3a+7) ÷ (10^b × h³)。10 の累乗は分子・分母の片方にまとめる
    let h3 = try mul(try mul(h, h), h)
    let e = 3 * a + 7 - b
    let (num, den) = e >= 0 ? (try mul(w, try pow10(e)), h3) : (w, try mul(h3, try pow10(-e)))
    var category = "肥満"
    for (bound, name) in bands where num < (try mul(bound, den)) {
        category = name
        break
    }
    // 目安 = 115 × (身長 ÷ 100)³ ÷ 10 = 115 × h³ ÷ 10^(3a+7)
    let d = try pow10(3 * a + 7)
    return [
        "index": try fmt1(num, den),
        "category": category,
        "normal_low": try fmt1(try mul(115, h3), d),
        "normal_high": try fmt1(try mul(145, h3), d),
    ]
}

// ランナー規約（標準入力の 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 に読み、
// 体重 ÷ (身長 ÷ 100)³ × 10 を計算して、区分は丸める前の指数で決め、表示は String(format: "%.1f")。
import Foundation

private func judge(_ index: Double) -> String {
    if index < 100 { return "やせ" }
    if index < 115 { return "やせ気味" }
    if index < 145 { return "ふつう（標準）" }
    if index < 160 { return "太り気味" }
    return "肥満"
}

func roehrer(heightCm: String, weightKg: String) throws -> [String: Any] {
    guard let h = Double(heightCm), let w = Double(weightKg), h > 0, w > 0 else { return ["error": "invalid_input"] }
    let hm = h / 100
    let index = w / (hm * hm * hm) * 10
    return [
        "index": String(format: "%.1f", index),
        "category": judge(index),
        "normal_low": String(format: "%.1f", 115 * hm * hm * hm / 10),
        "normal_high": String(format: "%.1f", 145 * hm * hm * hm / 10),
    ]
}

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