Bonjour,
Dis toi qu'en fait créer une boucle for revient à créer une boucle while.
Effectivement pour créer une boucle for en utilisant une boucle while il te suffit de faire :
\\soit i une variable de type entier telle que i = 0;
\\soit n une variable de type entier
\\while (i != n)
\\i+=1;
\\fin de la boucle while

A partir de là, si tu sais faire l'algorithme de Fibonacci avec une boucle for il est alors facile de le faire avec une boucle while.
Bonne chance !  

Merci beaucoup pour votre réponse,
seulement, je ne comprends pas bien. Désolée mais les algorithmes ne sont pas mon fort.

Voici, l'algorithme avec la boucle "pour ou for" que j'ai programmé : file:///F:/Algorithme_Fibonacci.pdf
Ce dernier fonctionne mais je ne comprend pas comment vous fait pour le modifier en boucle "tant que ou while".

Je ne vois pas votre algorithme.

Voilà en faite ce que je propose en langage algobox : (en faite je ne sais pas trop ce qu'est algobox, j'espère quand même que je serais le plus clair possible)

INITIALISATION : I est une variable telle que I = 0
                 N est une variable 
                 A est une variable telle que A = 0
                 B est une variable telle que B = 1
                 C est une variable  telle que C = 0
 TRAITEMENT :  Demander la valeur de N 
Tant que I n'est pas égal à  N 
C = A 
A = B 
B = A + C 
I = I+1
FinTantQue

SORTIE : Afficher B 

AlgoBox est un logiciel libre, multi-plateforme et gratuit d'aide à l'élaboration et à l'exécution d'algorithmes

Voila, le programme de Thinking écrit pour pouvoir être traité dans Algobox.

VARIABLES
I EST_DU_TYPE NOMBRE
N EST_DU_TYPE NOMBRE
A EST_DU_TYPE NOMBRE
B EST_DU_TYPE NOMBRE
C EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
	I PREND_LA_VALEUR 0
	A PREND_LA_VALEUR 0
	B PREND_LA_VALEUR 1
	C PREND_LA_VALEUR 0
	LIRE N
	TANT_QUE (I != N) FAIRE
		DEBUT_TANT_QUE
		C PREND_LA_VALEUR A
		A PREND_LA_VALEUR B
		B PREND_LA_VALEUR A + C
		I PREND_LA_VALEUR I+1
	        FIN_TANT_QUE
        AFFICHER* B
FIN_ALGORITHME

Super merci beaucoup !! Par contre je n'arrive pas bien à saisir à quoi correspondent les lettres

Bonjour,

des variables
le nom est libre on peut aussi bien l'appeler A que X ou F ça n'a aucun espèce d'importance
on choisit généralement des noms correspondant à la signification de la variable pour celui qui conçoit l'algorithme

ici A représente un élément de la suite et B l'élément suivant

C ne sert à rien au départ (il sert dans la boucle pour décaler les éléments)

I est l'indice des éléments de la suite

N est le rang du dernier élément que l'on veut obtenir


c'est normalement exactement pareil que l'algorithme avec une boucle for / pour que tu dis avoir fait...

nota : fournir l'adresse sur ton disque dur (file:... ) est absurde,
de toute façon on ne peut (interdit) ni donner des liens ni joindre autre chose que des images

pour joindre un algorithme Algobox, c'est en texte comme a fait J-P
nul besoin de pdf ni d'images.

Tout est clair, merci beaucoup !!
Merci pour le conseil. Je viens d'arriver sur le site donc je ne sais pas tout encore

Bonne soirée à tous !!

Il se trouve que ce n'est pas la réponse que j'attendais. C'est de ma faute, je me suis mal exprimée et je m'en excuse.
Voici mon énoncé :
- Ecrire un algorithme permettant de dénombrer le nombre de couple de lapin au bout de n mois. (fait)
- Modifier l'algorithme précédent pour déterminer le nombre de mois au bout duquel le nombre de couples de lapins a atteint au moins un nombre donné.  (C'est celui que je ne parviens pas à faire mais je sais qu'il faut utiliser la boucle tant que ou while).

Merci

comme quoi il vaut toujours mieux donner l'énoncé exact dès le départ plutôt que de le "raconter" en en supprimant la moitié pour ne mettre que la question extraite de tout contexte.
sinon on a 9 fois sur 10 des réponses à côté de la plaque. et donc une perte de temps.


Principe d'un boucle pour :

pour i de 1 à n
calcul


on utilise cette construction si on connait à priori le nombre de calculs qu'il faut faire
(ainsi pour calculer le n^ème nombre de Fibonacci, on calcule les n nombres de Fibonacci de F₂ à F_n) étant donnés F₀ et F₁ connus

la boucle tant que est avant tout une répétition sans connaitre à priori le nombre de fois qu'il faudra répéter la boucle

