J'ai fait un petit programme de la suite de Fibonacci en Python et il ne veut pas tourner, si quelqu'un veut me dire pourquoi , le voici :
N = input("Entrer le maximum de la suite : ")
U[0]=1
U[1]=1
for i in range(2,N+1) :
U[i] = U[i-1] + U[i-2]
for i in range (2,N+1):
print U[i]
Il m'est indiqué dans l'erreur que je n'ai pas déclaré la variable U , comment faire ?
Salut,
Peux-tu utiliser les balises CODE? L'indentation étant indispensable en Python, elles sont d'autant plus demandées.
Après, peux-tu dire quelle version du langage tu utilises, sur quel système d'exploitation et donner l'exacte erreur?
J'ai fait un petit programme de la suite de Fibonacci en Python et il ne veut pas tourner, si quelqu'un veut bien me dire pourquoi , le voici :
N = input("Entrer le maximum de la suite : ")
U[0]=1
U[1]=1
for i in range(2,N+1) :
U[i] = U[i-1] + U[i-2]
for i in range (2,N+1):
print U[i]
Il m'est indiqué dans l'erreur que je n'ai pas déclaré la variable U , comment faire ? Merci .
Salut , merci pour ta réponse , ce n'est pas un problème d'indentation , ni de système d'exploitation ( je l'ai essayé sur windows et Unix ) et de version de python, d'ailleurs tu peux essayer mon programme et tu verras , il te demanderas de déclarer la variable U.
Par contre je sais qu'il a déjà bien fonctionné (je l'ai déjà essayé mais j'ai éffacé un truc) le problème est bien qu'il manque quelque chose dans le programme .
j'ai trouvé , il fallait écrire : U=range(1,N*N) et ça marche , voici le programme final :
N = input("Entrer le maximum de la suite : ")
U=range(1,N*N)
U[0]=1
U[1]=1
for i in range(2,N+1) :
U[i] = U[i-1] + U[i-2]
for i in range (0,N):
print U[i]
comme disait MaliciaR, utilise la balise code (le bouton dièse) pour insérer du code, surtout du python!
ensuite déclarer une taille N*N, c'est un peu beaucoup....
N suffit...
C'est plus joli avec l'indentation ! ! !Code:N=15 u=range(0,N) u[0]=1 for i in u[2:N]: u[i]=u[i-1]+u[i-2] print u
Jusqu'ici tout va bien...
Salut, moi j'ai fait ceci et ça fonctionne correctement
Code:n = int(input()) a = 0 b = 1 c = 0 print(0, end=" ") for i in range(n-1): a = b b = c c = a + b print(c, end=" ")
Dernière modification par gienas ; 07/06/2018 à 19h28. Motif: Ajouté les balises code obligatoires pour la lisibilité des programmes
Code:fibo = lambda k: fibo(k-2)+fibo(k-1) if k > 1 else 2 if k == 1 else 1 fibo(2**10)
Le plus rigolo est de faire un générateur :
Après, on peut demander la dixième valeur par exemple :Code:from itertools import islice def fib(): x, y = 0, 1 while True: yield x x, y = y, x+yOu toutes les valeurs jusqu'à la 20ème :Code:print(list(islice(fib(), 10, 11)))En fait, on crée un itérateur qui renvoie les valeurs. On peut faire des trucs marrant par exemple avoir les 20 1ères valeurs au carré :Code:print(list(islice(fib(), 0, 20)))
Code:print(list(islice(map(lambda x: x**2, fib()), 0, 20)))
Merci, je vais jouer avec ça!Envoyé par pm42
En aparté, je découvre Python depuis quelques semaines, c'est un jouet rigolo (je vais remplacer mes dev MATLAB par python), mais je ne suis pas sûr de la pertinence d'un langage non-typé comme 1ère approche d'un langage de prog, qui en plus multiplie les paradigmes, je suis peut-être trop formaté C et bas-niveau...
C'est un langage objet principalement avec quelques concepts de programmation fonctionnelle : c'est assez fréquent en ce moment.
Après, on peut programmer vite en Python, c'est un langage simple d'abord et facile à prendre en main, débugger, etc.
D'où son succès dans la communauté scientifique et notamment dans les "data-science".
Mais sa vraie valeur vient de l'immense écosystème construit autour : plein de librairies, puissantes, là aussi faciles d'abord. Ou d'environnements complets pour travailler sur des données & programmes en groupe.
Les autres langages sont souvent à la traine là dessus.
Après, si c'est pour écrire du gros progiciel, faire du multithreading et autres, ce n'est pas forcément le 1er choix.
une version récursive avec R:
fibonacci<-function(u=c(0,1),n=10) if(length(u)>=n)u else fibonacci(c(u,sum(tail(u,2))), n)
fibonacci(n=50)
[1] 0 1 1 2 3 5
[7] 8 13 21 34 55 89
[13] 144 233 377 610 987 1597
[19] 2584 4181 6765 10946 17711 28657
[25] 46368 75025 121393 196418 317811 514229
[31] 832040 1346269 2178309 3524578 5702887 9227465
[37] 14930352 24157817 39088169 63245986 102334155 165580141
[43] 267914296 433494437 701408733 1134903170 1836311903 2971215073
[49] 4807526976 7778742049
Bonjour,
On peut en faire un jeu : à mettre en rubrique la science en s'amusant : écrire le programme de suite de Fibonacci le plus court possible. Langages de programmation "pénibles" interdits (je pense à APL qui emporte toujours la palme dans ce genre d'exercice , mais ça fait des programmes pénibles à lire).
Ceci dit, dans la plupart des langages qui supportent la récursivité, Fibonacci s'écrit en une ligne. Mais même comme ça, il y a des trucs rigolos. Par exemple, en Scala, on peut le coder comme en python plus haut par lou_ibmix_xi mais il y a plus rigolo :
On dit que fibonacci est un Stream dont les 1ers éléments sont 0 et 1. Puis, on crée ensuite le flux composé de 2 élements : le flux lui même et le flux décalé de 2 élements. Et on fait la somme des 2 élements. Et ça marche.Code:val fibs: Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }
Comme plus haut, on se retrouve avec une liste virtuelle plutôt qu'une fonction où il est donc facile d'écrire des traitements composés.
Par exemple, si je veux la somme des 10 premiers éléments pairs de Fibonacci, j'écrit :
Code:fibs.filter(_ % 2 == 0).take(10).sum
Je propose aussi d'écrire le programme plus court qui : tire un dé à 6 faces 200 fois et affiche l'histogramme des résultats avec des X.
Par ex, le résultat ressemble à ça :
Code:2: XXXX 3: XXXXXXXXXX 4: XXXXXXXXXXXXXXXXXXXXXX 5: XXXXXXXXXXXXXXXXXXXXX 6: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 7: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 8: XXXXXXXXXXXXXXXXXXXXXXXXXX 9: XXXXXXXXXXXXXXXXXXXXX 10: XXXXXXXXXXXXXX 11: XXXXXXXXXXXX 12: XXXX
Je suis partant! Mais pourquoi écarté les langages pénibles? Pour le forum je me demande si celui-ci n'est pas plus adapté ?
Oui, tant qu'on y est, on peut donner des points à celui qui l'écrit dans les programmes de cette liste : https://listverse.com/2011/02/17/top...ing-languages/
Déjà, rien que du Malbolge ou du Brainfuck forcerait le respect
toujours avec R:
hist(apply(matrix(sample(6,400 ,replace=T),ncol=2),1,sum))
à cela près qu'on aura un histogramme en mode graphique (lequel demanderait pas mal de lignes de code s'il fallait le programmer sous R et 10 fois plus en C)
Sympa en effet. Curieusement, quand je le lance avec 400, le nombre d'occurrence de 2 est en moyenne toujours supérieur à celui de 12 et globalement, cela ne ressemble pas à une gaussienne.
Dernière modification par pm42 ; 10/06/2018 à 12h54.
ah oui j'ai vu (en remplaçant 400 par 400000 c'est encore plus flagrant). C'est la fonction "hist" de R qui fait un découpage pas catholique par défaut. On peut forcer les limites des classes ou bien on peut remplacer l'appel à "hist" par plot(table()) par exemple
plot(table(apply(matrix(sample (6,400000,rep=T),ncol=2),1,sum )),col="grey",lwd=25)
En effet. Avec plot, c'est nickel.
on peut même jouer avec plus de dés:
tiredes<-function(nb.tirages=200,nb.des =2,nb.faces=6)plot(table(apply (matrix(sample(nb.faces,nb.des *nb.tirages,rep=T),ncol=nb.des ),1,sum)),col="grey",lwd=round (250/(nb.des*nb.faces)))
on devrait constater que la courbe est de pus en plus gaussienne quand le nombre de dés augmente.
