ガチャの当選確率と必要回数

<?php
declare(strict_types=1);

/**
 * ガチャの当選確率と必要回数。
 * v2: 確率を「整数 / 10^k」の分数として GMP で正確に計算し、小数3桁への四捨五入も自前で行う。
 * 必要回数は log で見当を付け、正確な比較で ±1 補正する（log だけだと境界で1回ずれる）。
 */

/** "27.1" → [271, 10] */
function parseDecimal(string $s): array
{
    if (!preg_match('/^(\d+)(?:\.(\d+))?$/', $s, $m)) {
        throw new InvalidArgumentException("invalid decimal: {$s}");
    }
    $frac = $m[2] ?? '';
    return [gmp_init($m[1] . $frac, 10), gmp_pow(10, strlen($frac))];
}

/** 0 以上の num/den を小数3桁に四捨五入した文字列にする */
function dec3(GMP $num, GMP $den): string
{
    $n = gmp_div_q(2 * $num * 1000 + $den, 2 * $den); // floor(x*1000 + 1/2)
    return gmp_strval(gmp_div_q($n, 1000)) . '.' . str_pad(gmp_strval(gmp_mod($n, 1000)), 3, '0', STR_PAD_LEFT);
}

/** @return array{at_least_one:string, none:string, expected:string} */
function gachaProb(string $rate, int $trials): array
{
    [$rn, $rd] = parseDecimal($rate);          // 排出率(%) = rn/rd
    $den = $rd * 100;                           // p = rn/den
    $noneNum = gmp_pow($den - $rn, $trials);    // (1-p)^N = noneNum/noneDen
    $noneDen = gmp_pow($den, $trials);
    return [
        'at_least_one' => dec3(($noneDen - $noneNum) * 100, $noneDen),
        'none' => dec3($noneNum * 100, $noneDen),
        'expected' => dec3($rn * $trials, $den),
    ];
}

/** @return array{trials:int, actual:string, previous:string, expected:string} */
function gachaCount(string $rate, string $target): array
{
    [$rn, $rd] = parseDecimal($rate);
    [$tn, $td] = parseDecimal($target);
    $den = $rd * 100;
    $tden = $td * 100;
    $q = $den - $rn; // 1-p = q/den
    // (1-p)^n <= 1-t  ⇔  q^n * tden <= (tden - tn) * den^n
    $reaches = fn (int $n): bool => gmp_pow($q, $n) * $tden <= ($tden - $tn) * gmp_pow($den, $n);

    if (gmp_cmp($q, 0) === 0) {
        $n = 1;
    } else {
        $p = gmp_intval($rn) / gmp_intval($den);
        $t = gmp_intval($tn) / gmp_intval($tden);
        $n = max((int) ceil(log(1 - $t) / log(1 - $p)), 1);
        while ($n > 1 && $reaches($n - 1)) {
            $n--;
        }
        while (!$reaches($n)) {
            $n++;
        }
    }
    $prob = fn (int $k): string => $k === 0 ? '0.000' : dec3((gmp_pow($den, $k) - gmp_pow($q, $k)) * 100, gmp_pow($den, $k));
    return ['trials' => $n, 'actual' => $prob($n), 'previous' => $prob($n - 1), 'expected' => dec3($rn * $n, $den)];
}

<?php
declare(strict_types=1);

/**
 * ガチャの当選確率と必要回数。
 * v1: 素直に書いた版（float と pow / log / ceil、表示は number_format）。
 */
function fmt3(float $x): string
{
    return number_format($x, 3, '.', '');
}

/** @return array{at_least_one:string, none:string, expected:string} */
function gachaProb(string $rate, int $trials): array
{
    $p = (float) $rate / 100;
    $none = pow(1 - $p, $trials);
    return ['at_least_one' => fmt3((1 - $none) * 100), 'none' => fmt3($none * 100), 'expected' => fmt3($trials * $p)];
}

/** @return array{trials:int, actual:string, previous:string, expected:string} */
function gachaCount(string $rate, string $target): array
{
    $p = (float) $rate / 100;
    $t = (float) $target / 100;
    $n = (int) ceil(log(1 - $t) / log(1 - $p));
    if ($n < 1) {
        $n = 1;
    }
    $actual = 1 - pow(1 - $p, $n);
    $previous = $n > 1 ? 1 - pow(1 - $p, $n - 1) : 0.0;
    return ['trials' => $n, 'actual' => fmt3($actual * 100), 'previous' => fmt3($previous * 100), 'expected' => fmt3($n * $p)];
}

"""ガチャの当選確率と必要回数。

v2: fractions.Fraction で正確に計算し、小数3桁への四捨五入も自前で行う
（f"{x:.3f}" は2進の値を偶数丸めするため使わない）。
必要回数は log で見当を付け、正確な比較で ±1 補正する（log だけだと境界で1回ずれる）。
"""
import math
from fractions import Fraction


def dec3(x: Fraction) -> str:
    """0 以上の有理数を小数3桁に四捨五入した文字列にする。"""
    n = math.floor(x * 1000 + Fraction(1, 2))
    return f"{n // 1000}.{n % 1000:03d}"


