Bonjour, ben oui il faut que tu te lances et que tu tentes quelque chose.
tu demandes N puis effectivement une petite boucle Pour I allant de 1 à N, qui calcule les termes progressivement et les affiche. (une boucle tantque marche aussi)

Et aussi une autre question : comment fait-on pour demander un entier N qui soit forcément supérieur à 2 ?

on connait déjà les termes U₀ et U₁ de la suite (c'est pour ça que N doit être plus grand ou égal à 2, sinon on a rien à calculer)
on connait la relation de récurrence U_n+2=U_n+1+U_n
on va donc initialiser deux variables A et B : A=0 et B=1
le premier terme à calculer c'est U₂=U₁+U₀=A+B
on peut donc même faire commencer la boucle à Pour I allant de 2 à N
et faire U = A+B ; afficher U ; A = B ; B = U et continuer la boucle

Bonjour,

elle n'est pas "à compléter" vu qu'il y deja des trucs en trop dedans !!

dans la boucle on calcule un terme de la suite
alors pourquoi y faudrait-il deux additions ??

on calcule bien dans U le terme suivant, somme des termes précédents qui étaient dans A et B, OK

mais ensuite il faut jouer aux chaises musicale avec A, B, U pour remettre les bons dans les bonnes cases

fais au besoin un petit dessin avec des cases et vois quelle variable il faut transférer dans laquelle.
et il n'y a que ça à faire dans cette boucle après le
U prend la valeur A+B
Afficher U
quelque simples transferts d'une variable dans une autre

le tout est de bien faire lesquelles dans lesquelles ...

le "truc" est de concevoir ce qu'on appelle un "invariant de boucle"
une condition qui est vraie au début de chaque boucle

ici l'invariant de boucle est que chaque boucle calcule F_i+1 (dans U) à partir de F_i qui est dans B et F_i-1 qui est dans A
et que donc au début de la boucle on doit toujours avoir A et B qui contiennent ces F_i et F_i-1
c'est ça l'invariant de boucle :
en début de la boucle i, A contient F_i-1, B contient F_i

après le calcul et l'affichage de F_i+1 il faut donc restaurer cet invariant pour que il soit encore vrai au tour suivant dans lequel i est automatiquement incrémenté de 1 par le mécanisme même de la boucle pour


par contre raison essentielle de mon intervention, cet algorithme calcule les N premiers termes et non pas les termes inférieurs à N
mauvaise compréhension de l'énoncé ?
il faudra pour avoir celui qui est demandé remplacer la boucle "pour" par une boucle "tant que"...
le contenu de la boucle (le mécanisme de récurrence de la suite) sera toutefois le même

tout d'abord citer intégralement le message auquel on répond est
- inutile
- néfaste, il rend la discussion globalement illisible.

tu penses que au lycée on va t'apprendre l'invariant de boucle ? je ne pense pas

c'est parce que ça s'appelle comme ça que j'en ai parlé
mais c'est comme monsieur Jourdan qui faisait de la prose sans le savoir

le principe est d'avoir, toutes choses égales par ailleurs, un "truc" qui est toujours vrai dans la boucle
ici ce qui est toujours vrai c'est ce que représentent les variables A, B, U


au début de la boucle (en plein milieu de l'exécution du programme, à l'exécution de la 19ème boucle par exemple) tu as par exemple F17 dans la variable A et F18 dans la variable B, dans le but de calculer F19 dans U

quand je reboucle pour commencer la boucle suivante tout doit être décalé d'un cran

on doit avoir pour calculer F20 : dans A F18 et dans B F19

faisons un petit dessin

                                  A            B                U
debut de la boucle               F17          F18       pas encore calculé et on s'en fiche
calcul                                                         F19
brassage des valeurs pour aboutir à :

debut de la boucle suivante      F18          F19       poubelle (prêt à recevoir le calcul suivant)

Merci d'avoir répondu.

J'ai ré-essayer de construire un algorithme, je pense m'être pas mal débrouillé, sauf que lorsque je rentre un chiffre, par exemple N=13, mon algorithme me ressort bien tous les termes inférieurs ou égaux à N, mais aussi le suivant, ici 21.

Voilà mon algorithme :

Saisir N
A prend la valeur 0
B prend la valeur 1
Tant que U [inférieur ou égal] à N
  U prend la valeur A +B
  A prend la valeur B
  B prend la valeur U
  Afficher U
Fin Tant que

Merci !

Oui, ce problème est classique et connu sous le nomd e faire N+1/2 boucles
alors que on fait bien entendu les boucles un nombre entier de fois, comment pourrait on terminer ou commencer par une "demi-boucle" ??
cette plaisanterie cache un problème fréquent.

en fait ici il peut être résolu facilement en inversant l'ordre des opérations ;
afficher le résultat précédent, c'est à dire avant de calculer U
bien entendu avant de calculer U, le résultat, précédent ou pas, n'est pas dans U !!
par contre la signification des variables A, B et U permet de savoir quelle variable il faut afficher à la place.
on peut même se contenter de modifier le "afficher" sans en changer l'emplacement :
dans quelle variable se trouve le terme précédent ?

rahh... en fait le problème est aussi tout autre :
la condition du tant que est fausse !

à la première boucle il n'y a rien dans U
comment pourrait on répondre à la question "U est_il ≤ N ???

il faut de toute façon modifier cette condition (tester autre chose que U), ou calculer une première fois une valeur de U avant le "tant que"

salut qqchose de ce style ?

/***** Liste des termes inferieurs à N *****/
ListeTermes(N):={
  local u,v,w,L,k;
  u:=0;v:=1;k:=0;
  afficher("u("+k+")"=u);
  tantque v<=N faire
    w:=u;
    u:=v;
    v:=w+v;
    k:=k+1;
    afficher("u("+k+")"=u);
  ftantque
  retourne L
}:;

bof,

renvoyer une valeur indéterminée (L qui ne reçoit jamais aucune valeur) ...pas terrible

de plus écrire ça dans un langage de programmation alors qu'on demande un algorithme rend le truc un peu illisible sauf aux "initiés" (les signes cabalistiques ":" un peu partout, les accolafes, les mots clé "local" etc)
et ne correspond pas (écrit ainsi sous la forme de sous programme) à ce qui est demandé dans l'énoncé :
un algorithme qui demande un entier naturel N etc

ne pas confondre
algorithme : description formelle de la méthode utilisée et de l'enchainement des opérations
programme : traduction d'un algorithme dans un langage donné

la confusion entre les deux entraine la mauvaise habitude de se précipiter sur son clavier pour taper un programme que l'on "bidouille" jusqu'à ce qu'il marche.

il est vrai que la confusion est encouragée par l'existence de Algobox dans lequel le langage de programmation est tellement proche de l'écriture formelle de l'algorithme dit "en langage naturel" que on peut facilement confondre les deux et répondre par un programme en Algobox à la question "donner un algorithme".
on ne risque pas de confondre si on écrit en C, Python, Pascal etc : ils sont trop éloignés du langage dit "naturel".

D'accord... Mais même en calculant une fois une valeur de U avant la condition (A+B), ou même en lui affectant la valeur 0 ou 1, je me retrouve avec le même problème...

j'ai dit qu'il y avait deux problèmes dans ton algorithme :

l'un est la non affectation d'une valeur initiale de U avant de pouvoir faire un "tant que" dessus

l'autre est celui qui provoque ton défaut

soit le tant que n'est pas à faire sur U mais sur autre chose
soit les instructions dans la boucle sont à inverser, ou ce n'est pas U qu'il faut afficher
soit un cumul de toutes ces modifs

et que la compréhension et la solution venait de la compréhension de ce qu'il y a dans chacune des variables au cours des boucles

A : on l'initialise à F0
B : on l'initialise à F1

tant que c'est pas fini (on verra sur quelle condition exactement
ici en général on a donc A contient Fi-2 et B contient Fi-1 et U la même chose que B (voir la fin de la boucle)
on calcule U = Fi
on décale les valeurs de sorte que maintenant A contient Fi-1 et B contient aussi Fi
on affiche une de ces variables : donc Fi ou Fi-1, à voir
et on reboucle sur le tant que

si on affiche une valeur autre que celle qui a servi pour le tant que, c'est certain qu'avec cet algorithme on aura la valeur suivante d'affichée !

si on décide d'afficher U par exemple, le test du tant que ne peut pas porter sur la variable U puisque elle ne contient plus au moment où on l'affiche la valeur qui avait été testée au moment du tant que !!
il faut afficher la variable qui contient maintenant la valeur qu'avait U lorsque on a fait le test du tant que : la variable A
bien suivre le jeu de chaises musicale pour suivre les valeurs et savoir où elles sont !!


donc

entrer N
A = 0
B = 1
U = 1 (la même valeur que B pour être cohérent)
tant que U N
U prend la valeur A + B
A prend la valeur B
B prend la valeur U
Afficher A
Fin Tant que

on peut aussi faire un test sur autre chose que U,
vu que à chaque fois qu'on fait le "tant que" B et U ont la même valeur, on peut faire le test sur B :

A = 0
B = 1 Fi (F1)
tant que B N (tant que Fi N)
U prend la valeur A + B calculer F_i+1
A prend la valeur B Fi
B prend la valeur U
Afficher A afficher Fi
Fin Tant que

on peut aussi inverser les instructions :

A = 0
B = 1 Fi (F1)
tant que B N (tant que F_i N)
Afficher B afficher F_i
U prend la valeur A + B calculer F_i+1
A prend la valeur B F_i
B prend la valeur U F_i+1
Fin Tant que

etc

l'important est de savoir à tout instant qu'est-ce qui peut bien être dans chaque variable.
pour savoir ce qu'il faut tester et afficher.

en mode Xcas corrige !

ListeTermes(N):={
  local u,v,w,L;
  u:=0;v:=1;L:=[0];
  tantque v<=N faire
    w:=u;
    u:=v;
    v:=w+v;
    L:=append(L,u);
    ftantque
  retourne L
}:;

ListeTermes(150) retourne [0,1,1,2,3,5,8,13,21,34,55,89,144]

ListeTermes(144) retourne [0,1,1,2,3,5,8,13,21,34,55,89,144]

@mathafou
il faut peut-etre afficher le premier terme ?
et pourquoi pas le rang de chaque terme ?

on peut améliorer ce qui est demandé dans l'énoncé de tout un tas de façons différentes et le réaliser sur tout un tas de "machines" différentes
en appelant "machine" non seulement le matériel (calculette) mais le logiciel utilisé Xcas, Algobox Java etc etc
de toute façon ce n'est que de la traduction de l'algorithme demandé

l'énoncé demande un algorithme, pas un programme.

dans le post initial un programme est demande.
Mon avis:
l'algo demande devrait au minimum prevoir l'indexation des termes,
sinon à quoi peut-il servir ?

oui tu as raison, il demande : ensuite un programme sur la calculatrice.

quant à sortir l'indice de chaque terme, c'est juste un plus puisque le but énoncé du programme est

"qui calcule et affiche tous les termes de la suite de Fibonacci, inférieurs ou égaux à N."

que l'on affiche ces termes sous la forme de la simple suite des valeurs ou que l'on fasse afficher du texte plus compliqué sous la forme
F[1] = 1
F[2] = 1
F[3] = 2
...
c'est chacun qui voit comme ça l'arrange.

le but est bien d'afficher les valeurs.
c'est sûr que l'amélioration consistant à afficher un beau résultat "formaté" est intéressante surtout du point de vue programmation
et seulement un petit peu du point de vue algorithme puisqu'il s'agit juste d'ajouter une variable i initialisée à la bonne valeur et incrémentée de 1 dans la boucle.
(le seul intérêt du point de vue algorithme est justement la bonne valeur de l'initialisation de cette variable !)

qqs remarques.
1/ cet exercice n'est pas du niveau de seconde.
2/ en S je pense qu'on peut les initier à la programmation fonctionnelle.
Avoir une valeur de retour permet de reutiliser le resultat renvoye.
Avec Algobox on se contente d'afficher le resultat. En seconde ok ensuite je n'y suis pas tres favorable.

cet exercice est du niveau "initiation à l'algorithmique"

savoir écrire une boucle tant que
savoir entrer et sortir des valeurs
savoir manipuler des variables et comprendre ce qu'il y a dedans

et c'est tout.

après que ce soit en seconde ou en première qu'on fait ça ... il faut voir les programmes officiels.

il y a une derive manifeste depuis l'intro de l'algo qui fait qu'on depasse
trop souvent le niveau moyen d'un eleve de seconde.
Cet exercice est fait pour la serie S ou pour 3 eleves d'une classe de seconde ...