recursive factorial-Funktion

wie kann ich diese kombinieren zwei Funktionen in einer rekursiven Funktion, um zu diesem Ergebnis zu kommen:

factorial(6)
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720

dies sind die codes

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

wie sehen Sie die Ausführung dieser beiden gibt eine richtige Antwort, ich will nur zu machen, um eine rekursive Funktion.

Ich bekomme keine Grund verbindet beides in einer Funktion.
Hmm. Ist dieses Hausaufgaben? Was haben Sie bisher ausprobiert?
Nicht. Es sieht gut so wie es ist. Die Kombination macht die Dinge schwieriger.
FrustratedWithFormsDesigner: letztes Jahr Prüfung ... hahah .... Ich wünschte, ich könnte nehmen Sie die Jungs mit mir zu schreiben, meine Prüfung für mich, aber es ist nicht möglich 😛
Der Fragesteller hatte möglicherweise abgestuft, da die Frage. Jedenfalls hoffe ich, dass der Lehrer, der wollte, dass Sie zu implementieren, die die Fakultät rekursiv sagte Ihnen, dass die Effizienz der rekursiven Lösung ist so schrecklich, dass es sollte nie erlaubt sein. 🙂

InformationsquelleAutor user531225 | 2010-12-21

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

InformationsquelleAutor pythonFoo

2 Zeilen code:

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

Test:

print fac(4)

Ergebnis:

InformationsquelleAutor martynas

kurz:

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

InformationsquelleAutor Ilyas

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

InformationsquelleAutor Will McCutchen

versuchen Sie dies:

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

Eine Sache, die ich bemerkt ist, dass Sie wieder " 1 " n<1, das bedeutet, dass Ihre Funktion gibt 1 zurück, auch für negative zahlen. Möchten Sie vielleicht, um das zu beheben.

InformationsquelleAutor Vinay Pandey

Habe ich keine Erfahrung mit Python, aber sowas?

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

Ich bin mir nicht 100% sicher, dass dies korrekt ist, aber seit der OP sagte, es ist für eine Prüfung, ich gehe nicht in weitere details...

InformationsquelleAutor Mchl

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

InformationsquelleAutor T-kin-ter

2

Ist diese Hausaufgaben durch Zufall?
```
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))
```
Geben PEP227 einen Lesen Sie für weitere details. Die Kurzfassung ist, dass Python ermöglicht die Definition von Funktionen innerhalb von Funktionen.
- lol ... das war einer von den guten 😉
- Dies ist eine Recht ineffiziente Lösung, wie Sie berechnen, factorial(1) n mal, factorial(2) n-1 mal, factorial(3) n-2 mal und so weiter...
InformationsquelleAutor D.Shawley

Einer mehr

def fact(x):
    if x == 0:
        return 0
    elif x == 1:
        return 1
    else:
        return x * fact(x-1)

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

Mathematisch 0! 1 ausgewertet. So der erste Teil der bedingten geändert werden sollte.

InformationsquelleAutor MattyW

Ich weiß wirklich nicht, die Fakultät von negativen zahlen, aber dies funktioniert mit allen n >= 0:

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

InformationsquelleAutor Salah Hamza

Können diese 4 Zeilen code...

   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)))

InformationsquelleAutor Meir Keller

1

Und für die erste Zeit berechnen der Fakultät mit rekursiven und die while-Schleife.
```
def factorial(n):
    while  n >= 1:
        return n * factorial(n - 1)
    return 1
```
Obwohl die Möglichkeit, dass TrebledJ schrieb in den Kommentaren über die Verwendung if ist besser. Da while Schleife führt mehr Operationen (SETUP_LOOP, POP_BLOCK) als if. Die Funktion ist langsamer.
```
def factorial(n):
    if  n >= 1:
        return n * factorial(n - 1)
    return 1
```
timeit -n 10000 -r 10
- while 836 µs ± 11.8 µs pro Schleife
- if 787 µs ± 7.22 µs pro Schleife
- Obwohl richtig, die while ist überflüssig wie return wird kick in der ersten iteration (und keine weiteren Iterationen durchgeführt wird). Ändern while zu if ist viel besser.
- du hast Recht. Danke.
- Was ich meinte, durch redundante, war der kommunikative Aspekt... andere Programmierer sehen, die Funktion wird sehen while und denke: "Okay, es ist Fakt, indem die Schleife"; dann eine Zeile später sehen Sie return und merke, dass es tatsächlich die Fakultät mittels Rekursion. (In der Regel ist die Rekursion ein Ersatz for-Schleifen.) Und... ah, ich sehe, dass eine benchmark. Ein kleiner performance-Unterschied zwischen while-und if, aber der neue Inhalt scheint gut recherchiert. 🙂
InformationsquelleAutor Szczerski
0

Gibt es immer irgendeine Art von einer Schleife, die in rekursiven Funktionen und einige stoppen-codes, die verhindern, dass die Schleife:
```
public int recursivefactorial(int number)
{
    if(number==1)
        return 1;
    else
        return recursivefactorial(number-1)*number;
}
```
Wie Sie sehen können, die die Erfüllung der if Zustand führt zu der code, der tatsächlich endet die "loop" - und dies ist der wichtigste Teil einer rekursiven Funktion. Im Gegensatz dazu, die else Teil der Bedingung führt zum Aufruf recursivefactorial Funktion wieder, die effektiv mit einer Art Schleife.

InformationsquelleAutor Ali

-1

Einer mehr =)

#FAC calculation

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


print (fakulteta(12))

haben Sie eine Rekursion Fehler, als Sie nicht behandeln, 0 und unter

InformationsquelleAutor XraySensei

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.