Méthodologie tabulation et fonctions de programmation. Programmation de processus de calcul cyclique Programmation de processus de calcul cyclique vba

En programmation, nous sommes souvent confrontés à des tâches dans lesquelles des processus se produisent qui se répètent. Par conséquent, nous devons connaître et être capable d'utiliser un concept tel que " processus de calcul cycliques».

Il sera facile pour un programmeur novice de les comprendre à l'aide d'un exemple généralisé. De plus, il est important de comprendre que dans tous les langages de programmation, il existe des moyens d'implémenter des boucles.

Qu'est-ce qu'une boucle en programmation ?

Cycle - en programmation, cela s'appelle répétition multiple des mêmes actions ou calculs, mais selon les mêmes dépendances avec des valeurs de variables différentes.

Nous ne rencontrons pas seulement la notion de cycle en programmation. Il existe des cycles dans de nombreux domaines de notre vie.

Par exemple - le cycle de l'eau dans la nature, c'est un cycle naturel dans notre vie.

Voyons maintenant les règles générales et les concepts utilisés dans les cycles de calcul.

Étapes de processus cycliques

En général, le cycle doit être mis en œuvre en 4 étapes :

Etape 1 - préparation du cycle (initialisation).
Définition d'une valeur initiale pour un paramètre et une variable de boucle.
Paramètre de boucle- cette valeur, qui compte le nombre de pas du cycle (le nombre de répétitions du cycle).
Variable de boucle Est une valeur qui change de valeur à chaque étape du cycle.
Initialisation Est l'affectation de valeurs initiales au paramètre et à la variable de la boucle.
Étape 2 - le corps du cycle.
Il s'agit d'une répétition multiple d'une action dans une boucle ou de calculs sur les mêmes dépendances mathématiques avec des valeurs de variables différentes.
Étape 3 - modification (changement) du cycle.
Étape 4 - gestion du cycle.
Il s'agit d'un contrôle de la condition de poursuite ou de début de cycle.

Il y a 3 opérateurs de boucle dans pascal qui peuvent implémenter n'importe quel algorithmique - structure cyclique :

Opérateur de boucle avec paramètre
Opérateur de boucle avec précondition
Opérateur de boucle avec postcondition

Nous les examinerons en détail dans le prochain article.

Objectif:

Apprenez les opérateurs cycliques pour, while, do - while, apprenez à composer et programmer des algorithmes cycliques.

Brèves informations théoriques

Les opérateurs de boucle sont utilisés lorsqu'il est nécessaire de répéter plusieurs fois certaines actions (opérateurs et opérations), et ces sections d'algorithmes sont appelées boucles.

Pour l'opérateur de boucle

La forme principale de l'opérateur de boucle for est

pour (expression_1; expression_2; expression_3)

opérateur;

où expression_1- valeur initiale du paramètre de cycle ;

expression_2- vérifier la condition de poursuite du cycle ;

expression_3- modification du paramètre du cycle (correction) ;

opérateur- opérateur simple ou composé du langage C.

Le schéma de travail de l'opérateur est le suivant : expression_1 n'est calculée qu'une seule fois, puis expression_2 est vérifiée, et si elle est « vraie », alors la partie cyclique du programme est exécutée, puis le paramètre est corrigé, et ainsi de suite jusqu'à ce que expression_2 prenne le valeur "faux".

Par exemple: pour (k = 1; k<5; k++)

printf ("\ n% d", k);

À la suite de l'exécution de cet opérateur, les nombres de 1 à 4 sont imprimés dans une colonne.

Une variable de n'importe quel type de base peut être utilisée comme paramètre de boucle.

Par exemple:

pour (ch = 'a'; ch<=’z’; ch++) // Вывод на экран букв

printf ("% c", ch); // alphabet latin

Il est nécessaire de contrôler soigneusement la structure des boucles for dans le programme afin qu'une boucle infinie (dont il n'y a pas d'issue) ne se produise pas.

par exemple:

pour (k = 10; k> 6; k ++)

printf ("boucle sans fin \ n");

Quitter la boucle en avance sur le calendrier des manières suivantes :

