die maximale Rekursionstiefe überschritten im Vergleich

Schrieb ich dieses Stück code zur Berechnung der Anzahl der Kombinationen:

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

def combinations(n,k):
    return fact(n)/((fact(n - k) * fact(k)))

while(True):
    print(combinations(int(input()), int(input())))

Die factorial-Funktion scheint gut zu funktionieren. Aber warum macht es mir eine maximale Rekursionstiefe überschritten im Vergleich Fehlermeldung wenn ich versuche zu finden die Kombinationen von zwei zahlen? Gibt es etwas falsch mit der factorial-Funktion, da das ist, wo der Fehler scheint zu sein, entstehend aus?

War dies der Fehler, die ich bekam:

gelieferten.Absturz mit Laufzeitfehler: maximale Rekursionstiefe überschritten im Vergleich

Und die 2 zahlen.
Gibt es etwas falsch mit math.factorial?
und was ist falsch mit scipy.misc.comb?

InformationsquelleAutor Daniel Cook | 2013-11-17

3

Versuchen zu ersetzen:
```
def fact(n):
    return 1 if(n == 1) else n * fact(n - 1)
```
:
```
def fact(n):
    return 1 if(n <= 1) else n * fact(n - 1)
```
Weil wenn Sie 2 identische zahlen, würden Sie versuchen, zu berechnen fact(0) (die nennen würde fact(-1) und fact(-2) usw, bis die maximale Rekursionstiefe Fehler).

InformationsquelleAutor Maxime Chéramy
3

Sollten Sie versuchen zu vermeiden, die Rekursion für so eine einfache Funktion wie die Fakultät einer Zahl. Rekursion ist wirklich mächtig, aber manchmal ist es überlastet ohne Grund.

Hier ist der code für die iterative version von fakultaet-Funktion:
```
def fact(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
```
Bemerken, was Maxime sagt in der vorherigen Antwort, das ist genau das problem, das Sie haben: Ihre Funktion nicht über die Fakultät von 0.

InformationsquelleAutor ecampver
3

Den Standard-Rekursion Grenze in python 3.x-version ab 2000 nur, Wenn Sie rufen Sie die gleiche Funktion erneut, und wieder mehr als 2000-mal, erhalten Sie die maximale Rekursionstiefe Fehler. Der ideale Ansatz wäre zu schreiben Sie eine Logik ohne Rekursion. Aber Wenn Sie noch kleben, Rekursion, ändern Sie die Standard-Rekursion begrenzen von:

import sys

sys.setrecursionlimit(10000)# setzt Er die Rekursion limit auf 10000.

Aber die oben können nicht all Ihre Bedürfnisse in bestimmten Kontexten.

Hier haben wir ein Problem mit der Anzahl der rekursiven Vergleiche. Diese Grenze ist viel niedriger als die max rekursive Tiefe.

InformationsquelleAutor Siva Kumar
1

Ihre Rekursionstiefe aus der limit.
1. Rekursion ist nicht die idiomatische Weise, Dinge zu tun, in Python, da Sie nicht haben, tail-Rekursion Optimierung ist somit nicht praktikabel, die Verwendung von Rekursion als Ersatz für die iteration (auch wenn in deinem Beispiel die Funktion ist nicht tail-rekursiv ist, wäre das nicht trotzdem helfen). Grundsätzlich, das bedeutet, dass Sie sollten nicht es verwenden, für Dinge, die haben eine größere Komplexität als linear, wenn Sie erwarten, dass Ihre Eingaben zu groß sein.
2. Wenn Sie eine Plattform haben, die sich für ein höheres limit können Sie die Limits höher:
  
  sys.setrecursionlimit(some_number)
  sys.setrecursionlimit(some_number)
  
  Diese Funktion setzt die maximale Tiefe die der Python-interpreter-stack zu begrenzen. Dieses limit verhindert eine unendliche Rekursion verursachen einen überlauf des C-stack und stürzt Python. Die höchste mögliche Grenze ist Plattform-abhängig. Kann ein Benutzer benötigen, um das limit höher, wenn Sie ein Programm, das erfordert Tiefe der Rekursion und eine Plattform, die sich für ein höheres limit. Dies sollte mit Vorsicht durchgeführt werden, da ein zu hoher Wert kann zu einem Absturz führen.
ref:

Python-rekursive Funktion Fehler: "maximale Rekursionstiefe überschritten"

Python-max-Rekursion , Frage zu sys.setrecursionlimit()

InformationsquelleAutor hxysayhi
0
```
sys.setrecursionlimit(some_number)
```
InformationsquelleAutor user8301642

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.