単価の比較（どちらがお得か）

<?php
declare(strict_types=1);

use BcMath\Number;

/**
 * 単価の比較（どちらがお得か）。
 * v2: 十進（BcMath\Number）で単価を出し、小数第1位への四捨五入は RoundingMode::HalfAwayFromZero で明示する。
 * float だと 97 ÷ 80 × 100 が 121.24999… になり、本当は同じ単価を「A がお得」と判定してしまう。
 * 割り算は有限桁で打ち切るので、四捨五入の判定に影響しない桁数（20桁）まで出す。
 */
function tenths(string $price, string $qty, int $base): int
{
    // price × base × 10 ÷ qty を整数に四捨五入 = 単価を 0.1 単位にそろえた値
    return (int) (new Number($price) * $base * 10)->div($qty, 20)->round(0, RoundingMode::HalfAwayFromZero)->value;
}

function fmt1(int $t): string
{
    return intdiv($t, 10) . '.' . $t % 10;
}

/** @return array{unit_a:string, unit_b:string, verdict:string, diff:string} */
function compareUnitPrice(string $unit, string $aPrice, string $aQty, string $bPrice, string $bQty): array
{
    $base = $unit === '個' ? 1 : 100;
    $ta = tenths($aPrice, $aQty, $base);
    $tb = tenths($bPrice, $bQty, $base);
    $verdict = $ta === $tb ? 'same' : ($ta < $tb ? 'A' : 'B');
    return ['unit_a' => fmt1($ta), 'unit_b' => fmt1($tb), 'verdict' => $verdict, 'diff' => fmt1(abs($ta - $tb))];
}

<?php
declare(strict_types=1);

/**
 * 単価の比較（どちらがお得か）。
 * v1: よくある書き方（float で単価を出し、×10 して round で 0.1 単位にそろえて比べる）。
 * @return array{unit_a:string, unit_b:string, verdict:string, diff:string}
 */
function compareUnitPrice(string $unit, string $aPrice, string $aQty, string $bPrice, string $bQty): array
{
    $base = $unit === '個' ? 1 : 100;
    $ta = (int) round((float) $aPrice / (float) $aQty * $base * 10);
    $tb = (int) round((float) $bPrice / (float) $bQty * $base * 10);
    $verdict = $ta === $tb ? 'same' : ($ta < $tb ? 'A' : 'B');
    $f = fn (int $t): string => number_format($t / 10, 1, '.', '');
    return ['unit_a' => $f($ta), 'unit_b' => $f($tb), 'verdict' => $verdict, 'diff' => $f(abs($ta - $tb))];
}

"""単価の比較（どちらがお得か）。

v2: Fraction で単価を正確に出し、0.1 単位への四捨五入（0.05 ちょうどは繰り上げ）も整数で行う。
float だと 97 ÷ 80 × 100 が 121.24999… になり、本当は同じ単価を「A がお得」と判定してしまう。
"""
import math
from fractions import Fraction


def _tenths(price: str, qty: str, base: int) -> int:
    return math.floor(Fraction(price) / Fraction(qty) * base * 10 + Fraction(1, 2))


def _fmt(t: int) -> str:
    return f"{t // 10}.{t % 10}"


def compare(unit: str, a_price: str, a_qty: str, b_price: str, b_qty: str) -> dict:
    base = 1 if unit == "個" else 100
    ta, tb = _tenths(a_price, a_qty, base), _tenths(b_price, b_qty, base)
    verdict = "same" if ta == tb else ("A" if ta < tb else "B")
    return {"unit_a": _fmt(ta), "unit_b": _fmt(tb), "verdict": verdict, "diff": _fmt(abs(ta - tb))}

"""単価の比較（どちらがお得か）。

v1: よくある書き方（float で単価を出し、×10 して round で 0.1 単位にそろえて比べる）。
"""


def compare(unit: str, a_price: str, a_qty: str, b_price: str, b_qty: str) -> dict:
    base = 1 if unit == "個" else 100
    ta = round(float(a_price) / float(a_qty) * base * 10)
    tb = round(float(b_price) / float(b_qty) * base * 10)
    verdict = "same" if ta == tb else ("A" if ta < tb else "B")
    return {"unit_a": f"{ta / 10:.1f}", "unit_b": f"{tb / 10:.1f}", "verdict": verdict, "diff": f"{abs(ta - tb) / 10:.1f}"}

package main

import (
	"fmt"
	"math/big"
)

// Input は単価比較の入力。
type Input struct {
	Unit   string `json:"unit"`
	APrice string `json:"a_price"`
	AQty   string `json:"a_qty"`
	BPrice string `json:"b_price"`
	BQty   string `json:"b_qty"`
}