Par condition supplémentaire ;

En utilisant les opérateurs suivants :

Pause;- sortie de la boucle dans laquelle se trouve break, le contrôle est transféré à la première instruction exécutée après la boucle ;

sortie (int Kod);- sortie du programme ;

retourner;- sortir de la fonction ;

Utilisation de l'opérateur de saut inconditionnel aller à<метка>;

Tôt achèvement de l'étape du cycle en cours possible avec une condition ou un opérateur supplémentaire Continuez, qui interrompt l'exécution de l'étape en cours de la boucle, c'est-à-dire saute les instructions du reste de la boucle et transfère le contrôle à l'instruction head de la boucle pour corriger le paramètre et vérifier la condition.

Il est interdit de transférer le contrôle de l'extérieur vers l'intérieur du cycle.

L'une des expressions de la boucle for entre parenthèses peut être manquante, mais le ";" ne peut pas être omis.

par exemple:

pour (; je<3; i++)

met ("Bonjour!");

Boucles d'instructions while et do - while

La forme de base d'un opérateur cyclique tandis que:

Tandis que (condition)

opérateur;

où opérateur

La boucle est exécutée tant que la condition est « vraie », c'est-à-dire une expression entre parenthèses renvoie un résultat différent de zéro. Il s'agit d'une boucle avec une condition préalable - d'abord la condition est vérifiée, puis l'instruction est exécutée. Par conséquent, la boucle while ne sera pas exécutée même une fois si le résultat initial de l'évaluation de la condition est 0.

Forme d'opérateur de base faire pendant:

opérateur;

tandis que (état);

où opérateur Est un opérateur simple, composé ou vide.

Opérateur faire–tandis que- opérateur de boucle avec postcondition, c'est-à-dire l'instruction est exécutée en premier, puis la condition est vérifiée. Étant donné que dans la boucle do – while la condition est vérifiée à la fin de la boucle, la boucle sera exécutée au moins une fois.

Dans les boucles de type while et do - while, les mêmes méthodes de sortie anticipée de la boucle et de terminaison anticipée de l'étape actuelle de la boucle sont autorisées que dans l'instruction for, mais dans ce dernier cas, contrairement à la boucle for, control est transféré pour vérifier l'état. Pour éviter une boucle infinie à l'intérieur des boucles while et do - while, il est nécessaire de prévoir de modifier les variables incluses dans la condition.

Par exemple:

pour (i = 1; je<=300;i++) // Печать целых чисел, кратных 5

si (i% 5! = 0) continuer ;

printf ("% 5d", i);

Exemples de boucles infinies :

opérateur;

2) while (number_not_0) // Toujours vrai !

opérateur;

tandis que (nombre_pas_0) ; // Toujours vrai!

Il doit y avoir une condition de sortie parmi les opérateurs de boucle.

Boucles imbriquées

Dans le cas des boucles imbriquées, une boucle est à l'intérieur d'une autre, par exemple :

