"<i>How to calculate the 21!<\/i>如何计算21！<\/b> <i>(21 factorial) in swift?<\/i> （21阶乘）迅速？<\/b>"

Question

我正在制作快速计算阶乘的功能。 像这样

func factorial(factorialNumber: UInt64) -> UInt64 {
    if factorialNumber == 0 {
        return 1
    } else {
        return factorialNumber * factorial(factorialNumber - 1)
    }
}

let x = factorial(20)

Answer 1

func factorial(_ n: Int) -> Double {
  return (1...n).map(Double.init).reduce(1.0, *)
}

1. (1...n) ：我们创建一个包含操作中涉及的所有数字的数组（即： [1, 2, 3, ...] ）。

2. map(Double.init) ：我们从Int更改为Double因为我们可以用 Double 表示比Int更大的数字（ https://en.wikipedia.org/wiki/Double-precision_floating-point_format ）。 因此，我们现在将所有参与运算的数字作为Doubles数组（即： [1.0, 2.0, 3.0, ...] ）。

3. reduce(1.0, *) ：我们开始将1.0与数组中的第一个元素 ( 1.0*1.0 = 1.0 ) 相乘，然后将其结果与下一个元素 ( 1.0*2.0 = 2.0 ) 相乘，然后将其结果与下一个（ 2.0*3.0 = 6.0 ），依此类推。

第 2 步是避免溢出问题。

第 3 步是避免我们显式定义用于跟踪部分结果的变量。

Answer 2

无符号 64 位整数的最大值为 18,446,744,073,709,551,615。 虽然21！ = 51,090,942,171,709,440,000。 对于这种情况，您需要一个 Big Integer 类型。 我在 Swift 中发现了一个关于 Big Integer 的问题。 该链接中有一个 Big Integer 库。

Swift 中的 BigInteger 等价物？

Answer 3

您是否考虑过使用 double ？ 还是 NSDecimalNumber？

同样递归地调用相同的函数在性能方面确实很糟糕。

如何使用循环：

let value = number.intValue - 1

var product = NSDecimalNumber(value: number.intValue)

for i in (1...value).reversed() {
    product = product.multiplying(by: NSDecimalNumber(value: i))
}

Answer 4

这是一个函数，它接受任何符合Numeric协议的类型，这些类型都是内置的数字类型。

func factorial<N: Numeric>(_ x: N) -> N {
    x == 0 ? 1 : x * factorial(x - 1)
}

Answer 5

如果您愿意放弃精度，您可以使用 Double 粗略计算高达 170 的阶乘：

func factorial(_ n: Int) -> Double {
    if n == 0 {
        return 1
    }
    var a: Double = 1
    for i in 1...n {
        a *= Double(i)
    }
    return a
}

如果没有，请使用大整数库。

Answer 6

func factoruial(_ num:Int) -> Int{
        if num == 0 || num == 1{
            return 1
        }else{
           return(num*factoruial(num - 1))
       }
   }

Answer 7

var 温度：双 = 1.0

函数阶乘(x:Double) -> Double{

if(x==0){
    return temp
}else{
factorial(x: x-1)
    temp *= x
}
return temp

}

阶乘（x：21.0）

Answer 8

func factorial(a: Int) -> Int {

    return a == 1 ? a : a * factorial(a: a - 1)
}

print(factorial(a : 5))

print(factorial(a: 9))

Answer 9

使用递归来解决这个问题：

    func factorial(_ n: UInt) -> UInt {
        return n < 2 ? 1 : n*factorial(n - 1)
    }