Rust 计算阶乘时无法存储大值

我正在实现一个算法来获取编程类中某个数字的阶乘

fn factorial(number: u64) -> u64 {
    if number < 2 {
        1
    } else {
        number * factorial(number - 1)
    }
}

这样就不会出现恐慌，但结果总是零，所以我尝试使用f64，结果是零

100！=9332621544944100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

而不是

100！=933262154439441526816992388562667004907159682643816214685992963895217599322991608944146397615651828625369792082723723758251185210916864000000000000000000000000

是否有其他方法存储结果以返回正确的值？

100！这真是个大数字。事实上，

u64

中的最大阶乘只有20！。对于不适合

u64

的数字，是一个合适的存储选项

以下代码计算100！的值！。您可以在浏览器中运行它

<代码>外部板条箱数量； 使用num:：BigUint； fn阶乘（数：BigUint）->BigUint{ 让big_1=1u32.into（）； 让big_2=2u32.into（）； 如果数字 要深入了解为什么

u64

不起作用，可以对结果调用

bits

方法。如果你这样做，你会发现100的值！需要525位位来存储。这超过了8个u64的存储空间。

100！这真是个大数字。事实上，

u64

中的最大阶乘只有20！。对于不适合

u64

的数字，是一个合适的存储选项

以下代码计算100！的值！。您可以在浏览器中运行它

extern板条箱数量；
使用num:：BigUint；
fn阶乘（数：BigUint）->BigUint{
让big_1=1u32.into（）；
让big_2=2u32.into（）；
如果数字

---

要深入了解为什么

u64

不起作用，可以对结果调用

bits

方法。如果你这样做，你会发现100的值！需要525位位来存储。这比8

u64

的存储价值还高。

我想用一个迭代解决方案来补充@Jason Watkins的答案，使用：

extern板条箱数量；
使用num:：{bigint:：BigUint，One}；
fn阶乘（值：u32）->BigUint{
（2..=value）.fold（BigUint:：one（），| res，n | res*n）
}
fn main（）{
设结果=阶乘（10）；
assert_eq！（结果，3628800u32.into（））；
}

我想用一个迭代的解决方案来补充@Jason Watkins的答案，使用：

extern板条箱数量；
使用num:：{bigint:：BigUint，One}；
fn阶乘（值：u32）->BigUint{
（2..=value）.fold（BigUint:：one（），| res，n | res*n）
}
fn main（）{
设结果=阶乘（10）；
assert_eq！（结果，3628800u32.into（））；
}

除了下面的答案之外，我想我应该注意到您最初声称的价值为100！这是不正确的。“你是如何计算这个值的？”Jason WATKISS C++程序，但是显然是出了什么问题，谢谢你修复它。除了下面的答案，我想我应该注意到你最初声称的值为100。这是不正确的。“你是如何计算这个值的？”Jason WATKISS C++程序，但显然有些地方出错了，谢谢你修复它。为什么不使用<代码>如果数字< BigI2等？因为某些原因，当我最初写答案时，它对我来说不起作用。看起来它与最终版本的代码配合得很好，所以我将更新答案以使用它。注意，尾部递归版本更好：为什么不使用

if number

等？因为某些原因，在我最初编写答案时，这对我不起作用。看起来它与最终版本的代码配合得很好，因此我将更新答案以使用它。请注意，尾部递归版本更好：

fn factorial(number: u64) -> u64 {
    if number < 2 {
        1
    } else {
        number.wrapping_mul(factorial(number - 1))
    }
}

extern crate num;

use num::BigUint;

fn factorial(number: BigUint) -> BigUint {
    let big_1 = 1u32.into();
    let big_2 = 2u32.into();
    if number < big_2 {
        big_1
    } else {
        let prev_factorial = factorial(number.clone() - big_1);
        number * prev_factorial
    }
}

fn main() {
    let number = 100u32.into();
    println!("{}", factorial(number));
}