递归阶乘函数

Question

如何将这两个函数组合成一个递归函数以获得以下结果：

factorial(6)

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

这是我的阶乘函数的当前代码：

def factorial(n):
   if n < 1:   # base case
       return 1
   else:
       return n * factorial(n - 1)  # recursive call


def fact(n):
   for i in range(1, n+1 ):
       print "%2d! = %d" % (i, factorial(i))

并且该代码产生的输出如下：

fact(6)

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

如您所见，执行这两个函数给了我正确的答案，但我只是想将这两个函数简化为单个递归函数。

Answer 1

我们可以将这两个函数组合成这个单个递归函数：

def factorial(n):
   if n < 1:   # base case
       return 1
   else:
       returnNumber = n * factorial(n - 1)  # recursive call
       print(str(n) + '! = ' + str(returnNumber))
       return returnNumber

Answer 2

2行代码：

def fac(n):
    return 1 if (n < 1) else n * fac(n-1)

测试一下：

print fac(4)

结果：

24

Answer 3

def factorial(n):
    result = 1 if n <= 1 else n * factorial(n - 1)
    print '%d! = %d' % (n, result)
    return result

Answer 4

简短的：

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

Answer 5

试试这个：

def factorial( n ):
   if n <1:   # base case
       print "%2d! = %d" % (n, n)
       return 1
   else:
       temp = factorial( n - 1 )
       print "%2d! = %d" % (n, n*temp)
       return n * temp  # recursive call

我注意到的一件事是，对于 n<1，您将返回“1”，这意味着即使对于负数，您的函数也会返回 1。您可能想解决这个问题。

Answer 6

我没有使用Python的经验，但是像这样的东西？

def factorial( n ):
   if n <1:   # base case
       return 1
   else:
       f = n * factorial( n - 1 )  # recursive call
       print "%2d! = %d" % ( n, f )
       return f

Answer 7

这是作业吗？

def traced_factorial(n):
  def factorial(n):
    if n <= 1:
      return 1
    return n * factorial(n - 1)
  for i in range(1, n + 1):
    print '%2d! = %d' %(i, factorial(i))

请阅读 PEP227 了解更多详细信息。缺点是 Python 允许您在函数内定义函数。

Answer 8

fac = lambda x: 1 if x == 0 else x * fac(x - 1)

Answer 9

再来一张

def fact(x):
    if x in {0, 1}:
        return 1
    else:
        return x * fact(x-1)

for x in range(0,10):
    print '%d! = %d' %(x, fact(x))

Answer 10

并首次使用递归和 while 循环计算阶乘。

def factorial(n):
    while  n >= 1:
        return n * factorial(n - 1)
    return 1

虽然 TrebledJ 在关于使用 if 的注释中写的选项更好。因为 while 循环比 if 执行更多操作（SETUP_LOOP、POP_BLOCK）。该功能较慢。

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

timeit -n 10000 -r 10

• while 每个循环 836 µs ± 11.8 µs
• if 每个循环 787 µs ± 7.22 µs

Answer 11

可以使用这4行代码...

   def factorial(n):
        f = lambda n: n * f(n - 1) if n > 1 else 1

        for x in range(n):
            print('{}! = {}'.format(x + 1, factorial(x + 1)))

Answer 12

我真的不知道负数的阶乘，但这适用于所有 n >= 0：

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

    return 'error'

Answer 13

在 Python 3.8 中，您可以尝试阶乘函数本身。

import math
n=int(input())
print(math.factorial(n))

例如：

Input: 5

Output:120

Answer 14

递归函数中总是存在某种循环和一些停止循环的停止代码：

public int recursivefactorial(int number)
{
    if(number==1)
        return 1;
    else
        return recursivefactorial(number-1)*number;
}

如您所见，满足 if 条件会导致实际结束“循环”的代码，这是递归函数中最重要的部分。相反，条件的 else 部分会导致再次调用 recursivefactorial 函数，这实际上是一种循环。

Answer 15

再来一张 =)

#FAC calculation

def fakulteta(x):
    if x!=1:
         return x*fakulteta(x-1)
    return 1


print (fakulteta(12))