Apprendre à programmer en R : opérateurs logiques, if else, for et while. Boucles For et while, instructions break et continue, le mot magique else. Opérateurs logiques dans R

Dans cet article, je parlerai de boucles for et while, opérateurs casser Et continuer, et aussi sur le mot autre, qui, lorsqu'il est utilisé avec une boucle, peut rendre le code du programme un peu plus compréhensible.

boucle while

While est l'une des boucles les plus polyvalentes de Python, elle est donc assez lente. Exécute le corps de la boucle tant que la condition de la boucle est vraie.

>>> i = 5 >>> tandis que je< 15 : ... print (i ) ... i = i + 2 ... 5 7 9 11 13

pour la boucle

La boucle for est un peu plus compliquée, un peu moins universelle, mais elle s'exécute beaucoup plus rapidement que la boucle while. Cette boucle parcourt n'importe quel objet itérable (tel qu'une chaîne ou une liste) et exécute le corps de la boucle à chaque passage.

>>> pour i dans "hello world" : ... print (i * 2 , end = "" ) ... hheelllloo wwoorrlldd

Continuer l'opérateur

L'instruction continue commence la prochaine itération de la boucle, en contournant le corps restant de la boucle (for ou while)

>>> for i in "hello world" : ... if i == "o" : ... continue ... print (i * 2 , end = "" ) ... hheellll wwrrlldd

instruction de pause

L'instruction break termine la boucle plus tôt.

>>> for i in "hello world" : ... if i == "o" : ... break ... print (i * 2 , end = "" ) ... hheellll

Le mot magique autrement

Le mot else utilisé dans une boucle for ou while vérifie si la boucle a été quittée par une instruction break ou de manière "naturelle". Le bloc d'instructions à l'intérieur de else ne sera exécuté que si la boucle s'est terminée sans l'aide de break.

>>> for i in "hello world" : ... if i == "a" : ... break ... else : ... print ( "La lettre a n'est pas dans la ligne") ... Il n'y a pas de lettre a dans la ligne

Cette leçon examine l'opérateur conditionnel en Pascal ( si). Explique comment utiliser plusieurs conditions dans une seule construction ( ET Et OU). Des exemples de travail avec un opérateur sont considérés

Nous vous rappelons que ce site n'a pas la prétention de fournir une présentation complète des informations sur le sujet. Le but du portail est de fournir la possibilité d'apprendre du matériel basé sur des exemples résolus prêts à l'emploi sur le thème « Langage de programmation Pascal » avec des tâches pratiques pour renforcer le matériel. Les tâches Pascal présentées sur le site sont classées séquentiellement à mesure que leur complexité augmente. Le site Web peut être utilisé par les enseignants et les conférenciers comme aide visuelle auxiliaire.

Avant d'aborder ce sujet, on utilisait principalement des algorithmes linéaires en Pascal, typiques des problèmes très simples lorsque les actions (opérateurs) sont exécutées séquentiellement, les unes après les autres. Des algorithmes plus complexes impliquent l’utilisation d’une construction de branchement.

Schéma fonctionnel de l'opérateur conditionnel :

L'instruction conditionnelle en Pascal a la syntaxe suivante :

Version courte :

si condition alors déclaration ;

Version complète :

if condition then instruction else instruction ;

L'opérateur conditionnel en Pascal - si - sert à organiser la progression d'une tâche de telle manière que la séquence d'exécution des opérateurs change en fonction d'une condition logique. Une condition logique peut prendre l'une des deux valeurs suivantes : respectivement vraie ou fausse, elle peut être vraie ou fausse.

Opérateur composé

Si, dans une condition vraie, il est nécessaire d'exécuter plusieurs instructions, alors Selon les règles du langage Pascal, ils doivent être enfermés dans un bloc, commençant par le mot de fonction début et se terminant par le mot de fonction fin . Un tel bloc est généralement appelé supports d'opérateur, et cette construction - opérateur composé:

Opérateur parenthèses et opérateur composé en Pascal :

si expression logique, alors commencez l'instruction 1 ;

opérateur2 ; fin sinon début instruction1 ;

opérateur2 ; fin;	La traduction de l’anglais de l’opérateur de condition facilitera la compréhension de son utilisation :	SI
ALORS	AUTRE	SI

QUE
SINON

• La condition (dans une expression logique) utilise des opérateurs relationnels.
• Considérez la liste des opérateurs relationnels de Pascal :
• plus >
• moins
• supérieur ou égal à en Pascal >=
• inférieur ou égal à en Pascal

comparaison en Pascal = pas égal en Pascal

Exemple:	trouver le plus grand de deux nombres

Option 1 Option 2

comparaison en Pascal = Comprendre le travail en détail

vous pouvez utiliser l'opérateur conditionnel en Pascal en regardant le didacticiel vidéo :

var x,y:réel; commencer writeln("entrez x"); lire(x); si x>0 alors y:=ln(x) sinon y:=exp(x); writeln ("y=", y:6:2) (le nombre résultant occupera 6 positions et aura 2 décimales) end.

Remarquez comment y est affiché dans cet exemple. Lors de la déduction de variables de type en pascal, vous pouvez utiliser ce qu'on appelle sortie formatée, ou notation avec deux deux-points :
y:6:2
- le chiffre après le premier deux-points (6) indique le nombre de caractères que le numéro occupera lorsqu'il sera affiché à l'écran
- le nombre après le deuxième deux-points (2) indique combien de décimales du nombre réel seront affichées

Ainsi, utiliser une telle notation en pascal permet pratiquement d'arrondir aux centièmes, millièmes, etc.

Tâche 0. Calculez la valeur de la variable y en utilisant l'une des deux branches :

Tâche 1. Deux nombres sont saisis dans l'ordinateur. Si le premier est supérieur au second, calculez leur somme, sinon le produit. Après cela, l'ordinateur devrait imprimer le résultat et le texte PROBLÈME RÉSOLU

Tâche 2. Le dragon fait pousser trois têtes chaque année, mais après l’âge de 100 ans, il n’en reste plus que deux. Combien de têtes et d’yeux a un dragon ? N années?

Opérations logiques en Pascal (en expression logique)

Lorsque vous devez utiliser une double condition en Pascal, vous aurez besoin d’opérations logiques.

• Opération logique ET (Et), placé entre deux conditions, dit que ces deux conditions doivent être remplies en même temps (doit être vraie). Le sens logique de l’opération est « conjonction ».
• Placé entre deux conditions, le signe OU (OR) dit qu'il suffit qu'au moins une d'entre elles soit satisfaite (une des deux conditions est vraie). Le sens logique de l’opération est « disjonction ».
• En Pascal XOR - un signe d'une opération logique qui a le sens de « disjonction stricte » et indique qu'il faut que l'une des deux conditions soit remplie (vrai), et l'autre non satisfaite (faux).
• Opération logique PAS devant une expression logique ou une variable, cela signifie « négation » ou « inversion » et indique que si une variable ou une expression donnée est vraie, alors sa négation est fausse et vice versa.

Important: Chaque condition simple doit être mise entre parenthèses.

Exemple: Regardons des exemples d'opérations logiques dans des expressions logiques en Pascal

1 2 3 4 5 6 7 8

var n : entier ;<10 ) then writeln ("истина" ) ; if (n>début n : = 6 ;<10 ) then writeln ("истина" ) ; if (n>si (n>5 ) et (n<10 ) then writeln ("истина" ) ; if not (n>7 ) ou (n

7)xor(n<10) then writeln("истина"); if (n>7) puis writeln("true");<10) then writeln("истина"); if (n>fin.<10) then writeln("истина"); if not(n>var n:entier; commencer n :=6 ; si (n>5) et (n

comparaison en Pascal = L'entreprise recrute des salariés de 25 à 40 ans inclus. Saisissez l'âge de la personne et déterminez si elle convient à cette entreprise (affichez la réponse « convenable » ou « ne convient pas »).
Particularité: nous devons vérifier si deux conditions sont remplies simultanément.

comparaison en Pascal =Étant donné un nombre entier A. Vérifiez la véracité de l’énoncé : « Le nombre A est impair. »

La capacité de contrôler le déroulement du programme permet l’exécution sélective de sections individuelles de code, ce qui constitue une fonctionnalité très précieuse de la programmation. L'instruction if nous permet d'exécuter ou non certaines sections de code, selon que la condition de l'instruction est vraie ou fausse. L'un des objectifs les plus importants de l'instruction if est qu'elle permet au programme d'agir en fonction de ce que l'utilisateur a saisi. Un exemple trivial d'utilisation de if consiste à vérifier le mot de passe saisi par l'utilisateur ; si le mot de passe est correct, le programme permet à l'utilisateur d'effectuer une action. Si le mot de passe est mal saisi, le programme ne permettra pas à l'utilisateur d'accéder à des ressources limitées ; .

Sans l'instruction conditionnelle, le programme s'exécuterait de la même manière encore et encore, quelle que soit l'entrée donnée par l'utilisateur. Si vous utilisez des opérateurs de sélection, le résultat du programme peut être beaucoup plus intéressant, puisqu’il dépendra directement des données saisies par l’utilisateur.

Avant de commencer à comprendre la structure de l'instruction if, il convient de prêter attention aux significations VRAI et FAUX dans le contexte de la programmation et de la terminologie informatique.

La valeur vraie (TRUE) a une valeur autre que zéro, FALSE équivaut à zéro. Lors de l'utilisation d'opérateurs de comparaison, l'opérateur renverra un si l'expression de comparaison est vraie, ou - 0 si l'expression conditionnelle est fausse. Par exemple, l'expression 3 == 2 renverra la valeur 0, puisque trois n'est pas égal à deux. L'expression 5 == 5 est évaluée comme vraie et renvoie la valeur 1. Si vous avez du mal à comprendre cela, essayez d'imprimer ces expressions à l'écran, par exemple : printf("%d", 7 == 0);

Au cours du processus de programmation, vous devez souvent comparer certaines variables avec d'autres et, sur la base de ces comparaisons, contrôler le déroulement du programme. Il existe toute une liste d'opérateurs qui permettent d'effectuer des comparaisons, la voici :

Vous connaissez probablement ces opérateurs de comparaison, mais juste au cas où, je les ai présentés dans le tableau ci-dessus. Ils ne devraient pas être difficiles à comprendre pour vous ; la plupart de ces opérateurs que vous avez appris à l’école dans les cours de mathématiques. Maintenant que vous comprenez ce que sont VRAI et FAUX, il est temps de tester l'instruction if select. si structure :

If (expression conditionnelle) // voici une instruction qui sera exécutée si l'expression conditionnelle est vraie

Voici un exemple simple d'utilisation de l'instruction if :

Si (7 > 6) printf("Sept est supérieur à six");

Dans cet exemple, le programme évalue l'expression conditionnelle : « sept est-il supérieur à six ? Pour voir le résultat de ce morceau de code, collez-le simplement dans la fonction main() et n'oubliez pas d'inclure l'en-tête stdio.h, exécutez le programme et voyez le résultat - vrai. Construction de l'opérateur de sélection si avec des accolades :

Si (VRAI) ( /* tout le code placé entre parenthèses sera exécuté */ )

Si vous n'utilisez pas d'accolades, une seule, la première instruction, se rapportera au corps de l'instruction if. Si vous devez contrôler plusieurs opérateurs, vous devez les placer entre accolades. Je recommande de toujours mettre des parenthèses après une déclaration if - c'est une bonne pratique de programmation et vous ne vous tromperez jamais dans votre code, car une telle déclaration est la plus compréhensible.

opérateur sinon

Parfois, lorsqu'une expression conditionnelle est FAUX, il serait pratique d'exécuter du code différent du code exécuté lorsque la condition est VRAIE. Comment cela se fait-il ?
Voici un exemple d'utilisation de l'instruction if else :

If (TRUE) ( /* exécute ce code si la condition est vraie */ ) else ( /* exécute ce code si la condition est fausse */ )

sinon si construction

Généralement, les instructions else if sont utilisées lorsqu'une sélection multiple est nécessaire, c'est-à-dire que, par exemple, plusieurs conditions sont définies qui peuvent être vraies en même temps, mais nous n'avons besoin que d'une seule vraie expression conditionnelle. Vous pouvez utiliser l'instruction if else immédiatement après l'instruction if, après son corps. Dans un tel cas, si la condition de la première instruction select est TRUE, alors la clause else if sera ignorée, alors que sinon, si la condition de la première instruction select est FALSE, la vérification dans la clause else if commencera à être exécuté. Autrement dit, si la condition d’une déclaration if est vraie, alors les autres ne seront pas vérifiées. Maintenant, afin de consolider fermement tout cela dans nos têtes et de le comprendre, regardons un exemple simple utilisant des constructions d'opérateurs de sélection.

#inclure #inclure int main() ( int age; // impossible sans variable... printf("Quel âge as-tu ?"); // demande à l'utilisateur son âge scanf("%d", &age); // utilisateur saisit le nombre d'années si (âge< 100) { // если введенный возраст меньше 100 printf ("Вы очень молоды!\n"); // просто показываем что программа сработала верно... } else if (age == 100) { // используем else для примера printf("Молодость уже позади\n"); // \n - символ перевода на новую строку. } else { printf("Столько не живут\n"); // если ни одно из выше-перечисленных условий не подошло, то программа покажет этот вариант ответа } return 0; }

Examinons des expressions conditionnelles intéressantes utilisant des opérateurs logiques.

Les opérateurs logiques vous permettent de créer des expressions conditionnelles plus complexes. Par exemple, si vous souhaitez vérifier si votre variable est supérieure à 0 mais inférieure à 10, il vous suffit alors d'utiliser l'opérateur logique - AND. Voici comment procéder - var > 0 et var.< 10 . В языке СИ есть точно такой же же оператор, только обозначается он иначе — && .
Lorsque vous utilisez des instructions if, vous devez souvent tester plusieurs conditions différentes. Il est donc important de comprendre les opérateurs logiques OR, NOT et AND. Les opérateurs logiques fonctionnent exactement de la même manière que les opérateurs de comparaison : ils renvoient 0 si l'expression booléenne est fausse ou 1 si l'expression booléenne est vraie.
Vous pouvez en savoir plus sur les opérations logiques dans .

Ramification(instruction conditionnelle) est une construction de langage de programmation qui garantit l'exécution d'une commande ou d'un ensemble de commandes spécifique uniquement si une certaine expression logique est vraie, ou l'exécution d'une parmi plusieurs commandes (ensembles de commandes) en fonction de la valeur d'un certain expression.

Faire du vélo est un type de structure de contrôle conçu pour organiser l'exécution multiple d'un ensemble d'instructions.

Les branchements et les boucles individuelles sont basés sur des opérateurs de comparaison logiques qui déterminent s'il faut exécuter les lignes de code suivantes ou passer aux autres.

Opérateurs de comparaison

Majorité opérateurs de comparaison applicable aux valeurs numériques. Ce sont tous des opérateurs binaires qui ont deux arguments numériques mais renvoient une valeur booléenne.

• > opérateur "supérieur à"
• >= opérateur supérieur ou égal
• < оператор «меньше»
• <= оператор «меньше или равно»
• != Opérateur "différent"
• == opérateur d'équivalence

Les deux derniers opérateur de comparaison sont utilisés non seulement pour les valeurs numériques, mais aussi pour les valeurs logiques. La comparaison de deux opérateurs de texte s'effectue à l'aide des méthodes equals(String object), equalsIgnoreCase(String object).

Il est très important de ne pas confondre l’opérateur d’équivalence avec l’opérateur d’affectation. Dans les expressions contenant des opérateurs de types différents, les opérations arithmétiques sont effectuées en premier, puis les opérations de comparaison, puis les opérations logiques et enfin l'affectation.

Opérateurs logiques

Lors de l'exécution d'opérations de comparaison ou d'affectation, des opérateurs logiques peuvent être présents. Il existe un opérateur logique unaire et plusieurs opérateurs logiques binaires. Les arguments de tous ces opérateurs sont des littéraux logiques (constantes), des variables logiques et des expressions ayant une valeur logique.

Les opérateurs logiques ont la priorité suivante : négation, conjonction, disjonction.

Tout comme pour les opérateurs arithmétiques, les parenthèses sont utilisées pour ajuster la priorité d'une opération. Si une paire de parenthèses est imbriquée dans une autre paire de parenthèses, la valeur entre parenthèses intérieures est évaluée en premier.

Exemples d'utilisation d'opérateurs logiques

Booléen a = vrai ; booléen b; booléen c; b = une || vrai; // b est vrai b = !b; // b faux System.out.println(b); // affiche la valeur false sur la console a = a || b; // a est vrai c = a && (a || b); // avec vrai System.out.println(c); // affiche sur la console la valeur true boolean m; booléen w; m = 5 >= 4 ; // vrai m = 5 != 5 || FAUX; // faux w = m == faux ; // true System.out.println(w); // affiche la valeur true sur la console

Opérateurs de succursales

Syntaxe de l'instruction de branche si sinon

If (condition)( ... // opérateur composé n° 1 ) else ( ... // opérateur composé n° 2 )

Si une instruction composée dans la branche principale ou alternative d'une instruction de contrôle ne contient qu'une seule instruction simple, les accolades peuvent être omises. Dans ce cas, la syntaxe de l'opérateur de branche prendra la forme :

Si (condition) ... // opérateur simple n°1 ; sinon... simple déclaration n°2 ;

L'objectif principal de l'opérateur de branchement est de mettre en œuvre des algorithmes de branchement. Par exemple, un fragment d'un programme pour calculer la fonction : Y(x) = x*x, pour x< 0 и Y(x) = 2*x, при x >= 0

Int x, y ; // Lecture des valeurs x, y depuis la console Scanner in = new Scanner(System.in); System.out.println("Entrez x:"); x = in.nextLine(); System.out.println("Entrez y:"); y = in.nextLine(); si(x< 0) y = x*x; else y = 2*x; System.out.printf ("Результат: %i\n", y);

Lors de la construction de programmes avec plusieurs instructions de branchement consécutives, la règle suivante doit être prise en compte : instruction autre fait référence à la dernière déclaration si. Par exemple, considérons un fragment de programme :

Si (x > 10,0) y = 2*x + 5 ; si (y< z) y = fabs(x); else y = 2.5*x;

S'il est nécessaire de rompre cet ordre (c'est-à-dire une succursale autre se référer au premier opérateur si), alors il faut inclure la deuxième instruction if dans l'opérateur composé de la branche directe de la première instruction if :

Si (x > 10,0) ( y = 2*x + 5; si (y< z) y = fabs(x); } else y = 2.5*x;

En programmation, il est souvent nécessaire de créer des instructions de branchement en cascade. La syntaxe d'une telle structure est :

Si (condition n° 1) (énoncé composé n° 1) sinon si (condition n° 2) (énoncé composé n° 2) ... ( ) sinon si (condition n° N) (énoncé composé n° N) sinon (déclaration composée n° N+ 1)

Branchement multivarié, instruction switch

Conception si sinon peut être gênant si vous devez choisir parmi plusieurs options. Opérateur changer fournit un moyen clair de basculer entre différents morceaux de code en fonction de la valeur d'une seule variable ou expression. La forme générale de cet opérateur est :

Switch (choix) (valeur de cas1 : pause ; valeur de cas2 : pause ; valeur de cas : pause ; valeur par défaut : )

L'exécution du code commence au niveau de l'étiquette cas, correspondant à la valeur de l'expression choix, et continue jusqu'à l'instruction suivante casser ou fin de déclaration changer. Si aucune étiquette ne correspond à la valeur de la variable, la section par défaut est exécutée, si elle est fournie.

Notez que l'étiquette cas doit être un entier. Vous ne pouvez pas vérifier les chaînes. Toutes les valeurs de cas doivent être des littéraux uniques. Si deux instructions case contiennent les mêmes valeurs, le traducteur générera un message d'erreur.

Notez que l'instruction par défaut est facultative. Dans le cas où aucune des instructions case ne correspond à la valeur de l'expression et dans changer il n'y a pas d'instruction par défaut. L'exécution du programme continue avec l'instruction qui suit l'instruction switch.

Si case ne se termine pas par une instruction break, alors après la section case en cours, la suivante sera exécutée. Parfois, il est pratique d'avoir plusieurs sections case contiguës dans une instruction switch, non séparées par une instruction break.

boucles Java

Il existe deux types de boucles en Java :

• boucle comme « while » - while et do… while
• tapez "n-time" - pour (initialisation ; condition ; itération)

Le premier type de « pendant » est conçu pour répéter une action tant qu’une certaine condition est remplie. Exemple : augmenter la valeur d'une variable de 3 jusqu'à ce qu'elle atteigne trois chiffres.

Le deuxième type « n-time » est destiné à répéter certaines actions un nombre de fois prédéterminé. Exemple : trouver la factorielle de 6.

Boucles while et do... while

Opérateur alors que répète les actions spécifiées tant que son expression a une vraie valeur.

Syntaxe de la boucle While

While (expression logique) ( ​​... // corps de la boucle )

Un exemple de sortie de valeurs de tableau sur la console :

String lst = ("Hiver", "Été", "Automne", "Printemps"); int je = 0; pendant que(i++< lst.length){ System.out.print(lst[i] + " "); }

La condition de nécessité de répéter le cycle est vérifiée avant chaque étape du cycle, y compris la toute première.

Java offre également la possibilité d'utiliser une boucle avec des tests post-conditions. Pour l'écrire, on utilise une construction d'opérateurs faire... pendant que.

Do ( ... // corps de la boucle ) while (expression logique)

La boucle suivante sera exécutée 4 fois et "1 2 3 4" sera imprimé sur la console :

Int je = 0 ; faire ( i++; System.out.print(Integer.valueOf(i) + " "); ) while(5 > i);

Corps de boucle faire... pendant que exécuté au moins une fois. Cet opérateur est pratique à utiliser lorsqu'une action du programme doit être effectuée au moins une fois, mais dans certaines conditions, elle devra être répétée plusieurs fois.

pour la boucle

Opérateur pour contient trois paramètres : paramètre d'initialisation, paramètre de répétition, paramètre d'itération.

pour la syntaxe de la boucle

For (initialisation; condition; itération) ( // corps de la boucle, c'est-à-dire actions répétées cycliquement)

Le premier paramètre définit une variable qui servira à compter le nombre de répétitions de la boucle. Cela s'appelle un compteur. Le compteur reçoit une valeur initiale (ils indiquent à partir de quelle valeur il va changer). Le deuxième paramètre indique une certaine limitation sur le compteur, c'est-à-dire à quelle valeur cela changera. Le troisième paramètre spécifie une expression qui modifie le compteur après chaque étape de boucle. Il s'agit généralement d'un incrément ou d'un décrément, mais vous pouvez utiliser n'importe quelle expression dans laquelle le compteur se verra attribuer une nouvelle valeur.

Le programme présenté affiche les valeurs du tableau sur la console :

String lst = ("Hiver", "Été", "Automne", "Printemps"); // dans l'ordre direct pour (int i = 0; i< lst.length; i++) { System.out.print(lsti] + " "); } // в обратном порядке for (int i = (lst.length - 1); i >= 0 ; i--) ( System.out.print(lsti] + " "); )

En un seul cycle, vous pouvez régler plusieurs compteurs à la fois. Pour ce faire, vous devez séparer plusieurs expressions en itération et initialisation par des virgules. Une seule condition de répétition peut être spécifiée, mais il peut s'agir d'une expression contenant plusieurs compteurs à la fois.

Le code présenté affichera la séquence suivante sur la console : « 0 -1 -4 -9 -16 -25 »

Pour(int a = 0, b = 0; a - b<= 10; a++, b--){ System.out.print(" " + a*b); }

Interrompre un cycle, pause

Pour terminer la boucle plus tôt, utilisez l'opérateur casser. Dans ce cas, il y a une sortie immédiate du cycle ; l'étape en cours ne sera pas terminée. Ceux. s'il y avait d'autres instructions après la pause, elles ne seront pas exécutées.

Exemples de boucles d'interruption :

// Interrompt la boucle for for (int a = 1; a<= 10; a++){ if (a == 5) break; System.out.println("a = " + a); } // Прерывание цикла while int s = 100; while(true) { System.out.print(s +" "); s = s / 2; if (s == 0) break; System.out.println("s = " + s); }

Interrompre la boucle, continuer

Pour interrompre la boucle, vous pouvez utiliser l'opérateur continuer. Contrairement à l'instruction break, qui termine la boucle, l'instruction continue interrompt uniquement l'étape en cours de la boucle et transfère le contrôle au début de la boucle.

// Interrompt la boucle while int s = 100; while(true) ( ​​​​​​System.out.print(s +" "); s = s / 2; if (s == 25) continue; else if (s == 0) ( break; ) else System.out .println ("s = " + s);

Dans l'exemple, si la valeur de s est égale à 25, la prochaine itération de la boucle sera interrompue et le contrôle sera transféré au début de la boucle.

Si l'opérateur continuer utilisé en boucle pour, il transférera alors le contrôle à l'opérateur d'incrémentation du compteur de boucle.