Comment écrire 2 ** n - 1 comme fonction récursive?

J'ai besoin d'une fonction qui prend n et renvoie 2 ⁿ - 1 . Cela semble assez simple, mais la fonction doit être récursive. Jusqu'à présent, je n'ai que 2 ⁿ :

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

L'exercice indique: "Vous pouvez supposer que le paramètre n est toujours un entier positif et supérieur à 0"

2**n -1est également 1 + 2 + 4 + ... + 2 ^n-1 qui peut être transformé en une seule fonction récursive (sans la seconde pour soustraire 1 de la puissance de 2).

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

Solution ci-dessous, ne cherchez pas si vous voulez essayer l'indice en premier.

Cela fonctionne si nest garanti supérieur à zéro (comme promis dans l'énoncé du problème):

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

Une version plus robuste gérerait également les valeurs nulles et négatives:

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'ajout d'une vérification pour les non-entiers est laissé comme exercice.)

Pour résoudre un problème avec une approche récursive, vous devez trouver comment définir la fonction avec une entrée donnée en termes de la même fonction avec une entrée différente. Dans ce cas, depuis f(n) = 2 * f(n - 1) + 1, vous pouvez faire:

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

pour que:

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

les sorties:

0
1
3
7
15

Vous pouvez extraire la partie vraiment récursive vers une autre fonction

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

Ou vous pouvez définir un indicateur et définir à quel moment soustraire

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

>>> print(required_steps(10))
1023

En utilisant un paramètre supplémentaire pour le résultat, 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

Vous pouvez également l'écrire en utilisant le décalage gauche au niveau du bit, <<-

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

La sortie est la même

Avoir un espace réservé pour se souvenir de la valeur d'origine de n, puis pour la toute première étape, c'est n == N-à- dire retourner2^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)

Une façon d'obtenir l'offset de "-1" consiste à l'appliquer dans le retour du premier appel de fonction à l'aide d'un argument avec une valeur par défaut, puis de définir explicitement l'argument offset à zéro lors des appels récursifs.

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

En plus de toutes les réponses impressionnantes données précédemment, ci-dessous montrera son implémentation avec les fonctions internes.

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

Fondamentalement, il attribue une valeur globale de n à k et revient à travers elle avec des comparaisons appropriées.