預金利息の計算（単利・複利・税引後）

言語ごとの結果

正解表 15件のうち、正解と一致した件数です。

PHPPHP 8.4.26

よくある書き方12 / 15

直した書き方15 / 15

PythonPython 3.14.7

よくある書き方9 / 15

直した書き方15 / 15

GoGo 1.27.2

よくある書き方11 / 15

直した書き方15 / 15

JavaScriptNode 24.15.0

よくある書き方12 / 15

直した書き方15 / 15

JavaJava 21.0.12

よくある書き方12 / 15

直した書き方15 / 15

C#.NET 10.0.402

よくある書き方10 / 15

直した書き方15 / 15

RustRust 1.99.0

よくある書き方12 / 15

直した書き方15 / 15

RubyRuby 4.0.7

よくある書き方12 / 15

直した書き方15 / 15

KotlinKotlin 2.4.21

よくある書き方12 / 15

直した書き方15 / 15

SwiftSwift 6.3.3

よくある書き方12 / 15

直した書き方15 / 15

なぜ割れたのか

よくある書き方が落ちたケースを、原因ごとにまとめた解説です（2本）。書いてある「落ちた言語」が今回の検証結果と一致することを確かめてから載せています。

2進小数の誤差

10万円・年0.5%・2年の利息 1,002.5円を、10言語とも 1,002円にした

対象のケースc005 c006 c007 落ちた言語PHPPythonGoJavaScriptJavaC#RustRubyKotlinSwift

10万円を年0.5%の複利で2年預けると（c006）、利息は 100,000 × 1.005² − 100,000 = 1,002.5円 です。円に四捨五入して 1,003円 が正解ですが、10言語すべてが 1,002円 と答えました。

1,000万円・年0.25%・2年（c007）の 50,062.5円も、10言語とも 50,062円でした。利息が1円少ないと、税額の切り捨ても変わり、税額まで1円ずれます。

1,000円・年0.35%・1年の単利（c005）の利息 3.5円は、10言語中9言語が 3円と答えました。正解の 4円を返したのは C# だけです。

なぜ少なくなったのか

計算	正確な値	2進数の小数での結果
100000 × 1.005² − 100000	1002.5	1002.4999999999709
1000 × 0.0035 × 1	3.5	3.4999999999999996

0.005 も 0.0035 も2進数では正確に表せず、累乗や掛け算の結果が 0.5 にわずかに届きません。C# 以外の9言語は、利息を2進数の小数（double・f64・Float など）で計算し、複利は累乗（pow や **）で求めたので、この誤差がそのまま答えに出ました。

C# は、お金なので decimal（十進の小数）で計算しました。単利の 3.5円（c005）は正確に表せて正解しました。ところが decimal には累乗の関数がありません。複利の (1 + 年利)^年数だけは Math.Pow（double）で計算して decimal に戻したため、そこで2進数の誤差が入り、c006・c007 は外れました。

どう直したか

年利を分数（分子・分母の整数）にして、利息を正確に求めてから円に丸めました。年利 0.005%・50年の複利では、(1 + 年利)^50 の分子と分母が250桁を超えます。そこで、多倍長整数を使いました。

使ったもの	言語
標準の多倍長整数	Python・Ruby（標準の整数）、Java・C#（BigInteger）、Go（math/big）、JavaScript（BigInt）、PHP（GMP）
自分で書いた多倍長整数	Rust・Swift（標準ライブラリに無いので、必要な分だけ）
十進の小数	Kotlin（BigDecimal の pow で (1 + 年利)^年数を正確に計算）

0.5 の丸め方

0.5円ちょうどの利息を、Python と C# は 0円にした（Go は CPU で答えが変わった）

対象のケースc003 c004 c011 落ちた言語PythonGoC#

1,000円を年0.005%の単利で10年預けると、利息は 0.5円 ちょうどです（c003）。円に四捨五入して 1円が正解です。10言語中8言語は 1円を返しましたが、Python と C# は 0円と答えました。1,300円・年0.5%・5年（c011）の 32.5円も、同じ2言語が 32円にしました（残りの8言語は正解の 33円）。

1,000円・年0.05%・1年の複利（c004）も利息は 0.5円ちょうどで、ここでは Python・C# に加えて Go も 0円と答えました。

偶数丸め

0.5 と 32.5 は2進数の小数でも誤差なく表せるので、c003・c011 の違いは丸め方だけです。

丸め方	言語	0.5 →	32.5 →
0.5 ちょうどを偶数の方へ	Python（`round()`）・C#（`Math.Round`）	0	32
0.5 ちょうどを大きい方（0 から遠い方）へ	PHP・Go・JavaScript・Java・Rust・Ruby・Kotlin・Swift	1	33

Python の round() と C# の Math.Round は、どちらも既定が偶数丸めです。C# は decimal で計算しているので、値そのものは正確です。それでも丸め方の既定で外れました。

Go だけ、CPU によって答えが変わった

c004 で Go が 0円と答えたのは、丸め方の問題ではありません。Go の math.Round は 0.5 を切り上げます。

Go のコンパイラは、ARM64（Apple Silicon・AWS の Graviton など）で p*math.Pow(1+r, 1) - p のような「掛けて引く」を、FMA（積和演算）の1命令にまとめます。FMA は掛け算の結果を途中で丸めずに引き算をするので、答えが 0.5 ではなく 0.49999999999994493 になりました。

p, r := 1000.0, 0.0005
a := p*math.Pow(1+r, 1) - p          // ARM64: 0.49999999999994493（FMA にまとめられる）
b := float64(p*math.Pow(1+r, 1)) - p // 0.5（明示的に丸めると、まとめない）

同じコードを x86-64 で動かすと、0.5 になります。Go の仕様は、この合成を認めています。同じ言語・同じコードでも、CPU によって小数の答えが変わることがある、という例です。この検証は Mac（Apple Silicon）と AWS CodeBuild（ARM64）で回しているので、どちらでも 0円になりました。

どう直したか

利息を分数のまま計算し、「分子 × 2 + 分母」を「分母 × 2」で割った商（切り捨て）を、円に四捨五入した利息にしました。0.5 ちょうどは必ず繰り上がります。2進数の小数を通らないので、FMA の影響も受けません。

正解表と、よくある書き方の答え

正解は実装より先に決めて固定しています。右の欄は、よくある書き方の答えを言語ごとにまとめたものです（赤い値は実際に返した間違った答え）。

