Éducation Nationale Française · Quatrième
Programmer en blocs : choix et variables
I
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
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.
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\) |
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 ».
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) ».
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 » |
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\) |
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\) |
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
Projet : le jeu du dé
Le projet, en trois étapes
Le lutin lance un dé de nombreuses fois, compte les 6, dit leur fréquence, puis joue avec l'utilisateur. Tout ce niveau y est : une variable réglée avant la boucle, un tirage rangé dans une variable, une condition, un compteur.
- Compter les 6. « mettre [six] à 0 » ; répéter \(1000\) fois : « mettre [dé] à (nombre aléatoire entre 1 et 6) », « si (dé) \(=\) 6 alors ajouter 1 à [six] » ; dire (six).
- La fréquence. Dire « (six) / 1000 ». Le nombre varie d'une exécution à l'autre ; quand le nombre de lancers grandit, la fréquence fluctue moins et se stabilise près de \(1/6 \approx 0{,}167\) — sans aucune garantie pour une exécution donnée de \(1000\) lancers. Pourquoi il en est ainsi appartient au chapitre de probabilités.
- Le jeu. « mettre [score] à 0 » ; répéter \(10\) fois : tirer le dé dans une variable, demander « Devine le dé », « si (réponse) \(=\) (dé) alors ajouter 1 à [score] » ; à la fin, dire le score.
Exemple
Voici le script des étapes 1 et 2. Pour le vérifier sur papier, « répéter 1000 fois » se lit « répéter 10 fois », « six / 1000 » se lit « six / 10 », et le dé donne \(6\), \(2\), \(6\), \(3\), \(1\), \(4\), \(6\), \(6\), \(5\), \(2\). Que dit le lutin, et que dirait le bloc de la fréquence avec \(10\) lancers ? 
Les 6 sont aux tours \(1\), \(3\), \(7\), \(8\) : « six » passe par \(1\), \(2\), \(3\), \(4\) et reste à \(4\) ailleurs. Le lutin dit « Six : 4 ». Avec \(10\) lancers la fréquence vaudrait \(4 / 10 = 0{,}4\) — loin de \(0{,}167\) : dix lancers sont trop peu pour que la fréquence se stabilise, et c'est précisément pourquoi le script lance \(1000\) fois.
Exemple
Voici le script de l'étape 3. Sur une partie de trois tours (la boucle lue « répéter 3 fois »), le dé donne \(3\), \(5\), \(2\) et le joueur répond \(3\), \(4\), \(2\). Remplir le tableau d'états et donner le score final. 
| tour | dé | réponse | réponse \(=\) dé ? | score | dit |
| – | \(0\) | ||||
| 1 | \(3\) | \(3\) | vrai | \(1\) | « Oui ! » |
| 2 | \(5\) | \(4\) | faux | \(1\) | « Non, c'était 5 » |
| 3 | \(2\) | \(2\) | vrai | \(2\) | « Oui ! » |
| – | \(2\) | « Score : 2 » |
Compétences à pratiquer
- Le projet en trois étapes
V
Pour aller plus loin
Compétences à pratiquer
- Problèmes
- Quiz
Aller à la section