Éducation Nationale Française · Cinquième
Programmer en blocs : le lutin parle et dessine
I
Les programmes
I.1
Le vocabulaire des programmes
Voici trois programmes. Le robot part de la case A1 en regardant vers la droite ; \(\rightarrow\) veut dire « avancer d'une case », \(\curvearrowleft\) « quart de tour à gauche ».
Quel point commun ont ces trois programmes ? Pour chacun, dire ce qui est donné au départ et ce qui est obtenu à la fin.
| Robot | Calcul | Construction |
| \(\rightarrow\ \rightarrow\ \curvearrowleft\ \rightarrow\ \rightarrow\) | Choisir un nombre. | Tracer un segment \([AB]\) de \(4\)~cm. |
| Le multiplier par \(2\). | Tracer la perpendiculaire à \((AB)\) en \(B\). | |
| Ajouter \(5\). | Placer \(C\) dessus, à \(3\)~cm de \(B\). | |
| Écrire le nombre obtenu. | Tracer le segment \([BC]\). |
Chacun des trois est une liste d'ordres, exécutés dans l'ordre, l'un après l'autre, sans rien décider : le robot se déplace, la calculatrice calcule, la main trace.
- Robot. Donné au départ : la case A1 et la direction « vers la droite ». Obtenu à la fin : la case d'arrivée — deux cases en avant jusqu'en C1, un quart de tour à gauche, le robot regarde maintenant vers le haut, deux cases en avant : C3.
- Calcul. Donné : un nombre, par exemple \(3\). Obtenu : \(3 \times 2 = 6\), \(6 + 5 = 11\) : le nombre \(11\). Avec \(10\) au départ, \(25\) à la fin : le même programme, un autre nombre.
- Construction. Donné : une feuille blanche. Obtenu : une figure — deux segments qui forment un angle droit en \(B\).
Définition — Instruction et séquence
Une instruction est un ordre assez précis pour être exécuté sans rien décider : « avancer d'une case », « multiplier par \(2\) », « tracer un segment de \(4\)~cm ». « Aller à la gare » n'est pas une instruction : celui qui la reçoit doit encore choisir le chemin.Une séquence d'instructions — un programme — est une liste d'instructions exécutées dans l'ordre, la première d'abord, la dernière en dernier. Les mêmes instructions dans un autre ordre font un autre programme : en partant de \(3\), « multiplier par \(2\), puis ajouter \(5\) » donne \(11\), tandis que « ajouter \(5\), puis multiplier par \(2\) » donne \(16\).
Définition — Entrée et sortie
L'entrée d'un programme est ce qui est donné avant de l'exécuter ; la sortie est ce qui est obtenu après. Le programme, lui, ne change pas : il est écrit une fois et fonctionne pour toute entrée permise. | Entrée | Sortie | |
| Programme du robot | la case et la direction de départ | la case et la direction d'arrivée |
| Programme de calcul | le nombre choisi | le nombre écrit |
| Programme de construction | une feuille blanche | la figure |
Méthode — Trois tâches avec une séquence
- Identifier. Cette ligne est-elle une instruction — peut-on l'exécuter sans rien choisir ? Cette liste est-elle une séquence — l'ordre compte-t-il, et est-il donné ?
- Exécuter. Exécuter une instruction à la fois, dans l'ordre, puis noter l'état après chacune : la case et la direction du robot, le nombre obtenu. Exécuter, c'est obéir exactement, même quand le programme a l'air faux.
- Produire. Pour obtenir une sortie imposée, mettre des cartes d'instructions dans l'ordre, puis exécuter la séquence obtenue pour vérifier qu'elle donne bien la sortie voulue. Si ce n'est pas le cas, c'est le programme qui est faux, pas celui qui l'exécute.
Exemple
- On dispose de trois cartes : « ajouter \(1\) », « multiplier par \(2\) », « multiplier par \(3\) ». Les mettre dans l'ordre pour que l'entrée \(4\) donne la sortie \(27\).
- Le robot part en regardant vers la droite. Lequel de ces deux programmes lui fait dessiner un carré ?
(a)\ \(\rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\) (b)\ \(\rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\)
- Essayer les ordres et exécuter chacun à partir de \(4\). « Multiplier par \(2\), ajouter \(1\), multiplier par \(3\) » : \(4 \times 2 = 8\), \(8 + 1 = 9\), \(9 \times 3 = 27\). Cet ordre convient. Un autre ordre, « ajouter \(1\), multiplier par \(2\), multiplier par \(3\) », donne \(4 + 1 = 5\), \(5 \times 2 = 10\), \(10 \times 3 = 30\) : pas \(27\).
- Exécuter les deux, en comptant les cases de chaque ligne droite. En (a), le robot fait \(2\) en avant, tourne à droite, \(2\) en avant, tourne à droite, \(2\) en avant, tourne à droite, \(2\) en avant : quatre côtés de \(2\) cases avec un quart de tour entre eux, il revient sur sa case de départ — un carré. En (b), les lignes droites font \(2\), \(1\), \(2\), \(1\) : un rectangle, pas un carré. Le programme (a).
Un programme n'a pas d'avis
Exécuter un programme, c'est lui obéir exactement : le robot ne devine pas où l'on voulait qu'il aille, le calcul ne se corrige pas tout seul. C'est pour cela qu'un programme se vérifie en l'exécutant, pas en le lisant et en le trouvant convaincant. Et c'est pour cela qu'on l'écrit une fois pour toutes les entrées : le même programme de calcul sert pour \(3\), pour \(10\), pour n'importe quel nombre choisi.
Compétences à pratiquer
- Identifier instructions et séquences
- Exécuter une séquence
- Produire une séquence
I.2
Répéter
Le robot part en regardant vers la droite et dessine un carré de \(3\) cases de côté : \(\rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright\ \rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright\) Seize instructions. Écrire ce programme plus court, sans changer ce que fait le robot.
Le même groupe de quatre instructions, \(\rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright\), revient quatre fois : un côté, puis un quart de tour. Le programme peut donc s'écrire répéter \(4\) fois \((\rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright)\) Le robot exécute toujours seize instructions — \(4\) côtés de \(3\) cases et \(4\) quarts de tour — et dessine toujours le même carré. Seule l'écriture est plus courte. En partant de B4 en regardant vers la droite, voici le carré que dessine le robot : 
(Rappel : pour le robot, \(\rightarrow\) veut dire « en avant, dans la direction où je regarde », pas « vers la droite de la feuille ».)
Définition — Répéter
L'instruction « répéter \(n\) fois ( …\ ) » exécute le groupe écrit entre les parenthèses — son corps — \(n\) fois de suite, puis continue avec ce qui suit la parenthèse. Chaque exécution du corps est un tour. On l'écrit aussi \(n \times (\ldots)\) : \(4 \times (\rightarrow\ \rightarrow\ \curvearrowright)\) et « répéter \(4\) fois \((\rightarrow\ \rightarrow\ \curvearrowright)\) » disent la même chose.Un programme avec un répéter a deux comptes :
- les instructions écrites : la ligne « répéter » et les instructions de son corps — pour « répéter \(4\) fois \((\rightarrow\ \rightarrow\ \rightarrow\ \curvearrowright)\) », \(1 + 4 = 5\) instructions écrites ;
- les instructions exécutées : le corps autant de fois qu'il y a de tours — \(4 \times 4 = 16\) instructions.
Méthode — Exécuter un répéter à la main
- Numéroter les tours. Écrire « tour 1 » et exécuter le corps en entier, une instruction à la fois, en notant l'état après chacune.
- Tour suivant. Revenir au début du corps et l'exécuter de nouveau, sous « tour 2 », et ainsi de suite jusqu'au tour \(n\).
- Après le dernier tour, continuer avec l'instruction qui suit la parenthèse — ne pas exécuter le corps une fois de plus.
- Un répéter dans un répéter : à chaque tour du répéter extérieur, le répéter intérieur est exécuté en entier, avec tous ses tours.
Exemple
Le robot part de A1, en regardant vers la droite, sur un quadrillage vide, et dessine son chemin. Exécuter « répéter \(3\) fois \((\rightarrow\ \rightarrow\ \curvearrowleft\ \rightarrow\ \curvearrowright)\) ». Où arrive-t-il, et que dessine-t-il ? | tour | instructions | état (case, regarde) |
| 1 | \(\rightarrow\ \rightarrow\) ; \(\curvearrowleft\) ; \(\rightarrow\) ; \(\curvearrowright\) | C1, droite ; C1, haut ; C2, haut ; C2, droite |
| 2 | \(\rightarrow\ \rightarrow\) ; \(\curvearrowleft\) ; \(\rightarrow\) ; \(\curvearrowright\) | E2, droite ; E2, haut ; E3, haut ; E3, droite |
| 3 | \(\rightarrow\ \rightarrow\) ; \(\curvearrowleft\) ; \(\rightarrow\) ; \(\curvearrowright\) | G3, droite ; G3, haut ; G4, haut ; G4, droite |
Exemple
La suite \(1\) ; \(2\) ; \(4\) ; \(8\) ; \(16\) ; …\ passe de chaque terme au suivant avec la même instruction. L'écrire comme un programme de calcul avec un répéter, puis déterminer son onzième terme.
D'un terme au suivant, le nombre est multiplié par \(2\). Le premier terme est \(1\), et atteindre le onzième demande \(10\) pas :
Le onzième terme est \(1\,024\). Quatre instructions écrites (la ligne « répéter » et son corps comptent pour deux), douze exécutées. Le tableau des tours est exactement ce qu'afficherait une colonne de tableur.
| Partir de \(1\). |
| Répéter \(10\) fois ( multiplier par \(2\) ). |
| Écrire le nombre obtenu. |
| tour | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| nombre | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 |
Exemple
À la règle et à l'équerre, un carré de \(4\)~cm de côté se trace aussi en répétant. Écrire le programme et dire d'où il repart à chaque tour.
Sur le papier, il n'y a pas de robot : le programme doit dire d'où repartir et de quel côté tourner, toujours le même.
Chaque tour repart de l'extrémité du côté qu'on vient de tracer, et le quart de tour est toujours vers la gauche : quatre côtés, quatre angles droits, et le quatrième côté revient en \(A\). Tourner à gauche à certains tours et à droite à d'autres ne donnerait pas un carré.
| Marquer un point \(A\) et choisir une direction. |
| Répéter \(4\) fois ( tracer un côté de \(4\)~cm à partir du point où l'on est ; |
| à l'extrémité de ce côté, tourner d'un quart de tour vers la gauche ). |
Pourquoi répéter ?
Un répéter rend un programme plus court et plus sûr : seize flèches recopiées à la main, ce sont seize occasions d'erreur, « répéter \(4\) fois » n'en est qu'une. Il dit aussi la structure : un carré, c'est quatre fois la même chose, un escalier, trois fois la même marche. Et compter les tours est exactement ce qu'une machine fait sans jamais se lasser : « répéter \(1\,000\) fois » ne s'écrit pas plus longuement que « répéter \(4\) fois », et la machine exécute les \(1\,000\) tours sans se tromper.
Compétences à pratiquer
- Exécuter un répéter
- Écrire avec un répéter
- Un répéter dans un répéter
I.3
Programmer un chemin
De la feuille à l'écran
À l'écran, un programme s'écrit avec des blocs qui s'emboîtent, et il est exécuté par un personnage — un lutin — qui se déplace en laissant un trait derrière lui. Les instructions sont celles du robot, avec deux conventions : 
- le lutin part d'une case du quadrillage, en regardant vers la droite ; le bloc « stylo en position d'écriture » lui fait dessiner son chemin ;
- « avancer de \(10\) pas » le fait avancer d'une case ; « tourner \(\circlearrowright\) de \(90\) degrés » est un quart de tour à droite et « tourner \(\circlearrowleft\) de \(90\) degrés » un quart de tour à gauche — la flèche montre de quel côté le lutin tourne, sur place.
Définition — Programme en blocs
Un programme en blocs est une séquence d'instructions écrite en blocs empilés de haut en bas : un bloc est une instruction, la pile est la séquence, et elle s'exécute depuis le haut. Un bloc répéter contient son corps ; les blocs placés à l'intérieur s'exécutent à chaque tour, le bloc placé dessous après le dernier tour. Méthode — Programmer un chemin simple
- Dessiner le chemin sur le quadrillage, de la case de départ à la case d'arrivée.
- Le découper en lignes droites et en virages. À chaque virage, décider pour le lutin si c'est à droite ou à gauche — suivre le chemin du doigt, en regardant où regarde le lutin.
- Un bloc par morceau : « avancer de \(10 \times k\) pas » pour une ligne droite de \(k\) cases, « tourner de \(90^\circ\) à droite/à gauche » pour chaque virage.
- Chercher un groupe qui revient — un côté et un virage, une marche d'escalier — et l'écrire une seule fois dans un bloc répéter.
- Exécuter le programme depuis le départ et comparer le trait obtenu au chemin voulu.
Exemple
Le bus part de l'École (case A1, \(\bullet\)), en regardant vers la droite, et doit atteindre le Stade (case E3, \(\bigstar\)). 
- Écrire un programme en blocs qui fait dessiner au bus son trajet.
- Dessiner ce que trace le programme « répéter \(4\) fois ( avancer de \(20\) pas ; tourner de \(90^\circ\) à droite ) » sur un quadrillage vide, en partant de B4.
- Les cases grises sont des immeubles : le bus longe la ligne 1 jusqu'en E1, puis monte jusqu'en E3 — \(4\) cases vers la droite, un virage, \(2\) cases vers le haut. En regardant vers la droite, monter est un virage à gauche.
- Quatre lignes droites de \(2\) cases avec un virage à droite après chacune : un carré de \(2\) cases de côté, tracé depuis B4 vers la droite, puis vers le bas — et le lutin finit là où il a commencé, en regardant de nouveau vers la droite.
Le bloc faux
Quand le trait obtenu n'est pas le chemin voulu, le lutin a obéi : l'erreur est dans le programme. Pour la trouver, exécuter le programme bloc par bloc et comparer, après chaque bloc, la case atteinte et la direction à celles attendues — le premier bloc après lequel elles diffèrent est le bloc faux (un virage faux ne change pas la case : c'est la direction qui le trahit). Un virage du mauvais côté, une ligne droite d'une case de trop, un répéter d'un tour de trop : trois erreurs qui ne se voient qu'en exécutant.
Compétences à pratiquer
- Lire un programme en blocs
- Écrire un programme en blocs
- Repérer le bloc faux
II
Programmer en blocs : le lutin
II.1
Le lutin et la scène
Sur papier, ce programme faisait dessiner un carré à un robot sur un quadrillage. On le recopie dans Scratch, bloc par bloc : 
En cliquant sur le drapeau vert : rien ne se passe. En cliquant sur la pile de blocs : le lutin bouge, mais rien ne se dessine ; et il part de là où il se trouve — déplacé à la souris entre deux clics, il ne refait pas le même chemin. Que manque-t-il ?
Trois choses, dont le robot sur papier n'avait pas besoin. 
- Un départ. Un script ne s'exécute que si quelque chose le déclenche : le bloc « quand drapeau vert est cliqué » posé en haut le fait démarrer au drapeau.
- Un stylo. Le lutin ne laisse un trait que si son stylo est posé : « effacer tout » pour nettoyer la scène d'abord, « relever le stylo » pour que le saut vers le départ ne laisse pas de trait, « stylo en position d'écriture » avant de dessiner.
- Un état initial. Le drapeau ne remet rien en place : le lutin reste là où la dernière exécution l'a laissé, stylo levé ou posé. « aller à x: \(-50\) y: \(50\) » et « s'orienter à \(90\) » le ramènent au même endroit, dans la même direction, à chaque fois.
Définition — Le lutin, la scène et le script
Dans Scratch, un programme est exécuté par un personnage, le lutin, sur un rectangle appelé la scène. La scène a \(480\) pas de large et \(360\) pas de haut ; chacun de ses points a deux coordonnées, \(x\) de \(-240\) à \(240\) et \(y\) de \(-180\) à \(180\), le centre étant en \((0 ; 0)\). Sur la scène, il n'y a plus de cases : le pas est son unité de longueur (« \(10\) pas = une case » n'était qu'une convention du quadrillage) ; sur les figures, un carreau fait \(50\) pas. Le lutin a toujours une position \((x ; y)\) et une direction, donnée en degrés : \(90\) veut dire « regarde vers la droite », \(0\) « vers le haut », \(-90\) « vers la gauche », \(180\) « vers le bas ».Un script est une pile de blocs qui s'emboîtent ; un bloc est une instruction, et le lutin les exécute de haut en bas. Les blocs sont rangés par catégories, une couleur chacune : mouvement (bleu), apparence (violet), événements (jaune), contrôle (orange), capteurs (bleu clair), opérateurs (vert), variables (orange foncé), stylo (vert foncé).
Définition — Démarrer un script
Un script commence par un bloc événement, un bloc « chapeau » au-dessus duquel rien ne peut se placer. Le plus courant est « quand drapeau vert est cliqué » : le script s'exécute quand on clique sur le drapeau vert au-dessus de la scène. Une pile de blocs sans chapeau ne démarre pas au drapeau — elle ne s'exécute que si l'on clique dessus.Le drapeau ne remet rien en place : position, direction, stylo levé ou posé, dessins restent comme la dernière exécution les a laissés. Un script qui dessine commence donc par son état initial : effacer tout, relever le stylo, aller à un point choisi, s'orienter dans une direction choisie, stylo en position d'écriture — le stylo d'abord relevé, sinon le saut vers le point de départ laisse un trait.
Définition — Se déplacer, dessiner, parler
- Se déplacer. « avancer de \(10\) pas » fait avancer le lutin de \(10\) pas, dans sa direction. « tourner \(\circlearrowright\) de \(15\) degrés » le fait tourner dans le sens des aiguilles d'une montre — vers sa droite — sans le déplacer ; « tourner \(\circlearrowleft\) » le fait tourner dans l'autre sens. « aller à x: \(0\) y: \(0\) » le fait sauter à un point ; « s'orienter à \(90\) » fixe sa direction.
- Dessiner. « stylo en position d'écriture » : à partir de là, le lutin dessine son chemin, sauts « aller à » compris ; « relever le stylo » : il se déplace sans dessiner ; « effacer tout » nettoie la scène.
- Parler. « dire Bonjour ! » affiche une bulle qui reste ; « dire Bonjour ! pendant \(2\) secondes » l'affiche deux secondes, puis l'efface, et le script attend pendant ce temps.
Méthode — Suivre le lutin
Pour lire un script, on suit le lutin bloc par bloc, comme on suivait le robot case par case. - Écrire l'état initial : position \((x ; y)\), direction, stylo levé ou posé — tels que les premiers blocs les fixent. Sans ces blocs, l'état est inconnu, et le dessin aussi.
- Exécuter un bloc à la fois, de haut en bas, puis écrire le nouvel état après chaque bloc qui le change : « avancer » change la position, « tourner » change seulement la direction, « dire » change ce que montre la bulle.
- Donner l'état final — et, si le stylo était posé, le trait dessiné.
Exemple
On clique sur le drapeau vert. Que dit le lutin, où est-il à la fin, et dans quelle direction regarde-t-il ? 
| bloc | position | direction |
| aller à x: \(0\) y: \(0\) ; s'orienter à \(90\) | \((0 ; 0)\) | \(90\) |
| dire « Bonjour ! » pendant \(2\) secondes | \((0 ; 0)\) | \(90\) |
| avancer de \(100\) pas | \((100 ; 0)\) | \(90\) |
| tourner \(\circlearrowleft\) de \(90\) degrés | \((100 ; 0)\) | \(0\) |
| avancer de \(50\) pas | \((100 ; 50)\) | \(0\) |
Exemple
Que dessine ce script ? Donner la position et la direction du lutin à la fin. 
État initial : \((-50 ; 50)\), direction \(90\), stylo posé. Puis quatre fois « \(100\) pas en avant, quart de tour à droite » : \((50 ; 50)\) regarde vers le bas (\(180\)), \((50 ; -50)\) vers la gauche (\(-90\)), \((-50 ; -50)\) vers le haut (\(0\)), \((-50 ; 50)\) vers la droite (\(90\)). 
Un carré de côté \(100\), et le lutin est revenu à son point de départ, dans sa direction de départ : \((-50 ; 50)\), \(90\).
Exemple
Que dessine ce script, et où finit le lutin ? 
« aller à » saute en ligne droite. Stylo posé, le saut de \((-100 ; 50)\) à \((100 ; -50)\) dessine un segment ; stylo levé, le saut vers \((0 ; 0)\) ne dessine rien. Le lutin finit au centre, et sa direction n'a jamais changé. 
Cinq pièges des premiers scripts
- « dire » laisse la bulle sur la scène ; « dire pendant \(2\) secondes » l'efface — et le script attend deux secondes avant le bloc suivant.
- « tourner » ne change que la direction : le lutin reste où il est. Deux scripts avec les mêmes « avancer » et des virages de côtés différents dessinent des figures en miroir.
- Un stylo levé ne dessine rien, quel que soit le chemin ; « effacer tout » efface les dessins, pas le lutin.
- Une pile sans bloc chapeau ne démarre jamais au drapeau.
- Un stylo resté posé à la fin d'une exécution dessine le saut « aller à » de la suivante : l'état initial relève le stylo avant de sauter.
Compétences à pratiquer
- Lire un script
- Les coordonnées sur la scène
- Mettre les blocs dans l'ordre
II.2
Demander et répondre
Ce script dit « Bonjour ! » à tout le monde. On voudrait qu'il dise « Bonjour Lina » à Lina et « Bonjour Noah » à Noah, avec un seul et même script. Que doit-il faire qu'il ne fait pas encore ?
Il doit recevoir une information de celui qui l'utilise : son prénom. Un script peut poser une question et attendre la réponse tapée au clavier ; ce qui a été tapé est ensuite gardé, et le script peut s'en servir dans son « dire ». Un seul et même script saluera alors Lina, Noah, ou n'importe qui : c'est ce que permettent les deux blocs de cette section.
Définition — Demander et la réponse
Le bloc « demander … et attendre » fait poser la question par le lutin, dans une bulle, et fait apparaître une case pour taper en bas de la scène ; le script attend que l'utilisateur valide. Ce qui a été tapé est ensuite gardé dans réponse, un bloc rond bleu clair que l'on peut glisser dans d'autres blocs. « dire (réponse) » l'affiche dans la bulle.« réponse » est une seule mémoire : chaque nouveau « demander » remplace ce qu'elle contenait. « réponse » est une variable : un nom sous lequel une valeur est gardée en mémoire — ici, c'est « demander » qui la remplit, et le script la lit.
Définition — Entrées et sorties d'un script
Les entrées d'un script sont ce que l'utilisateur lui donne pendant qu'il s'exécute : ce qui est tapé après un « demander », une touche pressée. Ses sorties sont ce qu'il montre : ce que dit le lutin, ce qu'il dessine, où il va. Le même script donne des sorties différentes pour des entrées différentes — c'est pour cela qu'on l'écrit. Sur papier, l'entrée était donnée avant d'exécuter (le nombre choisi, la case de départ) ; un script la reçoit pendant qu'il s'exécute, quand il la demande. Son point de départ n'est plus une entrée : c'est l'état initial, que le script fixe lui-même. Méthode — Entrée, puis sortie
Pour prévoir ce que fait un script avec un « demander » pour une entrée donnée : - Lire la question et écrire l'entrée à côté — ce que tape l'utilisateur.
- Remplacer « réponse » par cette entrée partout où elle apparaît en dessous, dans l'ordre. Un second « demander » remplace l'entrée pour les blocs qui le suivent.
- Écrire la sortie : exactement ce que montre la bulle, écrite entre guillemets quand c'est un texte.
Exemple
L'utilisateur tape « Lina ». Que dit le lutin ? 
L'entrée est « Lina », gardée dans « réponse ». Le bloc vert « regrouper » colle deux textes, sans rien ajouter entre eux : « Bonjour » suivi de « Lina » — l'espace qui les sépare a été tapé à la fin de « Bonjour ». Le lutin dit « Bonjour Lina » pendant deux secondes. Avec un autre prénom tapé, le même script dit un autre bonjour : c'est tout l'intérêt de « réponse ».
Exemple
L'utilisateur tape « Noah », puis « 12 ». Que dit le lutin à la fin ? 
Après le premier « demander », « réponse » contient « Noah ». Après le second, elle contient « 12 » : le prénom est parti. Le lutin dit « 12 ». Pour garder deux entrées, il faut deux mémoires : « réponse » seule ne garde que la dernière.
« réponse » est un texte tant qu'on ne calcule pas
Ce qui est tapé après un « demander » est gardé tel quel : « 12 » est le texte fait des chiffres 1 et 2. « dire (réponse) » l'affiche tel quel ; seul un calcul en fait un nombre.
Compétences à pratiquer
- Entrées et sorties
- Prévoir une réponse
- Écrire un dialogue
II.3
Les formules en blocs
Le programme de calcul « choisir un nombre ; ajouter \(6\) ; multiplier le résultat par \(3\) » donne \(30\) quand on choisit \(4\). Un bloc « dire » n'a qu'un trou : comment y faire tenir les deux opérations, dans le bon ordre, pour n'importe quel nombre tapé ?
Le nombre tapé est « réponse ». L'opération faite en premier doit se trouver à l'intérieur de l'autre : le bloc vert « réponse \(+\) 6 » se glisse dans un trou du bloc « ( ) \(*\) 3 », ce qui donne « (réponse \(+\) 6) \(*\) 3 » ; ce bloc entier entre dans le trou de « dire ». Pour \(4\) : \(4 + 6 = 10\), puis \(10 \times 3 = 30\). 
L'emboîtement joue le rôle des parenthèses.
Définition — Les blocs opérateurs
Les blocs opérateurs verts calculent : « ( ) + ( ) », « ( ) \(-\) ( ) », « ( ) \(*\) ( ) » pour un produit, « ( ) / ( ) » pour un quotient. Chacun a deux trous ronds, où l'on glisse un nombre, « réponse » ou un autre bloc opérateur. Un opérateur placé dans un autre est calculé en premier : l'emboîtement joue le rôle des parenthèses. La valeur est calculée au moment où le bloc s'exécute, avec ce que contient « réponse » à ce moment-là. 
Méthode — Traduire une formule
- De la formule aux blocs : repérer l'opération faite en dernier — c'est le bloc extérieur ; mettre dans ses trous les deux parties, traduites à leur tour. \((a + 10) \times 2\) : la dernière opération est \(\times\), le bloc extérieur est « ( ) \(*\) ( ) », son trou de gauche reçoit « ( ) + ( ) » avec \(a\) et \(10\), son trou de droite reçoit \(2\).
- Des blocs à la formule : partir du bloc extérieur et écrire des parenthèses autour de chaque bloc intérieur.
- Calculer pour une valeur : remplacer « réponse » par la valeur et calculer de l'intérieur vers l'extérieur.
Méthode — Du programme de calcul au script
Un programme de calcul — « choisir un nombre ; le multiplier par \(2\) ; ajouter \(5\) ; écrire le résultat » — devient un script en trois pas : - « Choisir un nombre » devient « demander un nombre et attendre » : le nombre choisi est « réponse ».
- Chaque instruction devient un bloc opérateur, qui reçoit le précédent dans un de ses trous : « réponse \(*\) \(2\) », puis « (réponse \(*\) \(2\)) + \(5\) ».
- « Écrire le résultat » devient « dire » avec le bloc extérieur dedans.
Exemple
L'utilisateur tape \(12\). Que dit le lutin ? 
« réponse » contient « 12 » ; le bloc « ( ) + ( ) » en fait le nombre \(12\) et calcule \(12 + 1 = 13\) ; « regrouper » colle le texte et le nombre. Le lutin dit « L'an prochain tu auras 13 ». C'est le premier calcul sur une entrée : le même script marche pour tout âge.
Exemple
Donner la formule calculée par ce script, puis ce que dit le lutin si l'utilisateur tape \(4\), puis \(9\). 
Le bloc extérieur est « ( ) \(*\) ( ) » ; son trou de gauche contient « réponse + 10 » : la formule est \((\text{réponse} + 10) \times 2\). Pour \(4\) : \((4 + 10) \times 2 = 28\) — le lutin dit « 28 ». Pour \(9\) : \((9 + 10) \times 2 = 38\).
Exemple
Écrire le programme de calcul « choisir un nombre ; le multiplier par \(2\) ; ajouter \(5\) ; écrire le résultat » comme un script et donner sa sortie pour \(7\).
« Choisir » est un « demander » ; « multiplier par \(2\) » est « réponse \(*\) \(2\) » ; « ajouter \(5\) » l'enveloppe : « (réponse \(*\) \(2\)) + \(5\) » ; « écrire » est « dire ». 
Pour \(7\) : \(7 \times 2 = 14\), \(14 + 5 = 19\) — le lutin dit « 19 ».
Exemple
Que calcule ce script ? Donner sa sortie pour \(6\). 
\(4 \times \text{réponse}\) est le périmètre d'un carré de côté « réponse ». Pour \(6\) : \(4 \times 6 = 24\), et « regrouper » ajoute l'unité — le lutin dit « 24 cm ». Une formule, un script, tous les carrés.
Deux emboîtements, deux formules
Avec les trois mêmes pièces — réponse, \(10\), \(2\) — les blocs peuvent s'emboîter de deux façons, et ce sont deux formules : 
À gauche, \((\text{réponse} + 10) \times 2\) : pour \(4\), \(28\). À droite, \(\text{réponse} + (10 \times 2)\) : pour \(4\), \(24\). Lire quel bloc est dans quel autre, c'est lire les parenthèses.
Compétences à pratiquer
- Associer blocs et formules
- Calculer la valeur
- Du programme de calcul au script
II.4
Répéter un nombre de fois
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.5
Projet : une frise de polygones
Le projet, en trois étapes
Le lutin demande combien de côtés, puis dessine trois polygones réguliers ayant ce nombre de côtés, côte à côte (jusqu'à \(7\) côtés ; au-delà, avec des côtés de \(40\) et des sauts de \(90\), ils se chevauchent). Tout ce qui précède y est : un état initial, un « demander », une formule dans un bloc, un répéter dans un répéter.
- Le polygone. Demander « Combien de côtés ? » ; puis répéter « réponse » fois : avancer de \(40\) pas, tourner \(\circlearrowleft\) de \(360 / \text{réponse}\) degrés. Le nombre de tours et l'angle viennent tous deux de l'entrée — « réponse » se glisse dans un « répéter » comme dans un opérateur.
- L'espace. Relever le stylo, avancer de \(90\) pas, poser le stylo : le lutin est prêt pour le polygone suivant, tourné vers la droite.
- La frise. Envelopper les étapes 1 et 2 dans « répéter 3 fois ».
Exemple
Voici le script terminé. Dessiner ce qu'il produit quand l'utilisateur tape \(4\), puis quand il tape \(5\). 
Pour \(4\) : le répéter intérieur fait \(4\) tours avec un virage de \(360 / 4 = 90\) — un carré de côté \(40\) — puis le lutin saute de \(90\) pas ; trois fois : trois carrés, depuis \((-200 ; 40)\), et le lutin finit en \((70 ; 40)\). Pour \(5\) : des virages de \(360 / 5 = 72\), trois pentagones réguliers de côté \(40\). 
Compétences à pratiquer
- Le projet en trois étapes
III
Pour aller plus loin
Compétences à pratiquer
- Problèmes
- Quiz
Aller à la section