Pas de panique : Scratch, ce ne sont pas des maths compliquées, c'est du bon sens rangé dans des blocs. En dix minutes tu tiens l'essentiel pour ton contrôle. On va voir trois mots, une seule formule, et un exemple fait de A à Z.
Les 3 mots à connaître (et rien de plus)
Ce qu'il faut déjà savoir : lire un bloc Scratch (répéter, si, mettre, ajouter), savoir multiplier deux nombres, et comparer deux nombres (plus grand, égal).
1. La variable — c'est une case mémoire qui porte un nom et qui retient une valeur (un nombre ou du texte). Par exemple une variable score qui vaut $0$ au début, puis $1$, puis $2$...
2. La condition — le bloc si (quelque chose est vrai) alors exécute les blocs intérieurs seulement quand c'est vrai. Le bloc sinon (facultatif) s'exécute quand c'est faux.
3. La boucle imbriquée — c'est une boucle répéter glissée à l'intérieur d'une autre boucle répéter. La formule qui rapporte des points au contrôle :
$\text{total} = n_{\text{externe}} \times n_{\text{interne}}$
Autrement dit : on multiplie le nombre de tours de la boucle du dehors par le nombre de tours de la boucle du dedans. On multiplie, on n'additionne pas.
Un exemple, en entier, tout de suite
Le programme : répéter 3 fois [ répéter 4 fois [ avancer de 10 pas ] ]. Une boucle dans une boucle : la structure ressemble à deux boîtes emboîtées (figure).
Combien de fois « avancer de 10 pas » est-il exécuté ?
Boucle externe : $3$ tours. Boucle interne : $4$ tours.
À chaque tour de la boucle externe, la boucle interne s'exécute entièrement, soit $4$ fois. Donc au total :
$3 \times 4 = 12$ exécutions du bloc « avancer de 10 pas ».
Et la distance parcourue ? Chaque exécution avance de $10$ pas, donc :
$12 \times 10 = 120$ pas au total.
Voilà : tu sais déjà répondre au type de question le plus fréquent. Le reste, c'est du confort.
Ah, ça revient ! Les petits blocs colorés, le chat qui se déplace... On reprend proprement, cette fois avec les vraies définitions, une méthode pas-à-pas, et les deux directions de la condition (vrai / faux). Rien de sorcier, juste bien rangé.
Les variables : « mettre à » et « ajouter à »
Définition. Une variable est une case mémoire qui porte un nom et contient une valeur (un nombre ou du texte). On peut la lire, et on peut la modifier avec deux blocs qu'il ne faut surtout pas confondre.
Le bloc « mettre [score] à 0 » fixe la valeur à $0$. C'est l'initialisation : on la place avant la boucle, une seule fois, pour partir sur une valeur propre.
Le bloc « ajouter 1 à [score] » augmente la valeur de $1$. C'est l'incrémentation : on la met généralement à l'intérieur de la boucle, pour qu'elle agisse à chaque tour.
À retenir : mettre ... à remplace la valeur ; ajouter ... à augmente la valeur. Et la variable peut être lue dans n'importe quel autre bloc, y compris dans une condition.
Les conditions : si … alors … sinon
Le bloc « si (condition) alors » : les blocs intérieurs ne s'exécutent que si la condition est vraie.
Le bloc « sinon » (facultatif) : il s'exécute uniquement quand la condition est fausse. Une condition n'a donc que deux issues : vrai ou faux (figure).
Exemples de conditions que Scratch sait évaluer : $\text{score} > 10$, $\text{compteur} = 5$, ou encore « touche espace pressée ».
Comment on l'évalue. On remplace les variables par leur valeur du moment, puis on regarde si la phrase est vraie. Si $\text{compteur} = 3$ et que la condition testée est $\text{compteur} = 5$, alors $3 = 5$ est faux : on n'entre pas dans le alors.
Les boucles imbriquées, et la méthode pour tracer
Définition. Une boucle imbriquée est un bloc répéter placé à l'intérieur d'un autre bloc répéter. À chaque tour de la boucle externe, la boucle interne repart de zéro et s'exécute entièrement.
Nombre total d'exécutions du bloc central : $\text{total} = n_{\text{externe}} \times n_{\text{interne}}$. Par exemple, externe $3$ tours et interne $4$ tours donnent $3 \times 4 = 12$ exécutions (figure).
La méthode pour tracer un algorithme Scratch (à réutiliser à chaque exercice) :
1. Repérer toutes les variables et noter leur valeur initiale.
2. Identifier les boucles, de l'extérieur vers l'intérieur, et leur nombre de tours.
3. Construire un tableau : une ligne par tour, une colonne par variable.
4. Mettre à jour chaque variable à chaque ligne, dans l'ordre des blocs.
5. Évaluer les conditions avec les valeurs courantes du tableau.
6. Conclure sur le résultat affiché ou l'action effectuée.
Maintenant on met les mains dans le cambouis, ensemble. Je rédige devant toi, ligne par ligne, comme si on était côte à côte au fond de la classe. Regarde comment on tient un tableau de trace : c'est là que tout devient facile.
Exemple A — une variable et une condition
Le programme : mettre compteur à 0 / répéter 5 fois [ ajouter 1 à compteur / si (compteur = 3) alors dire « Milieu ! » ].
On applique la méthode. Variable : compteur, valeur initiale $0$ (fixée avant la boucle). Une boucle de $5$ tours. On dresse le tableau, une ligne par tour.
| Tour | compteur (après « ajouter 1 ») | compteur = 3 ? | action |
|---|---|---|---|
| 1 | 0 + 1 = 1 | non | — |
| 2 | 1 + 1 = 2 | non | — |
| 3 | 2 + 1 = 3 | oui | dire « Milieu ! » |
| 4 | 3 + 1 = 4 | non | — |
| 5 | 4 + 1 = 5 | non | — |
Conclusion : la condition n'est vraie qu'au tour 3, donc « Milieu ! » est dit une seule fois. Un tableau bien tenu, et la réponse tombe toute seule.
Exemple B — deux boucles imbriquées
Le programme : répéter 3 fois [ répéter 4 fois [ avancer de 10 pas ] ].
On repère les boucles de l'extérieur vers l'intérieur : externe $3$ tours, interne $4$ tours.
À chaque tour de la boucle externe, la boucle interne s'exécute entièrement, donc $4$ fois. On peut le lister : tour externe 1 → 4 avancées ; tour externe 2 → 4 avancées ; tour externe 3 → 4 avancées.
Nombre total d'exécutions de « avancer de 10 pas » : $3 \times 4 = 12$ (et non $3 + 4 = 7$).
Distance totale parcourue : $12 \times 10 = 120$ pas.
Conclusion : le lutin avance 12 fois, soit 120 pas. On a bien multiplié les deux nombres de tours.
Exemple C — quand la condition a un « sinon »
Le programme : mettre score à 0 / répéter 4 fois [ ajouter 2 à score ] / si (score > 5) alors dire « Gagné » sinon dire « Perdu ».
D'abord la boucle. Variable score, initialisée à $0$ avant la boucle. À chaque tour on ajoute $2$, et il y a $4$ tours.
Tour 1 : $0 + 2 = 2$. Tour 2 : $2 + 2 = 4$. Tour 3 : $4 + 2 = 6$. Tour 4 : $6 + 2 = 8$.
Après la boucle, $\text{score} = 8$. On évalue alors la condition une seule fois (elle est en dehors de la boucle) : $8 > 5$ ?
$8 > 5$ est vrai, donc on entre dans le alors : le lutin dit « Gagné ». Le sinon (« Perdu ») ne s'exécute pas.
Conclusion : le lutin affiche « Gagné ». Note bien : on ne prend jamais les deux branches à la fois — soit le alors, soit le sinon.
Le niveau attendu au brevet, maintenant. Les questions se ressemblent toutes ; ce qui fait perdre des points, ce sont quatre pièges toujours les mêmes. On les désamorce un par un, et on regarde exactement ce que le correcteur veut voir sur ta copie.
Les quatre pièges classiques
Piège 1 — l'initialisation au mauvais endroit. Si tu écris mettre n à 0 à l'intérieur de la boucle, la variable est remise à $0$ à chaque tour : elle ne progresse jamais. L'initialisation doit être avant la boucle.
Piège 2 — confondre « mettre » et « ajouter ». mettre ... à remplace la valeur (elle repart de ce nombre) ; ajouter ... à l'augmente (elle grandit). Deux blocs, deux effets opposés.
Piège 3 — croire que la boucle interne ne repart qu'une fois. Non : elle repart de zéro et s'exécute entièrement à chaque tour de la boucle externe, pas seulement au premier.
Piège 4 — additionner au lieu de multiplier. Le nombre total d'exécutions est $n_{\text{externe}} \times n_{\text{interne}}$, pas $n_{\text{externe}} + n_{\text{interne}}$. Exemple : $3 + 4 = 7$ est faux ; $3 \times 4 = 12$ est juste.
Problème type 1 — l'initialisation qui change tout
Deux programmes se ressemblent. Que dit le lutin dans chaque cas ?
Programme correct : mettre n à 0 / répéter 3 fois [ ajouter 1 à n / dire n ].
Tour 1 : $n = 0 + 1 = 1$, le lutin dit $1$. Tour 2 : $n = 1 + 1 = 2$, il dit $2$. Tour 3 : $n = 2 + 1 = 3$, il dit $3$. Il affiche donc $1$, puis $2$, puis $3$.
Programme piégé : répéter 3 fois [ mettre n à 0 / ajouter 1 à n / dire n ].
Ici l'initialisation est dans la boucle. Tour 1 : on remet $n = 0$, puis $0 + 1 = 1$, il dit $1$. Tour 2 : on remet encore $n = 0$, puis $1$, il dit $1$. Tour 3 : pareil, il dit $1$.
Conclusion : le programme correct affiche $1, 2, 3$ ; le programme piégé affiche $1, 1, 1$. Le seul changement, c'est la position du bloc mettre n à 0.
Problème type 2 — compter les exécutions d'un quadrillage
Énoncé : un lutin doit dessiner un quadrillage. On écrit : répéter 5 fois [ répéter 3 fois [ estampiller un carré ] ]. Combien de carrés sont estampillés ?
Boucle externe : $5$ tours. Boucle interne : $3$ tours. La boucle interne s'exécute entièrement à chaque tour externe.
Nombre total : $5 \times 3 = 15$ carrés.
Le piège : répondre $5 + 3 = 8$. C'est l'erreur la plus fréquente et elle coûte tous les points de la question.
Ce que le correcteur attend sur ta copie : écrire clairement les deux nombres de tours ($5$ et $3$), poser explicitement le calcul $5 \times 3$, donner le résultat $15$, et rédiger une phrase de conclusion (« le lutin estampille 15 carrés »). Pour une trace, montrer le tableau : c'est lui qui prouve ton raisonnement, pas seulement le résultat final.
Tu as tout ce qu'il faut pour le contrôle. Si tu veux prendre de l'avance, voilà où ces petits blocs te mènent : vers les vraies maths, et vers le code que tu écriras l'an prochain. Spoiler : c'est exactement la même idée, juste habillée autrement.
Des ponts vers d'autres notions
Variable Scratch ↔ variable en maths. Le score qui change de valeur, c'est déjà l'idée d'une variable comme le $x$ des fonctions : un nom qui peut prendre plusieurs valeurs. Quand tu étudieras les fonctions, tu retrouveras ce réflexe « une case, un nom, une valeur qui varie ».
Boucle ↔ répétition organisée. Une boucle, c'est répéter une action de façon contrôlée. C'est la même logique que dans un calcul répété ou dans une liste de valeurs qu'on construit pas à pas.
Boucles imbriquées ↔ multiplication et aire. $n_{\text{externe}} \times n_{\text{interne}}$, c'est exactement le nombre de cases d'un quadrillage de $n_{\text{externe}}$ lignes et $n_{\text{interne}}$ colonnes — donc l'aire d'un rectangle en carreaux. Compter les exécutions d'une double boucle, c'est compter les cases d'un tableau.
Pourquoi total = produit (la justification)
On dit « on multiplie », mais pourquoi ? Reprenons la double boucle : externe $3$ tours, interne $4$ tours.
À chaque tour de la boucle externe, le bloc central est exécuté $4$ fois. Comme la boucle externe tourne $3$ fois, on additionne trois fois ce paquet de $4$ :
$4 + 4 + 4 = 12$.
Or additionner un même nombre plusieurs fois, c'est précisément multiplier : $4 + 4 + 4 = 3 \times 4$. Voilà la vraie raison de la formule $\text{total} = n_{\text{externe}} \times n_{\text{interne}}$ — ce n'est pas une règle à croire, c'est de l'addition répétée (figure).
Un aperçu de l'an prochain
Au lycée, en seconde et en sciences numériques, tu retrouveras exactement les trois outils d'aujourd'hui — variables, conditions, boucles — mais écrits en texte plutôt qu'en blocs colorés. Les mots changent : si (condition) alors ... sinon devient if ... else, et répéter devient for ou while.
Les boucles imbriquées serviront à parcourir des tableaux et des quadrillages, ligne par ligne puis colonne par colonne — la même image que le quadrillage de tout à l'heure.
Et compter le nombre total d'exécutions d'un programme, ce que tu viens de faire avec $n_{\text{externe}} \times n_{\text{interne}}$, c'est le premier pas vers une grande question de l'informatique : « combien d'opérations mon programme fait-il ? ». Tu fais déjà de l'algorithmique pour de vrai.