Yinelenen işlev olarak 2 ** n - 1 nasıl yazılır?

Ben n alır ve 2 ⁿ - 1 döndüren bir işleve ihtiyacım var . Kulağa yeterince basit geliyor, ancak işlev özyinelemeli olmalıdır. Şimdiye kadar sadece 2 ^{n var} :

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

Alıştırma şunları söylüyor: "n parametresinin her zaman pozitif bir tam sayı ve 0'dan büyük olduğunu varsayabilirsiniz"

2**n -1ayrıca tek bir özyinelemeli işlev haline getirilebilen 1 + 2 + 4 + ... + 2 ^n-1'dir (ikincisi olmadan 2'nin gücünden 1 çıkarmak).

İpucu : 1 + 2 * (1 + 2 * (...))

Aşağıdaki çözüm, önce ipucunu denemek isteyip istemediğinize bakmayın.

Bu n, sıfırdan büyük olduğu garanti edilirse çalışır (aslında sorun bildiriminde vaat edildiği gibi):

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

Daha sağlam bir sürüm sıfır ve negatif değerleri de işleyebilir:

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)

(Tamsayı olmayanlar için bir kontrol ekleme alıştırması olarak bırakılmıştır.)

Özyinelemeli bir yaklaşımla bir sorunu çözmek için, belirli bir girdiyle işlevi farklı bir girdiyle aynı işlev açısından nasıl tanımlayabileceğinizi öğrenmeniz gerekir. Bu durumda, çünkü f(n) = 2 * f(n - 1) + 1şunları yapabilirsiniz:

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

Böylece:

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

çıktılar:

0
1
3
7
15

Gerçekten özyinelemeli parçayı başka bir işleve çıkarabilirsiniz

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

Veya bir bayrak ayarlayabilir ve ne zaman çıkarılacağını belirleyebilirsiniz

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

>>> print(required_steps(10))
1023

Sonuç için ek bir parametre kullanarak, 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

Ayrıca bitsel sola kaydırma kullanarak da yazabilirsiniz, <<-

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

Çıktı aynı

İlk aşamada, yani daha sonra orijinal n değerini ve hatırlamak için bir yer tutucu var n == N, dönüş2^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)

"-1" ofsetini almanın bir yolu, varsayılan değerde bir argüman kullanarak ilk işlev çağrısından geri dönüşte uygulamak ve sonra özyinelemeli çağrılar sırasında ofset bağımsız değişkenini açıkça sıfıra ayarlamaktır.

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

Daha önce verilen tüm müthiş cevapların üstünde, aşağıda iç işlevlerle uygulanmasını gösterecektir.

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

Temel olarak, k'ye küresel bir n değeri atar ve uygun karşılaştırmalar ile tekrar eder.