def gacha_prob(rate: str, trials: int) -> dict:
    p = Fraction(rate) / 100
    none = (1 - p) ** trials
    return {"at_least_one": dec3((1 - none) * 100), "none": dec3(none * 100), "expected": dec3(trials * p)}


def gacha_count(rate: str, target: str) -> dict:
    p = Fraction(rate) / 100
    t = Fraction(target) / 100

    def reaches(n: int) -> bool:
        return (1 - p) ** n <= 1 - t

    if p == 1:
        n = 1
    else:
        n = max(math.ceil(math.log(1 - float(t)) / math.log(1 - float(p))), 1)
        while n > 1 and reaches(n - 1):
            n -= 1
        while not reaches(n):
            n += 1
    previous = 1 - (1 - p) ** (n - 1) if n > 1 else Fraction(0)
    return {"trials": n, "actual": dec3((1 - (1 - p) ** n) * 100), "previous": dec3(previous * 100), "expected": dec3(n * p)}

"""ガチャの当選確率と必要回数。

v1: 素直に書いた版（float と ** / math.log / math.ceil、表示は f"{x:.3f}"）。
"""
import math


def gacha_prob(rate: str, trials: int) -> dict:
    p = float(rate) / 100
    none = (1 - p) ** trials
    return {"at_least_one": f"{(1 - none) * 100:.3f}", "none": f"{none * 100:.3f}", "expected": f"{trials * p:.3f}"}


def gacha_count(rate: str, target: str) -> dict:
    p = float(rate) / 100
    t = float(target) / 100
    n = max(math.ceil(math.log(1 - t) / math.log(1 - p)), 1)
    actual = 1 - (1 - p) ** n
    previous = 1 - (1 - p) ** (n - 1) if n > 1 else 0.0
    return {"trials": n, "actual": f"{actual * 100:.3f}", "previous": f"{previous * 100:.3f}", "expected": f"{n * p:.3f}"}

package main

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

// v2: math/big.Rat で正確に計算し、小数3桁への四捨五入も自前で行う
// （strconv.FormatFloat は2進の値を偶数丸めするため使わない）。
// 必要回数は math.Log で見当を付け、正確な比較で ±1 補正する（log だけだと境界で1回ずれる）。

// dec3 は 0 以上の有理数を小数3桁に四捨五入した文字列にする。
func dec3(x *big.Rat) string {
	v := new(big.Rat).Mul(x, big.NewRat(1000, 1))
	v.Add(v, big.NewRat(1, 2))
	n := new(big.Int).Quo(v.Num(), v.Denom()) // 0 以上なので Quo は floor
	q, r := new(big.Int).QuoRem(n, big.NewInt(1000), new(big.Int))
	return fmt.Sprintf("%s.%03d", q, r.Int64())
}

func parseRate(s string) (*big.Rat, error) {
	r, ok := new(big.Rat).SetString(s)
	if !ok {
		return nil, fmt.Errorf("invalid decimal: %q", s)
	}
	return r.Quo(r, big.NewRat(100, 1)), nil
}

func powRat(x *big.Rat, n int) *big.Rat {
	e := big.NewInt(int64(n))
	return new(big.Rat).SetFrac(new(big.Int).Exp(x.Num(), e, nil), new(big.Int).Exp(x.Denom(), e, nil))
}

var one = big.NewRat(1, 1)

func sub(a, b *big.Rat) *big.Rat { return new(big.Rat).Sub(a, b) }
func percent(x *big.Rat) string  { return dec3(new(big.Rat).Mul(x, big.NewRat(100, 1))) }

// GachaProb は N 回引いて1回以上当たる確率を求める。
func GachaProb(rate string, trials int) (map[string]any, error) {
	p, err := parseRate(rate)
	if err != nil {
		return nil, err
	}
	none := powRat(sub(one, p), trials)
	expected := new(big.Rat).Mul(p, big.NewRat(int64(trials), 1))
	return map[string]any{"at_least_one": percent(sub(one, none)), "none": percent(none), "expected": dec3(expected)}, nil
}

// GachaCount は目標確率以上で当てるのに必要な回数を求める。
func GachaCount(rate, target string) (map[string]any, error) {
	p, err := parseRate(rate)
	if err != nil {
		return nil, err
	}
	t, err := parseRate(target)
	if err != nil {
		return nil, err
	}
	q, rest := sub(one, p), sub(one, t)
	reaches := func(n int) bool { return powRat(q, n).Cmp(rest) <= 0 }

	n := 1
	if q.Sign() != 0 {
		pf, _ := p.Float64()
		tf, _ := t.Float64()
		n = max(int(math.Ceil(math.Log(1-tf)/math.Log(1-pf))), 1)
		for n > 1 && reaches(n-1) {
			n--
		}
		for !reaches(n) {
			n++
		}
	}
	prob := func(k int) string { return percent(sub(one, powRat(q, k))) }
	expected := new(big.Rat).Mul(p, big.NewRat(int64(n), 1))
	return map[string]any{"trials": n, "actual": prob(n), "previous": prob(n - 1), "expected": dec3(expected)}, nil
}

