我正在用 Swift 编写一个计算阶乘的函数，代码如下：
func factorial(factorialNumber: UInt64) -> UInt64 {
if factorialNumber == 0 {
return 1
} else {
return factorialNumber * factorial(factorialNumber - 1)
}
}
let x = factorial(20)
这个函数可以计算到20。
我认为21的阶乘值大于UINT64_MAX。
那么如何在Swift中计算21！（21的阶乘）？
func factorial(_ n: Int) -> Double {
return (1...n).map(Double.init).reduce(1.0, *)
}
(1...n):我们创建一个包含所有参与操作的数字的数组（例如：[1, 2, 3, ...]）。
map(Double.init):我们将类型从Int更改为Double，因为使用Double可以表示比Int更大的数字（https://en.wikipedia.org/wiki/Double-precision_floating-point_format）。因此，我们现在将参与操作的所有数字作为Doubles数组（例如：[1.0, 2.0, 3.0, ...]）。
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是为了避免显式定义变量来跟踪部分结果。
无符号 64 位整数的最大值为 18,446,744,073,709,551,615。而 21! = 51,090,942,171,709,440,000。对于这种情况，您需要使用大整数类型。我在 Swift 中找到一个关于大整数的问题。该链接中有一个专门用于处理大整数的库。
你是否考虑过使用双倍精度或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))
}
首先，我们需要声明一个类型为double的临时变量，以便它可以存储数字的大小。
然后我们创建一个函数，该函数接受类型为double的参数。
然后我们检查，如果数字等于0，我们可以返回或什么都不做。我们有一个if条件，因此我们可以中断函数的递归调用。最后，我们返回temp，它保存给定数字的阶乘。
var temp:Double = 1.0
func factorial(x:Double) -> Double{
if(x==0){
//do nothing
}else{
factorial(x: x-1)
temp *= x
}
return temp
}
factorial(x: 21.0)
如果你愿意放弃精度，你可以使用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
}
extension Int {
var factorial:Double {
var num:Double = Double(self)
var product:Double = 1
while(num > 0) {
product *= num
num -= 1
}
return product
}
}
print(170.factorial) // 7.257415615308004e+306
print(21.factorial) // 5.109094217170944e+19
func factorialNumber( namber : Int ) -> Int {
var x = 1
for i in 1...namber {
x *= i
}
return x
}
print ( factorialNumber (namber : 5 ))
func factorial<N: Numeric>(_ x: N) -> N {
x == 0 ? 1 : x * factorial(x - 1)
}
func factorial(a: Int) -> Int {
return a == 1 ? a : a * factorial(a: a - 1)
}
print(factorial(a : 5))
print(factorial(a: 9))
func factoruial(_ num:Int) -> Int{
if num == 0 || num == 1{
return 1
}else{
return(num*factoruial(num - 1))
}
}
25321 非法指令 (核心已转储) - General Grievance
H,L样式的变量（每个数字使用两个变量），或者使用某种bigint库。如果你选择使用bigints，也许这个快速精确的bigint阶乘能帮上一些忙。 - Spektre