ケース	入力	正解	よくある書き方の答え（10言語）
c001基本・複利	principal 1000000 rate 0.2 years 10 mode compound	gross_total 1020181 interest 20181 tax 4099 net_interest 16082 net_total 1016082	✓10言語すべて正解
c002基本・単利	principal 1000000 rate 0.2 years 10 mode simple	gross_total 1020000 interest 20000 tax 4063 net_interest 15937 net_total 1015937	✓10言語すべて正解
c003利息がちょうど 0.5円（単利） 0.5円 → 1円。2進数でも 0.5 ちょうどなので、偶数丸めの言語は 0円にするなぜ？解説を読む	principal 1000 rate 0.005 years 10 mode simple	gross_total 1001 interest 1 tax 0 net_interest 1 net_total 1001	Python・C#gross_total1000interest0net_interest0net_total1000 PHP・Go・JavaScript・Java・Rust・Ruby・Kotlin・Swift✓ 正解
c004利息がちょうど 0.5円（複利1年） 0.5円 → 1円なぜ？解説を読む	principal 1000 rate 0.05 years 1 mode compound	gross_total 1001 interest 1 tax 0 net_interest 1 net_total 1001	Python・Go・C#gross_total1000interest0net_interest0net_total1000 PHP・JavaScript・Java・Rust・Ruby・Kotlin・Swift✓ 正解
c005利息がちょうど 3.5円 3.5円 → 4円。2進数の小数では 3.4999999999999996 になり 3円に落ちるなぜ？解説を読む	principal 1000 rate 0.35 years 1 mode simple	gross_total 1004 interest 4 tax 0 net_interest 4 net_total 1004	PHP・Python・Go・JavaScript・Java・Rust・Ruby・Kotlin・Swiftgross_total1003interest3net_interest3net_total1003 C#✓ 正解
c006複利の利息がちょうど 1,002.5円 1.005² の誤差で 1002.4999999999709 になり、1,002円に落ちるなぜ？解説を読む	principal 100000 rate 0.5 years 2 mode compound	gross_total 101003 interest 1003 tax 203 net_interest 800 net_total 100800	PHP・Python・Go・JavaScript・Java・C#・Rust・Ruby・Kotlin・Swiftgross_total101002interest1002net_interest799net_total100799
c007複利の利息がちょうど 50,062.5円利息が1円ずれると、税額（切り捨て）もずれるなぜ？解説を読む	principal 10000000 rate 0.25 years 2 mode compound	gross_total 10050063 interest 50063 tax 10170 net_interest 39893 net_total 10039893	PHP・Python・Go・JavaScript・Java・C#・Rust・Ruby・Kotlin・Swiftgross_total10050062interest50062tax10169
c008大きな元本・長期の複利利息は約91兆円。倍精度の小数でも 2^53 未満に収まる	principal 10000000000 rate 20 years 50 mode compound	gross_total 91004381500021 interest 90994381500021 tax 18485508601729 net_interest 72508872898292 net_total 72518872898292	✓10言語すべて正解
c009金利0%	principal 1000000 rate 0 years 10 mode compound	gross_total 1000000 interest 0 tax 0 net_interest 0 net_total 1000000	✓10言語すべて正解
c010税の切り捨て・小さな利息利息19円。15.315% は 2.90985 → 2円、5% は 0.95 → 0円	principal 19000 rate 0.1 years 1 mode simple	gross_total 19019 interest 19 tax 2 net_interest 17 net_total 19017	✓10言語すべて正解
c011利息がちょうど 32.5円 32.5円 → 33円なぜ？解説を読む	principal 1300 rate 0.5 years 5 mode simple	gross_total 1333 interest 33 tax 6 net_interest 27 net_total 1327	Python・C#gross_total1332interest32tax5 PHP・Go・JavaScript・Java・Rust・Ruby・Kotlin・Swift✓ 正解
c012期間0年はエラー	principal 1000000 rate 0.2 years 0 mode compound	error invalid_input	✓10言語すべて正解
c013年利が20%を超えるとエラー	principal 1000000 rate 20.5 years 1 mode compound	error invalid_input	✓10言語すべて正解
c014年利が小数第4位まであるとエラー	principal 1000000 rate 0.0005 years 1 mode compound	error invalid_input	✓10言語すべて正解
c015元本0円はエラー	principal 0 rate 0.2 years 1 mode compound	error invalid_input	✓10言語すべて正解

コード

「違い」では、よくある書き方から直した書き方へ、どの行をどう変えたかを示しています（赤が消した行、緑が足した行、濃い色が行の中で変わった部分）。計算の部分だけを載せ、入出力を受け渡す部分は除いています。

Deposit.php+17 −7よくある書き方（0605a4d）→ 直した書き方

deposit.py+7 −5よくある書き方（0605a4d）→ 直した書き方

deposit.go+20 −12よくある書き方（0605a4d）→ 直した書き方

deposit.mjs+20 −7よくある書き方（0605a4d）→ 直した書き方

Deposit.java+22 −6よくある書き方（0605a4d）→ 直した書き方

Deposit.java

import java.math.BigInteger;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 預金利息の計算。
 * v2: 年利を BigInteger の分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
 * double と Math.pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
 */
public final class Deposit {
    private Deposit() {}

    public static Map<String, Object> calc(long principal, String rate, long years, String mode) {
        Map<String, Object> out = new LinkedHashMap<>();
        if (principal < 1 || principal > 10_000_000_000L || !rate.matches("\\d+(\\.\\d{1,3})?") || years < 1 || years > 50
                || !(mode.equals("simple") || mode.equals("compound"))) {
            out.put("error", "invalid_input");
            return out;
        }
        String[] parts = rate.split("\\.");
        String frac = parts.length > 1 ? parts[1] : "";
        BigInteger rn = new BigInteger(parts[0] + frac);
        BigInteger rd = BigInteger.TEN.pow(frac.length()).multiply(BigInteger.valueOf(100)); // 年利 ÷ 100 = rn / rd
        if (rn.multiply(BigInteger.valueOf(5)).compareTo(rd) > 0) { out.put("error", "invalid_input"); return out; }
        BigInteger p = BigInteger.valueOf(principal);
        BigInteger num, den;
        if (mode.equals("simple")) {
            num = p.multiply(rn).multiply(BigInteger.valueOf(years));
            den = rd;
        } else {
            den = rd.pow((int) years);
            num = p.multiply(rd.add(rn).pow((int) years)).subtract(p.multiply(den));
        }
        long interest = num.shiftLeft(1).add(den).divide(den.shiftLeft(1)).longValueExact(); // 円に四捨五入（0.5 は繰り上げ）
        long tax = interest * 15315 / 100000 + interest * 5 / 100; // それぞれ1円未満切り捨て
        long net = interest - tax;
        out.put("gross_total", principal + interest);
        out.put("interest", interest);
        out.put("tax", tax);
        out.put("net_interest", net);
        out.put("net_total", principal + net);
        return out;
    }
}

Deposit.cs+14 −10よくある書き方（0605a4d）→ 直した書き方

deposit.rs+37 −13よくある書き方（0605a4d）→ 直した書き方

biguint.rs

//! 0 以上の多倍長整数（Rust の標準ライブラリに無いため、必要な分だけ自分で書く）。
//! 2^32 進数の桁を下の位から Vec<u32> に持つ。掛け算・足し算・引き算・比較・累乗だけ。

use std::cmp::Ordering;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BigUint(Vec<u32>);

impl BigUint {
    pub fn from_u128(mut v: u128) -> BigUint {
        let mut d = Vec::new();
        while v > 0 {
            d.push(v as u32);
            v >>= 32;
        }
        BigUint(d)
    }

    fn trim(mut self) -> BigUint {
        while self.0.last() == Some(&0) {
            self.0.pop();
        }
        self
    }

    pub fn mul(&self, o: &BigUint) -> BigUint {
        BigUint(mul_digits(&self.0, &o.0)).trim()
    }

    pub fn mul_small(&self, k: u128) -> BigUint {
        self.mul(&BigUint::from_u128(k))
    }

    pub fn add(&self, o: &BigUint) -> BigUint {
        let n = self.0.len().max(o.0.len());
        let mut r = Vec::with_capacity(n + 1);
        let mut carry = 0u64;
        for i in 0..n {
            let t = *self.0.get(i).unwrap_or(&0) as u64 + *o.0.get(i).unwrap_or(&0) as u64 + carry;
            r.push(t as u32);
            carry = t >> 32;
        }
        if carry > 0 {
            r.push(carry as u32);
        }
        BigUint(r).trim()
    }

    /// self − o（self >= o のときだけ呼ぶ）
    pub fn sub(&self, o: &BigUint) -> BigUint {
        assert!(self.cmp(o) != Ordering::Less, "負になる引き算");
        let mut r = Vec::with_capacity(self.0.len());
        let mut borrow = 0i64;
        for i in 0..self.0.len() {
            let mut t = self.0[i] as i64 - *o.0.get(i).unwrap_or(&0) as i64 - borrow;
            borrow = if t < 0 { 1 } else { 0 };
            if t < 0 {
                t += 1 << 32;
            }
            r.push(t as u32);
        }
        BigUint(r).trim()
    }

    pub fn pow(&self, mut e: u64) -> BigUint {
        let mut base = self.clone();
        let mut acc = BigUint::from_u128(1);
        while e > 0 {
            if e & 1 == 1 {
                acc = acc.mul(&base);
            }
            e >>= 1;
            if e > 0 {
                base = base.mul(&base);
            }
        }
        acc
    }
}

/// 筆算の掛け算（桁数 a.len() + b.len() の結果）
fn mul_school(a: &[u32], b: &[u32]) -> Vec<u32> {
    let mut r = vec![0u32; a.len() + b.len()];
    for (i, &x) in a.iter().enumerate() {
        let mut carry = 0u64;
        for (j, &y) in b.iter().enumerate() {
            let t = x as u64 * y as u64 + r[i + j] as u64 + carry;
            r[i + j] = t as u32;
            carry = t >> 32;
        }
        r[i + b.len()] = carry as u32;
    }
    r
}

/// r[at..] += v（繰り上がりは r の中に収まる前提）
fn add_at(r: &mut [u32], v: &[u32], at: usize) {
    let mut carry = 0u64;
    let mut i = 0;
    while i < v.len() || carry > 0 {
        let t = r[at + i] as u64 + *v.get(i).unwrap_or(&0) as u64 + carry;
        r[at + i] = t as u32;
        carry = t >> 32;
        i += 1;
    }
}

