如何在 python 中进行双阶乘？

Question

我已经被这个问题困扰了很长时间。 我已经成功地完成了一次递归阶乘。

def factorial(n):
     if n == 0:
         return 1
     else:
         return n * factorial(n-1)

双阶乘 对于偶数 n，双阶乘是所有小于或等于 n 的偶数正整数的乘积。对于奇数整数 p，双阶乘是所有小于或等于 p 的奇数正整数的乘积。

如果 n 是偶数，则 n!! = n*(n - 2)*(n - 4)*(n - 6)* ... *4*2

如果 p 是奇数，则 p!! = p*(p - 2)*(p - 4)*(p - 6)* ... *3*1

但我不知道做双阶乘。有什么帮助吗？

Answer 1

from functools import reduce # only in Python 3

reduce(int.__mul__, range(n, 0, -2))

Answer 2

这不是与具有不同结束条件和不同参数的递归调用的阶乘相同吗？

def doublefactorial(n):
     if n <= 0:
         return 1
     else:
         return n * doublefactorial(n-2)

如果n是偶数，那么当n == 0时它将停止。如果n是奇数，那么当n == -1时它将停止。

Answer 3

这里的问题是双阶乘是为负实数（-1）定义的！ = 1, (-3)!! = -1（即使是负整数（例如-2，-4，...）也应该有+/- inf的解决方案）所以......在负数的所有解决方案中有些东西闻起来很糟糕。如果想为所有实数定义双阶乘，这些解决方案不起作用。解决方案是使用 gamma 函数定义双阶乘。

import scipy.special as sp
from numpy import pi

def dfact(x):
    n = (x + 1.)/2.
    return 2.**n * sp.gamma(n + 0.5)/(pi**(0.5))

有用！ ：D

Answer 4

从 Python 3.8 开始，我们可以使用 <来自 mathprod 函数code> 模块，它计算可迭代中所有元素的乘积，在我们的例子中是 range(n, 0, -2)：

import math

math.prod(range(n, 0, -2))

请注意，这也处理 的情况n = 0 在这种情况下，结果为 1。

Answer 5

我的递归解决方案的版本，一行：

dfact = lambda n: (n <= 0) or n * dfact(n-2)

然而，有趣的是，双阶乘可以用“正常”阶乘来表示。对于奇数，

n!! = (2*k)! / (2**k * k!)

其中 k = (n+1)/2。对于偶数参数 n=2k，虽然这与对复杂参数的概括不一致，但表达式更简单，

n!! =（2k）！！ = 2*k * k!。

所有这些意味着您可以使用标准数学库中的阶乘函数编写代码，这总是很好：

import math
fact = math.factorial
def dfact(n):
  if n % 2 == 1:
    k = (n+1)/2
    return fact(2*k) / (2**k * fact(k))
  else:
    return 2**k * fact(k)

现在，这段代码对于大 n 显然不是很有效，但它非常有启发性。更重要的是，由于我们现在正在处理标准阶乘，因此在处理非常大的数字时，这是优化的一个非常好的起点。您尝试使用对数或伽马函数来获得大数的近似双阶乘。

Answer 6

def doublefactorial(n):
     if n in (0, 1):
         return 1
     else:
         return n * doublefactorial(n-2)

应该这样做。

Answer 7

def double_fact(number):
    if number==0 or number==1:
        return 1
    else:
        return number*double_fact(number-2)

我认为这应该对你有用。

Answer 8

我希望我理解正确，但这行得通吗

 def factorial(n):
 if n == 0 or n == 1:
     return 1
 else:
     return n * factorial(n-2)

Answer 9

reduce(lambda x,y: y*x, range(n,1,-2))

这与简单的迭代版本基本相同：

x = n
for y in range(n-2, 1, -2):
    x*=y

显然你也可以递归地执行，但是什么是观点 ？使用递归性实现的这种示例在使用所有递归语言时都很好，但对于命令式语言，它总是使像递归性这样的简单工具看起来比必要的更加复杂，而在处理像树这样的基本递归结构时，递归性可以是一个真正的简化器。

Answer 10

def doublefactorial(n):
     if n <= 0:
         return 1
     else:
         return n * doublefactorial(n-2)

应该可以做到这一点。除非我误会了

Answer 11

我遇到了同样的问题，我是这样决定的：

def double_factorial(N):
if N == 0: return 1
elif N == 1: return 1
elif N == 2: return 2
else:
    return N * double_factorial(N - 2)