Como escrever 2 ** n - 1 como uma função recursiva?

Eu preciso de uma função que leva n e retorna 2 ⁿ - 1 . Parece bastante simples, mas a função precisa ser recursiva. Até agora eu tenho apenas 2 ⁿ :

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

O exercício declara: "Você pode assumir que o parâmetro n é sempre um número inteiro positivo e maior que 0"

2**n -1é também 1 + 2 + 4 + ... + 2 ^n-1 que pode ser transformado em uma única função recursiva (sem a segunda para subtrair 1 da potência de 2).

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

Solução abaixo, não procure se você quiser tentar a dica primeiro.

Isso funciona se né garantido que seja maior que zero (como foi realmente prometido na declaração do 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)

Uma versão mais robusta também lidaria com valores zero e negativos:

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)

(Adicionar uma verificação para números não inteiros é deixado como um exercício.)

Para resolver um problema com uma abordagem recursiva, você teria que descobrir como definir a função com uma entrada especificada em termos da mesma função com uma entrada diferente. Nesse caso, desde f(n) = 2 * f(n - 1) + 1, você pode fazer:

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

de modo a:

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

saídas:

0
1
3
7
15

Você pode extrair a parte realmente recursiva para outra função

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

Ou você pode definir um sinalizador e definir exatamente quando subtrair

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

>>> print(required_steps(10))
1023

Usando um parâmetro adicional para o resultado, 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

Você também pode escrevê-lo usando o deslocamento à esquerda bit a bit, <<-

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

A saída é a mesma

Tenha um espaço reservado para lembrar o valor original de n e, em seguida, para o primeiro passo n == N, ou seja , retornar2^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)

Uma maneira de obter o deslocamento de "-1" é aplicá-lo no retorno da primeira chamada de função usando um argumento com um valor padrão e defina explicitamente o argumento de deslocamento como zero durante as chamadas recursivas.

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

Além de todas as respostas impressionantes fornecidas anteriormente, a seguir mostramos sua implementação com funções internas.

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

Basicamente, está atribuindo um valor global de n a ke recorrendo a ele com comparações apropriadas.