fn add_digits(a: &[u32], b: &[u32]) -> Vec<u32> {
    let mut r = vec![0u32; a.len().max(b.len()) + 1];
    add_at(&mut r, a, 0);
    add_at(&mut r, b, 0);
    r
}

/// a −= b（a >= b の前提）
fn sub_in_place(a: &mut Vec<u32>, b: &[u32]) {
    let mut borrow = 0i64;
    for i in 0..a.len() {
        let mut t = a[i] as i64 - *b.get(i).unwrap_or(&0) as i64 - borrow;
        borrow = if t < 0 { 1 } else { 0 };
        if t < 0 {
            t += 1 << 32;
        }
        a[i] = t as u32;
    }
}

/// 掛け算。桁数が多いときは Karatsuba 法（3回の掛け算に分ける）で、累乗が大きくなっても時間がかかりすぎないようにする
fn mul_digits(a: &[u32], b: &[u32]) -> Vec<u32> {
    if a.is_empty() || b.is_empty() {
        return Vec::new();
    }
    if a.len().min(b.len()) < 48 {
        return mul_school(a, b);
    }
    let h = a.len().max(b.len()) / 2;
    let (a0, a1) = a.split_at(h.min(a.len()));
    let (b0, b1) = b.split_at(h.min(b.len()));
    let z0 = mul_digits(a0, b0);
    let z2 = mul_digits(a1, b1);
    let mut z1 = mul_digits(&add_digits(a0, a1), &add_digits(b0, b1));
    sub_in_place(&mut z1, &z0);
    sub_in_place(&mut z1, &z2);
    while z1.last() == Some(&0) {
        z1.pop();
    }
    let mut r = vec![0u32; a.len() + b.len() + 1];
    add_at(&mut r, &z0, 0);
    add_at(&mut r, &z1, h);
    add_at(&mut r, &z2, 2 * h);
    r.truncate(a.len() + b.len());
    r
}

impl PartialOrd for BigUint {
    fn partial_cmp(&self, o: &BigUint) -> Option<Ordering> {
        Some(self.cmp(o))
    }
}

impl Ord for BigUint {
    fn cmp(&self, o: &BigUint) -> Ordering {
        self.0.len().cmp(&o.0.len()).then_with(|| self.0.iter().rev().cmp(o.0.iter().rev()))
    }
}

deposit.rs

//! 預金利息の計算。
//! v2: 年利を分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
//! f64 と powi だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
//! 複利の (1 + 年利)^50 は u128 に入らないので、自作の多倍長整数（biguint.rs）で計算する。割り算は無いので、
//! 「q × 2 × 分母 ≤ 2 × 分子 + 分母」を満たす最大の q（＝四捨五入した利息）を二分探索で求める。

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

fn parse_rate(r: &str) -> Option<(u128, u128)> {
    let (int, frac) = r.split_once('.').unwrap_or((r, ""));
    let ok = !int.is_empty() && int.bytes().all(|b| b.is_ascii_digit()) && frac.len() <= 3 && frac.bytes().all(|b| b.is_ascii_digit())
        && (r.contains('.') == !frac.is_empty());
    if !ok {
        return None;
    }
    Some((format!("{int}{frac}").parse().ok()?, 10u128.pow(frac.len() as u32) * 100)) // 年利 ÷ 100 = rn / rd
}

pub fn calc(principal: i64, rate: &str, years: i64, mode: &str) -> Result<Value, String> {
    let invalid = || Ok(obj(vec![("error", s("invalid_input"))]));
    if !(1..=10_000_000_000).contains(&principal) || !(1..=50).contains(&years) || !(mode == "simple" || mode == "compound") {
        return invalid();
    }
    let Some((rn, rd)) = parse_rate(rate) else { return invalid() };
    if rn * 5 > rd {
        return invalid();
    }
    let p = principal as u128;
    let interest: u128 = if mode == "simple" {
        let (num, den) = (p * rn * years as u128, rd);
        (2 * num + den) / (2 * den)
    } else {
        let den = BigUint::from_u128(rd).pow(years as u64);
        let num = BigUint::from_u128(rd + rn).pow(years as u64).mul_small(p).sub(&den.mul_small(p));
        let target = num.mul_small(2).add(&den); // 2 × 分子 + 分母
        let den2 = den.mul_small(2);
        let (mut lo, mut hi) = (0u128, 1u128 << 60); // 利息は 2^60 円未満
        while lo < hi {
            let mid = (lo + hi + 1) / 2;
            if den2.mul_small(mid) <= target { lo = mid } else { hi = mid - 1 }
        }
        lo
    };
    let interest = interest as i64;
    let tax = interest * 15315 / 100000 + interest * 5 / 100; // それぞれ1円未満切り捨て
    let net = interest - tax;
    Ok(obj(vec![("gross_total", n(principal + interest)), ("interest", n(interest)), ("tax", n(tax)), ("net_interest", n(net)), ("net_total", n(principal + net))]))
}

deposit.rb+6 −5よくある書き方（0605a4d）→ 直した書き方

Deposit.kt+14 −9よくある書き方（a2834e5）→ 直した書き方

Deposit.swift+30 −16よくある書き方（f6ad5dd）→ 直した書き方

Runner.swift+7 −6よくある書き方（f6ad5dd）→ 直した書き方

BigUInt.swift

// 符号なし多倍長整数（Swift の標準に無いので自作）。32bit の桁を下位から並べる。
// 足し算・引き算・掛け算・割り算（Knuth の算法 D）・比較・累乗・十進の読み書きだけ。

struct BigUInt: Comparable, CustomStringConvertible {
    private(set) var limbs: [UInt32] // 下位から。末尾に 0 を残さない（0 は空）

    init(_ v: UInt64 = 0) {
        limbs = v == 0 ? [] : (v >> 32 == 0 ? [UInt32(v)] : [UInt32(truncatingIfNeeded: v), UInt32(v >> 32)])
    }

    init(_ v: Int) {
        precondition(v >= 0, "BigUInt に負の数")
        self.init(UInt64(v))
    }

    private init(limbs: [UInt32]) {
        self.limbs = limbs
        normalize()
    }

    /// 十進の数字だけの文字列から
    init?(_ s: Substring) {
        guard !s.isEmpty else { return nil }
        var r = BigUInt()
        var chunk: UInt64 = 0, len = 0
        for ch in s.utf8 {
            guard ch >= 48 && ch <= 57 else { return nil }
            chunk = chunk * 10 + UInt64(ch - 48)
            len += 1
            if len == 9 {
                r = r.mulSmall(1_000_000_000).addSmall(chunk)
                chunk = 0; len = 0
            }
        }
        if len > 0 {
            var p: UInt64 = 1
            for _ in 0..<len { p *= 10 }
            r = r.mulSmall(p).addSmall(chunk)
        }
        self = r
    }

    init?(_ s: String) { self.init(Substring(s)) }

    private mutating func normalize() {
        while let last = limbs.last, last == 0 { limbs.removeLast() }
    }

    var isZero: Bool { limbs.isEmpty }

    /// 64bit に収まれば、その値
    var uint64: UInt64? {
        switch limbs.count {
        case 0: return 0
        case 1: return UInt64(limbs[0])
        case 2: return UInt64(limbs[0]) | UInt64(limbs[1]) << 32
        default: return nil
        }
    }

    static func < (a: BigUInt, b: BigUInt) -> Bool {
        if a.limbs.count != b.limbs.count { return a.limbs.count < b.limbs.count }
        var i = a.limbs.count - 1
        while i >= 0 {
            if a.limbs[i] != b.limbs[i] { return a.limbs[i] < b.limbs[i] }
            i -= 1
        }
        return false
    }

    static func + (a: BigUInt, b: BigUInt) -> BigUInt {
        let n = max(a.limbs.count, b.limbs.count)
        var out = [UInt32](repeating: 0, count: n + 1)
        var carry: UInt64 = 0
        for i in 0..<n {
            let s = UInt64(i < a.limbs.count ? a.limbs[i] : 0) + UInt64(i < b.limbs.count ? b.limbs[i] : 0) + carry
            out[i] = UInt32(truncatingIfNeeded: s)
            carry = s >> 32
        }
        out[n] = UInt32(carry)
        return BigUInt(limbs: out)
    }

