Programmer en blocs : boucles « répéter jusqu'à » et « Mes blocs »

Ce script dessine un carré : après son état initial, il prend huit blocs — quatre fois les deux mêmes. L'écrire avec moins de blocs, sans changer ce que dessine le lutin.

Le groupe « avancer de \(100\) pas, tourner \(\circlearrowright\) de \(90\) degrés » revient quatre fois : le bloc orange en forme de C « répéter 4 fois » l'enveloppe. Trois blocs écrits — le répéter et les deux blocs de son corps — au lieu de huit ; le lutin exécute toujours huit blocs de mouvement.

Définition — Le bloc répéter

Le bloc « répéter \(n\) fois » est une boucle, en forme de C : les blocs placés à l'intérieur du C — son corps — sont exécutés \(n\) fois de suite, un tour après l'autre ; puis le lutin continue avec le bloc placé sous le C. Un répéter dans un répéter s'exécute en entier à chaque tour du répéter extérieur, comme pour le robot sur papier.

Méthode — Le motif répété

Repérer le motif qui revient — un côté et un virage, une marche, un pétale — et compter les tours : ils se comptent sur papier, tour par tour.
Vérifier la direction à la fin d'un tour : si le motif ne ramène pas le lutin dans sa direction de départ, le tour suivant part dans une autre direction — exprès ou non.
Regarder ce qui vient après le C : il s'exécute une fois, après le dernier tour.

Méthode — Un polygone régulier

