Opérateurs de boucle. Boucle For en Pascal. Dans le langage Pascal, il existe trois types d'opérateurs de boucle. Syntaxe Pascal pour écrire des opérateurs de boucle.

Tous les écoliers connaissent probablement un langage de programmation appelé « Pascal ». Qu'est-ce que c'est? Cette langue est morte depuis longtemps, car elle n'est utilisée que dans les écoles pour enseigner aux élèves et est considérée comme une langue de base. Il fait référence à une version simplifiée du langage Algol. Mais contrairement à ce dernier, Pascal peut être utilisé pour écrire de vrais programmes et même des jeux. Auparavant, il était très populaire, mais il n'est désormais conservé que essentiellement à des fins éducatives. La première chose qui attire les programmeurs potentiels vers Pascal est la capacité d'écrire tout en préservant les propriétés. langue anglaise, et ne vous creusez pas la tête sur l'utilisation de schémas spéciaux courants dans des langages comme C.

Pascal a été créé par Niklaus Wirth en 1970. Le langage doit son nom au scientifique Blaise Pascal, qui est devenu le père de la première machine au monde. Elle pourrait ajouter deux nombres différents. Un descendant direct du langage Pascal est Modula-2. Cette dernière est une version améliorée.

Système de programmation

Pascal ABC est un langage de programmation déjà introduit système existant. Cependant, celle décrite est une version nouvelle génération.

Pourquoi Pascal ABS a-t-il été créé ? Il y avait deux raisons importantes à cela :

• systèmes de langue d'origine obsolètes ;
• désir de créer un environnement de programmation plus moderne et intégré.

Le langage comprend le système Pascal classique, des éléments Delphi et ses propres extensions. Il est apparu en 2002.

Il existe également un compilateur du même nom, puissant et moderne, capable de fonctionner à la fois sous Linux, macOS et Windows.

La plateforme .NET vous permet d'utiliser certains fonctionnalités supplémentaires, ainsi que la programmation dans des styles structurels, orientés objet et fonctionnels. Par de cette langue est devenu Mihalkovitch. Il a été influencé non seulement par Pascal et Delphi, mais aussi par C# et Python.

Caractéristiques générales des opérateurs

Les opérateurs dans un langage de programmation sont nécessaires pour écrire un programme. Ils permettent d'exécuter certaines fonctions et algorithmes. En quoi les commandes en Pascal diffèrent-elles des autres éléments ? Parce qu'ils impliquent l'accomplissement d'une certaine action. "Pascal" est conçu de telle manière que tous les opérateurs sont constitués de mots de fonction spéciaux. Les commandes sont séparées les unes des autres et des autres éléments par le point-virgule (;). Tous les opérateurs sont conditionnellement divisés en groupes :

• Simple. Ces commandes ne contiennent pas d'autres éléments. Ce sont : (deux-points et égaux), procédures de saut inconditionnel (utilisées pour les étiquettes).
• Structuré. Ces opérateurs sont constitués d'autres éléments : conditions composées, boucles, ajout.

Les deux groupes seront discutés en détail plus loin dans l’article.

Opérateur de procédure

Cet opérateur est obligé d'appeler une procédure. Afin de créer une ligne dans l'environnement de programmation, vous devez spécifier un identifiant, suivi des paramètres d'appel. Cependant, il existe des procédures dans le langage qui ne comportent pas le dernier élément. En Pascal, ils sont divisés en deux types :

• standard (spécifié dans la langue elle-même) ;
• personnalisé (créé par le programmeur).

Lors de la spécification d'un certain ensemble d'éléments dans une ligne, l'une ou l'autre procédure est utilisée.

Les opérateurs (« Pascal »), responsables des actions standards, sont assez faciles à retenir. Vous devez écrire le mot utilisations dans la section des descriptions et saisir une description de la procédure. Certains éléments standards n’ont pas besoin d’être inclus dans le premier bloc. Ce sont les tâches de lecture, d'écriture et autres.

Les procédures utilisateur doivent être créées avant d'exécuter le programme et placées dans la section de description ou dans un module. Si cette dernière option est utilisée, elle doit être écrite dans la section UTILISATIONS ou PROCÉDURE.

Opérateur de saut inconditionnel

Les opérateurs simples sont assez faciles à utiliser, y compris GOTO. Pascal a une section de balises qui vous permet de placer un opérateur spécifique nécessaire au développeur, puis de vous y référer ultérieurement à l'aide d'un saut inconditionnel. L'étiquette doit être un ensemble de chiffres et de lettres sans signes ni espaces. Il est séparé de la ligne par deux points (:). Avant de créer une étiquette, vous devez spécifier les noms de cet élément dans la section descriptions de LABEL.

Avant de créer un département, vous devez connaître certaines nuances :

• toutes les balises décrites doivent être utilisées ;
• si les éléments ont des noms composés de nombres, alors ils ne peuvent pas être déclarés.

