Ik had het programma oorspronkelijk verkeerd gecodeerd. In plaats van de Fibonacci getallen tussen een bereik terug te geven (d.w.z. startNumber 1, endNumber 20 moet = alleen de getallen tussen 1 & 20), heb ik geschreven voor het programma om alle Fibonacci getallen tussen een bereik weer te geven (d.w.z. startNumber 1, endNumber 20 geeft weer = eerste 20 Fibonacci getallen). Ik dacht dat ik een zekere code had. Ik zie ook niet waarom dit gebeurt.
startNumber = int(raw_input("Enter the start number here "))
endNumber = int(raw_input("Enter the end number here "))
def fib(n):
if n < 2:
return n
return fib(n-2) + fib(n-1)
print map(fib, range(startNumber, endNumber))
Iemand wees mij er in mijn Deel II op (dat werd gesloten omdat het een duplicaat was - https://stackoverflow.com/questions/504193/how-to-write-the-fibonacci-sequence-in-python-part-ii) dat ik het startNummer en eindNummer door een generator moet laten lopen met behulp van een while-lus. Kan iemand mij in de richting wijzen hoe ik dit moet doen? Alle hulp is welkom.
Ik'ben een lerende programmeur en ik'ben een beetje op een kluwen gestuit. Mij is gevraagd een programma te schrijven dat de reeks van Fibonacci's zal berekenen en weergeven door een door de gebruiker ingevoerd startnummer en eindnummer (d.w.z. startNummer = 20 eindNummer = 100 en het zal alleen de getallen tussen dat bereik weergeven). De truc is om het inclusief te gebruiken (wat ik niet weet hoe dat moet in Python? - Ik'm neem aan dat dit betekent dat je een inclusief bereik moet gebruiken?).
Wat ik tot nu toe heb is geen eigenlijke codering maar eerder:
Ik heb geen idee waar ik moet beginnen en ik vraag om ideeën of inzicht in hoe ik dit moet schrijven. Ik heb ook geprobeerd om de Fib sequence forumla te schrijven maar ook daar raak ik de weg kwijt.
Er is veel informatie over de Fibonacci reeks te vinden op wikipedia en op wolfram. Veel meer dan je misschien nodig hebt. Hoe dan ook is het een goede zaak om te leren hoe je deze bronnen kunt gebruiken om (snel indien mogelijk) te vinden wat je nodig hebt.
In de wiskunde wordt het gegeven in een recursieve vorm:
fibonacci van wikipedia]3
In programmeren bestaat oneindig niet. Je kunt een recursieve vorm gebruiken door de wiskundige vorm direct in je taal te vertalen, bijvoorbeeld in Python wordt het:
def F(n):
if n == 0: return 0
elif n == 1: return 1
else: return F(n-1)+F(n-2)
Probeer het eens in je favoriete taal en zie dat deze vorm veel tijd vergt als n groter wordt. In feite is dit O(2n) in tijd.
Ga verder op de sites die ik je heb gelinkt en je zult dit zien (op wolfram):
Deze is vrij eenvoudig te implementeren en zeer, zeer snel te berekenen, in Python:
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
Een andere manier om het te doen is volgens de definitie (van wikipedia):
Het eerste getal van de reeks is 0, het tweede getal is 1, en elk volgende getal is gelijk aan de som van de vorige twee getallen van de reeks zelf, wat de reeks oplevert 0, 1, 1, 2, 3, 5, 8, etc.
Als uw taal iterators ondersteunt, kunt u iets doen als:
def F():
a,b = 0,1
while True:
yield a
a, b = b, a + b
Als je eenmaal weet hoe je Fibonacci getallen moet genereren, hoef je alleen maar door de getallen te lopen en te kijken of ze aan de gegeven voorwaarden voldoen.
Stel nu dat je een f(n) schreef dat de n-de term van de Fibonacci rij teruggeeft (zoals die met sqrt(5) )
In de meeste talen kun je zoiets doen als:
def SubFib(startNumber, endNumber):
n = 0
cur = f(n)
while cur <= endNumber:
if startNumber <= cur:
print cur
n += 1
cur = f(n)
In python zou ik'd de iterator vorm gebruiken en gaan voor:
def SubFib(startNumber, endNumber):
for cur in F():
if cur > endNumber: return
if cur >= startNumber:
yield cur
for i in SubFib(10, 200):
print i
Mijn tip is om te leren lezen wat je nodig hebt. Project Euler (google ervoor) zal je trainen om dit te doen :P Veel succes en plezier!
Het idee achter de Fibonacci-reeks wordt getoond in de volgende Python-code:
def fib(n):
if n == 1:
return 1
elif n == 0:
return 0
else:
return fib(n-1) + fib(n-2)
Dit betekent dat fib een functie is die een van de drie dingen kan doen. Het definieert fib(1) == 1, fib(0) == 0, en fib(n) te zijn:
fib(n-1) + fib(n-2)
Waarbij n een willekeurig geheel getal is. Dit betekent dat fib(2) bijvoorbeeld, uit te breiden is tot de volgende rekenkunde:
fib(2) = fib(1) + fib(0)
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(2) = 1 + 0
fib(2) = 1
We kunnen fib(3) op dezelfde manier berekenen met de rekenkunde hieronder:
fib(3) = fib(2) + fib(1)
fib(2) = fib(1) + fib(0)
fib(2) = 1
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(3) = 1 + 1 + 0
Het belangrijkste om hier te beseffen is dat fib(3) niet kan'worden berekend zonder fib(2) te berekenen, die wordt berekend door de definities van fib(1) en fib(0) te kennen. Een functie zichzelf laten aanroepen zoals de fibonacci functie doet heet recursie, en het'is een belangrijk onderwerp in programmeren.
Dit klinkt als een huiswerkopdracht dus ik'ga het begin/einde gedeelte niet voor je doen. Python is echter een wonderbaarlijk expressieve taal hiervoor, dus dit zou logisch moeten zijn als je wiskunde begrijpt, en zal je hopelijk leren over recursie. Veel succes!
Edit: Een mogelijk punt van kritiek op mijn code is dat het geen gebruik maakt van de superhandige Python functie yield, die de fib(n) functie een stuk korter maakt. Mijn voorbeeld is echter een beetje meer algemeen, aangezien niet veel talen buiten Python yield hebben.