Comment écrire la séquence de Fibonacci?
J'avais initialement codé le programme à tort. Au lieu de renvoyer les numéros de Fibonacci entre une plage (par exemple, startNumber 1, endNumber 20 devrait = uniquement les nombres compris entre 1 et 20), j’ai écrit pour que le programme affiche tous les nombres de Fibonacci entre une plage (par exemple, startNumber 1, endNumber 20 affiche = 20 premiers nombres de Fibonacci). Je pensais avoir un code infaillible. Je ne vois pas non plus pourquoi cela se produit.
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))
Quelqu'un a souligné dans ma partie II (qui était fermée pour cause de doublon - https://stackoverflow.com/questions/504193/how-twwrite-the-fibonacci-sequence-in-python-part-ii ) qu'il me faut passer les numéros startNumber et endNumber via un générateur utilisant une boucle while. Quelqu'un peut-il s'il vous plaît me diriger dans la direction sur la façon de faire cela? Toute aide est la bienvenue.
Je suis un programmeur d'apprentissage et je me suis trouvé un peu embrouillé. On me demande d'écrire un programme qui calculera et affichera la séquence de Fibonacci par un numéro de début et un numéro de fin entrés par l'utilisateur (c'est-à-dire startNumber = 20 endNumber = 100 et affichera uniquement les nombres compris dans cette plage). L'astuce consiste à l'utiliser de manière inclusive (ce que je ne sais pas faire en Python? Je suppose que cela signifie utiliser une plage inclusive?).
Ce que j'ai jusqu'à présent n'est pas un codage réel mais plutôt:
- Ecrire la formule de séquence Fib à l'infini
- Afficher startNumber à endNumber uniquement à partir de la séquence Fib.
Je ne sais pas par où commencer et je demande des idées ou des idées pour savoir comment écrire cela. J'ai aussi essayé d'écrire le forumla séquence de Fib mais je m'y perds aussi.
Il y a beaucoup d'informations sur la séquence de Fibonacci sur wikipedia et sur wolfram . Beaucoup plus que vous pourriez avoir besoin. Quoi qu’il en soit, c’est une bonne chose que d’apprendre à utiliser ces ressources pour trouver (rapidement si possible) ce dont vous avez besoin.
Ecrire la formule de séquence Fib à l'infini
En maths, c'est donné sous forme récursive:
En programmation, infinite n'existe pas. Vous pouvez utiliser un formulaire récursif traduisant le formulaire mathématique directement dans votre langue. Par exemple, en Python, il devient:
def F(n):
if n == 0: return 0
Elif n == 1: return 1
else: return F(n-1)+F(n-2)
Essayez-le dans votre langue préférée et constatez que cette forme nécessite beaucoup de temps à mesure que n s'agrandit. En fait, c’est O (2n) à l'heure.
Allez sur les sites que je vous ai liés et vous verrez ceci (sur wolfram ):
Celui-ci est assez facile à implémenter et très, très rapide à calculer, en Python:
from math import sqrt
def F(n):
return ((1+sqrt(5))**n-(1-sqrt(5))**n)/(2**n*sqrt(5))
Une autre façon de le faire est de suivre la définition (de wikipedia ):
Le premier numéro de la séquence est 0, le deuxième numéro est 1 et chaque le nombre suivant est égal à la somme des deux numéros précédents du séquence elle-même, donnant la séquence 0, 1, 1, 2, 3, 5, 8, etc.
Si votre langue prend en charge les itérateurs, vous pouvez faire quelque chose comme:
def F():
a,b = 0,1
while True:
yield a
a, b = b, a + b
Afficher startNumber à endNumber uniquement à partir de la séquence Fib.
Une fois que vous savez comment générer des numéros Fibonacci, il vous suffit d’en parcourir les numéros et de vérifier s’ils vérifient les conditions données.
Supposons maintenant que vous écriviez un f(n) renvoyant le nième terme de la séquence de Fibonacci (comme celui avec sqrt (5))
Dans la plupart des langues, vous pouvez faire quelque chose comme:
def SubFib(startNumber, endNumber):
n = 0
cur = f(n)
while cur <= endNumber:
if startNumber <= cur:
print cur
n += 1
cur = f(n)
En python, j'utiliserais le formulaire itérateur et choisirais:
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
Mon conseil est de apprendre à lire ce dont vous avez besoin. Project Euler (google pour cela) va vous apprendre à le faire: P Bonne chance et amusez-vous!
Générateur Pythonic efficace de la séquence de Fibonacci
J'ai trouvé cette question en essayant d'obtenir la génération Pythonic la plus courte de cette séquence (réalisant plus tard que j'en avais vu une similaire dans une proposition d'amélioration Python ), et je n'ai remarqué personne d'autre solution (bien que la réponse se rapproche, mais toujours moins élégante), donc voilà, avec des commentaires décrivant la première itération, car je pense que cela peut aider les lecteurs à comprendre:
def fib():
a, b = 0, 1
while True: # First iteration:
yield a # yield 0 to start with and then
a, b = b, a + b # a will now be 1, and b will also be 1, (0 + 1)
et utilisation:
for index, fibonacci_number in Zip(range(10), fib()):
print('{i:3}: {f:3}'.format(i=index, f=fibonacci_number))
impressions:
0: 0
1: 1
2: 1
3: 2
4: 3
5: 5
6: 8
7: 13
8: 21
9: 34
10: 55
(Aux fins d'attribution, j'ai récemment remarqué une implémentation similaire dans la documentation de Python sur les modules, même en utilisant les variables a et b, que je me souviens maintenant d'avoir vues avant d'écrire cette réponse. Mais je pense que cette réponse montre mieux utilisation de la langue.)
Implémentation définie récursivement
La Encyclopédie en ligne de séquences entières définit la séquence de Fibonacci de manière récursive comme
F (n) = F(n-1) + F(n-2) avec F(0) = 0 et F(1) = 1
Définir cela de manière récursive en Python peut être fait comme suit:
def rec_fib(n):
'''inefficient recursive function as defined, returns Fibonacci number'''
if n > 1:
return rec_fib(n-1) + rec_fib(n-2)
return n
Mais cette représentation exacte de la définition mathématique est incroyablement inefficace pour des nombres bien supérieurs à 30, car chaque nombre calculé doit également être calculé pour chaque nombre inférieur. Vous pouvez démontrer à quel point il est lent en utilisant les éléments suivants:
for i in range(40):
print(i, rec_fib(i))
Mémorisation de la récursivité pour plus d'efficacité
Il peut être mémorisé pour améliorer la vitesse (cet exemple tire parti du fait qu'un argument de mot clé par défaut est le même objet chaque fois que la fonction est appelée, mais normalement, vous n'utiliseriez pas d'argument par défaut mutable pour cette raison):
def mem_fib(n, _cache={}):
'''efficiently memoized recursive function, returns a Fibonacci number'''
if n in _cache:
return _cache[n]
Elif n > 1:
return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
return n
Vous constaterez que la version mémo est beaucoup plus rapide et dépassera rapidement votre profondeur de récursivité maximale avant même de penser à vous lever pour un café. Vous pouvez voir à quel point c'est visuellement plus rapide en procédant comme suit:
for i in range(40):
print(i, mem_fib(i))
(Il peut sembler que nous pouvons simplement faire ce qui suit, mais cela ne nous permet pas de tirer parti du cache, car il s'appelle lui-même avant l'appel de setdefault.)
def mem_fib(n, _cache={}):
'''don't do this'''
if n > 1:
return _cache.setdefault(n, mem_fib(n-1) + mem_fib(n-2))
return n
Générateur défini récursivement:
En apprenant Haskell, je suis tombé sur cette implémentation à Haskell:
fib@(0:tfib) = 0:1: zipWith (+) fib tfib
Le plus proche, je pense que je peux arriver à cela en Python pour le moment est:
from itertools import tee
def fib():
yield 0
yield 1
# tee required, else with two fib()'s algorithm becomes quadratic
f, tf = tee(fib())
next(tf)
for a, b in Zip(f, tf):
yield a + b
Cela le démontre:
[f for _, f in Zip(range(999), fib())]
Il ne peut cependant aller que jusqu'à la limite de récursivité. Habituellement, 1000, alors que la version Haskell peut atteindre des centaines de millions, bien qu'elle utilise les 8 Go de mémoire de mon ordinateur portable pour le faire:
> length $ take 100000000 fib
100000000
Pourquoi ne pas simplement faire ce qui suit?
x = [1,1]
for i in range(2, 10):
x.append(x[-1] + x[-2])
print(', '.join(str(y) for y in x))
L'idée derrière la séquence de Fibonacci est montrée dans le code Python suivant:
def fib(n):
if n == 1:
return 1
Elif n == 0:
return 0
else:
return fib(n-1) + fib(n-2)
Cela signifie que fib est une fonction capable de faire l'une des trois choses suivantes. Il définit fib (1) == 1, fib (0) == 0 et fib (n) comme étant:
fib (n-1) + fib (n-2)
Où n est un entier arbitraire. Cela signifie que fib (2), par exemple, s'étend à l'arithmétique suivante:
fib(2) = fib(1) + fib(0)
fib(1) = 1
fib(0) = 0
# Therefore by substitution:
fib(2) = 1 + 0
fib(2) = 1
Nous pouvons calculer fib (3) de la même manière avec l'arithmétique ci-dessous:
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
La chose importante à réaliser ici est que fib (3) ne peut être calculé sans calculer fib (2), qui est calculé en connaissant les définitions de fib (1) et fib (0). Avoir une fonction qui s'appelle comme la fonction fibonacci s'appelle récursion, et c'est un sujet important en programmation.
Cela ressemble à un devoir, donc je ne vais pas faire la partie début/fin pour vous. Python est un langage merveilleusement expressif pour cela cependant, cela devrait donc avoir un sens si vous comprenez les mathématiques et, espérons-le, vous enseignera la récursivité. Bonne chance!
Edit: Une critique potentielle de mon code est qu’il n’utilise pas le rendement extrêmement pratique de la fonction Python, ce qui rend la fonction fib (n) beaucoup plus courte. Mon exemple est cependant un peu plus générique, car peu de langages en dehors de Python ont en réalité un rendement.
Complexité temporelle:
La fonctionnalité de mise en cache réduit le mode de calcul normal de la série de Fibonacci de O (2 ^ n) à O(n) en éliminant les répétitions de l’arbre récursif de la série de Fibonacci:
Code:
import sys
table = [0]*1000
def FastFib(n):
if n<=1:
return n
else:
if(table[n-1]==0):
table[n-1] = FastFib(n-1)
if(table[n-2]==0):
table[n-2] = FastFib(n-2)
table[n] = table[n-1] + table[n-2]
return table[n]
def main():
print('Enter a number : ')
num = int(sys.stdin.readline())
print(FastFib(num))
if __name__=='__main__':
main()
Ceci est assez efficace, en utilisant les opérations arithmétiques de base O (log n).
def fib(n):
return pow(2 << n, n + 1, (4 << 2*n) - (2 << n) - 1) % (2 << n)
Celui-ci utilise O(1) les opérations arithmétiques de base, mais la taille des résultats intermédiaires est grande et n'est donc pas du tout efficace.
def fib(n):
return (4 << n*(3+n)) // ((4 << 2*n) - (2 << n) - 1) & ((2 << n) - 1)
Celui-ci calcule X ^ n dans l'anneau polynomial Z [X]/(X ^ 2 - X - 1) en utilisant l'exponentiation par la quadrature. Le résultat de ce calcul est le polynôme Fib (n) X + Fib (n-1), à partir duquel le nième numéro de Fibonacci peut être lu.
Encore une fois, ceci utilise des opérations arithmétiques O (log n) et est très efficace.
def mul(a, b):
return a[0]*b[1]+a[1]*b[0]+a[0]*b[0], a[0]*b[0]+a[1]*b[1]
def fib(n):
x, r = (1, 0), (0, 1)
while n:
if n & 1: r = mul(r, x)
x = mul(x, x)
n >>= 1
return r[0]
Code Python canonique pour imprimer la séquence de Fibonacci:
a,b=1,1
while(True):
print a,
a,b=b,a+b # Could also use b=a+b;a=b-a
Pour le problème "Imprimez le premier numéro de Fibonacci de plus de 1000 chiffres":
a,b=1,1
i=1
while(len(str(a))<=1000):
i=i+1
a,b=b,a+b
print i,len(str(a)),a
utiliser la récursivité:
def fib(n):
if n == 0:
return 0
Elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
x=input('which fibonnaci do you want?')
print fib(x)
Nous savons que
Et que la puissance nième de cette matrice nous donne:
Nous pouvons donc implémenter une fonction qui calcule simplement la puissance de cette matrice à la puissance n-ème -1.
comme tout ce que nous savons le pouvoir a ^ n est égal à
Donc, à la fin, la fonction fibonacci serait O (n) ... rien de bien différent d’une implémentation plus facile sans le fait que nous savons aussi que x^n * x^n = x^2n et l’évaluation de x^n peuvent donc être réalisés avec la complexité O ( log n)
Voici mon implémentation fibonacci en utilisant le langage de programmation Swift:
struct Mat {
var m00: Int
var m01: Int
var m10: Int
var m11: Int
}
func pow(m: Mat, n: Int) -> Mat {
guard n > 1 else { return m }
let temp = pow(m: m, n: n/2)
var result = matMultiply(a: temp, b: temp)
if n%2 != 0 {
result = matMultiply(a: result, b: Mat(m00: 1, m01: 1, m10: 1, m11: 0))
}
return result
}
func matMultiply(a: Mat, b: Mat) -> Mat {
let m00 = a.m00 * b.m00 + a.m01 * b.m10
let m01 = a.m00 * b.m01 + a.m01 * b.m11
let m10 = a.m10 * b.m00 + a.m11 * b.m10
let m11 = a.m10 * b.m01 + a.m11 * b.m11
return Mat(m00: m00, m01: m01, m10: m10, m11: m11)
}
func fibonacciFast(n: Int) -> Int {
guard n > 0 else { return 0 }
let m = Mat(m00: 1, m01: 1, m10: 1, m11: 0)
return pow(m: m, n: n-1).m00
}
Cela a une complexité O (log n). Nous calculons la puissance de Q avec l'exposant n-1, puis nous prenons l'élément m00 qui est Fn + 1 qui, à l'exposant de puissance n-1, correspond exactement au nième nombre de Fibonacci que nous souhaitions.
Une fois que vous avez la fonction rapide fibonacci, vous pouvez parcourir le numéro de début et le numéro de fin pour obtenir la partie de la séquence de Fibonacci qui vous intéresse.
let sequence = (start...end).map(fibonacciFast)
bien sûr, commencez par vérifier le début et la fin pour vous assurer qu'ils peuvent former une plage valide.
Je sais que la question a 8 ans, mais je me suis bien amusé à répondre quand même. :)
OK .. après avoir été fatigué de renvoyer toutes les longues réponses, retrouvez maintenant le type ci-dessous et doux, assez simple pour implémenter Fibonacci en python. Vous pouvez l'améliorer comme vous le souhaitez en obtenant un argument ou en obtenant la participation de l'utilisateur… ou en modifiant les limites à partir de 10000. Selon vos besoins…
def fibonacci():
start = 0
i = 1
lt = []
lt.append(start)
while start < 10000:
start += i
lt.append(start)
i = sum(lt[-2:])
lt.append(i)
print "The Fibonaccii series: ", lt
Cette approche fonctionne également bien. Trouvez l'analyse de la course ci-dessous
In [10]: %timeit fibonacci
10000000 loops, best of 3: 26.3 ns per loop
il existe une méthode très simple pour réaliser cela!
vous pouvez exécuter ce code en ligne librement en utilisant http://www.learnpython.org/
# Set the variable brian on line 3!
def fib(n):
"""This is documentation string for function. It'll be available by fib.__doc__()
Return a list containing the Fibonacci series up to n."""
result = []
a = 0
b = 1
while a < n:
result.append(a) # 0 1 1 2 3 5 8 (13) break
tmp_var = b # 1 1 2 3 5 8 13
b = a + b # 1 2 3 5 8 13 21
a = tmp_var # 1 1 2 3 5 8 13
# print(a)
return result
print(fib(10))
# result should be this: [0, 1, 1, 2, 3, 5, 8]
Celles-ci ont toutes l'air un peu plus compliquées qu'elles ne devraient l'être ... Mon code est très simple et rapide:
def fibonacci(x):
List = []
f = 1
List.append(f)
List.append(f) #because the fibonacci sequence has two 1's at first
while f<=x:
f = List[-1] + List[-2] #says that f = the sum of the last two f's in the series
List.append(f)
else:
List.remove(List[-1]) #because the code lists the fibonacci number one past x. Not necessary, but defines the code better
for i in range(0, len(List)):
print List[i] #prints it in series form instead of list form. Also not necessary
def fib():
a,b = 1,1
num=eval(input("Please input what Fib number you want to be calculated: "))
num_int=int(num-2)
for i in range (num_int):
a,b=b,a+b
print(b)
import time
start_time = time.time()
#recursive solution
def fib(x, y, upperLimit):
return [x] + fib(y, (x+y), upperLimit) if x < upperLimit else [x]
#To test :
print(fib(0,1,40000000000000))
print("run time: " + str(time.time() - start_time))
Résultats
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368 , Cliquez sur le bouton "Stock", cliquez ici. , 12586269025, 2036501108, 32951280099, 53316291173, et autres articles de la section Stock-Bas
durée: 0.04298138618469238
Utiliser pour boucle et imprimer uniquement le résultat
def fib(n:'upto n number')->int:
if n==0:
return 0
Elif n==1:
return 1
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
return b
Résultat
>>>fib(50)
12586269025
>>>>
>>> fib(100)
354224848179261915075
>>>
Imprimer la list contenant tous les nombres
def fib(n:'upto n number')->int:
l=[0,1]
if n==0:
return l[0]
Elif n==1:
return l
a=0
b=1
for i in range(0,n-1):
b=a+b
a=b-a
l.append(b)
return l
Résultat
>>> fib(10)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
Une autre façon de le faire:
a,n=[0,1],10
map(lambda i: reduce(lambda x,y: a.append(x+y),a[-2:]),range(n-2))
Assigner une liste à 'a', assigner un entier à 'n' Map et réduire sont deux des trois fonctions les plus puissantes en python. Ici, la carte est utilisée uniquement pour itérer 'n-2' fois . A [-2:] recevra les deux derniers éléments d'un tableau . A.append (x + y) ajoutera les deux derniers éléments et va ajouter au tableau
La récursivité ajoute du temps. Pour éliminer les boucles, commencez par import math. Ensuite, utilisez math.sqrt et le nombre d'or dans une fonction:
#!/usr/bin/env python3
import math
def fib(n):
gr = (1 + math.sqrt(5)) / 2
fib_first = (gr**n - (1 - gr)**n) / math.sqrt(5)
return int(round(fib_first))
fib_final = fib(100)
print(fib_final)
def fib(lowerbound, upperbound):
x = 0
y = 1
while x <= upperbound:
if (x >= lowerbound):
yield x
x, y = y, x + y
startNumber = 10
endNumber = 100
for fib_sequence in fib(startNumber, endNumber):
print "And the next number is... %d!" % fib_sequence
c'est une amélioration par rapport à la réponse de Mathew Henry:
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print b
a = b
b = c
le code doit imprimer b au lieu de c
sortie: 1,1,2,3,5 ....
C'est la plus simple en python pour les séries de Fibonacci mais elle a été ajustée [0] dans le tableau en sortie par append () pour générer la seconde variable de la liste de résultats qui est result.append(second).
def fibo(num):
first = 0
second = 1
result = [0]
print('Fibonacci series is')
for i in range(0,num):
third = first + second
#print(second)
result.append(second)
first = second
second = third
print(result)
return
fibo(7)
SORTIE
Fibonacci series is
[0, 1, 1, 2, 3, 5, 8, 13]
Fonction optimisée de recherche de Fibonacci en gardant la liste en mémoire
def fib(n, a=[0, 1]):
while n > len(a):
a.append(a[-1] + a[-2])
return a[n-1]
print("Fibonacci of 50 - {}".format(fib(50))
La séquence de Fibonacci est: 1, 1, 2, 3, 5, 8, ....
C'est f(1) = 1, f(2) = 1, f(3) = 2, ..., f(n) = f(n-1) + f(n-2).
Ma mise en œuvre préférée (la plus simple et pourtant qui réalise une vitesse de la lumière comparée aux autres mises en œuvre) est la suivante:
def fibonacci(n):
a, b = 0, 1
for _ in range(1, n):
a, b = b, a + b
return b
Test
>>> [fibonacci(i) for i in range(1, 10)]
[1, 1, 2, 3, 5, 8, 13, 21, 34]
Timing
>>> %%time
>>> fibonacci(100**3)
CPU times: user 9.65 s, sys: 9.44 ms, total: 9.66 s
Wall time: 9.66 s
Edit: un exemple de visualisation pour cette implémentation.
Fondamentalement traduit de Ruby:
def fib(n):
a = 0
b = 1
for i in range(1,n+1):
c = a + b
print c
a = b
b = c
...
Peut-être que cela aidera
def fibo(n):
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, b + a
return result
Je viens de passer http://projecteuler.net/problem=2 ceci était mon point de vue
# Even Fibonacci numbers
# Problem 2
def get_fibonacci(size):
numbers = [1,2]
while size > len(numbers):
next_fibonacci = numbers[-1]+numbers[-2]
numbers.append(next_fibonacci)
print numbers
get_fibonacci(20)
Celui-ci, ça va? Je suppose que ce n’est pas aussi sophistiqué que les autres suggestions car il exige la spécification initiale du résultat précédent pour produire le résultat attendu, mais j’estime qu’il s’agit d’une option très lisible, c’est-à-dire qu’il ne fait que fournir le résultat et le résultat précédent à la récursion.
#count the number of recursions
num_rec = 0
def fibonacci(num, prev, num_rec, cycles):
num_rec = num_rec + 1
if num == 0 and prev == 0:
result = 0;
num = 1;
else:
result = num + prev
print(result)
if num_rec == cycles:
print("done")
else:
fibonacci(result, num, num_rec, cycles)
#Run the fibonacci function 10 times
fibonacci(0, 0, num_rec, 10)
Voici le résultat:
0
1
1
2
3
5
8
13
21
34
done
De manière pythonique, vous pouvez écrire des séries fibannoïques en appliquant la méthode suivante:
a,b = 0,1
while b < 1000:
b = (b, end = ' ', flush = True)
a,b = b , a+b
C’est un exercice pratique que j’ai vu sur la programmation Sal sur Python de Khan Academy: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/exercise---write-a- fonction fibonacci
Il n’est probablement pas le premier à attribuer cette tâche à une tâche bien difficile. Mais c'est génial de le découvrir par vous-même. J'ai beaucoup appris à le comprendre et c'était génial.
Je vous recommande de le découvrir vous-même avant d'essayer de copier le code de quelqu'un d'autre à la maison.
Dans la vidéo ci-dessus, Sal, l'instructeur, montre toute la théorie qui sous-tend le nombre de Fibonacci et, dans cet esprit, vous devriez pouvoir la comprendre.
Cela m'a pris environ 10 minutes et c'est le code que j'ai créé (j'apprends Python depuis 3 jours et c'est mon premier langage de programmation à apprendre). Je n'aurais pas pu écrire le code s'il ne s'agissait pas de la vidéo du tutoriel auparavant: https://www.khanacademy.org/science/computer-science-subject/computer-science/v/comparing- fonctions factorielles itératives et récursives que l'on donne un exemple de Sal faisant une équation factorielle récursive et vous donne l'état d'esprit pour résoudre ce problème.
Voici mon code:
def fibonacci(num):
if num <= 1: #base case
return num
else:
return fibonacci(num-1) + fibonacci(num-2)
Vous pouvez voir que si le nombre est 1 ou 0, vous retournez simplement le nombre.
Je trouve cela plus propre que de dire si le nombre est 1, renvoyer 1 et si le nombre est 0, renvoyer 0.
Simple def - essayez ceci ..
def fib(n):
first = 0
second = 1
holder = 0
array = []
for i in range(0, n):
first = second
second = holder
holder = first + second
array.append(holder)
return array
input -> 10
output -> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
Fibo simple:
def fibo(start, count):
a = [start, start+1]
for i in range(count-len(a)):
a.append(a[-1]+a[-2])
return a
a = fibo(0, 10)
print 'fibo', a
SORTIE: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Fibonacci écrit en tant que générateur:
# fill in this function
def fib():
a = 1
b = 1
yield(a)
yield(b)
for i in range(2, 10):
c = a+b
a, b = b, c
yield(c)
#pass #this is a null statement which does nothing when executed, useful as a placeholder.
# testing code
import types
if type(fib()) == types.GeneratorType:
print("Good, The fib function is a generator.")
counter = 0
for n in fib():
print(n)
counter += 1
if counter == 10:
break
Faire cette solution en appelant fonction et modularisé
def userInput():
number = int(input('Please enter the number between 1 - 40 to find out the
fibonacci :'))
return number
def findFibonacci(number):
if number == 0:
return 0
Elif number == 1:
return 1
else:
return findFibonacci(number - 1) + findFibonacci (number - 2)
def main():
userNumber = userInput()
print(findFibonacci(userNumber))
main()
Sur le format beaucoup plus court:
def fibbo(range_, a, b):
if(range_!=0):
a, b = b, a+b
print(a)
return fibbo(range_-1, a, b)
return
fibbo(11, 1, 0)
Ceci est similaire à ce qui a été posté, mais c'est propre, rapide et facile à lire.
def fib(n):
# start with first two fib numbers
fib_list = [0, 1]
i = 0
# Create loop to iterate through n numbers, assuming first two given
while i < n - 2:
i += 1
# append sum of last two numbers in list to list
fib_list.append(fib_list[-2] + fib_list[-1])
return fib_list
Au bout de 15 minutes de didacticiel utilisé lors de l’apprentissage de Python, le lecteur était invité à écrire un programme permettant de calculer une séquence de Fibonacci à partir de 3 nombres entrés (premier numéro de Fibonacci, deuxième numéro et numéro auquel arrêter la séquence). Le tutoriel ne couvrait que les variables if/thens et les boucles jusqu’à ce point. Aucune fonction pour le moment. Je suis venu avec le code suivant:
sum = 0
endingnumber = 1
print "\n.:Fibonacci sequence:.\n"
firstnumber = input("Enter the first number: ")
secondnumber = input("Enter the second number: ")
endingnumber = input("Enter the number to stop at: ")
if secondnumber < firstnumber:
print "\nSecond number must be bigger than the first number!!!\n"
else:
while sum <= endingnumber:
print firstnumber
if secondnumber > endingnumber:
break
else:
print secondnumber
sum = firstnumber + secondnumber
firstnumber = sum
secondnumber = secondnumber + sum
Comme vous pouvez le constater, c'est vraiment inefficace, mais ça marche.
sur la base de la séquence de fibonacci classique et juste pour les one-liners
si vous avez juste besoin du nombre de l'index, vous pouvez utiliser la réduction (même si réduire ce n'est pas la meilleure solution pour cela, cela peut être un bon exercice)
def fibonacci(index):
return reduce(lambda r,v: r.append(r[-1]+r[-2]) or (r.pop(0) and 0) or r , xrange(index), [0, 1])[1]
et pour obtenir le tableau complet, supprimez simplement le ou (r.pop (0) et 0)
reduce(lambda r,v: r.append(r[-1]+r[-2]) or r , xrange(last_index), [0, 1])
Cela peut être fait de la manière suivante.
n = 0 nombres = [0] pour i dans l'intervalle (0,11): imprimer n , numbers.append (n) prev = numeros [-2] si n == 0: n = 1 sinon: n = n + prev
J'essayais d'éviter une fonction récursive pour résoudre ce problème, alors j'ai adopté une approche itérative. Je faisais initialement une fonction récursive mémoisée mais je continuais à frapper la profondeur récursive maximale. J'avais aussi des objectifs stricts en matière de mémoire, vous me verrez donc garder le tableau aussi petit que possible pendant le processus de bouclage en ne conservant que 2 ou 3 valeurs dans le tableau à tout moment.
def fib(n):
fibs = [1, 1] # my starting array
for f in range(2, n):
fibs.append(fibs[-1] + fibs[-2]) # appending the new fib number
del fibs[0] # removing the oldest number
return fibs[-1] # returning the newest fib
print(fib(6000000))
Obtenir le 6 millionième numéro de fibonacci prend environ 282 secondes sur ma machine, alors que le fibronacci de 600 000 secondes ne prend que 2,8 secondes. Je ne pouvais pas obtenir de si grands nombres de fibonacci avec une fonction récursive, même mémoisée.
def fib(x, y, n):
if n < 1:
return x, y, n
else:
return fib(y, x + y, n - 1)
print fib(0, 1, 4)
(3, 5, 0)
#
def fib(x, y, n):
if n > 1:
for item in fib(y, x + y, n - 1):
yield item
yield x, y, n
f = fib(0, 1, 12)
f.next()
(89, 144, 1)
f.next()[0]
55
Utiliser la fonction append pour générer les 100 premiers éléments.
def generate():
series = [0, 1]
for i in range(0, 100):
series.append(series[i] + series[i+1])
return series
print(generate())
Une explication plus détaillée du fonctionnement de la mémorisation pour la séquence de Fibonacci.
# Fibonacci sequence Memoization
fib_cache = {0:0, 1:1}
def fibonacci(n):
if n < 0:
return -1
if fib_cache.has_key(n):
print "Fibonacci sequence for %d = %d cached" % (n, fib_cache[n])
return fib_cache[n]
else:
fib_cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
return fib_cache[n]
if __== "__main__":
print fibonacci(6)
print fib_cache
# fibonacci(7) reuses fibonacci(6) and fibonacci(5)
print fibonacci(7)
print fib_cache
Découvrez comment convertir un problème récursif en un problème itératif. Devrait pouvoir calculer à partir de là.
C'est peut-être les principes qu'ils essaient de vous faire apprendre, surtout s'il s'agit d'un cours d'algorithmes.
Essaye ça:
def nth_fib(n):
if n == 0:
return 1
Elif n == 1:
return 0
else:
return nth_fib(n - 1) + nth_fib(n - 2)
Si vous êtes un fan de récursion, vous pouvez facilement mettre les résultats en cache avec le décorateur lru_cache (décorateur de cache le moins récemment utilisé).
from functools import lru_cache
@lru_cache()
def fib(n):
if n == 0:
return 0
Elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
Si vous devez mettre en cache plus de 128 valeurs, vous pouvez passer maxsize en tant qu'argument au lru_cache (par exemple lru_cache(maxsize=500). Si vous définissez maxsize=None, le cache peut croître sans limite.