Lors de l'étude de la boucle for, nous avons dit que si le nombre de répétitions de toute action est connu, vous pouvez raccourcir le programme à l'aide de l'opérateur de boucle for. Mais que se passe-t-il si le nombre de répétitions n'est pas connu ? Et cela arrive assez souvent.
Par exemple, rappelons-nous la conversion d'un nombre d'un système de numération décimal à un autre : nous devons diviser le nombre (puis le résultat de la division) par la base du système de numération jusqu'à ce que nous obtenions zéro dans la réponse. Combien de fois nous partagerons est inconnu. Et il existe de nombreux programmes qui implémentent un tel algorithme.
Comment cela est-il mis en œuvre ?
Pour de tels cas en programmation, il existe un opérateur de boucle avec une condition.
Dans le langage de programmation Pascal, une instruction de boucle conditionnelle commence par le mot while et a la structure suivante.
tandis que <condition> commence
corps de boucle
fin
Comme nous le savons déjà :
- une condition est une expression dont le résultat peut être vrai ou faux (comme dans une instruction conditionnelle)
- le corps de la boucle correspond aux commandes qui doivent être répétées
- begin et end peuvent être omis si le corps de la boucle se compose d'un seul opérateur
Comment fonctionne l'opérateur :
1. Tout d'abord, le programme évalue la condition après le mot while. Si la condition est remplie (true), alors le programme exécute la ou les instructions contenues dans le corps de la boucle.
2. Comme dans la boucle for, si le corps de la boucle ne contient qu'une seule instruction, les mots begin et end qui mettent en surbrillance le corps de la boucle peuvent être omis.
3. Une fois l'exécution du corps de la boucle terminée, le programme revient pour vérifier la condition et la vérifie à nouveau.
4. Ces actions (vérification de la condition - exécution du corps de la boucle) sont répétées jusqu'à ce que la condition devienne fausse.
5. Si à la première exécution de cet opérateur, la condition n'est pas immédiatement satisfaite (faux), alors le programme n'exécutera jamais le corps de la boucle.
En analysant le travail de cet opérateur, il devrait devenir clair que le corps de la boucle doit contenir un opérateur qui affecte la condition.
Par exemple, une boucle peut incrémenter la valeur d'une variable utilisée dans une condition.
Un exemple de programme que nous appellerons "Silent count"
Faisons en sorte que le programme compte à notre place, par exemple, jusqu'à 10.
Le programme devrait afficher la phrase "Démarrer" et "Terminer", et entre ces actions s'affichent les nombres en cours de calcul.
Comme ça,
Commencer
1 2 3 4 5 6 7 8 9 10
Terminer
Un programme utilisant une boucle while ressemblerait à ceci.
var i : entier ;
commencer
writeln('Démarrer');
je := 1;
alors que je <= 10 commence
écrire (je, ' ');
je += 1 ; //Opérateur qui affecte le changement de la variable dans la condition
fin;
écrireln();
writeln('Terminer');
fin.
Dans ce programme, nous attribuons une valeur à la variable i := 1 - l'origine
De plus, tant que la valeur de la variable i n'est pas supérieure (c'est-à-dire inférieure ou égale) à la valeur dont nous avons besoin, nous
1 - afficher la valeur de la variable i
2 - augmenter la valeur de la variable i de 1 - cet opérateur affecte la valeur de la condition entre parenthèses. La variable i est incrémentée, c'est-à-dire qu'à un moment donné, la condition i<=10 deviendra fausse. Cela se produira lorsque i deviendra égal à 11. Dans ce cas, le corps de la boucle ne sera plus exécuté et le programme exécutera l'instruction suivante après la boucle, c'est-à-dire écrireln();
writeln('Terminer');
|
Essayons d'écrire un programme pour résoudre le problème suivant :
Vous devez saisir un nombre (qu'il soit inférieur à 3 000 000) et déterminer le nombre de chiffres qu'il contient.
Idée de solution
Commençons un compteur de chiffres d'un nombre. Initialement, le compteur est 0. Nous avons juste besoin de couper séquentiellement le dernier chiffre du nombre (cela peut être fait en réduisant le nombre de 10 fois, en utilisant une division entière par 10), et à chaque fois nous devons augmenter le compteur de 1.
En conséquence, après avoir coupé tous les chiffres, dans le compteur, nous obtiendrons le nombre de chiffres dans le nombre.
D'une autre manière, l'algorithme peut être formulé comme suit :
JUSQU'À CE QUE LE NOMBRE NE SOIT PAS ZÉRO, DIMINUEZ-LE 10 fois et AUGMENTEZ LE COMPTEUR DE 1.
| nombre (n) |
compteur |
| 123 |
0 |
| 12 |
1 |
| 1 |
2 |
| 0 |
3 |
Le programme ressemblera à ceci.
var n, compte : entier ;
commencer
lire(n);
compter := 0;
tandis que n <> 0 pour commencer
compter += 1 ;
n := n div 10;
fin;
writeln('Nombre - ', n, ' contient ', compte, ' chiffres');
fin.
Vous devez connaître ce programme par cœur, car. sur sa base, de nombreux autres problèmes liés au calcul des nombres par chiffres sont résolus.
|
Tâche
L'entrée du programme est le flux de données — une séquence d'entiers qui se termine par zéro (zéro n'est pas inclus dans la séquence). Vous devez trouver la somme des éléments de cette séquence.
Algorithme de résolution
somme=0
entrée x // entrer le premier nombre
tandis que x != 0 // le signe de fin d'entrée est défini dans la condition,
nc // c'est-à-dire jusqu'à ce que vous saisissiez zéro
somme = somme + x // vous pouvez faire quelque chose avec le nombre d'origine.
// Vous pouvez ajouter une vérification numérique pour certaines conditions, etc.
input x // entrez le nombre suivant
kts
imprimer la somme // sortie du résultat
|