Malheureusement ou heureusement, l'opérateur GOTO n'est pas utilisé dans les langages de programmation modernes. Cela est dû au fait que de tels systèmes, lorsqu'ils fonctionnent, créent le principe d'une bande transporteuse. Et les opérateurs (« Pascal ») tels que GOTO perturbent le processus de calcul.

Opérateurs conditionnels

L'instruction conditionnelle, représentée par les constructions IF-THEN-ELSE, est utilisée pour montrer les branches dans lesquelles l'une des options est nécessairement fausse. Le processus de calcul se poursuivra selon l'une des options présentées. Classiquement, le processus est divisé en deux types :

• structure de fourche (quand il existe deux options d'action et que chacune mène à son propre résultat) ;
• structure de parcours (lorsque la deuxième option est fausse, auquel cas le programme parcourt le résultat censé être vrai).

La construction IF-THEN-ELSE représente des instructions structurées. Ces mots sont des mots de service. Toutefois, ce dernier n’est pas soumis à un usage obligatoire.

Comment fonctionne la conception ? De l'anglais, il est traduit par « if-then-else ». Si la condition spécifiée par le programme est vraie, alors ce qui est écrit après le mot est alors exécuté. Et si c’est incorrect, alors ce qui est écrit après else ou après la ligne with then est considéré comme valide.

Opérateur composé

Pour comprendre cette phrase, vous devez connaître la définition. Les instructions composées ("Pascal") sont un ensemble d'opérations dans un programme écrit placées entre parenthèses BEGIN-END. De ce fait, le groupe de commandes est présenté comme le seul complet.

Opérateur de sélection

L'instruction IF ne pouvant gérer que deux branches, la commande CASE select a été créée. Ce système a des mots de service - cas, de, fin, sinon. Mais ce dernier peut aussi être absent. Avant que l'instruction puisse être exécutée, le paramètre et sa valeur doivent être déclarés. Si la clé de sélection correspond aux constantes de sélection, alors l'instruction qui suit la dernière est exécutée. Si ce n'est pas correct, toutes les commandes sont ignorées. L'option qui vient après le mot ELSE ou après l'instruction CASE est exécutée.

Cet opérateur de sélection en Pascal n'utilise pas de système tel que IF. Il n’y a pas de vérification de condition explicite ici. Si nous regardons son travail plus en détail, nous pouvons voir que CASE introduit une légère dissonance dans le programme, puisque l'instruction se termine par le mot END, qui n'a pas de BEGIN apparié. Il est beaucoup plus pratique à utiliser, surtout s'il y a 5 options ou plus parmi lesquelles choisir. L'enregistrement IF-THEN prendra beaucoup de temps, et ce n'est pas un processus pratique.

Opérateurs ("Pascal") : boucles

Que sont les cycles ? Ils consistent à répéter plusieurs fois certains systèmes de commande jusqu'à ce que la condition soit complètement satisfaite. Il y en a deux connus en Pascal :

• boucle avec paramètre ;
• itératif.

Que représente chacun ? Le premier a toujours des paramètres connus. Parfois, on l'appelle aussi régulier. Sa principale différence est que le nombre de répétitions du cycle est connu avant qu'il ne commence.

En itératif, une telle nuance est inconnue. La boucle continue jusqu'à ce que la condition soit remplie.

Vous pouvez distinguer les types et types de cycles à l'aide de certaines structures :

• RÉPÉTER : répéter avec postcondition.
• WHILE : répéter avec une condition préalable.
• POUR - opérateur de comptage. Il s'utilise dans une boucle avec un paramètre.

Les deux premières options sont utilisées pour la répétition itérative. La principale différence entre eux et le dernier opérateur est qu'ils peuvent être utilisés dans une boucle avec un paramètre, mais FOR ne peut pas être utilisé pour des répétitions sans paramètre.

Opérateurs d'E/S

Les opérateurs d'E/S sont responsables de l'interaction de l'environnement de programmation avec l'environnement. Ils permettent de saisir des informations et d'afficher le résultat à l'écran ou sous forme imprimée. La commande read permettra à l'utilisateur de programme en cours d'exécution indiquez vos coordonnées. Comment cela se produit-il ? Le programme s'arrête pendant un moment et un curseur clignotant apparaît sur l'écran, attendant la saisie des données d'une personne. Il y a peu de différence dans le fonctionnement des deux opérateurs read et readln. Ce dernier déplace simplement le curseur sur la ligne suivante.

L'opérateur de sortie ("Pascal") est write(ln). La particule LN vous permet de continuer à générer des données sur la ligne suivante. Si vous spécifiez un opérateur simple dans le programme, un terme vide sera affiché à l'écran. Utiliser dans ce sens cette commande pas nécessaire.

Il existe également des opérateurs var et close. Il n'est pas nécessaire de les utiliser à moins que le programme lui-même ne l'exige.

Les opérateurs de base ("Pascal") sont décrits dans l'article. Ils vous aideront à écrire un meilleur programme, mais ils travaillent eux-mêmes assez rapidement et sans échec. Sans eux, rien ne fonctionnera pour le futur programmeur travaillant avec le langage Pascal. Malheureusement, il est impossible d'imaginer des programmes sans opérateurs. Cela signifie que vous devez être capable de fonctionner avec eux. Les opérateurs de boucle peuvent sembler compliqués, mais avec de la pratique, les problèmes disparaîtront tous. Bonne chance avec votre travail!

Un opérateur est un élément indivisible d'un programme qui permet d'effectuer certaines actions algorithmiques. La différence entre un opérateur et les autres éléments est qu’il implique toujours une sorte d’action. En Pascal, les opérateurs sont constitués de mots de fonction. Les opérateurs utilisés dans un programme sont séparés les uns des autres et des autres éléments du programme par le symbole (;). Tous Opérateurs Pascal peut être grossièrement divisé en deux groupes:

1. simple;
2. structuré.

Opérateurs simples sont des opérateurs qui ne contiennent pas d’autres opérateurs. Ceux-ci incluent :

• opérateur d'affectation (:=);
• déclaration de procédure ;
• opérateur de saut inconditionnel (GOTO).

Déclarations structurées sont des opérateurs qui contiennent d’autres opérateurs. Ceux-ci incluent :

• opérateur composé ;
• opérateurs conditionnels (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: [procedure_name] (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 d'une instruction de procédure entraîne l'activation des actions décrites dans son corps. Il existe deux types de procédures en Pascal :

• Les standards, qui sont décrits dans la langue elle-même et font partie de la langue ;
• Procédures utilisateur créées par l'utilisateur.

Pour appeler des procédures standards, vous devez vous connecter dans la section USES du nom du module (bibliothèque), où il est décrit cette procédure. 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 Pascal standard sont READ, WRITE, REWRITE, CLOSE, RESET.

LIRE ([file_variable], [input_list])

LIRE(x,y)

Les procédures utilisateur (non standards) doivent être créées avant leur utilisation 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 GOTO inconditionnel

Format: ALLER À [étiquette] ;

ALLER À- mot réservé en langage Pascal. [label] est un identifiant arbitraire qui vous permet de marquer une certaine instruction de programme et d'y faire référence ultérieurement. En Pascal, il est possible d'utiliser des entiers non signés comme étiquettes. L'étiquette est placée avant et séparée de l'opérateur marqué (:). Une déclaration peut être marquée de plusieurs étiquettes. Ils sont également séparés les uns des autres (:). Avant d'utiliser un label dans la section instruction, il doit être décrit dans la section LABEL (section description).

L'action GOTO transfère le contrôle à l'instruction marquée appropriée. Lorsque vous utilisez des balises, vous devez suivre les règles suivantes :

• l'étiquette doit être décrite dans la section des descriptions 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, dans ordinateurs modernes La méthode dite du convoyeur est utilisée. Si un opérateur de saut inconditionnel est rencontré dans un programme, un tel opérateur rompt l'ensemble du pipeline, forçant sa création à nouveau, ce qui ralentit considérablement le processus de calcul.

Déclarations structurées

Déclarations de condition IF

L'opérateur conditionnel est utilisé dans le programme pour implémenter la structure algorithmique - le branchement. Dans cette structure, le processus de calcul peut se poursuivre dans l’une des directions possibles. Le choix de la direction s'effectue généralement en vérifiant certaines conditions. Il existe deux types de structures de branchement : les structures de dérivation et de dérivation.

En langage Pascal, l'opérateur conditionnel IF est un moyen d'organiser un processus de calcul de branchement.

Format: SI [expression_booléenne] Alors [opérateur_1] ; Sinon [operator_2] ;

SI, Alors, Sinon sont des mots de fonction. [operator_1], [operator_2] - opérations ordinaires du langage Pascal. La partie Else est facultative (peut être manquante).

L'instruction IF fonctionne comme ceci : elle vérifie d'abord le résultat d'une expression booléenne. Si le résultat est VRAI, alors [statement_1] suivant le mot de fonction Then est exécuté et [statement_2] est ignoré. Si le résultat est FALSE, alors [statement_1] est ignoré et [statement_2] est exécuté.

Si la partie Else est manquante, alors l'instruction IF n'est pas sous sa forme complète :

SI [expression booléenne] Alors [opérateur] ;

Dans ce cas, si le résultat est True (TRUE), alors l'[instruction] est exécutée ; si False (FALSE), alors le contrôle est transféré à l'instruction qui suit l'instruction IF.

Il y a 2 nombres A et B. Trouvez le nombre maximum.

Opérateur composé

Une instruction composée est une séquence d'opérations arbitraires dans un programme, entourée de ce que l'on appelle des crochets d'opérateur (Begin-End).

Format: Commencez [opérateurs] ; Fin;

Les instructions composées permettent de représenter un groupe d’instructions comme une seule instruction.

Déclaration de sélection CASE

Conçu pour implémenter plusieurs branches, puisque 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é par l'instruction CASE.

Format: CAS [select_key] DE

[selection_constant_1] :[operator_1] ;

[selection_constant_2] :[operator_2] ;

[selection_constant_N] :[operator_N] ;

AUTRE [opérateur] ;

CASE, OF, ELSE, END - mots de fonction. [select_key] est un paramètre de l'un des types ordinaux. [selection_constants] - constantes du même type que la clé de sélection qui implémente la sélection. [operator_1(N)] est un opérateur ordinaire. ELSE peut être manquant.

L'opérateur de sélection fonctionne de la manière suivante : avant que l'opérateur n'agisse, la valeur du paramètre clé de sélection est déterminée. Ce paramètre peut être exprimé soit sous forme de variable dans le programme, soit d'une autre manière. Ensuite, le paramètre clé de sélection est comparé séquentiellement à la constante de sélection. Si la valeur de la clé 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 clé de sélection ne correspond à aucune des constantes, l'instruction qui suit Else est exécutée. Souvent, Else est facultatif et si la clé de sélection ne correspond à aucune des constantes de sélection et en l'absence d'Else, le contrôle est transféré à l'instruction qui suit l'instruction CASE.

L'instruction CASE ne comporte pas les vérifications conditionnelles explicites trouvées dans l'instruction IF. Dans le même temps, l’opération de comparaison est effectuée implicitement. CASE introduit une dissonance dans un programme Pascal, puisque cette instruction se termine par le mot de service End, qui n'a pas de Begin apparié.

Créer un algorithme et un programme pour un problème simulant le fonctionnement d'un feu de circulation. Lorsque vous entrez le symbole de la première lettre des couleurs des feux de signalisation, le programme doit afficher un message sur la couleur et les actions correspondantes.

Le programme fonctionne de la manière suivante : à l'aide de la procédure Lecture, la lettre symbole de la couleur du feu est saisie à partir du clavier. Si la lettre « z » correspondant à la couleur verte est saisie, alors dans l'instruction CASE la valeur saisie dans la liste de sélection trouvera la constante de sélection « z » et le message « Couleur verte, le mouvement est autorisé » s'affichera. Lorsque vous saisissez le symbole des lettres « k » et « zh », des messages similaires s'afficheront. Si vous entrez un autre caractère, le message « Le feu de circulation ne fonctionne pas » s'affichera, car dans ce cas, la partie Else de l'instruction CASE fonctionne.

Instructions 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 boucles en programmation : la boucle avec un paramètre et la boucle itérative.

Dans un cycle avec un paramètre, il y a toujours ce qu'on appelle des paramètres de cycle : X, X n, X k, ∆X. Parfois, une boucle avec un paramètre est appelée une boucle régulière. Une 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 est impossible de déterminer le nombre de boucles avant de l’exécuter. Il est exécuté tant que la condition de continuation de la boucle est satisfaite.

Le langage Pascal dispose de 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 ;
• opérateur de boucle avec précondition WHILE ;
• opérateur de boucle avec postcondition REPEAT.

Les deux derniers se concentrent 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.

POUR opérateur

Format: FOR [loop_parameter] := [n_z_p_ts] À [k_z_p_ts] Faire [opérateur] ;

FOR, To, Do sont des mots fonctionnels. [cycle_parameter] - paramètre de cycle. [n_z_p_ts] - la valeur initiale du paramètre de cycle. [k_z_p_ts] - valeur finale du paramètre de cycle. [opérateur] - opérateur arbitraire.

Le paramètre de boucle doit être une variable ordinale. 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.

Regardons le travail de l'opérateur à l'aide de son algorithme :

Dans un premier temps, la valeur du paramètre cycle prend [n_z_p_ts], puis le paramètre cycle est vérifié comme étant inférieur ou égal à [k_z_p_ts]. Cette condition est la condition pour continuer la boucle. Si elle est exécutée, la boucle continue son fonctionnement et l'[instruction] est exécutée, après quoi le paramètre de boucle est augmenté (diminué) de un. Puis, avec la nouvelle valeur du paramètre de boucle, la condition de poursuite de la boucle est vérifiée. Si cela est réalisé, alors les actions sont répétées. Si la condition n’est pas remplie, la boucle s’arrête.

L'opérateur For est très différent des opérateurs similaires dans d'autres langages de programmation. Les différences sont les suivantes :

• corps de l’opérateur For. L'instruction ne peut pas être exécutée une seule fois, puisque la condition de continuation de la boucle est vérifiée avant le corps de la boucle ;
• le pas de changement de 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. Si l'action du corps de la boucle nécessite plus d'une instruction simple, alors ces instructions doivent être converties en une seule instruction composée à l'aide des crochets d'opérateur (BEGIN-END) ;
• Un paramètre de boucle ne peut être qu'une variable ordinale.

Exemple d'utilisation de l'opérateur FOR : créer un tableau pour convertir les roubles en dollars.

Instruction WHILE (instruction de boucle avec précondition)

Format: PENDANT que [condition] Faites [opérateur] ;

WHILE, Do - mots fonctionnels. [condition] - expression de type logique. [opérateur] - opérateur ordinaire.

;

L'instruction While fonctionne comme suit : tout d'abord, le résultat de la condition logique est vérifié. Si le résultat est vrai, alors l'instruction est exécutée, après quoi elle revient à la vérification de la condition avec la nouvelle valeur des paramètres dans l'expression logique de la condition. Si le résultat est faux, alors la boucle est terminée.

Lorsque vous travaillez avec While, vous devez faire attention à ses propriétés :

• Les conditions utilisées dans While sont la condition de continuation de boucle ;
• dans le corps de la boucle, la valeur du paramètre inclus dans l'expression de condition change toujours ;
• La boucle While ne peut pas s'exécuter une seule fois, puisque la vérification de la condition dans la continuation de la boucle est effectuée avant le corps de la boucle.

Instruction REPEAT (instruction de boucle avec postcondition)

Format: RÉPÉTER [cycle_body] ; JUSQU'À [condition] ;

L'instruction REPEAT fonctionne comme suit : 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, il revient à l'exécution des instructions du corps de boucle suivant. Si le résultat est vrai, alors l'opérateur quitte.

L'opérateur Répéter présente les fonctionnalités suivantes :

• en Répétition, la condition de fin de boucle est vérifiée et si la condition est remplie, la boucle cesse de fonctionner ;
• 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 instructions du corps de la boucle n'ont pas besoin d'être placées entre crochets d'opérateur (BEGIN-END), tandis que le rôle des crochets d'opérateur est joué par Repeat et Until.

Calculez y=sin(x), où xn=10, xk=100, le pas est de 10.

Bonjour, chers lecteurs ! Nous arrivons ici à l’étude des cycles. Cycles en Pascal. Qu'est-ce que c'est? Comment l'utiliser ? A quoi servent-ils ? Telles sont les questions auxquelles je répondrai aujourd’hui.
Si vous avez lu, vous savez qu'il existe trois types d'algorithmes : linéaires, ramifiés et cycliques. Vous et moi savons déjà comment 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 en-tête. Le corps de la boucle est un ensemble d’instructions répétées et la condition est expression logique, en fonction du résultat dont la boucle est répétée.

Prenons un problème que nous résoudrons en utilisant différents types cycles.

Tâche 1. Imprimez tous les nombres de 1 au nombre saisi au clavier.

Tandis que, ou boucle avec précondition

Comme vous l'avez probablement déjà compris d'après le titre, alors que est un cycle dans lequel la condition passe avant le corps. De plus, le corps de la boucle est exécuté si et seulement si la condition vrai; dès que la condition devient FAUX

Tandis que a le format :

alors que < условие> faire<оператор 1>; (Au revoir... fais....)

Ce cycle ne convient qu'à une seule instruction, si vous souhaitez utiliser plusieurs instructions dans votre code, vous devez les mettre entre crochets - commencer Et fin;.

Résoudre le problème.

Exemple de programme_while ; var i, N : entier ; (déclarer des variables) start i:= 1; ( Définir i sur 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 une boucle avec une postcondition

Répéter- tout le contraire alors 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 logique devient vrai, l'exécution de la boucle s'arrête.

La répétition a le format :

répéter(répéter...)
<оператор 1>;
< оператор 2>;
…
jusqu'à(à…) <условие>

Commencer Et fin pas requis.

Résoudre le problème.

Exemple de programme_repeat ; var i, N: entier;( déclarer les variables ) commencer i:= 1; ( Définir i sur 1 ) readln(N); (Lire le dernier numéro) répéter (le début et la fin ne sont pas requis après la répétition) write(i, " "); (Résultat i) Inc(i); (augmenter i de un.) jusqu'à ce que i = N + 1 ; (Par exemple, i = 11 et N = 10. La boucle s'arrêtera, donc la condition deviendra vraie.) fin.

Pour, ou boucle avec un paramètre

Pour est une boucle dans laquelle le corps est exécuté un nombre de fois spécifié.

Il existe deux formes d'enregistrement de ce cycle :

Premier formulaire

<счетчик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>il y en aura plus<конечное_значение>

Si vous devez écrire plusieurs instructions dans le corps de la boucle, utilisez commencer Et fin.

ET<счетчик1>, Et<конечное_значение>, Et<значение1>- variables le tout taper.

Le plus souvent, la variable i est utilisée comme compteur.

Deuxième forme

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 plus petit<конечное_значение>, l'exécution de la boucle s'arrêtera.

Deux remarques importantes :

1. Le cycle est répété tant que la valeur du compteur se situe dans l'intervalle [valeur ; valeur_finale].
2. Changer la valeur du compteur à l'intérieur du corps c'est interdit! Voici ce que produit le compilateur :

Solution au problème :

Exemple de programme_pour ; var i, N : entier ; commencer la lecture (N); (en supposant que nous ayons entré 10) pour i:= 1 à N do write(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 faire du vélo pour n'est pas une boucle très ordinaire ; elle n'a pas de condition logique. C'est pourquoi une boucle avec un paramètre est appelée sucre syntaxique en programmation. Le sucre syntaxique est un ajout à la syntaxe d'un langage de programmation qui n'ajoute pas de nouvelles fonctionnalités, mais rend le langage plus pratique à utiliser pour les humains.

Résolvons quelques problèmes.

Pour1. Étant donné les entiers K et N (N > 0). Imprimez le nombre K N fois.

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) fin.. < B). Вывести в порядке возрастания все целые числа, расположенные между A и B (включая сами числа A и B), а также количество N этих чисел.

Pour2< B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.

Depuis qu'un

Programme pour2 ; var A, B, i, nombre : entier ; commencer la lecture (A, B);. pour i:= A à B, écrivez(i, " "); (on note les nombres du plus petit au plus grand) count:= B - A + 1 ; (compter le nombre de nombres) écrire;< B). Найти сумму квадратов всех целых чисел от A до B включительно.

write("Nombre de nombres - ", count); fin.

Programme pour9 ; var A, B, i, S : entier ; commencer la lecture (A, B);

S := 0 ; (PascalABC le fait automatiquement, mais si vous disposez d'un autre compilateur, nous vous recommandons de réinitialiser les variables manuellement) for i:= A to B do S:= S + Sqr(i); (ajouter tous les carrés) writeln ;. write("Somme des carrés - ", S); fin.

Pour13°

Un entier N (> 0) est donné. Trouver la valeur de l'expression 1,1 – 1,2 + 1,3 – … (N termes, signes alternés). N'utilisez pas d'opérateur conditionnel.

Afin de changer le signe, à chaque itération de la boucle nous changeons la valeur de la variable spéciale à l'opposé.. Programme pour 13 ; var N, A, i : entier ;

S : réel ; commencer Write("N = ");

readln(N);

S := 1,1 ;.UNE := 1 ; (Positif en premier) pour i:= 2 à N do (nous avons déjà terminé la première itération de la boucle, donc nous commençons à compter à partir de 2) start A:= -A; (Maintenant négatif) S := S + A * (1 + i / 10) ; (Ajouter) fin ;

Écrire(S:5:1); (Donnons une place pour la partie fractionnaire) fin.<>Tandis que1°

Étant donné les nombres positifs A et B (A > B). Un segment de longueur A contient le nombre maximum possible de segments de longueur B (sans chevauchements). Sans utiliser les opérations de multiplication et de division, trouvez la longueur de la partie inoccupée du segment A.

Chaque fois que nous soustrayons B de A tant que A - B >= 0.

Programme while1 ; var A, B : entier ; commencer readln(A, B);

<идентификатор (имя) переменной>:= <выражение>

tandis que (A - B) >= 0 fait A:= A - B ; (Tant que la différence est positive, on soustrait. Il faut fournir une option multiple de A et B, donc >=) write(A); fin.

Tandis que4°

Un entier N (> 0) est donné. S'il s'agit d'une puissance de 3, alors imprimez True ; si ce n'est pas le cas, imprimez False.

On procède de la manière suivante : tandis que N est divisible par trois, divisez N par un tout. Alors, si N = 1, le nombre est une puissance de trois ; si N

Parmi les opérateurs d'un opérateur composé, il peut y avoir d'autres opérateurs composés, c'est-à-dire que n'importe quelle profondeur d'imbrication est autorisée. Par exemple:

Opérateurs de saut conditionnel.

Ils existent pour organiser des branches en fonction de la vérité ou de la fausseté d'une condition. Il existe deux opérateurs de ce type : un opérateur conditionnel complet et un opérateur conditionnel incomplet.

Déclaration conditionnelle complète

Implémente la conception algorithmique « full fork » :

Son format :

si <логическое выражение> alors <оператор 1> autre <оператор 2>

Si, alors, sinon – mots de service « si », « alors », « sinon ». Il n'y a pas de point-virgule devant le mot else. Les instructions 1 et 2 peuvent être des instructions simples ou composées. Une instruction composée doit être placée entre parenthèses de début et de fin.

Actes opérateur conditionnel: si l'expression logique est évaluée à vrai, alors l'opérateur 1 est exécuté, si l'expression logique est évaluée à faux, alors l'opérateur 2 est exécuté.

Instruction conditionnelle incomplète

Implémente la conception algorithmique « fork incomplet »

Son format :

si<логическое выражение> alors<оператор >

Si, alors – mots de service « si », « alors ». Un opérateur peut être soit un opérateur simple, soit un opérateur composé.

Actions de l'opérateur conditionnel : si l'expression logique est évaluée à vrai, alors l'instruction est exécutée, si l'expression logique est évaluée à faux, alors l'instruction conditionnelle est ignorée et l'instruction qui la suit est exécutée.

Les opérateurs conditionnels (complets et incomplets) peuvent avoir une structure imbriquée, c'est-à-dire qu'après les mots THEN ou ELSE, un opérateur conditionnel est à nouveau utilisé. Mot de service ELSE fait toujours référence au mot le plus proche à gauche de ALORS.

Une instruction conditionnelle peut contenir une instruction simple. Si la signification de la tâche nécessite l'insertion de plusieurs opérateurs, ils sont alors combinés en un seul.

Commentaire: après le mot ALORS, une nouvelle instruction conditionnelle ne peut pas être écrite immédiatement, mais après ELSE, elle le peut. Par exemple:

Dans les cas où plusieurs conditions doivent être testées, des instructions conditionnelles complexes sont utilisées. Ils utilisent les opérateurs logiques et, non, ou. Par exemple:

si ((x>3) et (y>3) et (z>3)) alors ...

Opérateurs d’organisation en boucle.

Un cycle est une section d'un programme qui est répétée plusieurs fois. Pour organiser une boucle en Pascal, trois opérateurs sont utilisés : un opérateur avec une précondition, un opérateur avec une postcondition et un opérateur avec un paramètre.

Opérateur de boucle avec condition préalable

Cette instruction implémente un diagramme en boucle avec une condition préalable :

Son format :

Alors que <логическое выражение> Faire <тело цикла>

Tandis que (« pour l’instant »), Do (« faire ») sont des mots fonctionnels.

Actions de l'opérateur : tant que l'expression logique est vraie, le corps de la boucle est exécuté ; Une fois qu'une expression booléenne est évaluée comme fausse, l'instruction se termine et l'instruction qui la suit est exécutée. La valeur de l'expression logique est vérifiée avant le corps de la boucle. Si l’expression logique est fausse dès le début, alors le corps de la boucle est immédiatement omis.

Si le corps d'une boucle contient une séquence d'instructions, alors on dit qu'elle forme une instruction composée, au début et à la fin de laquelle les crochets d'opérateur Begin et End doivent être écrits.

Si le corps de la boucle est une instruction (et non une instruction composée), les crochets d'opérateur ne sont pas requis. Le traducteur considère alors que le corps de la boucle se termine au « ; » le plus proche. Il n'y a pas de mots spéciaux en Pascal pour indiquer le début et la fin d'une boucle. Il existe des mots universels Début et Fin pour tous les cas.

Opérateur de boucle avec postcondition

Cette instruction implémente un diagramme en boucle avec une postcondition :

Son format :

Répéter <тело цикла> Jusqu'à <логическое выражение>

Répéter (« répéter »), Jusqu'à (« jusqu'à ») sont des mots de fonction.

Le corps de la boucle peut être une instruction unique ou composée, mais l'utilisation de Begin et End n'est pas requise, puisque les mots Repeat et Until agissent eux-mêmes comme des crochets d'opérateur.

Actions de l'opérateur : le corps de la boucle est exécuté, puis la valeur de l'expression logique est vérifiée. Si l’expression logique est fausse, le corps de la boucle est à nouveau exécuté. Cela continue jusqu'à ce que l'expression booléenne soit évaluée comme vraie. Autrement dit, le corps de la boucle répète son exécution si la condition est fausse. La répétition se termine lorsque la condition devient vraie. L'action de l'instruction se termine et l'instruction qui la suit est exécutée. La valeur de l'expression booléenne est vérifiée après le corps de la boucle.

Remarques :

Avant chaque exécution du corps de la boucle, l'expression booléenne doit avoir une valeur spécifique.

Le corps de la boucle doit contenir au moins une instruction qui affecte la valeur de l'expression logique, sinon la boucle s'exécutera sans fin.

Finalement, l'expression booléenne doit donner une valeur qui termine la boucle.

Opérateur de boucle avec paramètre

Cette instruction implémente le schéma fonctionnel d'une boucle avec un compteur. Son format :

pour <параметр цикла>:= <арифметическое выражение 1> à <арифметическое выражение 2> faire <тело цикла>

pour < параметр цикла >:= < арифметическое выражение 1> jusqu'à < арифметическое выражение 2> faire <тело цикла>

Un paramètre de boucle est une variable de tout type autre que réel.

Les expressions arithmétiques 1 et 2 doivent être du même type que le paramètre de boucle. Le corps de la boucle est n'importe quel opérateur Pascal (simple, complexe, composé).

Actions de l'opérateur : le paramètre de boucle reçoit la valeur de l'expression arithmétique 1. Si elle est inférieure (pour pour- à- faire) ou plus (pour pour- jusqu'à- faire) la valeur de l'expression arithmétique 2, puis le corps de la boucle est exécuté. Le paramètre de boucle est ensuite augmenté (diminué) du montant spécifié dans le corps de la boucle. Ensuite, il est à nouveau comparé à l'expression arithmétique 2. Et ainsi de suite jusqu'à ce que le paramètre de boucle devienne supérieur (inférieur) à la valeur de l'expression arithmétique 2. Ensuite, l'opérateur de boucle termine son travail et l'opérateur suivant est exécuté.

Si le paramètre de boucle est de type entier, alors avec le mot jusqu'au pas de modification du paramètre, le paramètre est égal à un (avec le pas jusqu'au pas est -1).

Cet opérateur a une utilité limitée, c'est-à-dire qu'il ne peut être utilisé que dans les cas où le nombre de répétitions du corps de la boucle est connu.

Très souvent, il est nécessaire d'exécuter la même instruction (ou groupe d'instructions) plusieurs fois. A cet effet dans la langue Pascal fourni opérateurs de boucle.

1. Opérateur de boucle avec condition préalable.

Formulaire d'inscription : alors que<условие>faire<оператор>;

Ici alors que(Au revoir), faire (faire)- mots réservés.

L'opérateur peut être n'importe quel opérateur simple ou composé. Ici<оператор>exécuté seulement si et aussi longtemps que vrai<условие>, qui est vérifié à chaque fois que l'instruction est exécutée. Si dès le début la condition compte FAUX , l'opérateur de boucle ne sera pas exécuté une seule fois.

Un schéma fonctionnel de l'algorithme de fonctionnement d'un tel opérateur est présenté sur la Fig. 1.

Riz. 1. Opérateur de boucle avec condition préalable

Exemple

je chemin

. Calculer la factorielle d'un nombre n(c'est-à-dire les produits 1 2 ...n):

Fait du programme_1 ;

Const n = 5 ;

Var i, fait : entier ;

Commencer

je:=1; Fait :=1 ;

pendant que je<=n do {заголовок цикла}

commencer (début de boucle)

fait:= fait*i;

je:= je + 1

fin; (fin de cycle)

WriteLn("factoriel", n, " = ",Fait:10)

Fin.

2. Opérateur de boucle avec postcondition. Le schéma fonctionnel de l'algorithme de travail de l'opérateur est présenté sur la Fig. 2.