pour (i = nn; je

pour (j = mn; j

opérateur;

où opérateur Est un opérateur simple, composé ou vide. La boucle interne s'exécutera pour chaque valeur du paramètre i qui remplit la condition de la boucle externe.

Exemple:

pour (i = 1; je<10;i++) // Печать таблицы умножения

pour (j = 1; j<4;j++)

printf ("\ n% d *% d =% 2d", i, j, i * j);

printf ("\ n");

Un exemple d'utilisation de l'instruction for

Calculer. Le programme doit imprimer les résultats intermédiaires et finaux.

Le texte du programme peut ressembler à

#inclure

met (« Entrez N »);

scanf ("% d", & N);

pour (s = 0, k = 1; k<=N; k++) // В заголовке цикла можно выпол-

(// nat et double affectation

printf ("\ n k =% d s =% f", k, s);

printf ("\ n REPONSE: s =% f, Appuyez sur n'importe quelle touche ...", s);

Options pour les devoirs individuels

Créer un programme pour définir une table de valeurs de fonction à dans une plage arbitraire [ une,b] l'argument change X avec un pas arbitraire h... Les valeurs a, b, h saisie depuis le clavier. Le tableau doit contenir les colonnes suivantes : ordinal, valeur de l'argument X, la valeur de la fonction, un message sur l'augmentation ou la diminution de la fonction, la différence entre deux valeurs adjacentes de la fonction.

Déterminer les valeurs maximales et minimales de la fonction.

1. a = -p; b = p; h = 0,4.

2. a = 0,7 ; b = 1,8 ; h = 0,1.

3. a = -0,5 ; b = 2,5 ; h = 0,2.

4. a = -0,9 ; b = 2,7 ; h = 0,3.

5. a = -2; b = 0,8 ; h = 0,2.

6. a = -1,9 ; b = 2,7 ; h = 0,3.

7. a = -0,4p ; b = 0,4p ; h = 0,5.

8. a = -0,3p ; b = 1,3p ; h = p/10.

9. a = -p/2; b = p/2 ; h = p/10.

10. a = -3 ; b = 3 ; h = 0,5.

1. Méthodes de construction de processus de calcul cyclique dans les programmes.

2. L'ordinateur est entréNnombres réels. Créez un programme qui affiche la moyenne arithmétique de cet ensemble.

introduction

Les programmes en boucle sont utilisés dans presque tous les logiciels. Dans ce cas, les boucles peuvent être explicites ou implicites. En particulier, la boucle implicite est présente dans les gestionnaires d'interruptions, qui fonctionnent en fait dans une boucle infinie, dont le corps est initié par une interruption. Les sous-programmes, les fonctions de fenêtre des applications Windows, sont également circulaires. De plus, nous considérons des programmes avec une boucle, dont le corps contient des modules fonctionnels.

Processus cyclique est un processus de calcul dans lequel les calculs sont effectués à plusieurs reprises en utilisant les mêmes formules pour différentes valeurs de l'argument.

Programmes qui mettent en œuvre un processus cyclique sont appelés programmes cycliques.

Dans l'organisation du cycle, on distingue les étapes suivantes :

préparation (initialisation) du cycle (I) ;

exécution des calculs de cycle (corps de cycle) (T) ;

modification des paramètres (M);

vérifier l'état de fin de cycle (Y).

L'ordre dans lequel ces étapes sont effectuées, telles que T et M, peut varier. Selon le lieu du contrôle, les conditions de fin de cycle distinguent les cycles avec les extrémités inférieures et supérieures. Pour une boucle avec une extrémité inférieure, le corps de la boucle est exécuté au moins une fois, puisque les premiers calculs sont effectués, puis la condition de sortie de la boucle est vérifiée.

Dans le cas d'une boucle avec une extrémité supérieure, le corps de la boucle peut ne pas être exécuté même une fois si la condition de sortie est immédiatement remplie.

Une boucle est dite déterministe si le nombre de répétitions du corps de la boucle est connu ou déterminé à l'avance. Une boucle est dite itérative si le nombre de répétitions du corps de la boucle n'est pas connu à l'avance, mais dépend des valeurs des paramètres (certaines variables) impliqués dans les calculs.

Corps de boucle est une section répétitive du programme.

Paramètre de boucle est une variable qui prend de nouvelles valeurs à chaque répétition de la boucle (les boucles peuvent être simples ou complexes).

Vue générale du cycle n fois

En général, le cycle s'écrit n fois comme ceci :

nts nombre de répétitions fois

Les mots de service nts (début de cycle) et kts (fin de cycle) sont écrits strictement l'un en dessous de l'autre et sont reliés par un trait vertical. A droite de cette ligne, la séquence répétée de commandes (le corps de la boucle) est écrite.

Le nombre de répétitions est un nombre entier arbitraire.

Lors de l'exécution de l'algorithme, la séquence de commandes dans le corps de la boucle est répétée le nombre de fois spécifié. Les règles du langage algorithmique permettent de spécifier n'importe quel nombre entier de répétitions. Il peut être nul ou même négatif. Ces cas ne sont pas considérés comme erronés, seul le corps de la boucle ne sera pas exécuté une seule fois, et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après kts

Vue générale du cycle jusqu'à présent

En général, le cycle s'écrit toujours ainsi :

nc jusqu'à présent état

| corps de la boucle (séquence de commandes)

Pendant le cycle, l'ordinateur répète les étapes suivantes :

a) vérifie la condition écrite après le mot de service pour l'instant ;

b) si la condition n'est pas remplie, alors l'exécution du cycle est terminée et le calculateur commence à exécuter les commandes écrites après kts. Si la condition est remplie, l'ordinateur exécute le corps de la boucle, vérifie à nouveau la condition, et ainsi de suite.

Vue générale du cycle pour

nts pour i de i1 à i2

| corps de la boucle (séquence de commandes)

Ici, i est le nom d'une valeur entière, i1, i2 sont des entiers arbitraires ou des expressions avec des valeurs entières. Le corps de la boucle est exécuté séquentiellement pour i = i1, i = i1 + 1, i1 + 2,… i = i2.

Les règles du langage algorithmique permettent de spécifier n'importe quel entier i1, i2. en particulier, i2 peut être inférieur à i1. ce cas n'est pas considéré comme erroné - seul le corps de la boucle ne sera pas exécuté une seule fois, et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après kts.

Boucle n fois et boucle au revoir

Les boucles n fois et alors qu'elles sont formatées dans le langage algorithmique sont quasiment les mêmes. Ce n'est pas surprenant, puisque ces deux commandes créent une boucle - une séquence répétitive de commandes. Les mots de service nts et kts indiquent que la boucle est en cours d'exécution et l'en-tête de boucle spécifie un mécanisme spécifique pour son exécution.

Cependant, ces deux cycles ont une différence significative. En commençant à exécuter la boucle n fois, l'ordinateur sait combien de fois il devra répéter le corps de la boucle. Lors de l'exécution d'une boucle, ce n'est pas encore le cas : l'ordinateur vérifie à chaque fois l'état de la boucle et ne peut pas déterminer à l'avance quand l'exécution se terminera. Il n'est possible de connaître le nombre de répétitions du cycle qu'une fois le cycle terminé.

De là, il est clair dans quels cas quel cycle doit être utilisé. Si le nombre de répétitions est connu au début du cycle, il convient d'utiliser le cycle n fois. Si le nombre de répétitions ne peut pas être déterminé à l'avance, un cycle jusqu'à présent est nécessaire.

Par exemple, un programme de contrôle automatique a la structure illustrée à la Fig. un. Modules de boucle(ainsi que les modules de traitement des interruptions), chacun avec une entrée et une sortie, ont généralement une caractéristique : les modules contiennent des variables statiques auxquelles une valeur est affectée dans le cycle en cours, et l'analyse de ces variables est effectuée dans le cycle suivant . Ainsi, les variables mentionnées caractérisent l'état du module à la fin du cycle en cours ou au début du cycle de programme suivant. Dans ce qui suit, nous ne considérerons que de tels modules de programmes cycliques et les désignerons brièvement par MCP.

Fig. 1. Structure typique d'un programme de commande avec une boucle infinie.

Les MCP ont une structure variée, dont la complexité doit être appréciée selon des critères particuliers. V.V. Lipaev a proposé un critère pratique et objectif pour la complexité des modules logiciels, à savoir : le nombre et la longueur totale des chemins dans le graphe de contrôle du module. Dans ce cas, seules les instructions conditionnelles et de sélection sont prises en compte. Cependant, ce critère n'est clairement pas suffisant pour un MPC avec mémoire statique, car lors de l'analyse d'un MPC, il est nécessaire de se souvenir des valeurs de toutes les variables statiques définies dans le cycle précédent. De plus, il n'y a pas de recommandations pour la standardisation des algorithmes et des programmes, à l'exception de la programmation structurée connue de longue date dans les langages de programmation courants tels que C et Pascal. Cet article propose de combler ces lacunes par rapport au MCP.

2. Fragments de modules de programmes cycliques

Un fragment bipolaire, ou simplement un fragment, sera considéré comme une section de programme avec une entrée et une sortie (y compris les opérateurs de boucle) en supposant que les MCP considérés sont structurés. L'extrait le plus simple comprend une seule instruction. Une séquence de fragments est aussi un fragment. MCP, à son tour, est un fragment et se compose d'une séquence de fragments.

Dans la méthode proposée de fragments indépendants pour la synthèse de la structure des modules qui mettent en œuvre des tables de décision. Dans ce cas, un tel fragment est considéré comme indépendant s'il peut être inséré n'importe où dans la séquence de fragments du module. L'indépendance de l'emplacement d'un tel fragment est due au fait que les données qui y sont analysées ne sont pas formées dans la séquence de fragments spécifiée et que les données générées dans un fragment indépendant ne sont pas analysées dans cette séquence de fragments. Par conséquent, des fragments indépendants peuvent être exécutés en parallèle (pseudo-parallèle). En figue. 2 montre des implémentations possibles d'un module avec deux fragments indépendants. Dans les variantes « a » et « b », les fragments sont réarrangés sans déformer l'essence du programme ; dans la variante « c », les fragments sont mis en œuvre en parallèle.

Figure 2. Options d'implémentation pour un module avec des fragments indépendants :

a) et b) - mise en œuvre séquentielle,