    /// a − b（a >= b）
    static func - (a: BigUInt, b: BigUInt) -> BigUInt {
        precondition(!(a < b), "BigUInt の引き算が負になる")
        var out = a.limbs
        var borrow: Int64 = 0
        for i in 0..<out.count {
            var d = Int64(out[i]) - Int64(i < b.limbs.count ? b.limbs[i] : 0) - borrow
            if d < 0 { d += 1 << 32; borrow = 1 } else { borrow = 0 }
            out[i] = UInt32(d)
        }
        return BigUInt(limbs: out)
    }

    static func * (a: BigUInt, b: BigUInt) -> BigUInt {
        if a.isZero || b.isZero { return BigUInt() }
        var out = [UInt32](repeating: 0, count: a.limbs.count + b.limbs.count)
        for i in 0..<a.limbs.count {
            var carry: UInt64 = 0
            let x = UInt64(a.limbs[i])
            if x == 0 { continue }
            for j in 0..<b.limbs.count {
                let t = x * UInt64(b.limbs[j]) + UInt64(out[i + j]) + carry
                out[i + j] = UInt32(truncatingIfNeeded: t)
                carry = t >> 32
            }
            var k = i + b.limbs.count
            while carry > 0 {
                let t = UInt64(out[k]) + carry
                out[k] = UInt32(truncatingIfNeeded: t)
                carry = t >> 32
                k += 1
            }
        }
        return BigUInt(limbs: out)
    }

    func mulSmall(_ m: UInt64) -> BigUInt { self * BigUInt(m) }
    func addSmall(_ m: UInt64) -> BigUInt { self + BigUInt(m) }

    func pow(_ e: Int) -> BigUInt {
        var result = BigUInt(1), base = self, e = e
        while e > 0 {
            if e & 1 == 1 { result = result * base }
            e >>= 1
            if e > 0 { base = base * base }
        }
        return result
    }

    /// 1桁（32bit）で割った商と余り
    func quotientAndRemainder(dividingBy d: UInt32) -> (BigUInt, UInt32) {
        precondition(d != 0, "0 で割った")
        var out = limbs
        var rem: UInt64 = 0
        var i = out.count - 1
        while i >= 0 {
            let cur = rem << 32 | UInt64(out[i])
            out[i] = UInt32(cur / UInt64(d))
            rem = cur % UInt64(d)
            i -= 1
        }
        return (BigUInt(limbs: out), UInt32(rem))
    }

    /// 商と余り（Knuth の算法 D）
    func quotientAndRemainder(dividingBy d: BigUInt) -> (quotient: BigUInt, remainder: BigUInt) {
        precondition(!d.isZero, "0 で割った")
        if self < d { return (BigUInt(), self) }
        if d.limbs.count == 1 {
            let (q, r) = quotientAndRemainder(dividingBy: d.limbs[0])
            return (q, BigUInt(UInt64(r)))
        }
        // 割る数の最上位桁の最上位ビットが立つように左へずらす
        let s = d.limbs.last!.leadingZeroBitCount
        let v = d.shiftedLeft(s).limbs
        var u = shiftedLeft(s).limbs
        u.append(0)
        let n = v.count, m = u.count - n - 1
        var q = [UInt32](repeating: 0, count: m + 1)
        let b: UInt64 = 1 << 32
        var j = m
        while j >= 0 {
            let num = UInt64(u[j + n]) << 32 | UInt64(u[j + n - 1])
            var qhat = num / UInt64(v[n - 1])
            var rhat = num % UInt64(v[n - 1])
            while qhat >= b || qhat * UInt64(v[n - 2]) > (rhat << 32 | UInt64(u[j + n - 2])) {
                qhat -= 1
                rhat += UInt64(v[n - 1])
                if rhat >= b { break }
            }
            // u[j...j+n] −= qhat × v
            var borrow: Int64 = 0
            var carry: UInt64 = 0
            for i in 0..<n {
                let p = qhat * UInt64(v[i]) + carry
                carry = p >> 32
                let t = Int64(u[i + j]) - borrow - Int64(p & 0xffff_ffff)
                u[i + j] = UInt32(truncatingIfNeeded: t)
                borrow = t < 0 ? 1 : 0
            }
            let t = Int64(u[j + n]) - borrow - Int64(carry)
            u[j + n] = UInt32(truncatingIfNeeded: t)
            if t < 0 {
                // 引きすぎたので1回足し戻す
                qhat -= 1
                var c: UInt64 = 0
                for i in 0..<n {
                    let s2 = UInt64(u[i + j]) + UInt64(v[i]) + c
                    u[i + j] = UInt32(truncatingIfNeeded: s2)
                    c = s2 >> 32
                }
                u[j + n] = UInt32(truncatingIfNeeded: UInt64(u[j + n]) + c)
            }
            q[j] = UInt32(qhat)
            j -= 1
        }
        let r = BigUInt(limbs: Array(u[0..<n])).shiftedRight(s)
        return (BigUInt(limbs: q), r)
    }

    private func shiftedLeft(_ s: Int) -> BigUInt {
        if s == 0 || isZero { return self }
        var out = [UInt32](repeating: 0, count: limbs.count + 1)
        for i in 0..<limbs.count {
            out[i] |= limbs[i] << s
            out[i + 1] = limbs[i] >> (32 - s)
        }
        return BigUInt(limbs: out)
    }

    private func shiftedRight(_ s: Int) -> BigUInt {
        if s == 0 || isZero { return self }
        var out = limbs
        for i in 0..<out.count {
            out[i] = limbs[i] >> s | (i + 1 < limbs.count ? limbs[i + 1] << (32 - s) : 0)
        }
        return BigUInt(limbs: out)
    }

    var description: String {
        if isZero { return "0" }
        var parts: [UInt32] = []
        var x = self
        while !x.isZero {
            let (q, r) = x.quotientAndRemainder(dividingBy: 1_000_000_000)
            parts.append(r)
            x = q
        }
        var s = String(parts.last!)
        for p in parts.dropLast().reversed() {
            let t = String(p)
            s += String(repeating: "0", count: 9 - t.count) + t
        }
        return s
    }
}

Deposit.swift

// 預金利息の計算。
// v2: 年利を分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
// Double と pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちた。
// 複利の (1 + 年利)^50 は Int にも Int128 にも入らないので、自作の多倍長整数（BigUInt.swift）で計算する。

/// "0.005" → 年利 ÷ 100 = (5, 100000)。小数第3位まで
private func parseRate(_ r: String) -> (UInt64, UInt64)? {
    let parts = r.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let int = parts[0], frac = parts.count > 1 ? parts[1] : ""
    guard !int.isEmpty, int.count <= 6, int.allSatisfy({ $0.isASCII && $0.isNumber }), frac.count <= 3,
          frac.allSatisfy({ $0.isASCII && $0.isNumber }), parts.count == 1 || !frac.isEmpty,
          let num = UInt64(int + frac) else { return nil }
    var den: UInt64 = 100
    for _ in frac { den *= 10 }
    return (num, den)
}

func deposit(principal: Int, rate: String, years: Int, mode: String) throws -> [String: Any] {
    let invalid: [String: Any] = ["error": "invalid_input"]
    guard (1...10_000_000_000).contains(principal), (1...50).contains(years), mode == "simple" || mode == "compound",
          let (rn, rd) = parseRate(rate), rn * 5 <= rd else { return invalid }
    let p = BigUInt(principal)
    // 利息 = 分子 ÷ 分母
    let num: BigUInt, den: BigUInt
    if mode == "simple" {
        num = p.mulSmall(rn).mulSmall(UInt64(years))
        den = BigUInt(rd)
    } else {
        den = BigUInt(rd).pow(years)
        num = BigUInt(rd + rn).pow(years) * p - den * p
    }
    // 四捨五入（0.5円は繰り上げ）= ⌊(2 × 分子 + 分母) ÷ (2 × 分母)⌋
    let q = (num.mulSmall(2) + den).quotientAndRemainder(dividingBy: den.mulSmall(2)).quotient
    guard let i64 = q.uint64, i64 <= UInt64(Int.max) else { throw Failure("interest overflow") }
    let interest = Int(i64)
    let tax = interest * 15315 / 100000 + interest * 5 / 100 // それぞれ1円未満切り捨て
    let net = interest - tax
    return ["gross_total": principal + interest, "interest": interest, "tax": tax, "net_interest": net,
            "net_total": principal + net]
}

Runner.swift

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

Deposit.swiftコミット f6ad5dd

// 預金利息の計算。
// v1: 素直に書いた版（Double と pow で計算し、利息は rounded()、税は floor で丸める）。
// 金額は円の整数なので Decimal は使わず、年利だけ Double で読む（Swift の標準の小数は Double）。
import Foundation