package main

import (
	"math"
	"strconv"
)

// v1: 素直に書いた版（float64 と math.Pow / math.Log / math.Ceil、表示は strconv.FormatFloat）。
func fmt3(x float64) string { return strconv.FormatFloat(x, 'f', 3, 64) }

// GachaProb は N 回引いて1回以上当たる確率を求める。
func GachaProb(rate string, trials int) (map[string]any, error) {
	r, err := strconv.ParseFloat(rate, 64)
	if err != nil {
		return nil, err
	}
	p := r / 100
	none := math.Pow(1-p, float64(trials))
	return map[string]any{"at_least_one": fmt3((1 - none) * 100), "none": fmt3(none * 100), "expected": fmt3(float64(trials) * p)}, nil
}

// GachaCount は目標確率以上で当てるのに必要な回数を求める。
func GachaCount(rate, target string) (map[string]any, error) {
	r, err := strconv.ParseFloat(rate, 64)
	if err != nil {
		return nil, err
	}
	tp, err := strconv.ParseFloat(target, 64)
	if err != nil {
		return nil, err
	}
	p, t := r/100, tp/100
	n := int(math.Ceil(math.Log(1-t) / math.Log(1-p)))
	if n < 1 {
		n = 1
	}
	actual := 1 - math.Pow(1-p, float64(n))
	previous := 0.0
	if n > 1 {
		previous = 1 - math.Pow(1-p, float64(n-1))
	}
	return map[string]any{"trials": n, "actual": fmt3(actual * 100), "previous": fmt3(previous * 100), "expected": fmt3(float64(n) * p)}, nil
}

// ガチャの当選確率と必要回数。
// v2: 確率を「BigInt / 10^k」の分数で正確に計算し、小数3桁への四捨五入も自前で行う
// （toFixed は2進の値を丸めるため 0.9975 を 0.997 にする）。
// 必要回数は Math.log で見当を付け、正確な比較で ±1 補正する（log だけだと境界で1回ずれる）。

/** "27.1" → { n: 271n, d: 10n } */
function parseDecimal(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) };
}

/** 0 以上の num/den を小数3桁に四捨五入した文字列にする */
function dec3(num, den) {
  const n = (2n * num * 1000n + den) / (2n * den); // floor(x*1000 + 1/2)
  return `${n / 1000n}.${String(n % 1000n).padStart(3, "0")}`;
}

export function gachaProb({ rate, trials }) {
  const r = parseDecimal(rate);
  const den = r.d * 100n; // p = r.n / den
  const N = BigInt(trials);
  const noneNum = (den - r.n) ** N;
  const noneDen = den ** N;
  return {
    at_least_one: dec3((noneDen - noneNum) * 100n, noneDen),
    none: dec3(noneNum * 100n, noneDen),
    expected: dec3(r.n * N, den),
  };
}

export function gachaCount({ rate, target }) {
  const r = parseDecimal(rate);
  const t = parseDecimal(target);
  const den = r.d * 100n;
  const tden = t.d * 100n;
  const q = den - r.n; // 1-p = q/den
  // (1-p)^n <= 1-t  ⇔  q^n * tden <= (tden - t.n) * den^n
  const reaches = (n) => q ** BigInt(n) * tden <= (tden - t.n) * den ** BigInt(n);

  let n;
  if (q === 0n) {
    n = 1;
  } else {
    const pf = Number(r.n) / Number(den);
    const tf = Number(t.n) / Number(tden);
    n = Math.max(Math.ceil(Math.log(1 - tf) / Math.log(1 - pf)), 1);
    while (n > 1 && reaches(n - 1)) n--;
    while (!reaches(n)) n++;
  }
  const prob = (k) => (k === 0 ? "0.000" : dec3((den ** BigInt(k) - q ** BigInt(k)) * 100n, den ** BigInt(k)));
  return { trials: n, actual: prob(n), previous: prob(n - 1), expected: dec3(r.n * BigInt(n), den) };
}

// ガチャの当選確率と必要回数。
// v1: 素直に書いた版（Number と Math.pow / Math.log / Math.ceil、表示は toFixed(3)）。

export function gachaProb({ rate, trials }) {
  const p = Number(rate) / 100;
  const none = Math.pow(1 - p, trials);
  return { at_least_one: ((1 - none) * 100).toFixed(3), none: (none * 100).toFixed(3), expected: (trials * p).toFixed(3) };
}

export function gachaCount({ rate, target }) {
  const p = Number(rate) / 100;
  const t = Number(target) / 100;
  let n = Math.ceil(Math.log(1 - t) / Math.log(1 - p));
  if (n < 1) n = 1;
  const actual = 1 - Math.pow(1 - p, n);
  const previous = n > 1 ? 1 - Math.pow(1 - p, n - 1) : 0;
  return { trials: n, actual: (actual * 100).toFixed(3), previous: (previous * 100).toFixed(3), expected: (n * p).toFixed(3) };
}