Pour dessiner un polygone régulier à \(n\) côtés (\(n\) entier, \(n \geqslant 3\)), le lutin répète \(n\) fois « avancer (d'un côté), tourner \(\circlearrowright\) de \(360 / n\) degrés ».

Pourquoi \(360 / n\) : à chaque sommet le lutin tourne de l'angle extérieur ; après \(n\) sommets il a fait un tour complet, \(360\) degrés, et regarde de nouveau dans sa direction de départ. Cet angle n'est pas, en général, l'angle intérieur du polygone : pour le carré, les deux valent \(90\), ce qui cache la différence ; pour le triangle équilatéral, l'angle intérieur vaut \(60\) et le lutin tourne de \(120\).
Vérifier : \(n\) fois \(360 / n\) fait \(360\) — le lutin regarde de nouveau dans sa direction de départ ; et, comme les \(n\) côtés sont égaux, ainsi que les \(n\) virages, le dessin se referme sur son point de départ.

Exemple

Que dessinent ces deux scripts ?

À gauche : \(3\) tours de « \(100\) pas, tourner \(\circlearrowleft\) de \(120\) » : \(360 / 3 = 120\), un triangle équilatéral de côté \(100\), dessiné vers le haut puisque les virages sont à gauche. À droite : \(6\) tours de « \(50\) pas, tourner \(\circlearrowleft\) de \(60\) » : \(360 / 6 = 60\), un hexagone régulier de côté \(50\). Dans les deux, le lutin finit à son point de départ, en regardant vers la droite.

Exemple

Que dessine ce script ? Où est le lutin à la fin ?

Chaque tour du répéter extérieur : un carré de côté \(60\) (quatre fois « \(60\) pas, tourner \(\circlearrowleft\) de \(90\) », retour au coin, tourné vers la droite), puis un saut de \(90\) pas stylo levé. Trois tours : trois carrés à la suite, espacés de \(30\) pas — une frise. Le lutin finit \(90\) pas après le coin de départ du troisième carré, en \((70 ; 30)\), en regardant vers la droite.

Exemple

Ce script dessine un rectangle. Comment le modifier pour qu'il dessine un carré de côté \(120\), en partant toujours de \((-80 ; -30)\) ?

Le rectangle est « grand côté, virage, petit côté, virage » deux fois : \(160\) sur \(60\). Un carré a quatre côtés égaux : remplacer les deux « avancer » par « avancer de \(120\) pas » — ou, plus simple, garder un seul « avancer de \(120\) » et un virage, et répéter \(4\) fois. Deux paramètres changés, ou un motif raccourci : deux scripts justes pour le même dessin.

Le carré à trois côtés

« répéter 3 fois » avec « avancer, tourner \(\circlearrowright\) de \(90\) » depuis la direction \(90\) dessine trois côtés et laisse le lutin regarder vers le haut, pas dans sa direction de départ : le carré est ouvert. « répéter 5 fois » dessine le premier côté deux fois. Et « tourner de \(90\) » ne dessine aucun triangle équilatéral : son angle extérieur est \(120\). Le nombre de tours et l'angle se lisent ensemble — \(n\) tours de \(360 / n\).

Compétences à pratiquer

Quelle figure ?
Remplir les ovales
Modifier un script
Écrire avec un répéter

II Si… alors… sinon

Ce script doit dire « plus grand que 10 » quand le nombre tapé est plus grand que \(10\), et « 10 ou moins » sinon. Tel quel, il dit « plus grand que 10 » quoi que tape l'utilisateur.

Avec les blocs vus jusqu'ici, le lutin peut-il dire deux choses différentes selon le nombre ? Que manque-t-il ?

Non : les blocs vus jusqu'ici s'exécutent tous, toujours, de haut en bas. Ce qui manque est un bloc qui choisit : le « si … alors … sinon » orange, avec dedans un bloc hexagonal vert — « réponse \(>\) 10 » — qui est vrai ou faux.

Pour \(7\), « \(7 > 10\) » est faux : le lutin dit « 10 ou moins ». Pour \(15\), c'est vrai : « plus grand que 10 ». Pour \(10\) exactement, « \(10 > 10\) » est faux : « 10 ou moins » — la frontière est dans la branche « sinon ».

Définition — Une condition

Une condition est un bloc vert hexagonal qui est soit vrai, soit faux : « ( ) \(<\) ( ) », « ( ) \(>\) ( ) », « ( ) \(=\) ( ) ». Sa valeur est calculée au moment où elle est testée, avec ce que contiennent alors les trous — pour « réponse \(>\) 10 », avec la dernière saisie. Un bloc hexagonal n'entre que dans un trou hexagonal, comme celui d'un « si ».
Il n'y a pas de bloc « \(\leqslant\) » : « 10 ou moins » est le « sinon » de « \(>\) 10 ».

Définition — Si… alors, si… alors… sinon

« si … alors » a une branche : quand la condition est vraie, les blocs dans le C sont exécutés ; quand elle est fausse, il ne se passe rien, et le script continue sous le C.
« si … alors … sinon » a deux branches : les blocs de la première quand la condition est vraie, les blocs après « sinon » quand elle est fausse. Exactement une des deux branches est exécutée, jamais les deux, jamais aucune.

Méthode — La garde

Pour écrire ou lire un « si », la condition se traite comme une garde à une porte :

Écrire la condition en bloc hexagonal, avec ce qui est comparé de chaque côté : « réponse \(>\) 10 ».
Dire ce qui se passe quand elle est vraie, et quand elle est fausse — le second cas compris : avec une seule branche, « faux » veut dire « rien ».
Tester avec trois valeurs : une de chaque branche et la valeur frontière. Pour « \(>\) 10 » : \(7\), \(15\) et \(10\) — la frontière montre de quel côté tombe le cas d'égalité.

Exemple

Que dit le lutin si l'utilisateur tape « sésame » ? Et « Sésame » ? Et « ouvre » ?

« = » compare aussi des textes. « sésame » est égal au texte du bloc : « Bienvenue ! ». « ouvre » ne l'est pas : « Mauvais mot de passe ». Pour « Sésame », Scratch ignore la différence entre majuscules et minuscules : « Bienvenue ! » aussi. Une condition n'a pas besoin de nombre.

Exemple

Que dit le lutin pour \(8\), \(10\), \(12\), \(15\) et \(18\) ?

Un « si … sinon » dans le « sinon » d'un autre donne trois cas. \(8\) : « \(8 < 10\) » vrai, « Il faut travailler ». \(10\) : « \(10 < 10\) » faux, puis « \(10 < 15\) » vrai, « Bien » — la frontière \(10\) tombe dans la branche du milieu. \(12\) : faux, puis « \(12 < 15\) » vrai, « Bien ». \(15\) : « \(15 < 10\) » faux, « \(15 < 15\) » faux, « Très bien » — la frontière \(15\) tombe dans la dernière branche. \(18\) : « Très bien ». Trois cas, deux conditions, et les deux frontières \(10\) et \(15\) vérifiées exprès.

Définition — Modulo

Le bloc vert « ( ) modulo ( ) » donne le reste de la division d'un nombre entier par un entier autre que \(0\) : « 17 modulo 5 » vaut \(2\), puisque \(17 = 3 \times 5 + 2\). Un entier est pair quand son reste par \(2\) est \(0\), impair quand il est \(1\) : la condition « ( réponse modulo 2 ) \(=\) 0 » est vraie exactement pour les nombres pairs — à condition que la saisie soit un entier.

Exemple

Que dit le lutin pour \(14\), \(27\) et \(0\) ?

« 14 modulo 2 » vaut \(0\) : « pair ». « 27 modulo 2 » vaut \(1\) : la condition est fausse, « impair ». « 0 modulo 2 » vaut \(0\) : « pair » — zéro est pair. Le bloc intérieur est calculé d'abord, puis comparé à \(0\).

D'autres événements, et une boucle sans fin

Jusqu'ici, un script démarre au drapeau, et chaque « si » est testé une seule fois, quand le script y arrive. Un jeu doit réagir aux touches du clavier et surveiller le bord de la scène sans arrêt : il lui faut d'autres événements que le drapeau, et une boucle qui ne s'arrête pas.

Définition — Un événement de plus : une touche

Le bloc chapeau « quand la touche [flèche droite] est pressée » lance son script à chaque fois que cette touche est pressée — comme le drapeau lance un script quand on clique dessus. « ajouter 10 à x » ajoute \(10\) au \(x\) du lutin : avec ces deux scripts, chaque appui déplace le lutin de \(10\) pas vers la droite ou vers la gauche. Un lutin peut porter plusieurs scripts, chacun attendant son propre événement.

Définition — Répéter indéfiniment et un capteur

Le bloc C orange « répéter indéfiniment » n'a pas de nombre de tours : ses blocs sont exécutés tour après tour jusqu'au clic sur le signe stop. Rien ne peut être placé sous lui.
Un capteur est un bloc hexagonal de la catégorie Capteurs dont la valeur vient de la scène : « touche le bord ? » est vrai quand le lutin touche un bord de la scène. Placé dans un « si » à l'intérieur d'un « répéter indéfiniment », il est testé à chaque tour — un « si » écrit une fois, hors de toute boucle, est testé une fois, au moment où le script y arrive.

Méthode — Le bord

Pour faire bouger le lutin sans qu'il quitte la scène :

L'état initial : aller à un point, s'orienter — comme pour tout script qui bouge.
« répéter indéfiniment » : dedans, « avancer de 10 pas » — un petit pas par tour.
La garde, dans la boucle : « si touche le bord ? alors rebondir si le bord est atteint » — le bloc rebondir retourne le lutin (la direction \(90\) devient \(-90\)), si bien que le tour suivant l'éloigne du bord.

Sur papier, le lutin est suivi comme un point : à \(10\) pas par tour depuis \((0 ; 0)\), tourné vers la droite, il atteint le bord droit \(x = 240\) après \(24\) tours, rebondit, et revient.

Exemple

Le lutin porte ces quatre scripts et part de \((0 ; 0)\). L'utilisateur appuie trois fois sur la flèche droite, deux fois sur la flèche haut, puis une fois sur la flèche gauche. Où est le lutin ?

Chaque appui exécute une fois le script correspondant. Droite trois fois : \(x = 30\). Haut deux fois : \(y = 20\). Gauche une fois : \(x = 30 - 10 = 20\). Le lutin est en \((20 ; 20)\) ; sa direction n'a pas changé, puisque « ajouter à x » déplace sans tourner.

Exemple

Suivre le lutin comme un point pendant les six premiers tours de la boucle. Où est-il, et dans quelle direction regarde-t-il, après le tour \(6\) ?

tour	après « avancer »	touche le bord ?	direction
1	\((210 ; 0)\)	faux	\(90\)
2	\((220 ; 0)\)	faux	\(90\)
3	\((230 ; 0)\)	faux	\(90\)
4	\((240 ; 0)\)	vrai : rebondit	\(-90\)
5	\((230 ; 0)\)	faux	\(-90\)
6	\((220 ; 0)\)	faux	\(-90\)

Après le tour \(6\) le lutin est en \((220 ; 0)\), tourné vers la gauche. À l'écran, le costume touche le bord bien avant que le centre atteigne \(240\) — avec le chat, dès que son centre dépasse environ \(190\), donc ici dès le premier tour ; sur papier, le lutin est un point.

Trois rôles, et trois pièges

Le chapeau déclenche le script, la boucle répète ses blocs, la condition teste — trois blocs différents pour trois tâches différentes.

Un « si » sans « sinon » ne fait rien quand la condition est fausse : si le lutin doit toujours répondre, il faut deux branches.
Un « si touche le bord ? » placé hors de toute boucle est testé une fois, au départ, quand le lutin est loin du bord : le lutin ne rebondit jamais.
« réponse \(=\) 12 » est vrai pour la saisie « 12 » : ce qui est tapé est comparé comme un nombre quand les deux membres sont des nombres, comme un texte sinon.

Compétences à pratiquer

Lire une condition
Prévoir ce que dit le lutin
Pair ou impair
Écrire une condition
Touches et bords

III Une variable

Dix fois, le lutin demande un nombre entier et dit s'il est pair ou impair. À la fin, il doit aussi dire combien de nombres pairs ont été tapés. Pourquoi « réponse » ne peut-elle pas le faire ?

« réponse » contient une seule chose : la dernière saisie. Compter demande une mémoire qui garde un total d'un tour à l'autre et grandit de \(1\) à chaque nombre pair : une variable, appelée ici « pairs ». Elle est mise à \(0\) avant la boucle, augmentée de \(1\) dans le « si », et dite à la fin.

Définition — Une variable

Une variable est une boîte avec un nom, qui contient une valeur — un nombre ou un texte. « réponse » en est une, remplie par « demander » ; les autres se créent dans la catégorie « Variables ». Trois blocs se servent de celles-ci :

« mettre [total] à 0 » met une valeur dans la boîte, quel que soit son contenu précédent ;
« ajouter 1 à [total] » ajoute \(1\) à ce que contient la boîte (avec un nombre négatif, il soustrait) ; le trou peut recevoir « réponse » ou une formule ;
le bloc rond (total) lit la valeur, et entre dans tout trou rond : « dire (total) », « avancer de (total) pas ».

La valeur est affichée sur la scène dans un petit moniteur. Comme la position du lutin, elle est gardée d'une exécution à l'autre et le drapeau ne remet rien en place : un script qui compte commence par régler sa variable — on dit qu'il l'initialise.

Définition — Nombre aléatoire

Le bloc vert « nombre aléatoire entre 1 et 6 » donne un entier de \(1\) à \(6\), bornes comprises, chacun des six aussi probable que les autres : un dé équilibré. À chaque évaluation du bloc, un nouveau tirage est fait : deux blocs de ce type dans le même tour peuvent donner deux valeurs différentes. Pour utiliser un tirage deux fois — le tester, puis le dire — on le range d'abord dans une variable : « mettre [dé] à (nombre aléatoire entre 1 et 6) ».

Méthode — Le compteur

Pour compter combien de fois quelque chose arrive pendant une boucle :

Avant la boucle : « mettre [compteur] à 0 » — jamais dedans, sinon le compte repart à chaque tour.
Dans la boucle, sous la condition : « ajouter 1 à [compteur] » dans le « si » qui reconnaît la chose à compter. Sans condition, le compteur compte les tours.
Après la boucle : lire le compteur — « dire (compteur) ».

Méthode — L'accumulateur

Pour additionner des valeurs qui arrivent une à une :

« mettre [total] à 0 » avant la boucle.
À chaque tour : obtenir la valeur — « demander … et attendre » — puis « ajouter (réponse) à [total] » : le total grandit de la valeur, pas de \(1\).
Après la boucle : « dire (total) ».

Le compteur est un accumulateur qui ajoute \(1\). Un accumulateur qui multiplie change deux blocs : il part de \(1\) — « mettre [produit] à 1 », car \(0\) fois n'importe quoi fait \(0\) — et, à l'étape 2, « mettre [produit] à (produit \(*\) réponse) » remplace « ajouter » : le bloc calcule d'abord produit \(*\) réponse avec l'ancienne valeur, puis range le résultat dans la boîte.

Méthode — Le tableau d'états

Pour suivre un script avec une variable, un tableau remplace le tableau des positions du niveau précédent :

Une colonne par variable, plus « tour », « bloc » et « dit ». La première ligne est l'état initial, après les blocs « mettre ».
Une ligne par bloc qui change quelque chose — un « mettre », un « ajouter », un « dire » — avec la nouvelle valeur de la variable.
Pour un script aléatoire, le tableau se remplit sur une suite de tirages donnée (« le dé donne 3, 6, 6, 1 … »). Ce que fait chaque tour se prévoit ; le total final d'une vraie exécution, non — il peut changer d'une exécution à l'autre.

Exemple

Que dit le lutin ? Remplir le tableau d'états.

tour	bloc	n	dit
–	mettre n à 0	\(0\)
1	ajouter 1 à n	\(1\)
2	ajouter 1 à n	\(2\)
3	ajouter 1 à n	\(3\)
4	ajouter 1 à n	\(4\)
5	ajouter 1 à n	\(5\)
–	dire (n)	\(5\)	« 5 »

Le lutin dit « 5 » : sans condition, le compteur compte les tours.

Exemple

L'utilisateur tape \(4\), puis \(9\), puis \(12\). Que dit le lutin ?

tour	réponse	bloc	total
–		mettre total à 0	\(0\)
1	\(4\)	ajouter (réponse) à total	\(4\)
2	\(9\)	ajouter (réponse) à total	\(13\)
3	\(12\)	ajouter (réponse) à total	\(25\)

Le lutin dit « Total : 25 ». « réponse » est remplacée à chaque tour ; « total » garde la somme.

Exemple

Le dé donne, dans l'ordre, \(3\), \(6\), \(6\), \(1\), \(5\), \(6\), \(2\), \(4\), \(6\), \(3\). Que dit le lutin ?

tour	dé	dé \(=\) 6 ?	six
–			\(0\)
1	\(3\)	faux	\(0\)
2	\(6\)	vrai	\(1\)
3	\(6\)	vrai	\(2\)
4	\(1\)	faux	\(2\)
5	\(5\)	faux	\(2\)
6	\(6\)	vrai	\(3\)
7	\(2\)	faux	\(3\)
8	\(4\)	faux	\(3\)
9	\(6\)	vrai	\(4\)
10	\(3\)	faux	\(4\)

Le lutin dit « 4 ». Avec une autre suite de tirages il dirait un autre nombre : le tableau prévoit ce que fait chaque tour, pas le résultat d'une vraie exécution.

Exemple

Le dé donne \(4\), \(2\), \(6\) et le joueur répond \(4\), \(5\), \(6\). Que dit le lutin à la fin ?

Tour \(1\) : dé \(4\), réponse \(4\), égaux : score \(1\). Tour \(2\) : dé \(2\), réponse \(5\) : le score reste \(1\). Tour \(3\) : dé \(6\), réponse \(6\) : score \(2\). Le lutin dit « Score : 2 ». Le tirage est d'abord rangé dans « dé », pour que la même valeur soit comparée à la réponse.

Exemple

Une variable dans un tracé. Que dessine ce script ? Donner la longueur de chaque côté et la position finale du lutin.

« longueur » part de \(10\) et grandit de \(10\) après chaque côté : les côtés mesurent \(10\), \(20\), \(30\), …, \(80\). Avec un virage à droite après chacun, le lutin dessine une spirale carrée : \((10 ; 0)\), \((10 ; -20)\), \((-20 ; -20)\), \((-20 ; 20)\), \((30 ; 20)\), \((30 ; -40)\), \((-40 ; -40)\), \((-40 ; 40)\). Après huit quarts de tour il regarde de nouveau vers la droite.

Exemple

Dans le script de la spirale, « mettre [longueur] à 10 » est remplacé par « ajouter 10 à [longueur] ». La variable vient d'être créée (elle vaut \(0\)). Qu'est-ce qui change quand on clique deux fois de suite sur le drapeau ?

La variable n'est plus remise à \(10\). À la fin de la première exécution, « longueur » vaut \(90\) ; la seconde commence par ajouter \(10\) : son premier côté mesure \(100\), et la spirale n'est plus la même. « mettre » donne un départ neuf, « ajouter » construit sur ce qui est là — une variable qu'on ne règle jamais garde la valeur de l'exécution précédente, exactement comme la position du lutin au niveau précédent.

Trois pièges de la variable

Non initialisée : un compteur sans « mettre … à 0 » continue depuis la dernière exécution.
« mettre » au lieu d'« ajouter » : « mettre [total] à (réponse) » oublie les valeurs précédentes — le total est la dernière saisie, pas la somme.
Le hasard tiré deux fois : « si (nombre aléatoire entre 1 et 6) \(=\) 6 alors dire (nombre aléatoire entre 1 et 6) » teste un tirage et en dit un autre. Ranger le tirage dans une variable.

Compétences à pratiquer

Lire une variable
Suivre un script
Tirages sur une suite donnée
Écrire avec une variable
Modifier un script

IV Répéter jusqu'à

Le lutin tire un nombre secret de \(1\) à \(20\) et le joueur doit le trouver. Avec un « répéter 5 fois », le jeu demande cinq fois quoi qu'il arrive : quand le joueur trouve le nombre au deuxième essai, le lutin demande encore trois fois ; quand le joueur n'a pas trouvé après cinq essais, le jeu s'arrête quand même.

Combien de tours la boucle devrait-elle avoir ? De quelle sorte de boucle a-t-on besoin ?

Personne ne le sait d'avance : cela dépend du joueur. La boucle doit s'arrêter quand le nombre est trouvé, quel que soit le nombre de tours — un, ou trente. C'est un bloc nouveau : « répéter jusqu'à réponse \(=\) secret ». Sa condition n'est pas un nombre de tours mais une condition d'arrêt, testée avant chaque tour.

La première question est posée avant la boucle : le test « réponse \(=\) secret » se fait avant le premier tour, et il doit porter sur une vraie proposition du joueur. Au clic sur le drapeau, Scratch vide « réponse » ; mais dans une deuxième partie, ou si le script est relancé autrement, « réponse » contient encore la dernière proposition, qui pourrait arrêter la boucle avant que le joueur ait joué.

Définition — Répéter jusqu'à

Le bloc C orange « répéter jusqu'à » est une boucle conditionnelle : son nombre de tours n'est pas écrit d'avance, il dépend d'une condition. Il exécute ses blocs tour après tour, et s'arrête quand la condition devient vraie. La condition est une condition d'arrêt : elle est testée avant chaque tour, le premier compris.

Si elle est déjà vraie quand le script arrive à la boucle, la boucle fait zéro tour.
Si elle ne devient jamais vraie, la boucle ne finit jamais : « répéter indéfiniment » est un « répéter jusqu'à » dont la condition n'arrive jamais.

Définition — Ce qui doit changer

L'arrêt vient de quelque chose qui change pendant la boucle : une variable que le corps modifie (« ajouter 1 à [n] »), une saisie (« demander » dans la boucle), ou ce que voit un capteur (le lutin avance vers le bord). Si la condition est fausse au départ et que rien de ce qu'elle regarde ne change, la boucle ne finit jamais. Modifier une variable ne suffit pas non plus : la condition doit finir par devenir vraie — « jusqu'à n \(=\) 10 » avec des pas de \(3\) depuis \(0\) passe par \(9\), puis \(12\), et ne s'arrête jamais.

Méthode — Jusqu'à

Pour lire ou écrire un « répéter jusqu'à » :

Écrire la condition d'arrêt — ce qui doit être vrai pour que la boucle s'arrête.
Dire ce qui change à chaque tour et finit par la rendre vraie.
Remplir le tableau d'états avec une colonne « arrêt ? », testée avant chaque tour : la ligne où elle devient vraie est la sortie, et le nombre de tours est le nombre de lignes où elle était fausse.

Méthode — La sentinelle

Pour prendre des saisies jusqu'à ce qu'un mot convenu — la sentinelle — soit tapé :

Un premier « demander » avant la boucle : le test d'arrêt, fait avant le premier tour, porte ainsi sur une vraie saisie — sans elle, il porterait sur une « réponse » vide (au drapeau) ou sur une saisie ancienne, qui pourrait faire sauter la boucle.
« répéter jusqu'à réponse \(=\) stop », avec dedans : traiter la saisie (la compter, l'ajouter), puis redemander.
Après la boucle : dire le résultat. La sentinelle elle-même n'est pas comptée : elle est testée avant le tour qui la compterait.