tant que on n'a pas encore un certaine condition
calcul

donc ici ce sera :

tant que F < le nombre donné
calculer le F suivant


et comme ce qui nous intéresse (la données de sortie de l'algorithme) c'est le nombre de boucles réellement effectuées, on va lui mettre un compteur de boucles
une variable i

i prend la valeur 0
tant que F < le nombre donné
| calculer le F suivant
| incrémenter i de 1

quand la boucle se termine (quand F ≥ au nombre donné), i contiendra le nombre de boucles effectuées
et donc dans le contexte le nombre de mois écoulés

moyennant quelques "ajustements" pour avoir ce nombre là et pas ce nombre là plus ou moins 1
(comment sont comptés les mois et à quel moment exact se produit la gestation des lapins)

dans tous les cas le calcul interne à la boucle est toujours exactement le même : calcul du F suivant

J'ai : F0=1, F1=1, F2=2 et F3=3 avec la formule de récurrence U[n+2]=U[n+1]+U[n].[tex]

Et nous voulons obtenir au moins un milliard de lapins soit au moins 500000000 de couples.

appeler F les valeurs d'une suite U, et U[n] au lieu de U_n cela me semble mélanger, et donc ne pas voir la différence absolument fondamentale entre
les éléments d'une suite, notion purement mathématique
et les valeurs de variables (voire pire les éléments d'un tableau ou d'une liste), notion purement algorithmique

enfin maintenant on sait que la suite F considérée ici commence par F₀ = 1, F₁ = 1
et pas F₀ = 0, F₁=1 comme dans les exemples de programmes ci-dessus.

ta notation de U semble indiquer que tu as utilisé un tableau (une LISTE dans le langage Algobox)
ce qui est un peu sot car on n'a pas besoin de mémoriser l'ensemble de toutes les valeurs de la suite !!!
vu que seules trois d'entre elles ne sont utiles à un instant donné (les trois variables A, B, C des algos précédents) :
- les deux éléments précédents
- l'élément suivant que l'on calcule
et c'est tout.

c'est sans doute la raison pour laquelle tu avais des difficultés à comprendre les algos proposés (signification des lettres)

en tout cas maintenant que l'on connait le décalage (les indices par rapport aux valeurs) de la suite on est rassuré sur le "à ± 1 près")
on peut raisonner pour faire la correspondance entre le mois = le rang i de l'élément F_i (ou U_i, tu l'appelles comme tu veux, du moment que tu es cohérent et que tu ne changes pas de nom en plein milieu d'un raisonnement)
et le nombre de lapins vu que le nombre de couples est F_i au mois i

par ailleurs le nombre de lapins demandés on se fiche de sa valeur pour écrire l'algorithme vu que c'est une donnée d'entrée (demandée par l'algorithme au moment de son exécution) que ce soit 100, 1000 ou un million de lapins n'entre absolument pas en ligne de compte pour la rédaction de l'algorithme :

entrée : P (un LIRE P en Algobox) nombre de couples de lapins demandés
F_0 = 1
F_1 = 1
i = 1
tant que F_1 < P (si P est le nombre de lapins au lieu du nombre de couples ce sera 2*F_1 < P)
calculer F suivant dans F_1 (F_2 = F_0+F_1, met F_1 dans F_0 et F_2 dans F_1)
incrémenter i de 1
sortie : i

à chaque exécution de la boucle, en permanence, on aura la variable unique F_1 contient la valeur de l'élément F_i de la suite
(bien faire la distinction entre le nom d'une variable F_1 et la valeur qu'elle contient, la valeur de l'élément mathématique de la suite F_i)
cette particularité de l'algorithme (que F_1 contient à tout instant l'élément d'indice i de la suite) est ce qu'on appelle un invariant de boucle (invariant parce qu'il est toujours vrai) :
il est vrai par l'écriture de l'initialisation : on a bien initialisé i à 1 et aussi en même temps F_1 à la valeur de F₁ justement.
et c'est conservé par l'exécution de chaque boucle. vu que l'élément suivant est remis de F_2 dans F_1 et que i augmente de 1

notion fondamentale si on veut écrire des algorithmes logiquement au lieu de les bidouiller.

tu n'as en fait qu'à traduire l'algorithme dont je t'ai écrit le squelette au dessus en Algobox !!
par contre chercher à comprendre réellement ce que je t'ai écrit te fera progresser dans "l'art" d'écrire des algorithmes
conserver et y revenir au besoin de temps en temps au fur et à mesure que tu t"habitues à en écrire, et que tu seras plus à même d'en comprendre tout.

Merci beaucoup  !!!  Votre aide m'a été très précieuse  !
Je vais donc finir mon DM et je vous souhaite une bonne soirée et d'excellente fête.