/// 小数第3位までの数か（"0.2"・"0.005"・"20"）
private func validRate(_ r: String) -> Bool {
    let parts = r.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
    let int = parts[0], frac = parts.count > 1 ? parts[1] : "0"
    return !int.isEmpty && int.allSatisfy { $0.isASCII && $0.isNumber } && (1...3).contains(frac.count)
        && frac.allSatisfy { $0.isASCII && $0.isNumber }
}

func deposit(principal: Int, rate: String, years: Int, mode: String) throws -> [String: Any] {
    guard (1...10_000_000_000).contains(principal), validRate(rate), (1...50).contains(years),
          mode == "simple" || mode == "compound", let rp = Double(rate) else { return ["error": "invalid_input"] }
    let r = rp / 100
    if r > 0.2 { return ["error": "invalid_input"] }
    let p = Double(principal)
    let gross = mode == "simple" ? p * r * Double(years) : p * pow(1 + r, Double(years)) - p
    let interest = Int(gross.rounded())
    let tax = Int(floor(Double(interest) * 0.15315)) + Int(floor(Double(interest) * 0.05))
    let net = interest - tax
    return ["gross_total": principal + interest, "interest": interest, "tax": tax, "net_interest": net,
            "net_total": principal + net]
}

Runner.swiftコミット f6ad5dd

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

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

typealias Input = [String: Any]

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

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

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

private let runtimeName: String = {
    #if swift(>=6.5)
    return "Swift 6.5+"
    #elseif swift(>=6.4)
    return "Swift 6.4"
    #elseif swift(>=6.3)
    return "Swift 6.3"
    #elseif swift(>=6.2)
    return "Swift 6.2"
    #elseif swift(>=6.1)
    return "Swift 6.1"
    #elseif swift(>=6.0)
    return "Swift 6.0"
    #else
    return "Swift 5"
    #endif
}()

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

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

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

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

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

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

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

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

仕様

着手前に測ったこと（2026-10-16）

元ツールの式（2進数の小数・Math.pow・Math.round）で、元本9通り × 年利15通り × 1〜30年 × 単利・複利の8,100通りを、正確な値と比べた。

利息を円に丸めた値が1円ずれるのは9通り（例: 10万円・年0.5%・2年・複利 → 利息 1,002.5円が 1,002円）
それより多いのは内訳のずれで、正確に計算しても 1,445通りで「利息 − 税額 ≠ 税引後の利息」 になる。利息・税額・税引後の利息を、それぞれ別に円へ丸めているため

そこで本 spec では、税を実務どおり（所得税・復興特別所得税 15.315% と住民税 5% をそれぞれ1円未満切り捨て）にし、税引後の利息は「利息 − 税額」と決めて、内訳が必ずそろうようにした。

入力

項目	型	説明
`principal`	整数	預入額（円）。1〜10,000,000,000
`rate`	文字列（小数）	年利（%）。0〜20、小数第3位まで（`"0.2"`・`"0.005"`）
`years`	整数	期間（年）。1〜50
`mode`	文字列	`"simple"`（単利）または `"compound"`（年1回の複利）

範囲外・形が違うときは {"error": "invalid_input"}。

出力（すべて整数・円）

項目	定義
`interest`	税引前の利息。単利は元本 × 年利 ÷ 100 × 年数、複利は元本 × (1 + 年利 ÷ 100)^年数 − 元本。円に四捨五入（0.5円ちょうどは繰り上げ）
`tax`	⌊利息 × 0.15315⌋ + ⌊利息 × 0.05⌋（それぞれ1円未満切り捨て）
`net_interest`	利息 − 税額
`gross_total`	元本 + 利息
`net_total`	元本 + 税引後の利息

計算は正確な値（分数）で行い、丸めるのは利息の1回と税の切り捨てだけ
複利は、税引前の元利合計を最後にまとめて計算する（元ツールと同じ目安。毎年の利息に課税して再投資する自動継続の計算ではない）

元ツールとの違い

元ツールは税額を「利息 × 20.315%」の1回で計算し、利息・税額・税引後の利息・元利合計をそれぞれ別に四捨五入して表示する。本 spec は上のとおり税を2つに分けて切り捨て、内訳がそろうようにした
元ツールは期間・元本に小数も受け付ける。本 spec は整数に限った

期待値の作り方

expect は oracle.py で、上の定義を分数（fractions.Fraction）でそのまま計算して生成した（2026-10-16）。実装ではない。runner は使わない。

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		// 預金利息の計算。
2		−	// v1: parseFloat と Math.pow で計算し、利息は Math.round、税は Math.floor で丸める素直な書き方。
	2	+	// v2: 年利を分数（BigInt の分子・分母）にして、利息を正確に計算してから円に四捨五入する。税の切り捨ても整数で行う。
	3	+	// Number と Math.pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
	4	+
	5	+	/** "0.25" → [25n, 100n] */
	6	+	function parseRate(s) {
	7	+	const [i, f = ""] = s.split(".");
	8	+	return [BigInt(i + f), 10n ** BigInt(f.length)];
	9	+	}
3	10
4	11		export function calcDeposit({ principal, rate, years, mode }) {
5	12		if (!Number.isInteger(principal) \|\| principal < 1 \|\| principal > 1e10 \|\| !/^\d+(\.\d{1,3})?$/.test(rate)
6	13		\|\| !Number.isInteger(years) \|\| years < 1 \|\| years > 50 \|\| !["simple", "compound"].includes(mode)) return { error: "invalid_input" };
7		−	const r = parseFloat(rate) / 100;
8		−	if (r > 0.2) return { error: "invalid_input" };
9		−	const gross = mode === "simple" ? principal * r * years : principal * Math.pow(1 + r, years) - principal;
10		−	const interest = Math.round(gross);
11		−	const tax = Math.floor(interest * 0.15315) + Math.floor(interest * 0.05);
	14	+	const [rn, rd0] = parseRate(rate);
	15	+	const rd = rd0 * 100n; // 年利 ÷ 100 = rn / rd
	16	+	if (rn * 5n > rd) return { error: "invalid_input" }; // 20% を超える
	17	+	const p = BigInt(principal), y = BigInt(years);
	18	+	// 税引前の利息 = num / den（正確な分数）
	19	+	let num, den;
	20	+	if (mode === "simple") { num = p * rn * y; den = rd; }
	21	+	else { den = rd ** y; num = p * (rd + rn) ** y - p * den; }
	22	+	const interest = (2n * num + den) / (2n * den); // 円に四捨五入（0.5 は繰り上げ）
	23	+	const tax = (interest * 15315n) / 100000n + (interest * 5n) / 100n; // それぞれ1円未満切り捨て
12	24		const net = interest - tax;
13		−	return { gross_total: principal + interest, interest, tax, net_interest: net, net_total: principal + net };
	25	+	const N = Number; // 結果は 2^53 未満
	26	+	return { gross_total: N(p + interest), interest: N(interest), tax: N(tax), net_interest: N(net), net_total: N(p + net) };
14	27		}

			@@ 変更前 3行目〜 / 変更後 3行目〜 @@