c) - mise en œuvre parallèle : une double ligne horizontale dénote la parallélisation du programme, une ligne horizontale en gras dénote la fin des processus parallèles.

Un fragment dépendant est celui dont l'emplacement dépend de l'emplacement d'un autre (s) fragment (s) dans le module. Nous distinguerons les fragments dépendants du haut et du bas. Le fragment ci-dessus dépendant doit toujours être situé en dessous d'un fragment dans lequel les variables utilisées dans ce fragment (dépendant) sont formées. Le fragment dépendant du bas doit toujours être placé au-dessus du fragment, qui utilise les variables formées dans ce fragment. Deux fragments dépendants, dont l'un est dépendant d'en haut du second, et le second d'en bas dépendant du premier, seront appelés fragments mutuellement dépendants. Ils ne peuvent pas être permutés et ne peuvent pas être mis en œuvre en parallèle. En figue. 3 montre un exemple de module avec des fragments mutuellement dépendants. Entre les fragments mutuellement dépendants, il peut y en avoir d'autres, dépendants ou non dépendants d'eux. Figure 3. Un module avec des fragments dépendants.

Fixed est un fragment dépendant dont l'emplacement dans le module est strictement défini. Par exemple, dans le module de reconnaissance d'un caractère saisi au clavier, le premier en partant du bas doit être le fragment dépendant du caractère saisi lui-même. Les opérateurs « début » et « fin » du module sont des fragments fixes.

