Bonsoir à tous!

Je vous écris car j'ai besoin d'aide pour mon entrainement à mon futur partiel d'informatique (je suis en filière économique, mes connaissances ne sont donc pas très larges dans le domaine...).
Voilà mon souci, on me demande de réécrire un fragment de programme qui est en FOR en utilisant une boucle WHILE à la place... On a étudié succinctement les 2, mais on a jamais vu comment passer de l'une à l'autre... C'est peut être tout bête, mais là je sèche !
Voici le fragment de programme : (on bosse en Pascal)

for i := 20 downto 3 do
writeln('i = ', i);

i étant une variable integer.
Pouvez-vous éclairer ma lanterne?? Merci d'avance!

les boucles for sont compose de 4 differentes chose.
l'initialisation du compteur, une condition d'arret, un "increment" et un block de code a executer.

Ici, l'initialisation est i := 20, la condition d'arret est i < 3, "l'increment" est i:= i-1 et le bloc de code est "writeln('i = ',i);"

Dans une boucle while, il n'y a que deux composant, un test, et un bloc de code.
Il faut donc faire l'initialisation au prealable et mettre "l'increment" a la fin.
ce qui donnerait quelquechose comme

i := 20
while (i <3)
do
writeln('i = ',i);
i:= i-1;
done

NB: je n'ai jamais ecrit de pascal de ma vie, donc la syntaxe est certainement inexacte.

Merci de ta réponse ! Cela me donne une meilleure approche pour aborder ce qu'on me demande (je comprends bien mieux le principe avec ton explication )
Encore merci! Si d'autres personnes ont déjà utilisé le Pascal je suis toujours preneur!

program foo (output);

var
     i : integer;

begin
     i := 20;
     while i >= 3 do
     begin
          writeln('i = ', i);
          dec(i)
     end
end.

J'ai tendance à rabacher (et d'ailleurs je le dis ici) :
« une boucle, c'est 3 choses :
1. l'initialisation d'une variable
2. un test
3. la mise à jour de la variable.
Débrouillez vous avec la syntaxe, mais il faut absolument ces trois choses là. »

Merci à tous!
Je ne connaissais pas la fonction "dec", ça devait être le chaînon manquant... J'ai bien compris le principe des boucles grâce à vous (en tout cas bien mieux qu'avec mon prof... )
Encore merci !

À te lire, j'ai l'impression que tu n'as pas entièrement compris leur utilité ou syntaxe.

Une boucle sert à répéter une action un certain nombre de fois.

Imaginons que tu souhaites apprendre à quelqu'un à compter jusqu'à 10.
Comment t'y prends-tu ?

Tu pars d'une valeur initiale, un chiffre, en l'occurence 1 dans ce cas.
Tu prononces la valeur à voix haute.

Une fois que tu as fini de prononcer cette valeur, tu lui ajoutes à chaque fois 1 afin obtenir la valeur suivante.

Tu prononces la valeur suivante à voix haute.
Et ainsi de suite, jusqu'à avoir prononcé le nombre 10.

On ne se préoccupe pas du temps écoulé entre chaque prononciation.

Donc les opérations effectuées dans l'ordre sont :

- Choix d'une valeur initiale ;
- Prononciation de la valeur ;
- Ajout de 1 à la valeur pour obtenir la valeur suivante.

Si on veut l'écrire en pseudo-code, ça donne :

X = 1

Si X n'a pas encore atteint la valeur 10, Alors
      Tant que X n'a pas encore atteint la valeur 10, Faire
            Prononciation de X
            X = X + 1
      Fin Tant que
Fin Si

Comment vérifier que X n'a pas atteint la valeur 10 ? Eh bien, la valeur initiale de X étant 1, et la valeur que l'on souhaite atteindre étant 10, il nous suffit de nous poser comme condition que X doit être inférieur OU égal à 10 ; le OU car on veut que X prenne pour valeur 10 ; si on ne le spécifie pas, on comptera jusqu'à 9, ce que l'on ne veut pas.