// tenths は price ÷ qty × base を 0.1 単位に四捨五入した整数を返す（0.05 ちょうどは繰り上げ）。
func tenths(price, qty string, base int64) (int64, error) {
	p, ok1 := new(big.Rat).SetString(price)
	q, ok2 := new(big.Rat).SetString(qty)
	if !ok1 || !ok2 {
		return 0, fmt.Errorf("invalid decimal: %q / %q", price, qty)
	}
	v := new(big.Rat).Quo(p, q)
	v.Mul(v, big.NewRat(base*10, 1))
	v.Add(v, big.NewRat(1, 2))
	return new(big.Int).Quo(v.Num(), v.Denom()).Int64(), nil
}

func fmt1(t int64) string { return fmt.Sprintf("%d.%d", t/10, t%10) }

// Compare はどちらがお得かを判定する。
// v2: math/big.Rat で単価を正確に出し、0.1 単位への四捨五入も整数で行う
// （float64 だと 97 ÷ 80 × 100 が 121.24999… になり、本当は同じ単価を「A がお得」と判定してしまう）。
func Compare(in Input) (map[string]string, error) {
	base := int64(100)
	if in.Unit == "個" {
		base = 1
	}
	ta, err := tenths(in.APrice, in.AQty, base)
	if err != nil {
		return nil, err
	}
	tb, err := tenths(in.BPrice, in.BQty, base)
	if err != nil {
		return nil, err
	}
	verdict, d := "same", ta-tb
	if ta < tb {
		verdict, d = "A", tb-ta
	} else if ta > tb {
		verdict = "B"
	}
	return map[string]string{"unit_a": fmt1(ta), "unit_b": fmt1(tb), "verdict": verdict, "diff": fmt1(d)}, nil
}

package main

import (
	"math"
	"strconv"
)

// Input は単価比較の入力。
type Input struct {
	Unit   string `json:"unit"`
	APrice string `json:"a_price"`
	AQty   string `json:"a_qty"`
	BPrice string `json:"b_price"`
	BQty   string `json:"b_qty"`
}

func num(s string) float64 { v, _ := strconv.ParseFloat(s, 64); return v }

// Compare はどちらがお得かを判定する。
// v1: よくある書き方（float64 で単価を出し、×10 して math.Round で 0.1 単位にそろえて比べる）。
func Compare(in Input) (map[string]string, error) {
	base := 100.0
	if in.Unit == "個" {
		base = 1
	}
	ta := int64(math.Round(num(in.APrice) / num(in.AQty) * base * 10))
	tb := int64(math.Round(num(in.BPrice) / num(in.BQty) * base * 10))
	verdict := "same"
	if ta < tb {
		verdict = "A"
	} else if ta > tb {
		verdict = "B"
	}
	f := func(t int64) string { return strconv.FormatFloat(float64(t)/10, 'f', 1, 64) }
	d := ta - tb
	if d < 0 {
		d = -d
	}
	return map[string]string{"unit_a": f(ta), "unit_b": f(tb), "verdict": verdict, "diff": f(d)}, nil
}

// 単価の比較（どちらがお得か）。
// v2: BigInt の分数で単価を正確に出し、0.1 単位への四捨五入（0.05 ちょうどは繰り上げ）も整数で行う。
// Number だと 97 ÷ 80 × 100 が 121.24999… になり、本当は同じ単価を「A がお得」と判定してしまう。

function dec(s) {
  const m = /^(\d+)(?:\.(\d+))?$/.exec(s);
  if (!m) throw new RangeError(`invalid decimal: ${s}`);
  const frac = m[2] ?? "";
  return { n: BigInt(m[1] + frac), d: 10n ** BigInt(frac.length) };
}

/** price ÷ qty × base を 0.1 単位に四捨五入した整数 */
function tenths(price, qty, base) {
  const p = dec(price), q = dec(qty);
  const num = p.n * q.d * base * 10n;
  const den = p.d * q.n;
  return (2n * num + den) / (2n * den);
}

const fmt = (t) => `${t / 10n}.${t % 10n}`;

export function compare({ unit, a_price, a_qty, b_price, b_qty }) {
  const base = unit === "個" ? 1n : 100n;
  const ta = tenths(a_price, a_qty, base);
  const tb = tenths(b_price, b_qty, base);
  const verdict = ta === tb ? "same" : ta < tb ? "A" : "B";
  return { unit_a: fmt(ta), unit_b: fmt(tb), verdict, diff: fmt(ta > tb ? ta - tb : tb - ta) };
}

// 単価の比較（どちらがお得か）。
// v1: よくある書き方（Number で単価を出し、×10 して Math.round で 0.1 単位にそろえて比べる）。

export function compare({ unit, a_price, a_qty, b_price, b_qty }) {
  const base = unit === "個" ? 1 : 100;
  const ta = Math.round((Number(a_price) / Number(a_qty)) * base * 10);
  const tb = Math.round((Number(b_price) / Number(b_qty)) * base * 10);
  const verdict = ta === tb ? "same" : ta < tb ? "A" : "B";
  return { unit_a: (ta / 10).toFixed(1), unit_b: (tb / 10).toFixed(1), verdict, diff: (Math.abs(ta - tb) / 10).toFixed(1) };
}