Come scrivere 2 ** n - 1 come funzione ricorsiva?

Ho bisogno di una funzione che accetta n e restituisce 2 ⁿ - 1 . Sembra abbastanza semplice, ma la funzione deve essere ricorsiva. Finora ho solo 2 ⁿ :

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

L'esercizio afferma: "Puoi presumere che il parametro n sia sempre un numero intero positivo e maggiore di 0"

2**n -1è anche 1 + 2 + 4 + ... + 2 ^n-1 che può trasformarsi in una singola funzione ricorsiva (senza che la seconda sottragga 1 dalla potenza di 2).

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

Soluzione di seguito, non guardare se vuoi provare prima il suggerimento.

Funziona se nè garantito che è maggiore di zero (come effettivamente promesso nella dichiarazione del problema):

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

Una versione più robusta gestirà anche i valori zero e negativo:

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)

(L'aggiunta di un controllo per i numeri non interi viene lasciata come un esercizio.)

Per risolvere un problema con un approccio ricorsivo, dovresti scoprire come definire la funzione con un determinato input in termini della stessa funzione con un input diverso. In questo caso, poiché f(n) = 2 * f(n - 1) + 1puoi fare:

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

così che:

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

uscite:

0
1
3
7
15

È possibile estrarre la parte realmente ricorsiva in un'altra funzione

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

Oppure puoi impostare un flag e definire solo quando sottrarre

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

>>> print(required_steps(10))
1023

Utilizzando un parametro aggiuntivo per il risultato, 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

Puoi anche scriverlo usando lo spostamento a sinistra bit a bit, <<-

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

L'output è lo stesso

Chiedi a un segnaposto di ricordare il valore originale di n e quindi per il primo passo n == N, ovvero restituire2^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)

Un modo per ottenere l'offset di "-1" è applicarlo nel ritorno dalla prima chiamata di funzione utilizzando un argomento con un valore predefinito, quindi impostare esplicitamente l'argomento offset su zero durante le chiamate ricorsive.

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

Oltre a tutte le fantastiche risposte fornite in precedenza, di seguito verrà mostrata la sua implementazione con funzioni interne.

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

Fondamentalmente, assegna un valore globale da n a k e lo ricorre attraverso di esso con confronti appropriati.