Les fragments absolument indépendants n'existent pas, ne serait-ce que parce que dans n'importe quel module il y a les fragments fixes mentionnés du début et de la fin. Par conséquent, un fragment indépendant, dans le cas général, a une zone de localisation possible limitée par deux fragments dépendants l'un de l'autre. C'est-à-dire qu'une définition plus rigoureuse d'un fragment indépendant est la suivante : indépendant par rapport à deux fragments fixes est un fragment qui peut être placé n'importe où dans une séquence de fragments délimitée au-dessus et au-dessous par les fragments fixes spécifiés.

"Programmation de processus de calcul cycliques"

Objectif: maîtriser les méthodes de compilation d'algorithmes pour les processus de calcul cyclique et organiser des programmes cycliques de structure complexe.

Partie théorique

4.1.1. Algorithmes cycliques.

Un cycle est une séquence d'actions pouvant être exécutées plusieurs fois.

Un algorithme de bouclage est un algorithme qui contient une ou plusieurs boucles.

Il existe 3 types de cycles :

Boucle avec précondition ;

Boucle avec postcondition ;

Cycle de compteur (cycle de comptage).

Si l'exécution de la boucle est associée à une condition logique, alors les boucles avec une précondition ou une postcondition sont utilisées.

Les boucles de compteur représentent une classe dans laquelle l'exécution du corps de la boucle doit être répétée un nombre prédéterminé de fois.

Les diagrammes en boucle ressemblent à ceci :

1. Cycle avec compteur.

2. Boucle avec précondition. 3. Boucle avec postcondition.