3	3
4	4		/**
5	5		* 預金利息の計算。
6		−	* v1: float と pow で計算し、利息は round、税は floor で丸める素直な書き方。
	6	+	* v2: 年利を GMP の分数（分子・分母）にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	7	+	* float と pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
7	8		*/
8	9		/** @param array{principal: int, rate: string, years: int, mode: string} $in */
9	10		function calcDeposit(array $in): array
10	11		{
11	12		['principal' => $principal, 'rate' => $rate, 'years' => $years, 'mode' => $mode] = $in;
12		−	if (!is_int($principal) \|\| $principal < 1 \|\| $principal > 10 ** 10 \|\| !preg_match('/^\d+(\.\d{1,3})?$/', $rate)
	13	+	if (!is_int($principal) \|\| $principal < 1 \|\| $principal > 10 ** 10 \|\| !preg_match('/^(\d+)(?:\.(\d{1,3}))?$/', $rate, $m)
13	14		\|\| !is_int($years) \|\| $years < 1 \|\| $years > 50 \|\| !in_array($mode, ['simple', 'compound'], true)) {
14	15		return ['error' => 'invalid_input'];
15	16		}
16		−	$r = (float) $rate / 100;
17		−	if ($r > 0.2) {
	17	+	$frac = $m[2] ?? '';
	18	+	$rn = gmp_init($m[1] . $frac, 10); // 基数を明示する（"035" を8進数として読ませない）
	19	+	$rd = gmp_mul(gmp_pow(10, strlen($frac)), 100); // 年利 ÷ 100 = rn / rd
	20	+	if (gmp_cmp(gmp_mul($rn, 5), $rd) > 0) {
18	21		return ['error' => 'invalid_input'];
19	22		}
20		−	$gross = $mode === 'simple' ? $principal * $r * $years : $principal * pow(1 + $r, $years) - $principal;
21		−	$interest = (int) round($gross);
22		−	$tax = (int) floor($interest * 0.15315) + (int) floor($interest * 0.05);
	23	+	$p = gmp_init($principal);
	24	+	if ($mode === 'simple') {
	25	+	$num = gmp_mul(gmp_mul($p, $rn), $years);
	26	+	$den = $rd;
	27	+	} else {
	28	+	$den = gmp_pow($rd, $years);
	29	+	$num = gmp_sub(gmp_mul($p, gmp_pow(gmp_add($rd, $rn), $years)), gmp_mul($p, $den));
	30	+	}
	31	+	$interest = gmp_intval(gmp_div_q(gmp_add(gmp_mul($num, 2), $den), gmp_mul($den, 2))); // 円に四捨五入（0.5 は繰り上げ）
	32	+	$tax = intdiv($interest * 15315, 100000) + intdiv($interest * 5, 100); // それぞれ1円未満切り捨て
23	33		$net = $interest - $tax;
24	34		return ['gross_total' => $principal + $interest, 'interest' => $interest, 'tax' => $tax, 'net_interest' => $net,
25	35		'net_total' => $principal + $net];

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		"""預金利息の計算。
2	2
3		−	v1: float と ** で計算し、利息は round、税は math.floor で丸める素直な書き方。
	3	+	v2: 年利を Fraction（分数）にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	4	+	float だと 10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。round() は偶数丸め（0.5円 → 0円）なので使わない。
4	5		"""
5	6		import math
6	7		import re
	8	+	from fractions import Fraction
7	9
8	10
9	11		def calc_deposit(principal, rate, years, mode):
10	12		if (not isinstance(principal, int) or not 1 <= principal <= 10**10 or not re.fullmatch(r"\d+(\.\d{1,3})?", rate)
11	13		or not isinstance(years, int) or not 1 <= years <= 50 or mode not in ("simple", "compound")):
12	14		return {"error": "invalid_input"}
13		−	r = float(rate) / 100
14		−	if r > 0.2:
	15	+	r = Fraction(rate) / 100
	16	+	if r > Fraction(1, 5):
15	17		return {"error": "invalid_input"}
16	18		gross = principal * r * years if mode == "simple" else principal * (1 + r) ** years - principal
17		−	interest = round(gross)
18		−	tax = math.floor(interest * 0.15315) + math.floor(interest * 0.05)
	19	+	interest = math.floor(gross + Fraction(1, 2)) # 円に四捨五入（0.5 は繰り上げ）
	20	+	tax = interest * 15315 // 100000 + interest * 5 // 100 # それぞれ1円未満切り捨て
19	21		net = interest - tax
20	22		return {"gross_total": principal + interest, "interest": interest, "tax": tax, "net_interest": net, "net_total": principal + net}

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		package main
2	2
3	3		import (
4		−	"math"
	4	+	"math/big"
5	5		"regexp"
6		−	"strconv"
	6	+	"strings"
7	7		)
8	8
9		−	// v1: float64 と math.Pow で計算し、利息は math.Round、税は math.Floor で丸める素直な書き方。
	9	+	// v2: 年利を math/big の整数の分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	10	+	// float64 と math.Pow だと 10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になる。さらに ARM64 では
	11	+	// p*math.Pow(1+r, n) - p が FMA（掛けて引くを1命令）にまとめられ、1,000円・0.05%・1年の 0.5円が 0.4999… になって 0円に落ちた。
10	12
11	13		var ratePattern = regexp.MustCompile(`^\d+(\.\d{1,3})?$`)
12	14
			@@ 変更前 15行目〜 / 変更後 17行目〜 @@
15	17		(mode != "simple" && mode != "compound") {
16	18		return map[string]any{"error": "invalid_input"}
17	19		}
18		−	rp, _ := strconv.ParseFloat(rate, 64)
19		−	r := rp / 100
20		−	if r > 0.2 {
	20	+	i, f, _ := strings.Cut(rate, ".")
	21	+	rn, _ := new(big.Int).SetString(i+f, 10)
	22	+	rd := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(len(f))), nil)
	23	+	rd.Mul(rd, big.NewInt(100)) // 年利 ÷ 100 = rn / rd
	24	+	if new(big.Int).Mul(rn, big.NewInt(5)).Cmp(rd) > 0 {
21	25		return map[string]any{"error": "invalid_input"}
22	26		}
23		−	p := float64(principal)
24		−	var gross float64
	27	+	p, y := big.NewInt(principal), big.NewInt(years)
	28	+	num, den := new(big.Int), new(big.Int)
25	29		if mode == "simple" {
26		−	gross = p * r * float64(years)
	30	+	num.Mul(p, rn).Mul(num, y)
	31	+	den.Set(rd)
27	32		} else {
28		−	gross = p*math.Pow(1+r, float64(years)) - p
	33	+	den.Exp(rd, y, nil)
	34	+	num.Exp(new(big.Int).Add(rd, rn), y, nil).Mul(num, p).Sub(num, new(big.Int).Mul(p, den))
29	35		}
30		−	interest := int64(math.Round(gross))
31		−	tax := int64(math.Floor(float64(interest)0.15315)) + int64(math.Floor(float64(interest)0.05))
	36	+	// 円に四捨五入（0.5 は繰り上げ）: (2num + den) / (2den)
	37	+	q := new(big.Int).Quo(new(big.Int).Add(new(big.Int).Lsh(num, 1), den), new(big.Int).Lsh(den, 1))
	38	+	interest := q.Int64()
	39	+	tax := interest15315/100000 + interest5/100 // それぞれ1円未満切り捨て
32	40		net := interest - tax
33	41		return map[string]any{"gross_total": principal + interest, "interest": interest, "tax": tax, "net_interest": net, "net_total": principal + net}
34	42		}

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
	1	+	import java.math.BigInteger;
1	2		import java.util.LinkedHashMap;
2	3		import java.util.Map;
3	4
4		−	/** 預金利息の計算。v1: double と Math.pow で計算し、利息は Math.round、税は Math.floor で丸める素直な書き方。 */
	5	+	/**
	6	+	* 預金利息の計算。
	7	+	* v2: 年利を BigInteger の分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	8	+	* double と Math.pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
	9	+	*/
5	10		public final class Deposit {
6	11		private Deposit() {}
7	12
			@@ 変更前 12行目〜 / 変更後 17行目〜 @@
12	17		out.put("error", "invalid_input");
13	18		return out;
14	19		}
15		−	double r = Double.parseDouble(rate) / 100;
16		−	if (r > 0.2) { out.put("error", "invalid_input"); return out; }
17		−	double gross = mode.equals("simple") ? principal * r * years : principal * Math.pow(1 + r, years) - principal;
18		−	long interest = Math.round(gross);
19		−	long tax = (long) Math.floor(interest * 0.15315) + (long) Math.floor(interest * 0.05);
	20	+	String[] parts = rate.split("\\.");
	21	+	String frac = parts.length > 1 ? parts[1] : "";
	22	+	BigInteger rn = new BigInteger(parts[0] + frac);
	23	+	BigInteger rd = BigInteger.TEN.pow(frac.length()).multiply(BigInteger.valueOf(100)); // 年利 ÷ 100 = rn / rd
	24	+	if (rn.multiply(BigInteger.valueOf(5)).compareTo(rd) > 0) { out.put("error", "invalid_input"); return out; }
	25	+	BigInteger p = BigInteger.valueOf(principal);
	26	+	BigInteger num, den;
	27	+	if (mode.equals("simple")) {
	28	+	num = p.multiply(rn).multiply(BigInteger.valueOf(years));
	29	+	den = rd;
	30	+	} else {
	31	+	den = rd.pow((int) years);
	32	+	num = p.multiply(rd.add(rn).pow((int) years)).subtract(p.multiply(den));
	33	+	}
	34	+	long interest = num.shiftLeft(1).add(den).divide(den.shiftLeft(1)).longValueExact(); // 円に四捨五入（0.5 は繰り上げ）
	35	+	long tax = interest * 15315 / 100000 + interest * 5 / 100; // それぞれ1円未満切り捨て
20	36		long net = interest - tax;
21	37		out.put("gross_total", principal + interest);
22	38		out.put("interest", interest);

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		// 預金利息の計算。
2		−	// v1: お金なので decimal で計算し、利息は Math.Round、税は Math.Floor で丸める素直な書き方。
3		−	// decimal に累乗の関数は無いので、複利の (1 + r)^n だけは Math.Pow（double）で求めて decimal に戻す。
4		−	using System.Globalization;
	2	+	// v2: 年利を BigInteger の分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	3	+	// v1 は decimal だったが、累乗に Math.Pow（double）を通したので 1,002.5円が 1,002円に落ち、Math.Round の既定（偶数丸め）で 0.5円が 0円になった。
	4	+	using System.Numerics;
5	5		using System.Text.RegularExpressions;
6	6
7	7		public static class Deposit
8	8		{
9	9		public static Dictionary<string, object?> Calc(long principal, string rate, long years, string mode)
10	10		{
11		−	if (principal < 1 \|\| principal > 10_000_000_000L \|\| !Regex.IsMatch(rate, @"^\d+(\.\d{1,3})?$") \|\| years < 1 \|\| years > 50
12		−	\|\| (mode != "simple" && mode != "compound"))
	11	+	var m = Regex.Match(rate, @"^(\d+)(?:\.(\d{1,3}))?$");
	12	+	if (principal < 1 \|\| principal > 10_000_000_000L \|\| !m.Success \|\| years < 1 \|\| years > 50 \|\| (mode != "simple" && mode != "compound"))
13	13		return new() { ["error"] = "invalid_input" };
14		−	decimal r = decimal.Parse(rate, CultureInfo.InvariantCulture) / 100;
15		−	if (r > 0.2m) return new() { ["error"] = "invalid_input" };
16		−	decimal gross = mode == "simple" ? principal * r * years : principal * (decimal)Math.Pow((double)(1 + r), years) - principal;
17		−	long interest = (long)Math.Round(gross);
18		−	long tax = (long)Math.Floor(interest * 0.15315m) + (long)Math.Floor(interest * 0.05m);
	14	+	string frac = m.Groups[2].Value;
	15	+	BigInteger rn = BigInteger.Parse(m.Groups[1].Value + frac);
	16	+	BigInteger rd = BigInteger.Pow(10, frac.Length) * 100; // 年利 ÷ 100 = rn / rd
	17	+	if (rn * 5 > rd) return new() { ["error"] = "invalid_input" };
	18	+	BigInteger p = principal, num, den;
	19	+	if (mode == "simple") { num = p * rn * years; den = rd; }
	20	+	else { den = BigInteger.Pow(rd, (int)years); num = p * BigInteger.Pow(rd + rn, (int)years) - p * den; }
	21	+	long interest = (long)((2 * num + den) / (2 * den)); // 円に四捨五入（0.5 は繰り上げ）
	22	+	long tax = interest * 15315 / 100000 + interest * 5 / 100; // それぞれ1円未満切り捨て
19	23		long net = interest - tax;
20	24		return new()
21	25		{

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		//! 預金利息の計算。
2		−	//! v1: f64 と powi（整数の指数）で計算し、利息は round、税は floor で丸める素直な書き方。
	2	+	//! v2: 年利を分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	3	+	//! f64 と powi だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
	4	+	//! 複利の (1 + 年利)^50 は u128 に入らないので、自作の多倍長整数（biguint.rs）で計算する。割り算は無いので、
	5	+	//! 「q × 2 × 分母 ≤ 2 × 分子 + 分母」を満たす最大の q（＝四捨五入した利息）を二分探索で求める。
3	6
	7	+	use crate::biguint::BigUint;
4	8		use crate::json::{n, obj, s, Value};
5	9
6		−	fn valid_rate(r: &str) -> bool {
7		−	let (int, frac) = r.split_once('.').unwrap_or((r, "0"));
8		−	!int.is_empty() && int.bytes().all(\|b\| b.is_ascii_digit()) && (1..=3).contains(&frac.len()) && frac.bytes().all(\|b\| b.is_ascii_digit())
	10	+	fn parse_rate(r: &str) -> Option<(u128, u128)> {
	11	+	let (int, frac) = r.split_once('.').unwrap_or((r, ""));
	12	+	let ok = !int.is_empty() && int.bytes().all(\|b\| b.is_ascii_digit()) && frac.len() <= 3 && frac.bytes().all(\|b\| b.is_ascii_digit())
	13	+	&& (r.contains('.') == !frac.is_empty());
	14	+	if !ok {
	15	+	return None;
	16	+	}
	17	+	Some((format!("{int}{frac}").parse().ok()?, 10u128.pow(frac.len() as u32) * 100)) // 年利 ÷ 100 = rn / rd
9	18		}
10	19
11	20		pub fn calc(principal: i64, rate: &str, years: i64, mode: &str) -> Result<Value, String> {
12		−	if !(1..=10_000_000_000).contains(&principal) \|\| !valid_rate(rate) \|\| !(1..=50).contains(&years) \|\| !(mode == "simple" \|\| mode == "compound") {
13		−	return Ok(obj(vec![("error", s("invalid_input"))]));
	21	+	let invalid = \|\| Ok(obj(vec![("error", s("invalid_input"))]));
	22	+	if !(1..=10_000_000_000).contains(&principal) \|\| !(1..=50).contains(&years) \|\| !(mode == "simple" \|\| mode == "compound") {
	23	+	return invalid();
14	24		}
15		−	let r: f64 = rate.parse::<f64>().map_err(\|e\| e.to_string())? / 100.0;
16		−	if r > 0.2 {
17		−	return Ok(obj(vec![("error", s("invalid_input"))]));
	25	+	let Some((rn, rd)) = parse_rate(rate) else { return invalid() };
	26	+	if rn * 5 > rd {
	27	+	return invalid();
18	28		}
19		−	let p = principal as f64;
20		−	let gross = if mode == "simple" { p * r * years as f64 } else { p * (1.0 + r).powi(years as i32) - p };
21		−	let interest = gross.round() as i64;
22		−	let tax = (interest as f64 * 0.15315).floor() as i64 + (interest as f64 * 0.05).floor() as i64;
	29	+	let p = principal as u128;
	30	+	let interest: u128 = if mode == "simple" {
	31	+	let (num, den) = (p * rn * years as u128, rd);
	32	+	(2 * num + den) / (2 * den)
	33	+	} else {
	34	+	let den = BigUint::from_u128(rd).pow(years as u64);
	35	+	let num = BigUint::from_u128(rd + rn).pow(years as u64).mul_small(p).sub(&den.mul_small(p));
	36	+	let target = num.mul_small(2).add(&den); // 2 × 分子 + 分母
	37	+	let den2 = den.mul_small(2);
	38	+	let (mut lo, mut hi) = (0u128, 1u128 << 60); // 利息は 2^60 円未満
	39	+	while lo < hi {
	40	+	let mid = (lo + hi + 1) / 2;
	41	+	if den2.mul_small(mid) <= target { lo = mid } else { hi = mid - 1 }
	42	+	}
	43	+	lo
	44	+	};
	45	+	let interest = interest as i64;
	46	+	let tax = interest * 15315 / 100000 + interest * 5 / 100; // それぞれ1円未満切り捨て
23	47		let net = interest - tax;
24	48		Ok(obj(vec![("gross_total", n(principal + interest)), ("interest", n(interest)), ("tax", n(tax)), ("net_interest", n(net)), ("net_total", n(principal + net))]))
25	49		}

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		# 預金利息の計算。
2		−	# v1: to_f の Float と ** で計算し、利息は round、税は floor で丸める素直な書き方。
	2	+	# v2: 年利を Rational（有理数）にして利息を正確に計算し、円への四捨五入（round(half: :up)）と税の切り捨てを整数で行う。
	3	+	# Float だと 10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちる。
3	4
4	5		module Deposit
5	6		module_function
			@@ 変更前 10行目〜 / 変更後 11行目〜 @@
10	11		return { "error" => "invalid_input" }
11	12		end
12	13
13		−	r = rate.to_f / 100
14		−	return { "error" => "invalid_input" } if r > 0.2
	14	+	r = Rational(rate) / 100
	15	+	return { "error" => "invalid_input" } if r > Rational(1, 5)
15	16
16	17		gross = mode == "simple" ? principal * r * years : principal * (1 + r)**years - principal
17		−	interest = gross.round
18		−	tax = (interest * 0.15315).floor + (interest * 0.05).floor
	18	+	interest = gross.round(half: :up)
	19	+	tax = interest * 15_315 / 100_000 + interest * 5 / 100 # それぞれ1円未満切り捨て（Integer の / は切り捨て）
19	20		net = interest - tax
20	21		{ "gross_total" => principal + interest, "interest" => interest, "tax" => tax, "net_interest" => net, "net_total" => principal + net }
21	22		end

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1		−	import kotlin.math.floor
2		−	import kotlin.math.pow
3		−	import kotlin.math.roundToLong
	1	+	import java.math.BigDecimal
	2	+	import java.math.RoundingMode
4	3
5		−	// 預金利息の計算。v1: Double と pow で計算し、利息は roundToLong、税は floor で丸める素直な書き方。
	4	+	// 預金利息の計算。
	5	+	// v2: 年利を BigDecimal（十進）で読み、(1 + 年利)^年数も pow で正確に計算して、利息は setScale(0, HALF_UP)、税は整数の割り算で切り捨てる。
	6	+	// Double と pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちていた。
	7	+
	8	+	val RATE_LIMIT: BigDecimal = BigDecimal(20)
6	9
7	10		fun deposit(principal: Long, rate: String, years: Long, mode: String): Map<String, Any?> {
8	11		if (principal < 1 \|\| principal > 10_000_000_000L \|\| !Regex("""\d+(\.\d{1,3})?""").matches(rate) \|\|
			@@ 変更前 10行目〜 / 変更後 13行目〜 @@
10	13		) {
11	14		return linkedMapOf("error" to "invalid_input")
12	15		}
13		−	val r = rate.toDouble() / 100
14		−	if (r > 0.2) return linkedMapOf("error" to "invalid_input")
15		−	val gross = if (mode == "simple") principal * r * years else principal * (1 + r).pow(years.toInt()) - principal
16		−	val interest = gross.roundToLong()
17		−	val tax = floor(interest * 0.15315).toLong() + floor(interest * 0.05).toLong()
	16	+	val pct = BigDecimal(rate)
	17	+	if (pct > RATE_LIMIT) return linkedMapOf("error" to "invalid_input")
	18	+	val r = pct.movePointLeft(2)
	19	+	val p = BigDecimal.valueOf(principal)
	20	+	val gross = if (mode == "simple") p * r * BigDecimal.valueOf(years) else p * (BigDecimal.ONE + r).pow(years.toInt()) - p
	21	+	val interest = gross.setScale(0, RoundingMode.HALF_UP).longValueExact() // 円に四捨五入（0.5 は繰り上げ）
	22	+	val tax = Math.multiplyExact(interest, 15315L) / 100000 + interest * 5 / 100 // それぞれ1円未満切り捨て（利息は 0 以上）
18	23		val net = interest - tax
19	24		return linkedMapOf(
20	25		"interest" to interest,

			@@ 変更前 1行目〜 / 変更後 1行目〜 @@
1	1		// 預金利息の計算。
2		−	// v1: 素直に書いた版（Double と pow で計算し、利息は rounded()、税は floor で丸める）。
3		−	// 金額は円の整数なので Decimal は使わず、年利だけ Double で読む（Swift の標準の小数は Double）。
4		−	import Foundation
	2	+	// v2: 年利を分数にして利息を正確に計算し、円への四捨五入と税の切り捨てを整数で行う。
	3	+	// Double と pow だと、10万円・年0.5%・2年の利息 1,002.5円が 1002.4999999999709 になり、1,002円に落ちた。
	4	+	// 複利の (1 + 年利)^50 は Int にも Int128 にも入らないので、自作の多倍長整数（BigUInt.swift）で計算する。
5	5
6		−	/// 小数第3位までの数か（"0.2"・"0.005"・"20"）
7		−	private func validRate(_ r: String) -> Bool {
	6	+	/// "0.005" → 年利 ÷ 100 = (5, 100000)。小数第3位まで
	7	+	private func parseRate(_ r: String) -> (UInt64, UInt64)? {
8	8		let parts = r.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
9		−	let int = parts[0], frac = parts.count > 1 ? parts[1] : "0"
10		−	return !int.isEmpty && int.allSatisfy { $0.isASCII && $0.isNumber } && (1...3).contains(frac.count)
11		−	&& frac.allSatisfy { $0.isASCII && $0.isNumber }
	9	+	let int = parts[0], frac = parts.count > 1 ? parts[1] : ""
	10	+	guard !int.isEmpty, int.count <= 6, int.allSatisfy({ $0.isASCII && $0.isNumber }), frac.count <= 3,
	11	+	frac.allSatisfy({ $0.isASCII && $0.isNumber }), parts.count == 1 \|\| !frac.isEmpty,
	12	+	let num = UInt64(int + frac) else { return nil }
	13	+	var den: UInt64 = 100
	14	+	for _ in frac { den *= 10 }
	15	+	return (num, den)
12	16		}
13	17
14	18		func deposit(principal: Int, rate: String, years: Int, mode: String) throws -> [String: Any] {
15		−	guard (1...10_000_000_000).contains(principal), validRate(rate), (1...50).contains(years),
16		−	mode == "simple" \|\| mode == "compound", let rp = Double(rate) else { return ["error": "invalid_input"] }
17		−	let r = rp / 100
18		−	if r > 0.2 { return ["error": "invalid_input"] }
19		−	let p = Double(principal)
20		−	let gross = mode == "simple" ? p * r * Double(years) : p * pow(1 + r, Double(years)) - p
21		−	let interest = Int(gross.rounded())
22		−	let tax = Int(floor(Double(interest) * 0.15315)) + Int(floor(Double(interest) * 0.05))
	19	+	let invalid: [String: Any] = ["error": "invalid_input"]
	20	+	guard (1...10_000_000_000).contains(principal), (1...50).contains(years), mode == "simple" \|\| mode == "compound",
	21	+	let (rn, rd) = parseRate(rate), rn * 5 <= rd else { return invalid }
	22	+	let p = BigUInt(principal)
	23	+	// 利息 = 分子 ÷ 分母
	24	+	let num: BigUInt, den: BigUInt
	25	+	if mode == "simple" {
	26	+	num = p.mulSmall(rn).mulSmall(UInt64(years))
	27	+	den = BigUInt(rd)
	28	+	} else {
	29	+	den = BigUInt(rd).pow(years)
	30	+	num = BigUInt(rd + rn).pow(years) * p - den * p
	31	+	}
	32	+	// 四捨五入（0.5円は繰り上げ）= ⌊(2 × 分子 + 分母) ÷ (2 × 分母)⌋
	33	+	let q = (num.mulSmall(2) + den).quotientAndRemainder(dividingBy: den.mulSmall(2)).quotient
	34	+	guard let i64 = q.uint64, i64 <= UInt64(Int.max) else { throw Failure("interest overflow") }
	35	+	let interest = Int(i64)
	36	+	let tax = interest * 15315 / 100000 + interest * 5 / 100 // それぞれ1円未満切り捨て
23	37		let net = interest - tax
24	38		return ["gross_total": principal + interest, "interest": interest, "tax": tax, "net_interest": net,
25	39		"net_total": principal + net]

			@@ 変更前 31行目〜 / 変更後 31行目〜 @@
31	31		/// Swift の nil を JSON の null にする
32	32		func orNull(_ v: Any?) -> Any { v ?? NSNull() }
33	33
	34	+	// コンパイラの版（#if swift(...) は言語モードの版で、swiftc の既定では Swift 5 になるので使わない）
34	35		private let runtimeName: String = {
35		−	#if swift(>=6.5)
	36	+	#if compiler(>=6.5)
36	37		return "Swift 6.5+"
37		−	#elseif swift(>=6.4)
	38	+	#elseif compiler(>=6.4)
38	39		return "Swift 6.4"
39		−	#elseif swift(>=6.3)
	40	+	#elseif compiler(>=6.3)
40	41		return "Swift 6.3"
41		−	#elseif swift(>=6.2)
	42	+	#elseif compiler(>=6.2)
42	43		return "Swift 6.2"
43		−	#elseif swift(>=6.1)
	44	+	#elseif compiler(>=6.1)
44	45		return "Swift 6.1"
45		−	#elseif swift(>=6.0)
	46	+	#elseif compiler(>=6.0)
46	47		return "Swift 6.0"
47	48		#else
48	49		return "Swift 5"