Lors de la résolution de l'écrasante majorité des tâches (y compris les très simples) dans le programme, il est presque impossible de spécifier explicitement toutes les opérations qui doivent être effectuées. En effet, supposons qu'il faille calculer la somme des n premiers termes de la série harmonique :
Y = 1+ 1/2 + 1/3 +… + 1 / n
Evidemment, en n'utilisant que les types d'opérateurs considérés ci-dessus, il est possible de composer un programme uniquement pour une valeur fixe de n. Par exemple, pour n = 5, les calculs requis peuvent être spécifiés à l'aide d'un opérateur d'affectation de la forme :
Y : = 1 + 1/2 + 1/3 + 1/4 + 1/5
Si la valeur de n n'est pas fixe, mais correspond aux données initiales saisies lors de l'exécution du programme (et même à une constante décrite dans le programme), alors un opérateur d'affectation similaire ne peut pas être écrit. Pour la notation de la forme Y : = 1 + 1/2 + 1/3 +… + 1 / n n'est pas autorisé dans les langages de programmation.
Pour éliminer les difficultés qui surviennent, servez instructions de boucle... Ils vous permettent de répéter l'exécution de différentes parties du programme. Ils sont quatre éditeur de cycle présent sous une forme ou une autre dans tous les langages de programmation : opérateur de boucle arithmétique simple(cycle avec paramètre à l'étape 1), opérateur de boucle arithmétique complexe(cycle avec un paramètre de pas arbitraire), opérateur de boucle itératif avec précondition, opérateur de boucle itératif avec postcondition.
Opérateur de boucle Pascal arithmétique simple (boucle avec paramètre)
Revenons au problème ci-dessus du calcul de la somme des n premiers termes d'une série harmonique dont les règles ne peuvent être fixées sous forme d'expression arithmétique si la valeur de n n'est pas fixée à l'avance.
En fait, le calcul de cette somme peut être effectué à l'aide d'un algorithme très simple et compact : on pose d'abord y = 0 (en utilisant l'opérateur d'affectation y : = 0), puis on exécute l'opérateur d'affectation y : = y + 1 / i pour les valeurs consécutives i = 1 , 2,…, n. A chaque prochaine exécution de cet opérateur, le prochain terme sera ajouté à la valeur courante de y. Comme vous pouvez le voir, dans ce cas le processus de calcul sera cyclique : l'opérateur y : = y + 1 / je doit être exécuté plusieurs fois, c'est-à-dire cycliquement, à différentes significations je.
Cet exemple de processus de calcul cyclique est très typique ; ses traits caractéristiques sont que
- le nombre de répétitions du cycle est connu au début de son exécution (dans ce cas, il est égal à la valeur n, supposée fixée à cet instant) ;
- le cycle est contrôlé par une variable type ordinal, qui dans ce processus cyclique prend des valeurs séquentielles d'une valeur initiale donnée à une valeur finale donnée (dans notre cas, il s'agit d'une variable entière i prenant des valeurs séquentielles de 1 à n).
Pour une tâche compacte de ce type de processus de calcul, et sert opérateur de boucle avec paramètre... La forme la plus couramment utilisée de cet opérateur est en Pascal :
Pour V : = E1 à E2 do S,
où pour(pour), à(augmentant jusqu'à) et faire(faire, faire) - mots officiels, V- une variable de type ordinal, appelée paramètre de boucle, E1 et E2- expressions du même type que le paramètre loop, S- un opérateur qui est exécuté plusieurs fois dans une boucle, appelé le corps de la boucle.
Notez qu'en Pascal après faire il doit y avoir un opérateur, s'il est nécessaire d'effectuer plusieurs actions, alors elles doivent être combinées en un opérateur composé en encadrant les crochets de l'opérateur.
Cet opérateur de boucle Pascal prévoit l'affectation des valeurs séquentielles du paramètre de boucle V de la valeur initiale égale à la valeur de l'expression E1 à la valeur finale égale à la valeur de l'expression E2, c'est-à-dire à chaque répétition, l'opérateur d'affectation est exécuté V : = succ (V), et l'exécution de l'opérateur S à chaque valeur du paramètre de boucle V. Dans ce cas, les valeurs des expressions E1 et E2 sont calculées une seule fois, lors de la saisie de l'opérateur de boucle, et la valeur du paramètre de boucle V doit ne change pas à la suite de l'exécution de l'opérateur S. Si la valeur finale spécifiée est inférieure à la valeur initiale (ce qui est autorisé), l'instruction S n'est jamais exécutée.
En Pascal, on suppose qu'à la fin normale de l'instruction de boucle, la valeur du paramètre de boucle n'est pas définie.
En utilisant opérateur de boucle avec paramètre l'algorithme de calcul de la somme des n premiers termes de la série harmonique peut être précisé comme suit :
Un exemple de code de programme pour additionner les n premiers termes d'une série harmoniqueReadln (n);
Y : = 0 ;
Pour i : = 1 à n faire y : = y + 1 / i ;
Dans certains cas, il est pratique que le paramètre de cycle Pascal prenne des valeurs séquentielles, mais pas croissantes, mais décroissantes. Pour de tels cas, Pascal fournit un opérateur de boucle avec un paramètre de la forme suivante :
Pour V : = E1 jusqu'à E2 do S,
où jusqu'à(décroissant vers) est un mot de service, et tous les autres mots et expressions ont le même sens. La modification du paramètre de boucle d'une valeur plus grande à une valeur plus petite se produit lorsque l'affectation V: = pred (V) est exécutée. remarquerez que valeur initiale peut être inférieur à la valeur finale. Dans ce cas, l'instruction S ne sera jamais exécutée. La valeur du paramètre loop à la fin de l'exécution d'une telle boucle est également considérée comme indéfinie.
Il faut également se rappeler que pour les deux options d'enregistrement boucle avec paramètre true : si les valeurs initiales et finales sont égales, alors le corps de la boucle (opérateur S) sera exécuté une seule fois.
Notez également que paramètre de boucle ne peut pas être utilisé dans le corps de la boucle, son objectif principal est donc de contrôler le nombre de fois que la boucle est répétée. Par exemple, la valeur y = x n, où n> = 0 est un entier, peut être calculée à l'aide de l'algorithme suivant : prédéfini y = 1, puis multipliez cette valeur par x n fois :
Exemple de code d'un programme de cycle PascalReadln (n);
Lireln (x);
Y : = 1 ;
Pour i : = 1 à n faire y : = y * x ;
Comme vous pouvez le voir, ici le paramètre de boucle i sert uniquement à ce que le corps de la boucle (opérateur y: = y * x) soit exécuté le nombre de fois requis.
Opérateur de cycle arithmétique Pascal avec pas arbitraire
Une complication naturelle du cycle arithmétique simple de Pascal est un cycle dans lequel le paramètre de cycle ne change pas de 1, mais d'une valeur arbitraire - pas d'incrément... Dans ce cas, dans le processus d'exécution du cycle, le pas évolue selon une loi donnée. Il existe des opérateurs standard pour implémenter un tel cycle dans Forth, dans d'autres langages, ils doivent être organisés à partir du cycle arithmétique le plus simple.
Opérateurs d'itération de boucle Pascal
Les boucles itératives diffèrent des boucles avec un paramètre en ce que le nombre de répétitions n'est pas connu à l'avance.
Pouvons-nous aller cueillir des champignons et rentrer à la maison quand le panier sera plein. Tous les cueilleurs de champignons sont divisés en 2 catégories :
- Ils regardent pour voir s'il y a de la place dans le panier, et ensuite seulement cueillent les champignons s'ils peuvent être placés dans le panier. (C'est vrai, dans la vie de ces cueilleurs de champignons n'a pas eu à se rencontrer)
- D'abord, ils cueillent les champignons, et alors seulement ils pensent comment les mettre dans le panier.
Cela donne deux options pour mettre en œuvre des boucles itératives :
avec une précondition et avec une postcondition.
Dans une boucle avec une condition préalable, la condition est d'abord vérifiée, puis une étape est franchie. Le ramasseur de champignons viendra avec un panier plein ou presque plein. Dans une boucle avec une postcondition, d'abord une étape puis une vérification. Comme tout ramasseur de champignons normal, celui-ci apportera un panier plein ou légèrement débordant.
Quel algorithme choisir ? Cela dépend de la tâche spécifique.
Si, après avoir fait un pas sans vérifier, vous pouvez tomber dans un trou, alors mieux vérifier au début (comme un aveugle avec un bâton). Eh bien, si une étape sans vérification ne vous fait pas peur, vous pouvez la reporter jusqu'à ce que l'étape soit terminée.
Nous devons également analyser l'événement que nous attendons. Si cela peut arriver avant la première étape, alors une boucle avec une condition préalable est nécessaire. Et si l'événement ne peut pas se produire avant la première étape, alors une boucle avec une postcondition est nécessaire.
Opérateur de boucle Pascal avec postcondition
Considérons maintenant un problème de mathématiques. Supposons que nous ayons besoin de calculer la somme des premiers termes de la série harmonique satisfaisant la condition 1 / i> = e, où 0< e<1, а i=1,2,3…...Эту задачу можно решить по следующему алгоритму: положить предварительно y=0 и i=0, а затем в цикле увеличивать i на 1, к значению y добавлять очередное слагаемое 1/ i до тех пор, пока текущее значение 1/ i впервые окажется больше заданного значения 0< e<1.
Évidemment, le nombre de répétitions de ce cycle n'est pas connu à l'avance. Dans de tels cas, nous ne pouvons formuler qu'une condition sous laquelle le processus d'ajout du terme suivant à la somme doit être achevé.
Pour définir de tels processus de calcul, l'opérateur de cycle Pascal avec une postcondition est utilisé. Cet opérateur a la forme :
Répétez S1 ; S2 ; ... ; Si jusqu'à B,
où répéter(répéter) et jusqu'à(avant) - mots de service, à travers Si tout opérateur Pascal est noté, et DANS – Expression booléenne.
Lorsque cette instruction de boucle est exécutée, la séquence d'instructions entre répéter et jusqu'à sera exécutée une ou plusieurs fois. Ce processus se termine lorsque, après l'exécution suivante de la séquence d'instructions spécifiée, l'expression logique B devient (pour la première fois) vraie. Ainsi, en utilisant l'expression logique B, la condition d'achèvement de l'exécution de l'opérateur de boucle est posée. Comme dans ce cas la condition est vérifiée après l'exécution de la séquence d'instructions (le corps de la boucle), cet opérateur de boucle est appelé opérateur de boucle avec une postcondition.
En utilisant ce type d'opérateur de cycle de Pascal, le problème de la sommation des premiers termes d'une série harmonique satisfaisant une condition donnée peut être implémenté comme suit :
Readln (e);
je : = 0 ;
y : = 0 ;
Répéter
je : = je + 1 ;
y : = y + 1 / je ;
Jusqu'au 1 / je
Notez que l'opérateur de boucle avec une postcondition est plus général que l'opérateur de boucle avec un paramètre - tout processus cyclique spécifié à l'aide d'une boucle avec un paramètre peut être représenté comme une boucle avec une postcondition. L'inverse est pas vrai. Par exemple, le problème de la somme des n premiers termes d'une série harmonique, considéré précédemment, avec un opérateur de boucle avec une postcondition ressemblerait à ceci :
Exemple de code pour un opérateur de boucle Pascal avec postconditionReadln (n);
je : = 0 ;
y : = 0 ;
Répéter
je : = je + 1 ;
y : = y + 1 / je ;
Jusqu'à i> n ;
Opérateur de boucle Pascal avec précondition
Dans le cas d'un opérateur de cycle Pascal avec une postcondition, la séquence d'opérateurs qu'il contient sera certainement exécutée au moins une fois. Pendant ce temps, de tels processus cycliques sont assez souvent rencontrés lorsque le nombre de répétitions de cycle est également inconnu à l'avance, mais pour certaines valeurs des données initiales, les actions prévues dans le cycle ne doivent pas être effectuées du tout, et même une seule l'exécution de ces actions peut conduire à des résultats incorrects ou indéfinis.
Soit, par exemple, un nombre réel M. Il faut trouver le plus petit nombre entier non négatif k pour lequel 3 k> M. Ce problème peut être résolu selon l'algorithme suivant : mettre d'abord y = 1 et k = 0 ; Ensuite, dans une boucle, multipliez y par 3 et augmentez k par 1 jusqu'à ce que le y actuel soit pour la première fois supérieur à M. À première vue, ici vous pouvez utiliser l'opérateur de boucle avec une postcondition :
Exemple de code pour un opérateur de boucle Pascal avec postconditionY : = 1 ; k : = 0 ;
Répéter
y : = y * 3 ;
k : = k + 1 ;
Jusqu'à y> M ;
Cependant, il est facile de vérifier que pour M<1 будет получен неправильный результат k=1, тогда как должно быть получено k=0: в этом случае предварительно сформированное значение k=0 является окончательным результатом и действия, предусмотренные в цикле, выполняться не должны.
Pour définir ce type de processus de calcul, lorsque le nombre de répétitions de boucle n'est pas connu à l'avance et que les actions fournies dans la boucle peuvent ne pas être exécutées du tout, un opérateur de boucle avec une condition préalable est utilisé. Cet opérateur de boucle a la forme suivante en Pascal :
où tandis que(tandis que), faire(faire, faire) - mots officiels, DANS- expression logique, S- opérateur. Ici, l'opérateur S est exécuté zéro ou plusieurs fois, mais avant chaque exécution suivante, la valeur de l'expression B est évaluée et l'opérateur S n'est exécuté que si la valeur de l'expression B est vraie. L'instruction de boucle se termine lorsque l'expression B est évaluée à faux pour la première fois. Si l'expression B prend cette valeur la première fois qu'elle est évaluée, alors l'opérateur S ne sera pas exécuté une seule fois.
Dans le problème considéré, la valeur correcte de k pour toute valeur de M peut être obtenue comme suit :
Exemple de code pour un opérateur de boucle Pascal avec une condition préalableY : = 1 ; k : = 0 ;
Alors que y Commencer
y : = y * 3 ;
k : = k + 1 ;
Finir;
L'opérateur de cycle Pascal avec une précondition peut être considéré comme le plus universel - en utilisant de tels opérateurs, vous pouvez également définir des processus cycliques définis par les opérateurs du cycle avec un paramètre et une postcondition.
Noter différences et caractéristiques d'un bon style de travail avec les opérateurs cycliques considérés.
| Boucle avec la précondition Tant que la condition est vraie) | Boucle avec répétition postcondition (jusqu'à ce que la condition soit vraie) |
|
|
|
|
|
|
|
|
|
|
|
|
| Boucle avec compteur (avec paramètre) Pour | |
|
|
|
|
|
|
|
|
|
|
Une instruction exécutée dans une boucle peut elle-même être une boucle. Ceci s'applique à tous les types de cycles. En conséquence, nous obtenons boucles imbriquées... Il est plus pratique de considérer le fonctionnement des boucles imbriquées en utilisant l'exemple des boucles imbriquées avec un paramètre. Supposons que nous ayons besoin de décrire le fonctionnement d'une horloge électronique, à partir de l'heure 0 heure, 0 minute, 0 seconde. La valeur des minutes ne deviendra égale à 1 qu'une fois que les secondes auront "passé" toutes les valeurs consécutives de 0 à 59. L'horloge ne changera sa valeur de 1 qu'une fois que les minutes auront "passé" toutes les valeurs consécutives de 0 à 59. Ainsi, la sortie de toutes les valeurs de temps du début de la journée à la fin de la journée peut être représentée par le fragment de programme suivant :
Pour h : = 0 à 23 faire
Pour m : = 0 à 59 faire
Pour s : = 0 à 59 faire
Writeln (h, ":", m, ":", s);
Pour faciliter l'implémentation des structures cycliques en Pascal, les dernières versions du langage ont introduit les opérateurs Pause et Continuez appliqué à l'intérieur des boucles. Ils élargissent l'utilisation des boucles et améliorent la structure du programme.
Au cours du processus d'exécution du corps de la boucle jusqu'à ce que la boucle soit terminée, des conditions supplémentaires peuvent survenir qui nécessitent la fin de la boucle. Dans ce cas, la boucle peut être terminée par l'instruction break.
Pendant l'exécution du cycle, une condition peut survenir dans laquelle il est nécessaire de sauter tout ou partie des actions prévues dans le cycle, sans arrêter le cycle du tout. Pour ce faire, utilisez l'opérateur continue, qui transfère le contrôle au point du programme où la condition de poursuite ou de fin de la boucle est vérifiée.
Bonjour chers lecteurs ! Nous voici avec vous et venons à l'étude des cycles. Boucles vers Pascal. Ce que c'est? Comment l'utiliser? A quoi servent-ils ? Telles sont les questions auxquelles je vais répondre aujourd'hui.
Si vous lisez, vous savez qu'il existe trois types d'algorithmes : linéaire, de branchement et cyclique. Nous savons déjà implémenter des algorithmes en Pascal. Commençons par étudier le dernier type d'algorithmes.
En Pascal, comme dans la plupart des langages de programmation, il existe trois types de constructions en boucle.
Toute boucle se compose d'un corps et d'un titre. Le corps de la boucle est un ensemble d'opérateurs répétés et la condition est une expression logique, selon le résultat duquel la boucle est répétée.
Prenons un problème que nous allons résoudre en utilisant différents types de boucles.
Objectif 1. Imprimez tous les nombres de 1 au nombre entré au clavier.
While, ou une boucle avec une condition préalable
Comme vous l'avez probablement déjà compris d'après le nom, tandis que Est un cycle dans lequel la condition est devant le corps. De plus, le corps du cycle est exécuté si et seulement si la condition vrai; dès que la condition devient faux
Alors qu'il a le format :
tandis que < условие> faire<оператор 1>; (Au revoir... fais....)
Cette boucle ne convient que pour un opérateur, mais si vous souhaitez utiliser plusieurs opérateurs dans votre code, vous devez les mettre entre crochets d'opérateur - commencer et finir;.
La solution du problème.
Exemple de programme_while; var i, N : entier ; (déclarant des variables) begin i: = 1; (Mettre i à 1) readln (N); (Lire le dernier numéro) pendant que je<= N do {Как только i станет больше N, цикл прекратится (можно было бы написать просто <, но пришлось бы добавлять 1 к N) } begin {Открываем операторные скобки} write(i, " "); {Выводим i} Inc(i); {увеличиваем i на один.} end; { закрываем скобки } end.
Répéter ou boucler avec postcondition
Répéter- totalement à l'opposé tandis que. Répéter Est une boucle dans laquelle la condition vient après le corps. De plus, elle est remplie si et seulement si le résultat de la condition faux; dès que l'expression booléenne devient vrai, la boucle est terminée.
La répétition a le format :
répéter( répéter … )
<оператор 1>;
< оператор 2>;
…
jusqu'à(avant…) <условие>
Commencer et finir non requis.
La solution du problème.
Exemple de programme_repeat; var i, N : entier ; (déclarant des variables) begin i : = 1 ; (Mettre i à 1) readln (N); (Nous lisons le dernier nombre) répéter (aucun début ni fin ne sont requis après la répétition) écriture (i, ""); (Nous sortons i) Inc (i); (augmenter i de un.) jusqu'à ce que i = N + 1 ; (Par exemple, i = 11 et N = 10. La boucle se termine, la condition devient donc vraie.) Fin.
For, ou une boucle avec un paramètre
Pour Est une boucle dans laquelle le corps est exécuté un nombre spécifié de fois.
Il existe deux formes d'écriture de ce cycle :
La première forme
pour<счетчик1> := <значение1>à<конечное_значение>faire<оператор1>;<счетчик1>augmentera de 1.
<значение1>Est la valeur initiale du compteur. Il peut s'agir d'une variable ou d'un nombre.
<конечное_значение>: dès que la valeur<счетчик1>deviendra plus<конечное_значение>
Si vous devez écrire plusieurs opérateurs dans le corps de la boucle, utilisez commencer et finir.
ET<счетчик1>, et<конечное_значение>, et<значение1>- variables entier taper.
La variable i est le plus souvent utilisée comme compteur.
Deuxième forme
pour<счетчик2> := <значение2>jusqu'à<конечное_значение>faire<оператор1>;Après chaque itération, la valeur<счетчик2>diminuera de 1.
<значение2>Est la valeur initiale du compteur.
<конечное_значение>: dès que la valeur<счетчик2>deviendra moins<конечное_значение>, la boucle s'arrêtera.
Deux remarques importantes :
- Le cycle se répète tant que la valeur de la valeur du compteur se trouve dans le segment [valeur ; valeur_fin].
- Changer la valeur du compteur à l'intérieur du corps c'est interdit! Voici ce que le compilateur affiche :
La solution du problème :
Exemple de programme_for; var i, N : entier ; commencer la lecture (N) ; (supposons que nous ayons entré 10) pour i : = 1 à N écrivez (i, ""); (nombre d'itérations - 10 - 1 + 1 = 10) fin.
D'accord, ce code est plus simple et plus concis que tous les précédents. Et le cycle pour- pas tout à fait un cycle ordinaire, il n'y a aucune condition logique dedans. Par conséquent, une boucle avec un paramètre en programmation est appelée sucre syntaxique. Le sucre syntaxique est un ajout à la syntaxe d'un langage de programmation qui n'ajoute pas de nouvelles fonctionnalités, mais rend l'utilisation du langage plus conviviale.
Résolvons quelques problèmes.
Pour une. Les entiers K et N (N> 0) sont donnés. Imprimez N fois le nombre K.
Nous organisons un cycle simple de 1 au nombre requis.
Programme pour1 ; var K, N, i : entier ; commencer la lecture (K, N); pour i : = 1 à N écrivez (K, ""); (On écrit K séparé par un espace) end.
Pour 2. < B). Вывести в порядке возрастания все целые числа, расположенные между A и B (включая сами числа A и B), а также количество N этих чисел.
Depuis un< B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.
Programme pour2; var A, B, i, compte : entier ; commencer à lire (A, B); pour i : = A à B écrivez (i, ""); (écrivez les nombres du plus petit au plus grand) comptez : = B - A + 1; (comptez le nombre de nombres) writeln; écrire ("Nombre de nombres -", compter); finir.
Pour9. On vous donne deux nombres entiers A et B (A< B). Найти сумму квадратов всех целых чисел от A до B включительно.
Nous organisons le même cycle que dans la tâche précédente, mais en même temps nous additionnons les carrés de tous les nombres. Pour calculer le carré, utilisez la fonction.
Programme pour9; var A, B, i, S : nombre entier ; commencer à lire (A, B); S : = 0 ; (PascalABC le fait automatiquement, mais si vous avez un autre compilateur, nous vous conseillons de réinitialiser les variables manuellement) pour i : = A vers B do S : = S + Sqr (i); (additionnez tous les carrés) writeln; écrire ("Somme des carrés -", S); finir.
Pour13°. Un entier N (> 0) est donné. Trouver la valeur de l'expression 1,1 - 1,2 + 1,3 -… (N termes, signes alternés). Opérateur conditionnel ne pas utiliser.
Afin de changer le signe, à chaque itération de la boucle, on change la valeur de la variable spéciale à l'opposé.
Programme pour 13 ; var N, A, i : entier ; S : réel ; commencer Ecrire ("N ="); readln (N); S : = 1,1 ; A : = 1 ; (Premier positif) pour i : = 2 à N do (nous avons déjà effectué la première itération de la boucle, nous commençons donc à compter à partir de 2) begin A : = -A ; (Maintenant négatif) S : = S + A * (1 + i / 10) ; (additionner) fin ; Writeln (S : 5 : 1) ; (Donnons une familiarité pour la partie fractionnaire) fin.
Tandis que1°. Étant donné les nombres positifs A et B (A> B). Le segment de longueur A contient le nombre maximum possible de segments de longueur B (sans chevauchement). Sans utiliser les opérations de multiplication et de division, trouvez la longueur de la partie inoccupée du segment A.
Soustraire B de A à chaque fois jusqu'à ce que A - B> = 0.
Programme while1; var A, B : entier ; commencer la lecture (A, B); tandis que (A - B)> = 0 faire A : = A - B ; (Tant que la différence est positive, soustraire. Il faut prévoir une variante de multiplicité A et B, donc > =) écrire (A) ; finir.
Tandis que4°.Un entier N (> 0) est donné. S'il s'agit d'une puissance de 3, émettre True, sinon, émettre False.
Nous procédons comme suit : tant que N est divisible par trois, divisez N entièrement. Alors, si N = 1, le nombre est une puissance de triplet ; si N<>1, alors le nombre n'est pas une puissance de trois. Afin de résoudre ce problème, vous devez savoir ce que c'est et comment cela fonctionne.
Programme while4; var N : entier ; commencer la lecture (N); tandis que N mod 3 = 0 do N : = N div 3 ; (Tant que le reste de la division par trois est égal à zéro, divisez N entièrement) writeln (N = 1); (expression booléenne) fin.
C'est tout pour aujourd'hui! N'oubliez pas de visiter notre site plus souvent et de cliquer sur les boutons situés devant les commentaires.
Très souvent, il devient nécessaire d'exécuter plusieurs fois la même instruction (ou groupe d'instructions). Pour cela dans la langue Pascal prévu opérateurs de boucle.
1. Un opérateur de boucle avec une condition préalable.
Formulaire d'enregistrement : tandis que<условие>faire<оператор>;
Ici tandis que(tandis que), faire (faire)- mots réservés.
L'opérateur peut être n'importe quel opérateur simple ou composé. Ici<оператор>n'est exécuté que si et tant que vrai<условие>, qui est vérifié à chaque exécution de l'instruction. Si dès le début la condition compte faux , l'opérateur de boucle ne sera pas exécuté une seule fois.
Le schéma fonctionnel de l'algorithme de fonctionnement d'un tel opérateur est présenté à la Fig. un.
Riz. 1. Opérateur de boucle avec précondition
Exemple
je façon
. Calcul de la factorielle d'un nombre N.-É.(c'est-à-dire les produits 1 2 ...N.-É.):
Programme Fact_1 ;
Const n = 5 ;
Var i, fait : entier ;
Commencer
je : = 1 ; Fait : = 1 ;
alors que je<=n do {заголовок цикла}
commencer (début de boucle)
fait : = fait * i;
je : = je + 1
finir; (fin de cycle)
WriteLn ("factorielle", n, "=", Fait : 10)
Finir.
2. Opérateur d'une boucle avec une postcondition. Le schéma fonctionnel de l'algorithme de travail de l'opérateur est illustré à la Fig. 2.
Formulaire d'enregistrement :
Répéter
<оператор1>; <оператор2>;
Jusqu'à<условие>;
Ici répéter (répéter jusque-là) Jusqu'à (jusqu'à ce que la condition soit remplie) - mots réservés.
Une séquence d'instructions peut consister en une ou plusieurs instructions. Contrairement à la précédente, dans cette boucle la condition est toujours vérifiée après l'exécution de l'opérateur (ou d'une séquence d'opérateurs), si elle est fausse, l'opérateur est à nouveau exécuté, sinon, la boucle pre croît. Avec cette structureopérateur au moins une fois obligation sera remplie.
Exemple:
II façon
. Calcul de la factorielle d'un nombre N.-É.(c'est-à-dire les produits 1 2 ...N.-É.):
Programme Fact_2 ;
Const n = 5 ;
Var i, fait : entier ;
Commencer
je : = 1 ; Fait : = 1 ;
Répéter
commencer (début de boucle)
fait : = fait * i;
je : = je + 1
finir; (corps de fin de boucle)
Jusqu'à i> n ; ( état )
WriteLn ('Factorial ", n," = ", Fait : 10)
Finir.
Ici je Est un compteur de répétitions qui doit être modifié manuellement en boucle.
3. Opérateur du cycle avec un paramètre.
Ce cycle vous permet de répéter une action un nombre connu de fois.
Un compteur est une variable qui compte le nombre de répétitions de la boucle. Dans un tel cycle, le compteur augmente automatiquement d'exactement 1.
Formulaire d'enregistrement :
POURcompteur = valeur_départÀvaleur_finFAIRE
COMMENCER
. . . .
FINIR;
S'il est nécessaire que le paramètre diminue de 1, alors utilisez appelle le mot Jusqu'à(la valeur de départ est supérieure à la valeur de fin).
Exemple:
III façon
Calcul de la factorielle d'un nombre N.-É.(c'est-à-dire les produits 1 2 ...N.-É.):
Programme Fact_3;
Const n = 5 ;
Var i, fait : entier ;
Commencer
Fait : = 1 ;
pour i : = 1 à n faire
commencer (début de boucle)
fait : = fait * i;
finir; (fin de cycle)
WriteLn ("Factorial", n, "=", Fait : 10)
Finir.
En tant qu'opérateur, vous pouvez utiliser n'importe quel simple ou avecopérateur de volets roulants.
Les règles suivantes doivent être gardées à l'esprit lors de l'utilisation de cet opérateur de boucle :
1) une variable simple peut être utilisée comme paramètre,décrit dans le même bloc ;
2) le paramètre doit être de type discret ;
3) les valeurs initiales et finales doivent être du même type que paramètre;
4) dans le corps de la boucle (opérateur), un changement explicite de la valeur du paramètre(par exemple, un opérateur d'affectation) peut donner un nombre infini cycle;
5) il est impossible dans le corps du cycle de modifier les valeurs initiales et finales de paparamètres, s'ils sont spécifiés par des variables ;
6) après la fin du cycle, la valeur du paramètre devient égale à la valeur finale du paramètre, si le cycle n'a pas été interrompuopérateur de transition.
TOUT SEUL
1. Ecrivez un programme qui imprime des nombres à l'écran au format zone :
7 49
5 25
3 9
1 1
2. Résoudre le problème de trois manières(en utilisant différents types de boucle):
Combien d'années L le montant de l'acompte atteindra le montant souhaité S (RUB), avec investissement initial V (roubles), si l'intérêt annuel garanti par la banque est de 10% du montant du dépôt.
Exécuter l'algorithme de S = 100 000 roubles, V = 10 000 roubles.
Les instructions de boucle forcent l'exécution de leurs instructions constituantes
à plusieurs reprises.
Il existe trois types d'opérateurs de boucle en Pascal : un opérateur de boucle avec un paramètre, un opérateur de boucle avec une précondition et un opérateur de boucle avec une postcondition.
Opérateur de boucle avec paramètre
Le format de l'opérateur de boucle avec un paramètre :
pour V : = E1 à E2 do S
où V est une variable de type ordinal, E1, E2 sont des expressions du même type, S est un opérateur appelé le corps de la boucle. Les expressions E1 et E2 sont évaluées une seule fois lors de l'entrée dans la boucle. Le paramètre V prend d'abord la valeur E1, puis immédiatement après (SUCC (V)), etc. avant d'atteindre E2. Pour chaque valeur de V, l'opérateur S est exécuté. Si plusieurs opérateurs doivent être exécutés dans le corps de la boucle, ils sont combinés en un seul à l'aide d'un opérateur composé. Si la valeur finale de E2 est inférieure à la valeur initiale de E1, alors l'opérateur S n'est pas exécuté une seule fois.
L'opérateur de boucle de paramètre est également utilisé sous la forme suivante :
pour V : = Е1 jusqu'à E2 do S
Contrairement au premier cas, V passe de E1 à E2, passant de V à pred (V).
A noter que si V, E1, E2 sont de type INTEGER, alors dans le premier cas c'est un cycle avec un pas de +1, et dans le second avec un pas de -1.
Opérateur de boucle avec précondition
Le format de l'opérateur de boucle avec une condition préalable :
où B est une expression logique, S est un opérateur. L'opérateur S sera exécuté tant que la condition B est vraie. L'instruction de bouclage se terminera lorsque l'expression B sera évaluée à faux pour la première fois.
Opérateur de boucle avec postcondition
Le format de l'opérateur de boucle avec postcondition :
répéter S jusqu'à B
où B est une expression logique, S est un opérateur. L'opérateur S est exécuté jusqu'à ce que B devienne vrai. L'instruction REPEAT est exécutée au moins une fois, puisque le test de vérité de la condition B est effectué après l'exécution de l'instruction S.
Les mots de service REPEAT et UNTIL jouent déjà le rôle de parenthèses, les opérateurs entre parenthèses BEGIN et END sont donc facultatifs.
Exemples de programmes
Comme exemple d'utilisation d'opérateurs de boucle, considérons un programme de calcul de la factorielle.
Programme 2.1.1. Boucle avec paramètre (étape +1)
PROGRAMME FACTORIAL1 ;
VAR I, N : ENTIER ;
ECRIRE ("ENTRER N");
LIRE (N) ; F : = 1 ;
POUR I : = 1 À N FAIRE F : = F * I ;
Programme 2.1.2. Boucle avec paramètre (étape -1)
PROGRAMME FACTORIAL2 ;
VAR I, N : ENTIER ;
ECRIRE ("ENTRER N");
LIRE (N) ; F : = 1 ;
POUR I : = N JUSQU'À 1 FAIRE F : = F * I ;
ÉCRIT ("FACTORIAL FROM", N, "EQUAL", F)
Programme 2.2. Boucle avec précondition
PROGRAMME FACTORIAL3;
VAR I, N : ENTIER ;
ECRIRE ("ENTRER N");
LIRE (N) ; F : = 1 ; moi : = 1 ;
ALORS QUE JE<=N DO
ÉCRIT ("FACTORIAL FROM", N, "EQUAL", F)
Un opérateur est un élément indivisible du programme, qui permet d'effectuer certaines actions algorithmiques. La différence entre un opérateur, par rapport à d'autres éléments, est qu'il signifie toujours une sorte d'action. En Pascal, les opérateurs sont constitués de mots de fonction. Les opérateurs utilisés dans le programme sont séparés les uns des autres et des autres éléments du programme par le symbole (;). Tout Opérateurs pascals peut être grossièrement divisé en deux groupes:
- Facile;
- structuré.
Opérateurs simples sont des opérateurs qui ne contiennent pas d'autres opérateurs. Ceux-ci inclus:
- opérateur d'affectation (: =);
- opérateur de procédure;
- opérateur de saut inconditionnel (GOTO).
Opérateurs structurés sont des opérateurs qui contiennent d'autres opérateurs. Ceux-ci inclus:
- opérateur composé ;
- instructions conditionnelles (IF, CASE);
- opérateurs de boucle (FOR, WHILE, REPEAT);
- opérateur de jointure (AVEC).
Opérateurs simples
Opérateur de procédure
Opérateur de procédure sert à appeler une procédure.
Format: [nom_procédure] (liste des paramètres d'appel) ;
Une instruction de procédure consiste en un identifiant de procédure, immédiatement suivi d'une liste de paramètres d'appel entre parenthèses. Pascal a des procédures sans paramètres. Dans ce cas, lors de l'appel, il n'y a pas de liste de paramètres. L'exécution de la procédure par l'opérateur entraîne l'activation des actions décrites dans son corps. Il existe deux types de procédures en Pascal :
- Standard, qui sont décrits dans la langue elle-même et appartiennent à la langue ;
- Procédures utilisateur que l'utilisateur crée.
Pour appeler des procédures standard, vous devez vous connecter dans la section USES du nom du module (bibliothèque), où cette procédure est décrite. Un certain nombre de procédures situées dans le module SYSTEM sont toujours connectées automatiquement au programme et leur connexion dans la section USES n'est pas nécessaire. Les procédures standard Pascal sont LIRE, ÉCRIRE, RÉÉCRIRE, FERMER, RÉINITIALISER.
LIRE ([variable_fichier], [liste_entrée])
LIRE (x, y)
Les procédures utilisateur (non standard) doivent être créées avant de les utiliser dans le programme et se trouvent soit dans la section de description du programme lui-même, soit dans des unités de programme distinctes du module. Si la procédure est dans un module, alors le nom de ce module doit être mentionné dans l'application USES.
Opérateur de saut inconditionnel GOTO
Format: GOTO [étiquette];
GOTO est un mot réservé dans le langage Pascal. [label] est un identifiant arbitraire qui vous permet de marquer un certain opérateur de programme et de vous y référer à l'avenir. En Pascal, il est permis d'utiliser un entier non signé comme étiquettes. L'étiquette est placée devant l'opérateur marqué et en est séparée (:). Un opérateur peut être marqué avec plusieurs balises. Ils sont également séparés les uns des autres (:). Avant d'utiliser une étiquette dans une section de déclaration, elle doit être décrite dans la section LABEL (section de description).
L'action GOTO transfère le contrôle à l'instruction signalée correspondante. Lors de l'utilisation d'étiquettes, les règles suivantes doivent être respectées :
- l'étiquette doit être décrite dans la section description et toutes les étiquettes doivent être utilisées ;
- si des entiers sont utilisés comme étiquettes, ils ne sont pas déclarés.
Contredit les principes de la technologie de programmation structurée. Les langages de programmation modernes n'incluent pas un tel opérateur et il n'est pas nécessaire de l'utiliser. De plus, la méthode dite du convoyeur est utilisée dans les ordinateurs modernes. Si un opérateur de saut inconditionnel est rencontré dans le programme, un tel opérateur interrompt l'intégralité du pipeline, forçant sa recréation, ce qui ralentit considérablement le processus de calcul.
Opérateurs structurés
Déclarations de condition SI
Un opérateur conditionnel est utilisé dans un programme pour implémenter une structure algorithmique - branchement. Dans cette structure, le processus de calcul peut se poursuivre dans l'une des directions possibles. Le choix de la direction se fait généralement en vérifiant certaines conditions. Il existe deux types de structure de branche : la structure en fourche et la traversée.
En Pascal, l'instruction conditionnelle IF est un moyen d'organiser un processus de calcul de branchement.
Format: IF [expression_booléenne] Then [instruction_1] ; Sinon [opérateur_2] ;
IF, Then, Else - mots de contrôle. [operator_1], [operator_2] - opérations ordinaires du langage Pascal. La partie Else est facultative (peut être manquante).
L'instruction IF fonctionne comme suit : tout d'abord, le résultat d'une expression booléenne est vérifié. Si le résultat est TRUE, alors [statement_1] suivant le mot-clé Then est exécuté et [statement_2] est ignoré. Si le résultat est FAUX, alors [statement_1] est ignoré et [statement_2] est exécuté.
Si la partie Else est manquante, l'instruction IF n'est pas complète :
IF [expression_booléenne] Then [instruction] ;
Dans ce cas, si le résultat est True (TRUE), alors la [instruction] est exécutée, si False (FALSE), alors le contrôle est transféré à l'opérateur suivant l'instruction IF.
il y a 2 nombres A et B. Trouvez le nombre maximum.
Opérateur composé
Un opérateur composé est une séquence d'opérations arbitraires dans un programme, entourée de crochets d'opérateur (Begin-End).
Format: Commencer [opérateurs] ; Finir;
Les opérateurs composés vous permettent de représenter un groupe d'opérateurs comme un seul opérateur.
Déclaration de sélection CASE
Conçu pour implémenter plusieurs branches, étant donné que l'opérateur IF ne peut implémenter que deux directions du processus de calcul, il n'est pas toujours pratique de l'utiliser pour implémenter plusieurs branches. Le branchement multiple est implémenté avec l'instruction CASE.
Format: CAS [select_key] DE
[select_const_1] : [operator_1] ;
[select_const_2] : [operator_2] ;
[choice_const_N] : [opérateur_N] ;
ELSE [opérateur];
CASE, OF, ELSE, END - mots de contrôle. [select_key] est un paramètre de l'un des types ordinaux. [select_constants] sont des constantes du même type que la touche select qui implémentent la sélection. [operator_1 (N)] est un opérateur ordinaire. ELSE peut être manquant.
L'opérateur de sélection fonctionne comme suit : avant que l'opérateur ne fonctionne, la valeur du paramètre de touche de sélection est déterminée. Ce paramètre peut être exprimé sous forme de variable dans le programme ou d'une autre manière. Ensuite, la touche de sélection de paramètre est comparée séquentiellement à la constante de sélection. Si la valeur de la touche de sélection correspond à l'une des constantes de sélection, l'opérateur suivant cette constante est exécuté et tous les autres opérateurs sont ignorés. Si la touche de sélection ne correspond à aucune des constantes, l'instruction qui suit Else est exécutée. Else est souvent facultatif, et si la touche de sélection ne correspond à aucune des constantes de sélection et si Else est absent, le contrôle est transféré à l'opérateur suivant l'instruction CASE.
Il n'y a pas de vérification de condition explicite dans l'instruction CASE qui est spécifique à l'instruction IF. Dans le même temps, l'opération de comparaison est effectuée implicitement. CASE introduit la dissonance dans le programme Pascal, puisque cet opérateur se termine par le mot de service End, qui n'a pas de Begin apparié.
Créez un algorithme et un programme pour un problème qui simule le travail d'un feu de circulation. Lorsque vous entrez le symbole de la première lettre des couleurs des feux de circulation, le programme doit afficher un message sur la couleur et les actions correspondantes.
Le programme fonctionne de la manière suivante : à partir du clavier, la procédure de lecture saisit une lettre symbole de la couleur d'un feu tricolore. Si la lettre '' est saisie, correspondant à la couleur verte, alors dans l'instruction CASE la valeur saisie dans la liste de sélection trouvera la constante '' 'et le message" Couleur verte, le mouvement est autorisé "sera affiché. Lorsque vous saisissez les lettres « k » et « z », des messages similaires seront affichés. Lorsque vous entrez un autre caractère, le message « Le feu de circulation ne fonctionne pas » s'affiche, car dans ce cas, la partie Else de l'instruction CASE fonctionne.
Opérateurs de boucle
Une structure algorithmique cyclique est une structure dans laquelle certaines actions sont effectuées plusieurs fois. Il existe deux types de structures de boucle en programmation : une boucle avec un paramètre et une boucle itérative.
Un cycle avec un paramètre contient toujours les paramètres dits de cycle : X, X n, X k, ∆X. Parfois, un cycle avec un paramètre est appelé cycle régulier. La caractéristique est que le nombre de boucles et de répétitions peut être déterminé avant l'exécution de la boucle.
Dans une boucle itérative, il n'est pas possible de déterminer le nombre de boucles avant son exécution. Elle est exécutée tant que la condition de continuation de la boucle est satisfaite.
Dans le langage Pascal, il existe trois opérateurs qui implémentent des structures de calcul cycliques :
- opérateur de comptage POUR. Il est destiné à implémenter une boucle avec un paramètre et ne peut pas être utilisé pour implémenter une boucle itérative ;
- un opérateur de boucle avec une condition préalable WHILE ;
- opérateur de boucle avec postcondition REPEAT.
Les deux derniers sont axés sur l'implémentation d'une boucle itérative, mais ils peuvent également être utilisés pour implémenter une boucle avec un paramètre.
Déclaration POUR
Format: FOR [cycle_parameter] : = [n_z_p_ts] To [k_z_p_ts] Do [operator] ;
POUR, À, Faire - mots de service. [cycle_parameter] est un paramètre de cycle. [n_z_p_ts] - valeur initiale du paramètre de cycle. [k_z_p_ts] - la valeur finale du paramètre de cycle. [operator] est un opérateur arbitraire.
Le paramètre de boucle doit être une variable de type ordinal. Les valeurs de début et de fin du paramètre de boucle doivent être du même type que le paramètre de boucle.
Considérons le travail de l'opérateur à l'aide de son algorithme :
A la première étape, la valeur du paramètre cycle prend [n_z_p_ts], puis le paramètre cycle est vérifié est inférieur ou égal à [k_z_p_ts]. Cette condition est une condition pour continuer le cycle. Si c'est fait, la boucle continue son travail et l'[opérateur] est exécuté, après quoi le paramètre de boucle est augmenté (diminué) de un. Puis, avec la nouvelle valeur du paramètre loop, la condition de poursuite de la boucle est vérifiée. S'il est exécuté, les actions sont répétées. Si la condition n'est pas remplie, le cycle arrête son travail.
L'instruction For diffère considérablement des instructions similaires dans d'autres langages de programmation. Les différences sont les suivantes :
- le corps de l'instruction For. L'instruction ne peut pas être exécutée même une fois, puisque la vérification de la continuation de la boucle est effectuée avant le corps de la boucle ;
- le pas de changement du paramètre de cycle est constant et égal à 1 ;
- le corps de la boucle dans l'instruction For est représenté par une seule instruction. Dans le cas où l'action du corps de boucle nécessite plus d'un opérateur simple, alors ces opérateurs doivent être transformés en un opérateur composé au moyen de crochets d'opérateur (BEGIN-END) ;
- Un paramètre de boucle ne peut être qu'une variable de type ordinal.
Exemple d'utilisation de l'instruction FOR : créer un tableau pour convertir les roubles en dollars.
Instruction WHILE (instruction de boucle de précondition)
Format: WHILE [condition] Do [opérateur];
PENDANT, Do - mots de service. [condition] est une expression de type booléen. [operator] est un opérateur ordinaire.
;
L'instruction While fonctionne comme suit : tout d'abord, le résultat d'une condition booléenne est vérifié. Si le résultat est vrai, l'opérateur est exécuté, après quoi la condition est renvoyée au test avec la nouvelle valeur de paramètre dans l'expression logique de la condition. Si le résultat est faux, la boucle est terminée.
Lorsque vous travaillez avec While, vous devez faire attention à ses propriétés :
- les conditions utilisées dans le While sont la condition pour la continuation de la boucle ;
- dans le corps du cycle, la valeur du paramètre de la condition inclus dans l'expression change toujours ;
- Bien que la boucle While ne puisse pas être exécutée une seule fois, la vérification conditionnelle dans la suite de la boucle est effectuée jusqu'au corps de la boucle.
Instruction REPEAT (instruction de boucle avec postcondition)
Format: REPEAT [boucle-corps] ; JUSQU'À [condition] ;
L'instruction REPEAT fonctionne comme suit : tout d'abord, les instructions du corps de la boucle sont exécutées, après quoi le résultat est vérifié pour la condition logique. Si le résultat est faux, alors un retour à l'exécution des opérateurs du corps de boucle suivant est effectué. Si le résultat est vrai, l'instruction se termine.
L'opérateur Répéter a les caractéristiques suivantes :
- dans Répéter, la condition de fin de boucle est vérifiée, et si la condition est remplie, la boucle se termine ;
- le corps de la boucle est toujours exécuté au moins une fois ;
- le paramètre de vérification de la condition est modifié dans le corps de la boucle ;
- les opérateurs du corps de la boucle n'ont pas besoin d'être placés entre crochets d'opérateur (BEGIN-END), tandis que le rôle des crochets d'opérateur est assuré par Repeat et Until.
Calculez y = sin (x), où xn = 10, xk = 100, le pas est de 10.