4.1.2 Opérateurs de la boucle dans le langage de programmation C++.

En C++, il existe un opérateur correspondant pour chaque type de boucle :

Boucle While (avec condition préalable) ;

Boucle comme do ... while (avec postcondition);

Boucle for (comptage).

1. L'opérateur de boucle du type while

Formulaire d'enregistrement :

énoncé while (condition) ;

où : (condition) - expression logique ;

opérateur - une instruction exécutée dans une boucle ou le corps d'une boucle.

Si le corps de la boucle est une instruction composée, elle doit être placée entre crochets d'opérateur (...) :

tandis que (condition)

groupe d'opérateurs

Comment fonctionne une telle boucle : tant que la condition est vraie, le corps de la boucle est exécuté et la condition est à nouveau vérifiée, etc. Lorsque la condition devient fausse (faux), la boucle se termine.

2. Un opérateur de boucle comme do ... while

Formulaire d'enregistrement :

opérateur;

tandis que (état);

Le schéma de travail d'un tel cycle: d'abord l'opérateur est exécuté, puis la condition est vérifiée, si la condition est vraie, l'opérateur est exécuté et la condition est vérifiée à nouveau, etc. Lorsque la condition devient fausse, la boucle se termine.

Si le corps de la boucle est une instruction composée, alors, comme pour une boucle avec une condition préalable, elle doit être placée entre crochets d'opérateur (...) :

groupe d'opérateurs

tandis que (état);

3. Opérateur d'une boucle de type for

Formulaire d'enregistrement :

opérateur;

A est une expression initiale qui définit des valeurs initiales pour le paramètre de boucle et, si nécessaire, des valeurs initiales pour d'autres paramètres. Par exemple:

i = 0, x = 0,5, p = 1, s = 0

B est une expression conditionnelle qui vérifie la condition de poursuite de la boucle. Par exemple:

C est une expression d'incrémentation qui définit un incrément pour un paramètre de boucle et, si nécessaire, pour d'autres paramètres, puis ils sont écrits sous forme de liste. Par exemple : x + = 0,1, i ++

4.1.3 Un exemple de compilation d'un algorithme et d'un programme en C++ pour un processus de calcul cyclique.

Calculer la valeur de l'expression :

b- la valeur initiale, sa valeur est saisie au clavier et ne change pas ;

une- les changements de gamme avec un pas de 1 ;

oui- le résultat, ses valeurs sont affichées à l'écran.

En fonction de la condition de réglage, la variable a est un nombre entier, elle peut donc être utilisée comme compteur dans un cycle de comptage.

Le schéma fonctionnel de l'algorithme pour résoudre ce problème à l'aide d'un cycle de comptage est le suivant :

#inclure

printf (« Entrez b : »);

scanf ("% f", & b);

printf ("a y \ n");

pour (a = 0; a<=10;a++)

printf (“% 3d”, a);

printf ("% 8.2f \ n", y);

y = (a-b) / carré (a);

printf ("% 8.2f \ n", y);

Le schéma fonctionnel de l'algorithme pour résoudre ce problème à l'aide d'une boucle avec une précondition est le suivant :

Le texte du programme C++ correspondant à cet algorithme ressemble à ceci :

#inclure

printf (« Entrez b : »);

scanf ("% f", & b);

printf ("a y \ n");

printf (“% 3d”, a);

printf ("% 8.2f \ n", y);

y = (a-b) / carré (a);

printf ("% 8.2f \ n", y);

else printf ("y n'existe pas \ n");

Le schéma fonctionnel de l'algorithme pour résoudre ce problème à l'aide d'une boucle avec une postcondition est le suivant :

Le texte du programme C++ correspondant à cet algorithme ressemble à ceci :

#inclure

printf (« Entrez b : »);

scanf ("% f", & b);

printf ("a y \ n");

printf (“% 3d”, a);

printf ("% 8.2f \ n", y);

y = (a-b) / carré (a);

printf ("% 8.2f \ n", y);

else printf ("y n'existe pas \ n");

tandis que (un<=10);

Partie pratique