Exemple

Dans le script de la définition « Répéter jusqu'à » (« mettre [n] à 0 », « répéter jusqu'à n \(=\) 10 », « ajouter 1 à [n] »), combien de tours la boucle fait-elle, et que dit le lutin ? Remplir le tableau d'états.

avant le tour	n	n \(=\) 10 ?	action
1	\(0\)	faux	n \(\leftarrow\) 1
2	\(1\)	faux	n \(\leftarrow\) 2
…	…	faux	…
10	\(9\)	faux	n \(\leftarrow\) 10
11	\(10\)	vrai	sortie

Dix tours, et le lutin dit « 10 ». Le test est fait onze fois : dix « faux » et un « vrai ».

Exemple

Deux variantes de la même boucle. Que fait chacune ?

À gauche : « n » vaut déjà \(10\) quand la boucle est atteinte, la condition est vraie au premier test : zéro tour, le lutin dit « 10 » tout de suite. À droite : « n » prend les valeurs \(3\), \(6\), \(9\), \(12\), \(15\), … et n'est jamais égal à \(10\) : la condition ne devient jamais vraie, la boucle ne finit jamais, et le « dire » n'est jamais atteint. Une condition d'arrêt doit être atteignable.

Exemple

Le lutin est suivi comme un point. Que dit-il à la fin ?

