Wie schreibe ich 2 ** n - 1 als rekursive Funktion?

Ich brauche eine Funktion, die n nimmt und 2 ⁿ - 1 zurückgibt . Es klingt einfach genug, aber die Funktion muss rekursiv sein. Bisher habe ich nur 2 ⁿ :

def required_steps(n):
    if n == 0:
        return 1
    return 2 * req_steps(n-1)

In der Übung heißt es: "Sie können davon ausgehen, dass der Parameter n immer eine positive ganze Zahl und größer als 0 ist."

2**n -1ist auch 1 + 2 + 4 + ... + 2 ^n-1, was zu einer einzigen rekursiven Funktion gemacht werden kann (ohne dass die zweite 1 von der Potenz von 2 subtrahiert).

Hinweis : 1 + 2 * (1 + 2 * (...))

Lösung unten, schauen Sie nicht, ob Sie den Hinweis zuerst versuchen möchten.

Dies funktioniert, wenn ngarantiert größer als Null ist (wie in der Problemstellung tatsächlich versprochen):

def required_steps(n):
    if n == 1: # changed because we need one less going down
        return 1
    return 1 + 2 * required_steps(n-1)

Eine robustere Version würde auch Null- und negative Werte verarbeiten:

def required_steps(n):
    if n < 0:
        raise ValueError("n must be non-negative")
    if n == 0:
        return 0
    return 1 + 2 * required_steps(n-1)

(Das Hinzufügen eines Schecks für Nicht-Ganzzahlen bleibt als Übung übrig.)

Um ein Problem mit einem rekursiven Ansatz zu lösen, müssten Sie herausfinden, wie Sie die Funktion mit einer bestimmten Eingabe in Bezug auf dieselbe Funktion mit einer anderen Eingabe definieren können. In diesem Fall können Sie seitdem f(n) = 2 * f(n - 1) + 1:

def required_steps(n):
    return n and 2 * required_steps(n - 1) + 1

damit:

for i in range(5):
    print(required_steps(i))

Ausgänge:

0
1
3
7
15

Sie können den wirklich rekursiven Teil in eine andere Funktion extrahieren

def f(n):
    return required_steps(n) - 1

Oder Sie können ein Flag setzen und festlegen, wann subtrahiert werden soll

def required_steps(n, sub=True):
    if n == 0: return 1
    return 2 * required_steps(n-1, False) - sub

>>> print(required_steps(10))
1023

Verwenden eines zusätzlichen Parameters für das Ergebnis, r-

def required_steps (n = 0, r = 1):
  if n == 0:
    return r - 1
  else:
    return required_steps(n - 1, r * 2)

for x in range(6):
  print(f"f({x}) = {required_steps(x)}")

# f(0) = 0
# f(1) = 1
# f(2) = 3
# f(3) = 7
# f(4) = 15
# f(5) = 31

Sie können es auch mit bitweiser Linksverschiebung schreiben, <<-

def required_steps (n = 0, r = 1):
  if n == 0:
    return r - 1
  else:
    return required_steps(n - 1, r << 1)

Die Ausgabe ist die gleiche

Haben Sie einen Platzhalter, um sich den ursprünglichen Wert von n zu merken n == N, und kehren Sie dann für den allerersten Schritt zurück2^n-1

n = 10
# constant to hold initial value of n
N = n
def required_steps(n, N):
    if n == 0:
        return 1
    elif n == N:
        return 2 * required_steps(n-1, N) - 1
    return 2 * required_steps(n-1, N)

required_steps(n, N)

Eine Möglichkeit, den Offset von "-1" zu erhalten, besteht darin, ihn in der Rückgabe des ersten Funktionsaufrufs mit einem Argument mit einem Standardwert anzuwenden und das Offset-Argument während der rekursiven Aufrufe explizit auf Null zu setzen.

def required_steps(n, offset = -1):
    if n == 0:
        return 1
    return offset + 2 * required_steps(n-1,0)

Zusätzlich zu den fantastischen Antworten, die zuvor gegeben wurden, wird unten die Implementierung mit inneren Funktionen gezeigt.

def outer(n):
    k=n
    def p(n):
        if n==1:
            return 2
        if n==k:
            return 2*p(n-1)-1
        return 2*p(n-1)
    return p(n)

n=5
print(outer(n))

Grundsätzlich weist es k einen globalen Wert von n zu und rekursiert ihn mit geeigneten Vergleichen durch.