4.2.1 Exigences pour l'exécution des travaux :

Complétez la tâche du travail de laboratoire n ° 3 pour la plage de valeurs de l'une des variables. La variable à modifier, la plage de son changement et le pas sont indiqués dans le tableau 4. Établissez des schémas fonctionnels d'algorithmes et de programmes pour les deux types de cycles indiqués dans la tâche individuelle (tableau 4).

Formatez la sortie des résultats de manière à ce que les valeurs du paramètre en cours de modification soient clairement mises en évidence et que pour chacune de ses valeurs spécifiques, les valeurs du résultat (trois variables de la colonne 2 du tableau 3) soient affiché sous forme de tableau.

L'ordre des travaux.

1. Analysez la tâche, formulez l'énoncé de la tâche.

2. Rédiger des schémas fonctionnels d'algorithmes.

3. Ecrivez un programme en C++. Fournir la saisie des données initiales à partir du clavier et l'affichage des résultats à l'écran.

4. Vérifiez la fonctionnalité du programme sur diverses données initiales.

5. Analysez les résultats.

Options pour les affectations individuelles.

Les options pour les devoirs individuels sont sélectionnées dans le tableau 4 en fonction du numéro de l'étudiant dans la liste de groupe dans le journal de l'enseignant.

Tableau 4. Options pour les tâches individuelles

P/p Non.	Variable mutable	Types de boucle

	10 ≤ un ≤ 10,Δ a = 1

	-4 ≤ d ≤ 4, Δ d = 0,5
	-6 x ≤ 3, Δ x = 0,5
	0 b ≤ 3 0, Δ b = 1,5	1.Avec condition préalable, 2.Comptable
	-15 j ≤ 1 0, Δ j = 0,5	1.Avec une précondition, 2.Avec une postcondition
	5 et ≤ 35,Δ e = 2	1.Comptable, 2.Avec postcondition
	-5 m ≤ 15,Δ m = 1	1.Avec condition préalable, 2.Comptable
	1 c ≤ 70,Δ c = 3	1.Avec une précondition, 2.Avec une postcondition
	1,5 c ≤ 15,Δ c = 0,5	1.Comptable, 2.Avec postcondition
	-8 b ≤ 28,Δ b = 2	1.Avec condition préalable, 2.Comptable
	-4,5 x 11,5,Δ x = 0,5	1.Avec une précondition, 2.Avec une postcondition
	-7 k ≤ 2,Δ k = 0,3	1.Comptable, 2.Avec postcondition
	-1 m 21,Δ m = 1	1.Avec condition préalable, 2.Comptable
	-2 e 34,Δ e = 2	1.Avec une précondition, 2.Avec une postcondition
	-11 c ≤ 23,Δ c = 2	1.Comptable, 2.Avec postcondition
	-13 p 50,Δ p = 3	1.Avec condition préalable, 2.Comptable
	3.3 b 9.3,Δ b = 0,3	1.Avec une précondition, 2.Avec une postcondition
	3,5 y 12,3,Δ y = 0,4	1.Comptable, 2.Avec postcondition
	-7,5 ≤ un ≤ 5,7,Δ a = 0,6	1.Avec condition préalable, 2.Comptable
	-1,5 h 1,2,Δ h = 0,1	1.Avec une précondition, 2.Avec une postcondition
	0 h ≤ 10,Δ h = 0,5	1.Comptable, 2.Avec postcondition
	-15 b ≤ 15, Δ b = 2	1.Avec condition préalable, 2.Comptable

	-7 l ≤ 3, Δ l = 0,5	1.Avec une précondition, 2.Avec une postcondition
	-5,5 b 6,5, Δ b = 0,5	1.Comptable, 2.Avec postcondition
	1 k ≤ 9, Δ k = 0,4	1.Avec condition préalable, 2.Comptable
	0 b ≤ 6,9,Δ b = 0,3	1.Avec une précondition, 2.Avec une postcondition
	-3 v ≤ 9,Δ v = 0,6	1.Comptable, 2.Avec postcondition
	-2 p 2,6,Δ p = 0,2	1.Avec condition préalable, 2.Comptable