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

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

Answer 2

是否与具有不同结束条件和递归调用的不同参数的factorial相同？

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

如果n是偶数，那么它会在n == 0时暂停。如果n为奇数，则会在n == -1时暂停。

Answer 3

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

我认为这应该适合你。

Answer 4

这里的问题是双因子被定义为负实数（-1）!! = 1，（ - 3）!! = -1（即使是负整数（例如-2，-4，......）也应该有+/- inf的解）所以......在负数的所有解中，某些东西闻起来很糟糕。如果想要为其他人定义双因素，那么这些解决方案就无法发挥作用。解决方案是使用伽马函数定义双因子。

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 5

从Python 3.8开始，我们可以使用prod模块中的math函数，该函数计算可迭代元素中所有元素的乘积，在我们的例子中为range(n, 0, -2)：

import math

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

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

Answer 6

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

应该这样做。除非我误解了

Answer 7

def doublefactorial(n):
     if n in (0, 1):
         return 1
     else:
         return n * doublefactorial(n-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

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

Answer 10

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

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

然而，值得注意的是，双因子可以用＆＃34; normal＆＃34;来表示。阶乘。对于奇数，

<磷>氮!! =（2 * k）！ /（2 ** k * k！）

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

<磷>氮!! =（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来说显然不是很有效，但它非常有启发性。更重要的是，由于我们现在正在处理标准阶乘，因此在处理非常大的数字时，它是优化的一个非常好的起点。一旦尝试使用对数或伽马函数来获得大数的近似双因子。

你是如何在python中进行双因素的？

10 个答案: