De manière générale, aujourd'hui nous en apprendrons plus sur chacun des cycles de Pascal et verrons comment ils sont définis. Nous allons démonter boucle while avec précondition, boucle for avec paramètre et répéter - jusqu'à boucle avec postcondition.
1. Boucle avec paramètre en Pascal - FOR
La boucle FOR définit une certaine condition selon laquelle le programme fonctionnera avant son exécution, disons que nous devons boucler le programme 5 (ou n) fois, alors cela peut être facilement fait en utilisant cette boucle. La boucle FOR a une caractéristique - un compteur, qui est généralement désigné par la lettre i ou j.
L'apparition d'une boucle avec un paramètre en pascal:
pour i: \u003d 1 à n faire // attribuer i d'abord à un, puis à deux, trois, ..., n
Après le premier passage, nous attribuons 1 à la variable i, après le second, nous attribuons 2 et ainsi de suite jusqu'à ce que nous atteignions n. to est up to .. par ordre croissant, il y a aussi downto - up to .. par ordre décroissant.
Schéma fonctionnel d'une boucle avec un paramètre:
2. Boucle avec précondition en Pascal - WHILE
Un opérateur de boucle avec une condition préalable effectue des actions un nombre inconnu de fois à l'avance. La boucle est quittée si une expression logique ou son résultat s'avère faux. Puisque l'exactitude de l'expression logique est vérifiée au début, le corps de la boucle peut ne pas être exécuté même une fois.
Structure de boucle avec précondition:
PENDANT QUE commencez la fin;
Une expression logique dont la vérité est vérifiée au début de l'exécution de l'opérateur cyclique;
Toutes les instructions de langage exécutables.
Ordre d'exécution du cycle:
Tant que la condition est vraie, le corps de la boucle est exécuté. Dès que la condition devient fausse, l'exécution de la boucle est terminée.
Schéma de principe d'une boucle avec une condition préalable:
Remarque: les blocs rectangulaires montrent toute action effectuée dans un cycle ou après (étape du cycle), dans des ovales - le début ou la fin de l'ensemble du programme ou de sa partie. Le rôle principal de ce bloc - diagramme est joué par sa partie centrale.
Exemple:
Tâche: calculer la somme des séries 1 + 1,5 + 2 + 2,5 + 3 + 3,5 + .. + 30
programme example-while;
Somme var: réel; n: réel; BEGIN somme: \u003d 0; n: \u003d 1; tandis que n
3. Boucle avec post-condition - Répéter - jusqu'à.
Cet opérateur est similaire à l'opérateur d'une boucle avec une précondition, mais en diffère en ce que la condition est vérifiée après l'exécution du corps (actions) de la boucle. Cela garantit qu'il est exécuté au moins une fois, contrairement aux boucles précédemment analysées.
Veuillez noter que cet opérateur de boucle suppose la présence de plusieurs opérateurs dans le corps de la boucle, c'est-à-dire que vous pouvez effectuer plusieurs actions, les mots de service Begin et End ne sont donc pas nécessaires.
La séquence d'instructions incluse dans le corps de la boucle est exécutée une fois, après quoi la conformité de la condition écrite après le mot de service Until est vérifiée. Si la condition n'est pas remplie, le cycle se termine. Sinon, le corps de la boucle est répété une fois de plus, après quoi la condition est à nouveau vérifiée.
Schéma fonctionnel d'une boucle avec une post-condition:
Format d'enregistrement, structure de la boucle:
RÉPÈTE JUSQU'À;
Exemple:
Programme test2; Var b: réel; Début b: \u003d 100; Répéter b: \u003d b / 2; Jusqu'à b
Conclusions:
1. Une boucle avec un paramètre utilise une variable appelée paramètre de boucle ou compteur. Avant d'exécuter le cycle, le paramètre (compteur) est mis à sa valeur initiale. Une fois l'étape de boucle exécutée, la valeur du paramètre est augmentée de un. Le cycle se poursuit jusqu'à ce que le paramètre atteigne sa valeur finale, qui est indiquée après à (downto).
2. La boucle avec une condition préalable est exécutée jusqu'à ce que la condition d'exécution devienne fausse, et continue si la condition est vraie.
3. La boucle avec la postcondition est exécutée jusqu'à ce que la condition devienne vraie, si la condition est fausse, la boucle continue.
objectif: pour donner une idée des boucles avec un paramètre, des schémas fonctionnels représentant de telles boucles. Apprenez à rédiger des organigrammes et des programmes avec des cycles en utilisant des exemples privés; donner une idée des différences entre les boucles avec une précondition, une postcondition et une boucle avec un paramètre; apprendre à utiliser différents cycles dans un programme si le programme contient plusieurs cycles; entrez et exécutez des programmes à l'aide de compilateurs BPW ou Turbo Pascal.
1. Opérateur pour ... faire ... faire ... boucleParfois, on sait à l'avance combien de fois le cycle doit être exécuté. Pour les problèmes de ce type, Pascal a les opérateurs boucles avec paramètres
.
Le format d'écriture de ces opérateurs est le suivant:
pour<cycle de vapeur> := <valeur de départ> à<valeur finale.> faire <opérateur>.
Ici pour, à, faire - mots réservés (pour, avant, exécuter);
<vapeur. cycle\u003e - paramètre de boucle - une variable de type entier (plus précisément, de tout type ordinal);
<de bonne heure sens.\u003e - valeur initiale - nombre ou expression du même type;
<fin sens.\u003e - valeur finale - nombre ou expression du même type;
<opérateur\u003e est un opérateur Pascal arbitraire.
S'il y a plusieurs opérateurs, alors, comme dans l'opérateur tandis que ... faire ..., les parenthèses d'opérateur sont utilisées: commencer ... fin.
Par exemple, les enregistrements d'opérateur de boucle suivants sont possibles:
pour i: \u003d a à b faire s1;
pour j: \u003d a à b commencez s1; s2; ..., sn fin; ou
pour k: \u003d p à m faire
commencer
s1;
s2;
...
sn
fin;
Ici s1, s2, s3, ... sn sont des opérateurs de cycle.
Lors de l'exécution de l'instruction pour l'expression est évaluée en premier<valeur de départ.\u003e et sa valeur est affectée à la variable de boucle
<cycle de vapeur> := <de bonne heure sens.>.
Après cela, ils sont répétés cycliquement:
1) vérification de l'état<cycle de vapeur> <fin sens.\u003e; si la condition n'est pas remplie, l'opérateur pour quitte;
2) exécution de l'opérateur<opérateur\u003e ou opérateurs s1; s2; s3; ... sn;
3) variable de boucle<vapeur. cycle\u003e augmente de un.
Vous devriez immédiatement remarquer qu'il est impossible de spécifier un pas de boucle autre que 1 dans cet opérateur.
Représentation graphique des cycles pour sera comme ça (voir fig.33):
Figure: 33
Ici: i est une variable de boucle; n est sa valeur initiale; k est sa valeur finale. Le corps de la boucle est constitué d'un opérateur ou de plusieurs opérateurs: s1; s2; ... sn; qui sont dessinés dans un rectangle.
Pour illustrer le travail de l'opérateur pour Prenons un exemple qui est déjà devenu traditionnel en étudiant le fonctionnement de cet opérateur.
Exemple 1. Créez un programme pour calculer la factorielle du nombre n, c'est-à-dire n!.
Rappelez-vous des mathématiques que la factorielle d'un nombre n est égale au produit des nombres de 1 à n.
Par exemple:
Z remarque . En mathématiques, il est accepté: 0! \u003d 1.
Diagramme
Figure: 34
Programme
Programme Problème1; (Calcul de la factorielle de n!)
les usages WinCrt;
var
n, f, i: entier long;
commencer
f: \u003d 1;
si n<> 0 puis pour i: \u003d 1 à n faire f: \u003d f * i;
fin.
Variable n - pour le nombre saisi par l'utilisateur, dont la factorielle doit être trouvée; f - la variable qui contiendra " accumuler"valeur de factorielle de nombre n; i - variable de boucle.
La valeur initiale de la variable f: \u003d 1 est définie.
Puis le cycle commence. La variable i reçoit une valeur initiale de 1; il est comparé au final - n (1<= n), si un la condition est vraie, puis l'opérateur est exécuté (dans ce programme il en est un): f: \u003d f * i, 1 * 1 \u003d 1; la valeur de la variable de boucle est augmentée de 1, c'est-à-dire qu'elle devient égale à: i: \u003d i + 1, 1 + 1 \u003d 2 et la boucle se répète.
Quand la valeur de i devient égale à n, puis la boucle s'exécutera pour la dernière fois, car le i suivant sera n + 1, ce qui est supérieur au n final, état je<= n - faussement, la boucle n'est pas exécutée.
2. Opérateur de boucle pour ... vers le bas ... faire ...
Il existe une autre forme d'opérateur de boucle pour:
pour<cycle de vapeur.> := <de bonne heure zn.> vers le bas <fin zn.> faire <opérateur>.
Remplacement d'un mot réservé à sur le vers le bas signifie que le pas du paramètre de boucle est (-1).
Le changement de la valeur du paramètre passe d'une valeur plus grande à une valeur plus petite, c'est-à-dire
<de bonne heure sens.> <fin sens.>.
Un programme de calcul de la factorielle d'un nombre peut être écrit à l'aide de cet opérateur de boucle.
Programme
Programme Problème1a;
les usages WinCrt;
var
n, i, f: entier long;
commencer
write ("Entrez un nombre naturel"); readln (n);
f: \u003d 1;
si n<> 0 puis pour i: \u003d n vers le bas1 faire f: \u003d f * i;
writeln ("nombre factoriel", n, "égal", f)
fin.
1. Modifiez le programme pour qu'il n'affiche pas un tableau de carrés de nombres de 1 à n, mais le carré d'un seul nombre n, entré par l'utilisateur.
2. Modifiez et complétez le programme pour qu'il affiche la valeur du carré du nombre et des nombres impairs dont il est égal à la somme.
3 ... Continuer le sujet de l'élévation des nombres naturels à une puissance,sans opérations de multiplication, considérons deux exemples plus intéressants. Dans le premier, nous devrons combiner, " investir"deux cycles l'un dans l'autre pour, et dans le second, cycles pouret répéter.
Exemple 3. Le cube de tout nombre naturel n est égal à la somme de n nombres impairs suivant dans l'ordre les nombres, dont la somme était le cube du nombre précédent n - 1:
13 = 1
23 = 3 + 5
33 = 7 + 9 + 11
43 = 13 + 15 + 17 + 19
. . . . . . . . . . . . . . . . . . . . . .
Sur la base de cette propriété, créez un programme qui imprime une table de cubes de nombres naturels.
Deux cycles sont déjà nécessaires ici. L'un est externe
, par le nombre de nombres impairs, qui est égal au nombre au cube, par exemple, pour 43 ce cycle doit être exécuté 4 fois. Dans le même cycle, après avoir calculé le montant, il sera nécessaire d'afficher sa valeur à l'écran avec le nombre qui est cube.
Le second est interne
qui additionnera les nombres impairs et " faire des exercices"les nombres impairs que vous souhaitez ajouter.
Diagramme
Figure: 36
Programme
Programme Problème3; (Cubes d'entiers naturels de 1 à n)
les usages WinCrt;
var
i, j, n, s, k: entier long;
commencer
writeln ("Entrez un nombre naturel jusqu'à lequel il est nécessaire");
write ("cubes de sortie de nombres"); readln (n);
writeln ("Les cubes de nombres sont les suivants:");
k: \u003d 1;
pour i: \u003d 1 à n faire
commencer
s: \u003d 0;
pour j: \u003d 1 à je faire
commencer
s: \u003d s + k;
k: \u003d k + 2
fin;
writeln ("Cube de nombres", i, "égal", s)
fin
fin.
Analysons le fonctionnement de ce programme
Les variables i et j sont nécessaires en tant que variables de la première boucle - externe et seconde - interne. Variable k pour les nombres impairs et s pour la somme des nombres. Le type de ces variables est défini sur entier, mais longint, car il peut y avoir des entiers assez grands supérieurs à 32767.
Le programme commence par demander à l'utilisateur utilisant writeln et write de saisir un nombre naturel, jusqu'à lequel une table de cubes de nombres doit être renvoyée. Ensuite, à l'aide de l'instruction readln, cette valeur est entrée dans la mémoire de l'ordinateur et affectée à la variable n.
L'inscription " Les cubes de nombres sont les suivants". Il est donné avant le début des boucles pour des raisons évidentes. Dans les boucles, il ne peut pas être donné - il sera répété plusieurs fois. À la fin des boucles aussi, il sera écrit en bas, après l'impression des nombres eux-mêmes. La variable k se voit attribuer la première valeur impaire 1.
La boucle externe commence sur le nombre de nombres, de 1 à n. Il y a plusieurs opérateurs dans la boucle, donc " ouvert"parenthèses d'opérateur: - commencer ...
Avant le début de la boucle interne, la variable s est mise à zéro - la somme. De plus, une telle remise à zéro se produira chaque fois que le externe
boucle avant de démarrer la boucle interne.
La boucle intérieure va de 1 à i. Pourquoi? La boucle calcule la somme et augmente les k impairs de 2, c'est-à-dire " produit"prochain nombre impair.
Remarquer!
La variable k n'est pas affectée avant le début de chaque boucle interne 1. Pourquoi?
L'instruction writeln suivante à l'intérieur de la boucle externe renvoie des informations à l'écran. Pourquoi est-il placé dans la boucle extérieure?
Exemple 4. Il est connu des mathématiques que toute puissance naturelle d'un nombre n est la somme de n nombres naturels impairs consécutifs. Écrivez un programme qui pour toute puissance d'un nombre naturel n trouverait une suite de nombres impairs dont la somme est égale à cette puissance.
Par exemple, pour 53, il produirait la séquence de nombres: 21, 23, 25, 27, 29.
Plan de programmation
1. Définissons l'objectif de l'élaboration du programme: spectacle
, qui est en réalité toute puissance naturelle d'un nombre naturel pouvez
représentent une somme de nombres impairs consécutifs.
Et si c'est le cas, il faut absolument connaître la valeur de la puissance du nombre n avec l'exposant k.
Cela peut être fait avec une simple boucle:
s: \u003d 1;
pour i: \u003d 1 à k faire s: \u003d s * n;
La valeur du degré sera accumulée dans la variable s, pour cela elle est initialisée à 1.
Dans la boucle, la valeur de s est séquentiellement multipliée k fois par la base de la puissance n. Après avoir exécuté la boucle, la variable s recevra la valeur de puissance du nombre n avec l'exposant k.
2. Toute l'acuité de la question réside dans le fait que le premier nombre impair est inconnu, à partir duquel il est nécessaire de commencer la sommation des nombres impairs consécutifs.
Pour cela, vous avez besoin essayer
ajouter les nombres impairs au début de 1 et plus (leur nombre est connu - n);
1 + 3 + 5 + 7 + 9 ...,
puis vérifier le résultat obtenu en le comparant à la valeur de la puissance s. Si l'égalité est vraie, terminez la boucle et affichez les nombres impairs résultants, si l'égalité n'est pas vraie, alors la somme doit être commencée à partir du nombre impair suivant - 3: 3 + 5 + 7 + 9 ... etc.
Ce processus est plus facile à organiser avec une boucle répéter... La variable j, qui définira les nombres impairs initiaux, doit être mise à la valeur initiale 1 avant le début du cycle.
Vue générale d'un tel cycle:
j: \u003d 1;
répéter
. . . . . .
j: \u003d j + 2
jusqu'à ce que ... \u003d s;
3. Il reste à réfléchir à la manière de calculer les sommes des nombres impairs consécutifs. Nous avons déjà rencontré cette question et nous savons que pour cela nous devons créer un cycle de 1 à n, dans lequel une des variables, disons m, accumule cette somme, et la deuxième variable doit " faire des exercices"prochain nombre impair.
Ce cycle peut être écrit comme ceci:
p: \u003d j; m: \u003d 0;
pour i: \u003d 1 à n faire
commencer
m: \u003d m + p;
p: \u003d p + 2
fin;
Remarque!
Variable p, à chaque cycle répéter, (externe à celle donnée), recevra une nouvelle valeur initiale d'un nombre impair, et la variable m pour la somme doit être remise à zéro avant chaque nouvelle sommation pour une autre séquence de nombres impairs.
4. Enfin, lorsqu'une séquence de nombres impairs est trouvée, elle doit être affichée. Pour ce faire, vous devez organiser un autre cycle de 1 à n, dans lequel les valeurs de ces nombres impairs doivent être sorties. Pour le premier nombre impair de la séquence, nous devons prendre la valeur j, mais comme elle a déjà augmenté de 2, alors 2 doit être soustrait de j. Ce cycle sera:
j: \u003d j - 2;
pour i: \u003d 1 à n faire
commencer
écrire (j, "");
j: \u003d j + 2
fin
Diagramme
Riz
. 37
Programme
Programme Problème4;
les usages WinCrt;
var
n, i, k, j, m, s, p: entier long;
commencer
write ("Entrez un nombre naturel - la base du degré"); readln (n);
write ("Entrez un nombre naturel - exposant"); readln (k);
s: \u003d 1; j: \u003d 1;
pour i: \u003d 1 à k faire s: \u003d s * n;
répéter
p: \u003d j;
m: \u003d 0;
pour i: \u003d 1 à n faire
commencer
m: \u003d m + p;
p: \u003d p + 2
fin;
j: \u003d j + 2
jusqu'à ce que m \u003d s;
write ("Degré avec base", n);
writeln ("et indicateur", k, "ie", s);
writeln ("est égal à la somme des prochains nombres impairs");
j: \u003d j - 2;
pouri: \u003d 1 à n faire
commencer
écrire (j, "");
j: \u003d j + 2
fin
fin.
Pour mieux comprendre comment cela fonctionne, prenez un degré de 25 et vérifiez comment les instructions du programme sont exécutées séquentiellement.
1 ... Exécutez ce programme sur les ordinateurs.
2
... Créez un organigramme et un programme qui déterminent si le travail peut
a) trois; b) quatre nombres naturels consécutifs égaux à une puissance d'un certain nombre naturel (carré, cube, etc.)?
4. Différentes tâches
Exemple 5. Imprimez tous les nombres à quatre chiffres qui n'ont pas deux chiffres identiques dans leur notation décimale.
Commentaire ... Avant de commencer à élaborer un organigramme de cette tâche, vous devez savoir comment les boucles sont représentées dans les boucles pour les boucles avec des paramètres. La construction générale de deux boucles imbriquées avec des paramètres sera la suivante:
Figure: 38
L'idée surgit immédiatement de rédiger un programme selon le schéma suivant:
organiser cycle par le nombre de milliers, t de 1 à 9, puis interne cycles: par le nombre de centaines, s de 0 à 9; par le nombre de dizaines, d de 0 à 9; par le nombre d'unités, e de 0 à 9; vérification de l'état: si un les chiffres sont différents, puis afficher le numéro à quatre chiffres qui en est composé.
Diagramme
Figure: 39
Programme
Programme Problème5; (1ère méthode)
les usages WinCrt;
var
t, s, d, e: entier;
commencer
pour t: \u003d 1 à 9 faire
pour s: \u003d 0 à 9 faire
pour d: \u003d 0 à 9 faire
pour e: \u003d 0 à 9 faire
si (t<> s) et (t<> ré) et (t<> e) et (s<> ré) et
(s<> e) et (ré<> e)
puis écrire (t * 1000 + s * 100 + d * 10 + e, "")
fin.
Il est clair que ce programme a été exécuté de manière irrationnelle. Dans celui-ci, tous les cycles sont effectués complètement.
Le programme peut être amélioré de cette manière. Lorsqu'un cycle de centaines est effectué, alors le prochain cycle de dizaines doit être démarré, si un
le chiffre des centaines de s n'est pas égal au chiffre des milliers de t, sinon, autrement
, le cycle des centaines doit être poursuivi, c'est-à-dire prendre le chiffre suivant des centaines.
Pour le chiffre des dizaines, définissez également la condition selon laquelle le prochain cycle de uns sera exécuté, si un
le chiffre des dizaines d n'est pas égal au chiffre des centaines et des milliers, sinon, autrement
, il est nécessaire de passer au chiffre suivant de dizaines.
Puis, " à l'intérieur"le cycle d'unités suffit pour noter la condition, si un
chiffres d'unité e pas égal à des dizaines ré, des centaines s et des milliers t,puis le numéro à quatre chiffres est le numéro souhaité et il est affiché à l'écran.
Diagramme
Riz . 40
Programme
Programme Problem5a; (2ème méthode)
les usages WinCrt;
var
t, s, d, e: entier;
commencer
writeln ("Tous les nombres à quatre chiffres de différents chiffres");
pour t: \u003d 1 à 9 faire
pour s: \u003d 0 à 9 faire si s<> t puis
pour d: \u003d 0 à 9 faire si (ré<> s) et (ré<> t) puis
pour e: \u003d 0 à 9 faire
si (e<> ré) et (e<> s) et (e<> t)
puis écrire ((((t * 10 + s) * 10 + d) * 10) + e, "")
fin.
Mission 4
1. Ajoutez et modifiez ce programme pour qu'il affiche à l'écran non seulement différents numéros à quatre chiffres, mais également leur numéro.
2. En multipliant un nombre à quatre chiffres, composé de chiffres différents, par 9, un nombre dans le produit a été obtenu, qui ne différait du nombre multiplicable qu'en ce qu'il y avait zéro entre les chiffres des milliers et des centaines. Trouvez le multiplicateur. Élaborez un organigramme et un programme.
Exemple 6. Les triplets de nombres naturels a, b, c satisfaisant l'égalité: - sont appelés nombres de Pythagore.
Par exemple, 3, 4 et 5 sont des nombres de Pythagore car
Créez un programme pour rechercher et imprimer tous les nombres de Pythagore ne dépassant pas 20.
Le calcul derrière cette question est simple. Pour les nombres a, b et c, les valeurs possibles sont des nombres naturels de 1 à 20.
La valeur initiale de a est un, a \u003d 1. Voyons toutes les valeurs possibles de b de 1 à 20, ainsi que les valeurs de c de 1 à 20, et vérifions si l'égalité a a + b b \u003d c c est satisfaite. Une fois que l'égalité est satisfaite, imprimez les valeurs de a, b et c.
Ensuite, vous devez prendre la valeur a \u003d 2 et vérifier les valeurs de b de 2 à 20. Pourquoi pas de 1, mais de 2? Parce que l'ensemble de deux nombres de 1 et 2 a déjà été considéré pour les valeurs a \u003d 1 et b \u003d 2, afin de ne pas répéter les valeurs de a et b, c'est-à-dire éviter l'apparition de deux paires de nombres identiques, les valeurs de b doivent commencer à être scannées ou jusqu'à ce que la valeur une ou de une jusqu'à 20.
À cet égard, il existe plusieurs manières d'organiser des boucles pour les variables a et b.
1ère voie:
pour a: \u003d 1 à 20 faire
pour b: \u003d a à 20 faire
2ème voie:
pour a: \u003d 20 vers le bas 1 faire
pour b: \u003d 1 à une faire
3ème voie:
pour a: \u003d 1 à 20 faire
pour b: \u003d 1 à une faire
Il est facile de voir que dans chacune de ces manières, les paires de nombres ne seront pas répétées. Vérifiez-le vous-même.
Pour les valeurs de c, nous devons vérifier tous les nombres naturels de 1 à 20 pour chaque paire de nombres a et b. Donc, la boucle pour c devrait être comme ceci: pour c: \u003d 1 à 20 faire
Diagramme
Riz . 41
Programme
Programme Problème6;
les usages WinCrt;
var
a, b, c: entier;
commencer
writeln ("Triples de nombres de Pythagore de l'intervalle");
pour a: \u003d 1 à 20 faire
pour b: \u003d 1 à une faire
pour c: \u003d 1 à 20 faire
si a * a + b * b \u003d c * c puis writeln (a, "", b, "", c)
fin.
1. Créez un organigramme et un programme qui trouve toutes les solutions à l'équation où n est un nombre donné de l'intervalle.
2. Trouvez tous les nombres naturels x à partir de l'intervalle pour lequel l'expression est le carré d'un entier naturel.
Exemple 7. De combien de façons un nombre naturel donné n peut-il être représenté comme la somme de deux cubes de nombres naturels:
Réorganiser les termes ne donne pas une nouvelle méthode. L'opération de montée à la puissance 1/3 ne peut pas être utilisée.
L'idée simple suivante de créer un programme apparaît immédiatement.
Organisez deux boucles, l'une est une boucle externe avec la variable i de 1 à n, et la seconde est une boucle interne passant par j, également de 1 à n.
L'essence du programme sera la suivante:
la première valeur de i est égale à 1, elle est multipliée trois fois par elle-même (cela remplace l'élévation à la 3ème puissance);
puis " surmonter"toutes les valeurs de j de 1 à n, dont chacune est également multipliée trois fois par elle-même et ajoutée à la valeur de i i i, c'est-à-dire i dans un cube;
en outre, cette somme est vérifiée si elle est égale à la valeur de n, si l'égalité est satisfaite, alors le compteur connu dans le programme est augmenté de 1, et les valeurs de i et j peuvent être affichées;
la boucle sur i continue, i prend la deuxième valeur - 2 et la boucle interne sur j de 1 à n recommence et ainsi de suite.
Si nous élaborons un programme selon ce plan, alors il aura deux inconvénients importants:
1) beaucoup de travail inutile est en cours - les deux cycles sont organisés de 1 à n, et parmi eux il y en a beaucoup inutiles (il suffit de prendre des valeurs de 1 à la racine cubique de n);
2) le programme renverra les valeurs obtenues en réorganisant les termes, par exemple: 2 2 2 + 3 3 3 \u003d 35 et 3 3 3 + 2 2 2 \u003d 35, ce qui est invalide selon l'énoncé du problème. Comment éliminer ces inconvénients?
Le premier inconvénient peut être éliminé si nous découvrons d'abord combien de valeurs pour chacun des nombres doivent être considérées pour que l'inégalité
Pour ce faire, vous pouvez organiser une boucle avec une précondition, une boucle " jusqu'à ce que
", dans lequel inclure un compteur - k, qui compterait combien de fois une telle boucle sera exécutée.
Vous pouvez le faire comme ceci:
k: \u003d 0; i: \u003d 1;
tandis que i * i * i + 1<= n faire
commencer
k: \u003d k + 1;
i: \u003d i + 1
fin;
Vous pouvez désormais réduire considérablement le nombre de cycles pour " sujets de test"nombres et les disposer de 1 à k, car pour i valeurs supérieures à k, même avec la plus petite valeur de j (j: \u003d 2), l'inégalité i i i + 1<=n не выполняется.
Pour éliminer le deuxième inconvénient, c'est-à-dire pour ne pas émettre d'options avec permutation de termes, vous pouvez effectuer les opérations suivantes:
arrangez la boucle extérieure sur i du premier nombre de k à 1, et faites la boucle intérieure pour le deuxième nombre sur j de 1 à i. Vous obtenez cette partie du programme:
p: \u003d 0;
pour i: \u003d k vers le bas 1 faire
pour j: \u003d 1 à je faire
si i * i * i + j * j * j \u003d n
puis
commencer
p: \u003d p + 1;
fin;
Comprenez bien cette partie du programme et réfléchissez à pourquoi dans ce cas nous évitons de répéter des variantes et d'exclure les cas de permutation de termes?
La gauche belle terminer le programme. En effet, très souvent, il y aura des cas où un nombre ne peut pas du tout être représenté comme la somme de cubes de deux nombres. Cette circonstance doit également être prise en compte.
Pour ce faire, après avoir terminé toutes les boucles, nous introduisons un opérateur conditionnel, dans lequel, en fonction des valeurs du compteur p, les messages correspondants seront affichés.
Si un
p \u003d 0, puis
émettre un message indiquant qu'un nombre ne peut pas être représenté comme une somme de cubes de deux nombres, et autrement, émettez un message sur le nombre de façons.
Cette partie du programme peut être réalisée comme ceci:
si p \u003d 0
puis
commencer
fin
autre
Diagramme
Riz
. 42
Programme
Programme Problème 7;
les usages WinCrt;
var
i, j, n, k, p: entier long;
commencer
write ("Entrez un nombre naturel"); readln (n);
k: \u003d 0; i: \u003d 1;
tandis que i * i * i + 1<= n faire
commencer
k: \u003d k + 1; i: \u003d i + 1
fin;
p: \u003d 0;
pour i: \u003d k vers le bas 1 faire
pour j: \u003d 1 à je faire
si i * i * i + j * j * j \u003d n
puis
commencer
p: \u003d p + 1;
writeln (i, "*", i, "*", i, "+", j, "*", j, "*", j, "\u003d", n)
fin;
si p \u003d 0
puis
commencer
write ("Number", n, "ne peut pas être représenté par");
writeln ("somme de cubes de deux nombres")
fin
autre writeln ("Le nombre de chemins est égal à", p)
fin.
Une autre solution à ce problème
Programme Problème7b;
les usages WinCrt;
étiquette1, 2;
var
i, j, m, k, n: entier long;
commencer
write ("Entrez un nombre naturel"); readln (n);
m: \u003d 0; i: \u003d 1; j: \u003d 1;
tandis que j * j * j + 1< n faire j: \u003d j + 1;
répéter
k: \u003d i * i * i + j * j * j;
si k \u003d n puis m: \u003d m + 1;
si k<= n puis i: \u003d i + 1;
si k\u003e \u003d n puis j: \u003d j - 1;
jusqu'à ce que i\u003e j;
si m \u003d 0 ensuite aller à 1;
write ("Number", n, "peut être représenté comme une somme");
writeln ("cubes de deux nombres", m, "voies"); goto 2;
1: write ("Ce nombre n'est pas représentable");
writeln ("la somme des cubes de deux nombres");
2: fin.
Étant donné le n naturel. N peut-il être représenté comme la somme de trois carrés d'entiers naturels? Si possible, alors indiquez tous les triplets x, y, z de tels nombres naturels que la permutation des termes ne donne pas une nouvelle voie. Élaborez un organigramme et un programme.
5. Conversion de type
Exemple 8. Un nombre décimal à deux chiffres ajouté au nombre écrit dans les mêmes chiffres, mais dans l'ordre inverse, donne un carré complet. Trouvez tous ces nombres.
Soit le nombre à deux chiffres requis \u003d a 10 + b, puis le nombre écrit dans les mêmes chiffres, mais dans l'ordre inverse, sera \u003d b 10 + a, par exemple, 12 et 21, 13 et 31, etc.
La somme de ces nombres doit donner un carré complet, c'est-à-dire carré exact des nombres entiers. Comment puis-je vérifier cela?
Le contrôle pourrait être fait comme ceci: extraire la racine carrée de la somme résultante; puis arrondissez le résultat à un entier, puis multipliez le résultat par vous-même, si la somme de ces nombres est obtenue à nouveau, alors c'est un carré exact ou parfait.
Par exemple, 12 + 21 \u003d 33, on prend la racine carrée de 33, c'est 5,74 ...; rond, ce sera 6; multipliez 6 par lui-même et obtenez 36.
Nous n'avons pas obtenu le résultat original, donc la somme de 33 n'est pas un carré exact.
Un autre exemple pour que vous compreniez l'idée de la solution. Soit 29 le nombre à deux chiffres, puis le nombre écrit dans les mêmes chiffres, mais dans l'ordre inverse - 92, au total ils donnent 121. Nous extrayons la racine carrée de 121 et obtenons 11. En multipliant 11 par lui-même, nous obtenons à nouveau 121. Nous concluons que nous avons obtenu un carré exact, ce qui signifie que le nombre à deux chiffres 29 est celui souhaité.
Pour composer un programme selon ce principe, vous devez extraire la racine carrée de la somme, ce qui peut être fait en utilisant la fonction standard sqrt (x). Le résultat de la fonction sqrt (x) est un nombre réel, il doit être arrondi ou la partie fractionnaire supprimée, et nous ne savons pas comment faire cela.
Mais, plus important encore, c'est que si la racine carrée de l'ensemble des entiers est extraite entièrement, comme pour 121 (elle est égale à 11), alors sur l'ensemble des nombres réels nous n'obtiendrons pas strictement le nombre 11, et le résultat sera très proche de 11 et après la multiplication en elle-même ne fonctionne toujours pas 121, c'est-à-dire Il y a un besoin transformer
valeur réelle en entier.
Nous avons donc deux tâches: 1) comprendre comment arrondir les nombres et; 2) Découvrez comment convertir un type réel en entier.
Pour cela, Pascal dispose des fonctions standard round (x) et trunc (x)
Fonctions standard rond et tronc sont destinés à remplacer les valeurs de type réel par des valeurs de type entier.
Fonction rond(x) arrondit un nombre réel x à un entier - sa valeur est l'entier le plus proche:
rond(4.2) = 4, rond(4.7) = 5, rond(4.5)=5,
rond(-4.2) = -4, rond(-4.7) = -5, rond(-4.5) = -5.
Fonction tronc(x) élimine (sans arrondir) la partie fractionnaire du nombre réel x:
tronc(1.2) = 1, tronc(5.8) = 5, tronc(-1.2) = -1,
tronc(-5.8) = -5, tronc(-6.7) = -6, tronc(8,9) = 8
Les fonctions d'arrondi sont liées comme suit:
tronc(x + 0,5) \u003d rond(X), si un
x 0,
tronc(x - 0,5) \u003d rond(X), si un
X< 0.
Ainsi, dans le programme, vous pouvez utiliser l'une de ces fonctions. Laquelle? Pensez par vous-même et essayez d'abord d'utiliser la fonction du programme troncpuis remplacez-le par rond et comparez les résultats.
- Pour quelle valeur naturelle de a le nombre a2 + a + 1589 sera-t-il un carré exact?
- Trouvez un nombre parfait de la forme 16p.
- Trouvez deux nombres si la somme de leurs carrés est 468 et la somme de leur plus grand diviseur commun et du plus petit multiple est 42.
L'instruction de boucle for implémente une structure algorithmique boucle avec paramètre (ou une boucle avec un compteur). La boucle for est utilisée lorsque dans le programme, avant d'exécuter les instructions de boucle, le nombre d'étapes de cette boucle devient connu (ou prédéterminé). Dans le diagramme, l'instruction for est représentée comme suit:
Syntaxe:
Pour ( initialisation; état; modification) (Instructions du corps de la boucle;)
S'il y a une instruction dans le corps de la boucle, alors () peut être omis. La variable de paramètre de boucle (compteur) peut être de n'importe quel type numérique. Cela rend une boucle for C ++ aussi polyvalente qu'une boucle while. Dans la section modification, l'opération la plus couramment utilisée est l'incrémentation (ou décrémentation) du suffixe ou du préfixe, mais toute expression d'affectation qui modifie la valeur d'un paramètre de boucle peut être utilisée. La boucle fonctionne comme ceci:
- Au début, il y a une description et une initialisation de la variable de compteur
- Ensuite, vérifiez la condition: si l'expression a une valeur vrai, l'itération se produira
- Après avoir exécuté les instructions du corps de la boucle, la valeur du compteur est modifiée
Remarque: en C ++ c'est une règle pour décrire la variable compteur dans l'en-tête de la boucle. Mais ce n'est pas nécessaire, surtout si vous prévoyez d'initialiser plusieurs variables dans la section d'initialisation telle qu'elle est implémentée dans le programme 9.2. Cependant, l'utilisation de la description d'une variable de compteur dans l'en-tête d'une boucle aboutit à une description d'une variable locale qui est automatiquement détruite à la fin de la boucle. Par conséquent, sauf si c'est absolument nécessaire, vous ne devez pas décrire la variable de compteur en dehors de la boucle for.
Pendant que la boucle for est en cours d'exécution, il n'est pas recommandé de changer les opérandes dans les expressions d'en-tête de boucle - cela entraînera toutes sortes d'erreurs! Mais les valeurs des variables (ou constantes) elles-mêmes, y compris les valeurs des variables (compteur), peuvent être utilisées. Regardons un exemple classique.
Programme 9.1 On donne un entier naturel N. Imprimez tous les diviseurs de ce nombre.
#comprendre
Utilisation d'une instruction continue dans une boucle for
Lors de l'utilisation de l'instruction continue dans une boucle for, il est nécessaire de prendre en compte les particularités de cette boucle:
- Les instructions qui suivent continuer seront ignorées
- Puis le compteur est modifié
- Passer à l'itération suivante (sinon, vérifiez la condition)
Montrons cela avec un exemple: int main () (for (int i \u003d 1; i< 20; i++) { if (i % 2 == 0) continue; cout << i << " "; } 1 3 5 7 9 11 13 15 17 19
Remarque... Remarque: bien que la sortie des nombres par condition soit ignorée, l'incrément du compteur est effectué. Cet exemple est juste pour l'illustration, vous ne devriez pas programmer une boucle comme ça! Il est préférable de résoudre ce problème comme suit:
Int main () (pour (int i \u003d 1; i< 20; i += 2) cout << i << " ";
Plusieurs expressions dans la section d'initialisation et de modification
Comme nous l'avons noté précédemment, il devrait y avoir trois sections dans l'en-tête de l'instruction for. Les expressions de ces sections peuvent être omises, mais ";" ... En fin de compte, vous ne pouvez que partir; ... Un en-tête sous la forme:
Pour (;;) (...)
est le cap d'une boucle «sans fin». (La sortie de la boucle doit être programmée à l'intérieur du corps de la boucle).
C ++ prend en charge plusieurs expressions dans les sections d'initialisation et de modification de l'en-tête de l'instruction for. Dans ce cas, la condition pour continuer le cycle doit être la même!
Par exemple. Énoncé du problème: Calculez la factorielle d'un nombre ne dépassant pas 20.
Programme 9.2
#comprendre
Remarque: notez que le flux de sortie sur la ligne 12 n'est pas le corps de la boucle! (À la fin du titre -;). Ainsi, cette boucle dans le corps a une instruction vide et toutes les expressions sont évaluées dans l'en-tête. Le programme 9.2 calcule correctement la factorielle d'un nombre compris entre 0 et 20.
Boucle for basée sur la plage
Pour parcourir les éléments d'un tableau ou d'un conteneur, vous devez effectuer le même type d'actions, tout en utilisant un code lourd. Pour simplifier l'utilisation des conteneurs en C ++, il existe une forme spéciale de la boucle for - basée sur la plage pour (boucle pour gamme basée ou une plage pour).
Syntaxe:
Pour ( un d : nom_séquence) loop_statement
Utilisation de la plage basée sur l'exemple d'un tableau C:
Programme 9.3
#comprendre
Pour que les éléments du tableau soient modifiés, la variable s doit être une variable de référence (comme dans l'exemple ci-dessus). Si la variable n'est pas une référence, les données seront copiées. Le spécificateur automatique est utilisé pour l'inférence de type automatique dans cette boucle. basé sur plage pour a une limitation sur le travail avec des tableaux dynamiques: il ne prend pas en charge le redimensionnement d'un tableau, car il contient un pointeur fixe vers la fin du tableau. Lorsque vous travaillez avec des baies de taille fixe, une plage pour est une excellente alternative sûre à la norme pour.
Nested for boucles
Comme les autres instructions de boucle, for prend en charge une structure de boucle imbriquée. L'utilisation de boucles for imbriquées pour organiser l'entrée et la sortie de tableaux à deux dimensions est beaucoup plus compacte que l'utilisation d'une boucle while.
Cependant, lors de la résolution des problèmes de traversée de tels tableaux, vous devez éviter d'utiliser l'instruction conditionnelle if. Souvent, la tâche peut être mise en œuvre de manière plus rationnelle en manipulant des indices (variables de boucle i et j). C'est-à-dire que le changement d'un indice dépend de la valeur d'un autre. Regardons deux exemples.
Programme 9.4 On vous donne une matrice carrée de taille n, dont les éléments sont égaux à 0. Remplissez les éléments situés en dessous et sur la diagonale principale avec des uns.
#comprendre
Programme 9.5 Créez un programme pour remplir un tableau avec des nombres du triangle de Pascal et sortir ce tableau. Le triangle de Pascal est: 
Dans ce triangle, il y a des unités au sommet et sur les côtés (dans le programme 9.5, le triangle est «posé sur son côté» - les côtés du triangle: la première colonne et la diagonale principale). Chaque nombre est égal à la somme des deux nombres au-dessus. Les lignes du triangle sont symétriques par rapport à l'axe vertical et contiennent des coefficients binomiaux.
#comprendre
Des questions
- Une instruction de boucle for peut-elle être remplacée par une instruction de boucle while dans un programme? Cela peut-il toujours être fait?
- Quand est-il plus pratique d'utiliser l'instruction for pour organiser les boucles? tandis que?
- Les expressions suivantes sont-elles possibles dans l'en-tête de l'instruction for: a) for (; a\u003e b &&! (A% 2);) b) for (a\u003e b ;;) c) for (;; i \u003d 0) d) for ( ; i \u003d 0;) e) pour (;; i ++, --b) f) pour (--i ;;) g) pour (b \u003d 0; b! \u003d a;)?
- La variable i est le paramètre de la boucle externe et j est la boucle imbriquée. J sera-t-il disponible dans la boucle externe? je dans une boucle imbriquée?
Cahier de texte
devoirs
- Arrière. 29. Ecrire un programme dans lequel des nombres naturels sont saisis une et b, et l'écran affiche tous les nombres premiers dans la plage de une avant b (Idée d'algorithme Programme 8.5)
- Arrière. 30. Parfait est un nombre égal à la somme de tous ses diviseurs inférieurs à lui-même (par exemple, le nombre 6 \u003d 1 + 2 + 3). Écrivez un programme qui entre un nombre naturel N et détermine si N est parfait.
- Écrivez un programme qui imprime un tableau numérique carré nxn qui ressemble à ceci pour n \u003d 10: 1 * * * * * * * * * * 2 * * * * * * * * * * 3 * * * * * * * * * * 4 * * * * * * * * * * 5 * * * * * * * * * 6 * * * * * * * * * * 7 * * * * * * * * * * 8 * * * * * * * * * * 9 * * * * * * * * * * 10
Littérature
- Laforêt R. Programmation orientée objet en C ++ (4e éd.). Pierre: 2004
- Prata, Stephen. Langage de programmation C ++. Conférences et exercices, 6e éd.: Per. de l'anglais - M.: LLC "I.D. Williams ", 2012
- Lippmann B. Stanley, Josie Lajoye, Barbara E. Mu. Langage de programmation C ++. Cours de base. Ed. 5ème. M: LLC «I. D. Williams », 2014
- Ellain A. C ++. Du lamer au programmeur. SPb.: Peter, 2015
- Schildt G. C ++: Cours de base, 3e éd. M.: Williams, 2010
L'opérateur de boucle avec un paramètre est utilisé précisément dans de tels cas où il est nécessaire d'organiser une boucle avec un nombre donné de répétitions.
pour <параметр_цикла>:=<начальное_знач> à <конечное_знач> faire <оператор>;
pour <параметр_цикла>:=<конечное_знач> vers le bas <начальное_зна.> faire <оператор>;
L'opérateur représentant le corps de la boucle peut être simple ou composé.
Le paramètre de boucle et sa plage ne peuvent être que de type entier ou énuméré.
Le paramètre est décrit avec d'autres variables.
Le pas de la boucle for est toujours constant et vaut "1" ou "-1".
Afficher les dix premiers entiers positifs
var i: entier; // entrer le compteur
fori: \u003d 1to10do // tant que le compteur est compris entre 1 et 10, procédez comme suit
writeln (i); // affiche la valeur du compteur
vari, somme: entier;
somme: \u003d 0; // remise à zéro de la valeur de la variable
fori: \u003d 10to99do // itérer sur des nombres positifs à deux chiffres
si i mod 3 \u003d 0 alors // multiplicité 3
somme: \u003d somme + i; // la somme de la valeur précédente de la variable et du nombre correspondant à la condition
Afficher le produit des dix premiers nombres pairs positifs
vari, pr: entier;
pr: \u003d 1; // lors de la recherche du produit, la valeur initiale de la variable n'est pas 0, mais 1
pour i: \u003d 1 à 10 faire
si i mod 2 \u003d 0 alors // définition de parité
On vous donne deux entiers A et B (A< B). Вывести в порядке возрастания все целые числа, расположенные между A и B (в том числе A и B), a также количество N этих чисел .
var i, pr: entier;
k: \u003d 0; // zéro la valeur de la variable représentant la quantité
fori: \u003d AtoBdo // itérer sur les nombres d'une plage donnée
writeln (i); // sortie en nombres dans l'ordre croissant
k: \u003d k + 1; // compter le nombre de nombres
writeln (k); // la sortie de la quantité se produit en dehors de la boucle, puisque affiché une fois
Entrez N nombres différents. Trouvez la moyenne arithmétique de tous les nombres.
Var n, i, a: entier;
Pour i: \u003d 1 à N faire
Writeln ("moyenne arithmétique \u003d", s / n: 4: 2);
Opérateur de boucle avec un temps ... Faire une précondition (pour l'instant ...)
L'opérateur while ... do est conçu pour implémenter des boucles avec une condition préalable.
La condition d'exécution du corps de la boucle while est vérifiée avant le début de chaque étape. Par conséquent, si la condition n'est pas immédiatement remplie, le corps de la boucle est ignoré et le contrôle est transféré à l'opérateur immédiatement après le corps de la boucle.
Appeler l'opérateurtout faire se traduit par "bye ... do" et ressemble à ceci:
tandis que <условие> faire <оператор>
La boucle while implique l'algorithme suivant: tant que la condition est vraie, les instructions du corps de la boucle sont exécutées.
La condition elle-même peut être une constante booléenne, une variable ou une expression booléenne.
Gardez à l'esprit les points suivants lors de l'écriture de boucles préconditionnées.
pour que la boucle ait une chance de se terminer un jour, le contenu de son corps doit nécessairement affecter la condition de la boucle.
la condition doit être constituée d'expressions et de valeurs valides définies avant la première exécution du corps de la boucle.
Si la condition de boucle est fausse, la boucle ne sera jamais exécutée!
expression1 et en expression2 - la valeur initiale et finale du paramètre de cycle.
L'action de l'opérateur de cycle de type pour (comptage direct):
2. la condition est vérifiée: la valeur de la variable est-elle supérieure à la valeur de expression2?
3. si oui, le cycle s'arrête; sinon, alors l'opérateur est exécuté, la valeur de la variable est augmentée de un, puis l'action est répétée à partir du point 2.
L'action d'un opérateur de boucle de type downto (compte à rebours):
1.la variable reçoit la valeur de expression1;
2. la condition est vérifiée: la valeur de la variable est-elle inférieure à la valeur de expression2?
3. si oui, le cycle s'arrête; sinon, alors l'opérateur est exécuté, la valeur de la variable est diminuée de un, puis l'action est répétée à partir du point 2.
Règles:
1. Paramètre de cycle il ne peut y avoir qu'une variable entière.
2. Paramètre de boucle ne peut pas être modifié explicitement dans le corps de la boucle.
Par exemple:
pour i: \u003d 1 à 10 faire
i: \u003d i + 1; (faux)
3. Le pas de la boucle ne peut être que +1 (boucle avec to) ou –1 (boucle avec downto).
4. Conformément à la vue générale, le corps de la boucle doit être constitué d'un seul opérateur, s'il y a plusieurs opérateurs, nous utilisons un opérateur composé et des crochets d'opérateur begin..end;.
5. Le cycle peut ne pas être exécuté une seule fois.
La tâche: Rédigez un organigramme et un programme pour calculer la moyenne de n nombres saisis à partir du clavier.
var i, n: entier; x, s: réel;
écrivez («Entrez le nombre de nombres»);
pour i: \u003d 1 à n faire
écrire («Entrer le numéro», i);
writeln («Moyenne \u003d», s / n);
Opérateur de boucle avec précondition (while)
Instruction de boucle While Est un opérateur de boucle avec un nombre de répétitions inconnu auparavant.
Forme générale:
tandis que l'expression booléenne do statement;
expression booléenne est la condition pour continuer le cycle.
| opérateur |
Action de l'opérateur:
1. une expression logique est calculée;
2. s'il est vrai, alors l'opérateur est exécuté, après quoi toutes les actions sont répétées à partir du point 1;
3. Si l'expression booléenne est fausse, la boucle est terminée.
Règles:
1. Le corps de la boucle doit être composé d'un seul opérateur, s'il y en a plusieurs, nous utilisons un opérateur composé.
2. Puisque la condition est vérifiée au début du cycle, le cycle peut ne pas être exécuté une seule fois.
3. Pour que la boucle ne devienne pas infinie, les valeurs de l'expression logique doivent changer dans le corps de la boucle.
Par exemple:
tandis qu'un<100 do
La tâche.Ecrivez un diagramme et un programme qui calcule et imprime un tableau de valeurs de fonction.
var x, xn, xk, y, h: réel;
writeln ("Entrez la valeur de début, de fin x et l'étape de changement x");
writeln ("| x | y |");
tandis que x<=xk do
writeln ("|", x: 7: 2, "|", y: 7: 2, "|");
Opérateur de boucle avec postcondition (boucle répétée..jusqu'à).
Répétition de l'opérateur de boucle ... jusqu'à est un opérateur de boucle avec un nombre de répétitions inconnu auparavant.
Forme générale:
les opérateurs;
jusqu'à expression booléenne;
L'action de l'opérateur de boucle se répète ... jusqu'à:
Les instructions dans le corps de la boucle sont exécutées tant que la valeur de l'expression logique est FALSE; dès que l'expression logique est évaluée à TRUE, l'exécution de l'instruction de boucle est terminée.
Règles:
1. Le corps de la boucle est toujours exécuté au moins une fois, puisque la condition est à la fin de la boucle.
2. Il n'y a pas besoin d'une instruction composée dans cet opérateur de boucle, toutes les instructions du corps de la boucle sont limitées aux mots-clés repeat..until.
La tâche.Rédiger un organigramme et un programme pour calculer 
.
programme rep_unt;
var n, k, s: entier;
write ("Enter k");
écrire ("Summarable", s);
Tableaux de données
Tableau Est une collection de données ordonnées qui ont le même nom et le même type, et diffèrent les unes des autres par un nombre (index). Les tableaux sont unidimensionnels et multidimensionnels. Exemples de tableaux:
2 5 –15 10 20 - tableau de type entier avec 6 éléments;
2,3 9 2,45 4,78 5,32 - tableau de type réel avec 5 éléments;
Ivanov Ivan Ivanovich - un tableau de caractères de 20 éléments;
Vue générale de la description des tableaux unidimensionnels:
var nom du tableau: tableau [valeur d'index de début .. valeur d'index de fin] de type;
où valeur d'index initiale et valeur d'index finale - valeurs entières spécifiant la plage de l'index du tableau.
Par exemple:
vecteur var: tableau de réels;
Vue générale de la description des tableaux multidimensionnels:
var nom du tableau: tableau [valeur d'index de début .. valeur d'index de fin, ..., ...] de<тип>;
Par exemple:
varmatrix: tableau d'entiers; - description de la matrice de taille 3´5.
Accès aux éléments du tableau.
Vous pouvez faire référence aux éléments d'un tableau en spécifiant son nom et en listant les valeurs de son index entre crochets (dans des tableaux multidimensionnels séparés par des virgules).
Seules les valeurs constantes entières peuvent être utilisées comme index.
Par exemple:
a [i], b, v1, a
BASE DE DONNÉES
Concept de base de données
Les ordinateurs ont été conçus à l'origine pour résoudre tâches informatiquesCependant, au fil du temps, ils ont commencé à être de plus en plus utilisés pour construire systèmes de traitement de documents, ou plutôt, les informations qu'ils contiennent. De tels systèmes sont appelés information... Un exemple est les systèmes comptabiliser le volume de travail effectué dans l'entreprise, paie, comptabilité des stocks, livres de comptabilité dans la bibliothèque etc.
Cette sorte système d'Information nécessite une création dans la mémoire de l'ordinateur mis à jour dynamiquement modèle du domaine en utilisant un référentiel unique - base de données (DB). Domaine - une partie du monde réel à étudier dans le but d'organiser le contrôle et, in fine, l'automatisation. Chaque domaine comprend un ensemble de objets... Groupes de ces objets, unis par tout attribut de regroupement, il est d'usage d'appeler entités ... Par exemple, si nous parlons de comptabiliser les produits dans un entrepôt, vous pouvez sélectionner des entités " produit", "acheteur", "lettre de voiture". Les objets seront leurs représentants spécifiques, par exemple sucre, JSC "Gefest", lettre de voiture n ° 252.
Base de données - il s'agit d'une collection d'informations sur de vrais objets, processus ou phénomèneslié à certains domaine, organisé de manière à fournir une représentation (accès, affichage) pratique de cet ensemble, à la fois dans son ensemble et dans une partie de celui-ci.
Magasins d'informations dans base de données sont les tables , chacun contenant des informations sur le même type objets (combiné attribut de regroupement) formant essence... Chaque ligne les tables inclut des données sur un objet, exemple entités (par exemple, marchandise, l'acheteur, aérien), et colonnes les tables contiennent diverses caractéristiques de ces objets - les attributs (par exemple, noms de produits, noms des acheteurs et numéros de facture).
En termes de bases de données cordes les tables sont appelées records et elle colonnes – marges ... Tout records ont la même structure - ils se composent de la même des champs , qui stockent des valeurs différentes les attributs objet. Chaque dossiers utiles contient une caractéristique objet et a un strictement défini type de données(par exemple, chaîne de texte, nombre, date). Tous les enregistrements de la même table ont le même des champs, seulement ils contiennent des valeurs différentes les attributs.
Avant de saisir des données dans les tables, vous devez définir structure celles-ci les tables... Cela signifie la description titres et types de champs, ainsi qu'un certain nombre d'autres caractéristiques (par exemple, taille du champ, critères de validation d'entrée). Un exemple de définition de la structure d'une table client est illustré à la figure 8.1.
La structure de la table "Acheteur".
Outre la description les structures tables dans un cadre assez complexe base de données besoin de définir connexionsentre les tables. la communication Est une association établie entre deux les tables... Par exemple, les informations client du tableau précédent peuvent être complétées par un autre tableau «Sortie de marchandises»
Tel base de données sont appelés relationnel (de relation - connexion, attitude). Base de données relationnelle est un ensemble de les tables, chacun contenant des informations sur objets d'un certain type.
Liens dans bases de données relationnelles déterminé par coïncidence de valeurs des champs dans différentes tables. Les champs par lesquels la relation est établie entre les tables sont appelés champs de communication ... Dans l'exemple donné, c'est champ Nom de l'acheteur.
Selon le type d'informations contenues dans les tables bases de données, il peut y avoir trois types principaux de liens entre elles: un-à-plusieurs, un par un, plusieurs à plusieurs.
Attitude un-à-plusieurs est défini entre les tables dans le cas où un enregistrement dans parent filiale table. Dans l'exemple donné, une relation de ce type est établie entre les tables «Acheteur» et «Sortie de marchandises».
Attitude un par un a lieu lorsqu'une entrée dans parent la table ne correspond pas à plus d'un enregistrement dans filiale table.
En cas de relation plusieurs à plusieurs une entrée dans parent la table peut correspondre à n'importe quel nombre d'enregistrements dans filiale table et vice versa.
Lié par la relation les tables interagir selon le principe accueil (Maître) - subalterne (détail). Dans notre exemple, la table "Client" - accueil, et le tableau "Marchandises libérées" - subalterne. Le principal table est aussi souvent appelée parent, et subalterne – filiale... Même table peut être le principal par rapport à un table bases de données et filiale par rapport à l’autre.
Systèmes de gestion de base de données (SGBD). Classification
Pour travailler avec des données sont utilisées systèmes de gestion de bases de données (SGBD). SGBD Sont des outils logiciels conçus pour définir les données (décrire la structure des bases de données - tables, liens), traiter et gérer les données. Exemples de SGBD - FoxPro, Oracle, SQL-Server, Delphi, dBase, Clipper, MS Access, etc.
Il existe trois principaux types de SGBD: usage industriel universel, usage spécial industriel et développé pour un client spécifique (personnalisé).
SGBD spécialisé sont créés pour gérer des bases de données dans un but précis - comptabilité, entrepôt, banque, etc.
SGBD universel n'ont pas de cadre d'application clairement défini, ils sont conçus "pour toutes les occasions" et, par conséquent, sont assez complexes et nécessitent des connaissances particulières de la part de l'utilisateur.
contrairement à industrielSUBCustomized prennent en compte au maximum les spécificités du travail du client (d'une entreprise particulière), leur interface est généralement intuitive pour les utilisateurs et ne nécessite pas de connaissances particulières de leur part. D'autre part, spécialisé et sGBD industriel universel relativement bon marché, suffisamment fiable (débogué) et prêt pour un travail immédiat, tout en sGBD personnalisé nécessitent des coûts importants, et leur préparation et leur débogage prennent un temps considérable (de plusieurs mois à plusieurs années).
En fonction de l'emplacement du SGBD, il existe localet distribué(serveur client) SGBD. Toutes les parties sGBD local hébergé sur l'ordinateur de l'utilisateur de la base de données. Si plusieurs utilisateurs accèdent simultanément à la même base de données sur un réseau informatique, chaque ordinateur utilisateur doit avoir sa propre copie du SGBD local. En revanche, une part importante des logiciels et du matériel sGBD distribué centralisé et situé sur un ordinateur suffisamment puissant (serveur),tandis que les ordinateurs des utilisateurs transportent une partie relativement petite du SGBD, qui est appelé le client. Local Les SGBD peuvent ou non fonctionner sur le réseau, tandis que distribué Les SGBD fonctionnent nécessairement dans réseau informatique.
Notez que l'emplacement lui-même base de données n'affecte en rien les spécificités du SGBD: local SGBD lui-même base de données peut être situé à la fois sur l'ordinateur de l'utilisateur et sur un ordinateur distant en réseau (serveur de fichiers).
Dignité inconditionnelle systèmes client-serveur est la possibilité de centraliser contrôle d'accès à base de données... Dans de tels systèmes base de données dans une large mesure protégé à la fois des distorsions accidentelles et intentionnelles, il est plus facile à mettre en œuvre intégrité et la cohérence des données.
Le SGBD est le composant le plus important système d'Information... Pour créer et gérer système d'Information Un SGBD est nécessaire autant que nécessaire traducteur Pour le developpement programmes sur le langage algorithmique.
Les principales fonctions assurées par le SGBD:
Gestion des données dans mémoire externe (sur disques);
Gestion des données dans mémoire vive;
- journalisation changements et récupération de base de données après des échecs;
Maintenir les langues bases de données (langage de définition de données - SDL, langage de manipulation de données - DML, ou un seul langage intégré qui contient tous les outils nécessaires pour travailler avec une base de données - langage de requête structuré SQL).