Formulaire d'inscription :

Répéter

<оператор1>; <оператор2>;

Jusqu'à<условие>;

Ici, répétez (répéter jusqu'à) Jusqu'à (jusqu'à ce que la condition soit remplie) - mots réservés.

Une séquence d'instructions peut être constituée d'une ou plusieurs instructions quelconques. 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 de la séquence d'opérateurs) si elle est fausse, l'opérateur est à nouveau exécuté, sinon la boucle continue ; disparaît. Avec une telle structurel'opérateur est obligé au moins une fois sera accompli.

Exemple:

II chemin

. Calculer la factorielle d'un nombre n(c'est-à-dire les produits 1 2 ...n):

Fait du programme_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

fin; (fin du corps de la boucle)

Jusqu'à ce que je >n ; ( condition )

WriteLn(‘ Factorielle ", n, " = ",Fait:10)

Fin.

Ici, je est un compteur de répétitions qui doit être modifié manuellement dans la boucle.

3. Opérateur de boucle avec paramètre.

Ce cycle permet de répéter des actions un nombre de fois connu.

Un compteur est une variable qui compte le nombre de fois qu'une boucle est répétée. Dans un tel cycle, l'indicateur du compteur augmente automatiquement d'exactement 1.

Formulaire d'inscription :

POURcompteur = valeur_débutÀvaleur_finaleFAIRE

COMMENCER

. . . .

FIN;

S'il est nécessaire que le paramètre diminue de 1, alors utilisez appelle le mot Jusqu'à(la valeur initiale est supérieure à la valeur finale).

Exemple:

III chemin

Calculer la factorielle d'un nombre n(c'est-à-dire les produits 1 2 ...n):

Fait du programme_3 ;

Const n = 5 ;

Var i, fait : entier ;

Commencer

Fait :=1 ;

pour i:=1 à n faire

commencer (début de boucle)

fait:= fait*i;

fin; (fin de cycle)

WriteLn("Factorial", n, "=",Fact:10)

Fin.

Vous pouvez utiliser n'importe quel opérateur simple ou complexe comme opérateur.opérateur permanent.

Lorsque vous utilisez cet opérateur de boucle, vous devez vous rappeler les règles suivantes :

1) Vous pouvez utiliser une simple variable comme paramètre,décrit dans le même bloc ;

2) le paramètre doit être de type discret ;

3) les valeurs de début et de fin 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, par un opérateur d'affectation) peut conduire à une infinité de faire du vélo;

5) Vous ne pouvez pas modifier les valeurs initiales et finales de la boucle dans le corps de la boucle.les paramètres, s'ils sont spécifiés par des variables ;

6) une fois la boucle terminée, la valeur du paramètre devient égale à la valeur finale du paramètre, si la boucle n'a pas été interrompueopérateur de transition.

SEUL

1. Écrivez un programme qui affiche les nombres au format zone :

7 49

5 25

3 9

1 1

2. Résolvez le problème de trois manières(en utilisant différents types faire du vélo):

Dans combien d'années L le montant du dépôt atteindra le montant souhaité S (RUB), avec dépôt initial V (rub.), si les intérêts annuels garantis par la banque sont de 10 % du montant du dépôt.

Exécutez l'algorithme à S = 100 000 roubles, V = 10 000 roubles.