Donc on a maintenant :

X = 1

Si X est inférieur OU égal à 10, Alors
      Tant que X est inférieur ou égal à 10, Faire
            Prononciation de X
            X = X + 1
      Fin Tant que
Fin Si

On remarque qu'il y a deux conditions identiques ; on peut donc omettre la première, le Si.

Pourquoi on ne peut pas enlever la seconde plutôt ?

Car cette dernière répète une ou des actions tant que la condition qu'on lui soumet est remplie, contrairement à la première qui elle n'est qu'une condition.

On a donc :

X = 1

Tant que X est inférieur OU égal à 10, Faire
      Prononciation de X
      X = X + 1
Fin Tant que

Maintenant que l'on a notre algorithme remplissant ce que l'on veut faire, on peut le traduire dans un autre langage, par exemple le Pascal :

Il nous faut connaître la syntaxe de ce langage et la traduction de nos mots à nous qui décrivent le but recherché. En l'occurence, l'affectation d'une valeur à une variable se note := ; le "Tant que" s'écrit "While" (note : le langage Pascal ne fait pas la différence entre
"While", "whilE", "while", "wHiLe", etc.) ; le "inférieur OU égal" se note <= (inférieur : "<" ; égal : "=") ; le "Faire" s'écrit "Do".

Dans notre cas, on ne veut pas prononcer la valeur mais l'afficher. On va donc utiliser la fonction WriteLn() pour afficher du texte, en l'occurence un chiffre ou nombre X, et un retour à la ligne.
Pour ajouter une valeur à X on écrira X := X + Y, avec Y étant égal à 1 dans notre cas.

Il faut savoir que chaque instruction se finit par un point-virgule, soit le caractère ";".

Il faut aussi savoir que lorsque l'on souhaite réaliser plusieurs actions une fois une condition remplie dans un "While" ("Tant que"), on doit utiliser le mot-clé "BEGIN" avant d'écrire lesdites actions et "END" à la fin de ces dernières, sur une nouvelle ligne.

Remarques :
- l'instruction se situant juste avant le mot-clé "END" ne nécessite pas de point-virgule en sa fin ;

- si des instructions se trouvent après le mot-clé "END", alors on doit écrire ce dernier "END;", sauf si l'instruction en question est "END." (fin du programme).

Notre algorithme en Pascal s'écrit donc comme suit :

X := 1;

While X <= 10 Do
BEGIN
      WriteLn(X);
      X := X + 1
END

Remarque :
Pascal offre la fonction Inc() et Dec() qui respectivement servent à incrémenter et décrémenter une variable. Leur syntaxe est (Inc OU Dec)(Nom_Variable, Ajout), avec Nom_Variable étant dans notre cas X, et Ajout 1. La valeur par défaut de Ajout étant 1.

On pourrait donc écrire : Inc(i) à la place de X := X + 1.

En Pascal, comme dans la plupart des langages de programmation, la boucle FOR existe. Elle n'est autre qu'une simplification de la boucle WHILE. Grâce à elle, on peut écrire l'initialisation de X, et la valeur que X doit atteindre, sans se soucier de l'incrément, car il est par défaut de 1. (Ce comportement n'est pas universel.)

Sa syntaxe est : For (initialisation) (DownTo|To) (valeur finale) Do

On utilise DownTo lorsque l'on veut décrémenter une variable à chaque itération (ex. : passer de 20 à 3 ; X := X - 1), et To lorsque l'on veut incrémenter une variable à chaque itération (ex. : passer de 1 à 10 ; X := X + 1).

Nous pouvons donc remplacer la boucle WHILE de notre code par une boucle FOR qui nous fait gagner quelques lignes, mais qui n'est pas vraiment explicite :

For X := 1 To 10 Do
      WriteLn(X);

Remarque :
On pourrait utiliser une autre logique pour la condition du "Tant que", comme vérifier que X est différent ( <> en Pascal ) de 11, ou que X est inférieur ( < ) à 11, par exemple.