Ici ce qui change n'est pas une variable mais la position : chaque tour rapproche le lutin de \(20\) pas du bord droit, \(x = 240\). Après \(12\) tours, \(x = 240\) : « touche le bord ? » devient vrai et la boucle s'arrête. Le compteur dit « 12 ». À l'écran, le costume touche le bord plus tôt — avec le chat, dès le dixième tour ; sur papier, le lutin est un point.

Exemple

Le reste par soustractions. L'utilisateur tape \(47\), puis \(6\). Remplir le tableau d'états et donner ce que dit le lutin.

La première saisie est gardée dans « a » ; la seconde reste dans « réponse » (\(6\)). « ajouter \(0 - 6\) à [a] » retire \(6\) à chaque tour, jusqu'à ce que « a \(<\) 6 » soit vrai.

avant le tour	a	a \(<\) 6 ?
1	\(47\)	faux
2	\(41\)	faux
3	\(35\)	faux
4	\(29\)	faux
5	\(23\)	faux
6	\(17\)	faux
7	\(11\)	faux
8	\(5\)	vrai : sortie

Sept soustractions : \(47 = 7 \times 6 + 5\). Le lutin dit « Reste : 5 ». Avec \(a = 0\) et \(b = 6\), « \(0 < 6\) » est vrai tout de suite : zéro tour, reste \(0\) — correct. Avec \(b = 0\), « a \(<\) 0 » n'est jamais vrai : la boucle ne finit jamais. C'est pourquoi le script demande des entiers plus grands que \(0\).

Jusqu'à n'est pas tant que

« répéter jusqu'à » s'arrête quand sa condition est vraie. D'autres langages utilisent « tant que », qui continue tant que sa condition est vraie : « jusqu'à n \(=\) 10 » est « tant que non (n \(=\) 10) ». En Python, cette boucle s'écrit « while », « tant que ».
Une condition jamais atteinte — « jusqu'à n \(=\) 10 » avec des pas de \(3\) — est le bug le plus courant de cette boucle : le script semble figé.
Le plus grand diviseur commun par soustractions, qui change deux variables tour à tour, attend la section suivante.

Compétences à pratiquer

Lire un jusqu'à
Compter les tours
Restes par soustractions
Écrire avec un jusqu'à

V Plusieurs variables et conditions composées

Le jeu de la section précédente demande jusqu'à ce que le nombre soit trouvé. On veut maintenant au plus cinq essais : le jeu s'arrête quand le nombre est trouvé, ou quand le cinquième essai a été joué. Le bloc « répéter jusqu'à » n'a qu'un trou hexagonal : comment y mettre deux conditions ? Que faut-il compter ?