Scratch 5e : variables et boucles imbriquées

1. Introduction et problématique

Situation-problème : on veut utiliser Scratch pour dessiner une figure géométrique répétée, par exemple une rosace composée de plusieurs carrés, ou une suite de polygones réguliers dont la taille augmente. Si l’on écrit tous les déplacements un par un, le programme devient très long, difficile à lire et presque impossible à corriger. Pourtant, dans une figure géométrique, beaucoup d’actions se répètent : avancer, tourner, tracer un côté, recommencer pour former un polygone, puis recommencer encore pour placer un nouveau motif.

En classe de 5e, l’objectif est d’apprendre à reconnaître ces répétitions et à les organiser avec des boucles. Une boucle permet de répéter plusieurs fois une même suite d’instructions. Lorsqu’une boucle est placée à l’intérieur d’une autre boucle, on parle de boucle imbriquée. Cette idée est très utile pour dessiner des figures en Scratch : une première boucle peut tracer un carré, un triangle ou un hexagone ; une deuxième boucle peut répéter ce polygone pour créer un motif plus complexe.

On utilise aussi des variables. Une variable est une mémoire qui contient une valeur : une longueur, un nombre de côtés, un angle, un compteur. Par exemple, si une variable appelée nombre vaut 6, elle peut représenter le nombre de côtés d’un hexagone. L’angle de rotation à utiliser pour tracer ce polygone régulier est alors 360 ÷ nombre, soit 360 ÷ 6 = 60 degrés.

La problématique de cette leçon est donc la suivante : comment utiliser correctement des variables et des boucles imbriquées dans Scratch pour construire un programme court, lisible et efficace qui dessine une figure géométrique ?

2. Définition

Définition : Une variable est un nom associé à une valeur que le programme peut utiliser, afficher ou modifier. Dans Scratch, une variable peut représenter une longueur, un nombre de côtés, un angle, un compteur ou toute autre quantité utile au programme.

Par exemple, la variable longueur peut contenir la valeur 80. Le bloc « avancer de longueur » fera avancer le lutin de 80 pas. Si l’on change la valeur de longueur, le même programme dessinera une figure plus petite ou plus grande sans qu’il soit nécessaire de modifier tous les blocs.

Définition : Une boucle est une structure qui répète plusieurs fois une suite d’instructions. Dans Scratch, on utilise souvent le bloc « répéter n fois ». Une boucle imbriquée est une boucle placée à l’intérieur d’une autre boucle.

Dans une boucle simple, les blocs contenus dans la boucle sont exécutés plusieurs fois de suite. Dans une boucle imbriquée, Scratch exécute toute la boucle intérieure à chaque tour de la boucle extérieure. Par exemple, si une boucle extérieure se répète 8 fois et contient une boucle intérieure qui se répète 4 fois, les blocs de la boucle intérieure seront exécutés 8 × 4 = 32 fois au total.

Un compteur est une utilisation particulière d’une variable. Il sert à compter les tours de boucle ou les étapes d’un programme. Par exemple, si la variable c commence à 0 et que l’on ajoute 1 à chaque tour, ses valeurs deviennent 1, 2, 3, 4, etc.

3. Propriétés et théorèmes

Théorème : Pour tracer un polygone régulier à n côtés avec Scratch, l’angle de rotation extérieur à utiliser après chaque côté est égal à 360 ÷ n degrés.

Cette propriété est fondamentale pour dessiner des polygones réguliers. Le lutin avance pour tracer un côté, puis il tourne toujours du même angle. Après avoir tracé tous les côtés, il doit avoir fait un tour complet, c’est-à-dire 360 degrés. Si le polygone a n côtés, il faut donc partager 360 degrés en n rotations égales.

Exemples :

• Triangle équilatéral : 360 ÷ 3 = 120, donc le lutin tourne de 120° après chaque côté.
• Carré : 360 ÷ 4 = 90, donc le lutin tourne de 90° après chaque côté.
• Pentagone régulier : 360 ÷ 5 = 72, donc le lutin tourne de 72° après chaque côté.
• Hexagone régulier : 360 ÷ 6 = 60, donc le lutin tourne de 60° après chaque côté.

Une autre propriété importante concerne les boucles imbriquées. Si une boucle extérieure se répète a fois et qu’elle contient une boucle intérieure qui se répète b fois, alors les instructions de la boucle intérieure sont exécutées a × b fois. Cette règle permet de prévoir le comportement du programme sans le lancer.

Enfin, si une variable est modifiée dans une boucle, sa valeur change à chaque passage. Si la variable longueur vaut 20 au départ et que l’on ajoute 10 à chaque tour, ses valeurs successives sont 30, 40, 50, 60, etc. Cela permet de créer des figures évolutives, comme des carrés de plus en plus grands ou une spirale.

4. Démonstration

Justifions d’abord la formule de l’angle de rotation d’un polygone régulier. Quand le lutin trace une figure fermée, il revient à son orientation de départ après avoir effectué un tour complet. Un tour complet mesure 360 degrés. Pour un polygone régulier, les rotations entre deux côtés successifs sont toutes égales. Si le polygone possède n côtés, le lutin effectue n rotations identiques. La somme de ces n rotations vaut donc 360 degrés.

On note A l’angle de rotation. On a alors : n × A = 360. Pour trouver A, on divise 360 par n : A = 360 ÷ n. Ainsi, pour un octogone régulier, A = 360 ÷ 8 = 45 degrés. Le bloc Scratch correspondant est donc « tourner de 45 degrés ».

Justifions maintenant le fonctionnement d’une boucle imbriquée. Imaginons le programme suivant : répéter 6 fois, et à l’intérieur, répéter 4 fois les instructions « avancer de 50 » puis « tourner de 90 ». La boucle intérieure trace un carré, car elle répète 4 fois un côté suivi d’un angle droit. La boucle extérieure recommence ce carré 6 fois. Si, après chaque carré, on ajoute une rotation de 60 degrés, les 6 carrés seront placés régulièrement autour d’un même point, car 360 ÷ 6 = 60.

On voit donc que la boucle intérieure sert à construire le motif de base, tandis que la boucle extérieure sert à répéter ce motif. Cette distinction est essentielle : une erreur fréquente consiste à placer la rotation de la rosace dans la boucle du carré, ce qui déforme le carré au lieu de placer les carrés autour du centre.

Enfin, une variable permet de rendre le programme général. Au lieu d’écrire « répéter 6 fois » et « tourner de 60 », on peut créer une variable nombre, mettre nombre à 6, puis tourner de 360 ÷ nombre. En changeant seulement nombre, on obtient une autre organisation de la figure.

5. Méthode pas à pas

1. Je repère ce qui se répète. Je regarde la figure attendue et je cherche le motif de base : un côté, un polygone, une étoile, une rosace ou une suite de formes.
2. Je choisis les variables utiles. Je peux créer une variable longueur, une variable nombre, une variable angle ou un compteur. Chaque variable doit avoir un rôle clair.
3. Je programme le motif de base. Pour un polygone régulier, j’utilise une boucle « répéter nombre fois ». À chaque tour, le lutin avance puis tourne de 360 ÷ nombre.
4. Je place la boucle intérieure. Si le motif de base est un carré, la boucle intérieure peut être : répéter 4 fois, avancer de longueur, tourner de 90.
5. Je place la boucle extérieure. Si je veux répéter le motif plusieurs fois, j’ajoute autour une deuxième boucle. Par exemple : répéter 12 fois pour dessiner 12 carrés.
6. Je distingue les deux rotations. La rotation dans la boucle intérieure sert à tracer le polygone. La rotation dans la boucle extérieure sert à orienter le motif suivant.
7. J’utilise le compteur si nécessaire. Si la taille doit changer, je peux ajouter 10 à longueur à chaque tour. Si je veux compter les motifs, j’ajoute 1 à un compteur.
8. Je teste et je corrige. Je lance le programme, je compare la figure avec celle attendue, puis je vérifie les valeurs, les angles, l’ordre des blocs et l’emplacement des boucles.

Routine à retenir : Je repère ce qui se répète, j’applique les boucles et les variables, je vérifie le dessin obtenu.

6. Exemple résolu 1 — cas direct

On veut tracer un hexagone régulier avec Scratch. On crée deux variables : nombre et longueur. On met nombre à 6, car un hexagone possède 6 côtés. On met longueur à 70, par exemple. L’angle de rotation est 360 ÷ nombre = 360 ÷ 6 = 60 degrés.

Le programme peut être décrit ainsi :

• mettre nombre à 6 ;
• mettre longueur à 70 ;
• stylo en position d’écriture ;
• répéter nombre fois :
  • avancer de longueur ;
  • tourner de 360 ÷ nombre degrés.

Le programme est court et général. Si l’on remplace nombre par 5, on obtient un pentagone régulier, car Scratch tournera de 360 ÷ 5 = 72 degrés. Si l’on remplace nombre par 8, on obtient un octogone régulier, car Scratch tournera de 360 ÷ 8 = 45 degrés.

La variable nombre contrôle donc à la fois le nombre de répétitions et l’angle de rotation. C’est une utilisation efficace d’une variable : une seule valeur permet de modifier plusieurs parties du programme de façon cohérente.

7. Exemple résolu 2 — cas inverse

On observe un programme Scratch et l’on doit prévoir la figure obtenue. Le programme dit :

• mettre longueur à 50 ;
• répéter 10 fois :
  • répéter 4 fois :
    • avancer de longueur ;
    • tourner de 90 degrés ;
  • tourner de 36 degrés ;

On analyse d’abord la boucle intérieure. Elle répète 4 fois « avancer » puis « tourner de 90 degrés ». C’est le programme d’un carré, car un carré possède 4 côtés et l’angle de rotation extérieur est 360 ÷ 4 = 90 degrés.

On analyse ensuite la boucle extérieure. Elle répète 10 fois le tracé du carré. Après chaque carré, le lutin tourne de 36 degrés. Or 360 ÷ 10 = 36. Les 10 carrés sont donc répartis régulièrement autour d’un tour complet. La figure obtenue est une rosace composée de 10 carrés.

On peut aussi calculer le nombre total de côtés tracés. Chaque carré contient 4 côtés, et il y a 10 carrés. Le programme trace donc 10 × 4 = 40 côtés. Cette méthode permet de comprendre le programme sans exécuter Scratch. Elle est très utile pour répondre à des questions du type : « Que dessine ce programme ? », « Combien de fois le bloc avancer est-il exécuté ? » ou « Quelle rotation faut-il modifier ? »

8. Exemple résolu 3 — problème concret

On veut créer une figure décorative pour une affiche : une spirale de carrés. Le premier carré doit avoir une longueur de 20 pas. À chaque nouveau carré, la longueur augmente de 10 pas. On veut dessiner 8 carrés au total, chacun légèrement tourné par rapport au précédent.

On crée une variable longueur. On la met à 20 au début. On utilise une boucle extérieure répétée 8 fois, car on veut 8 carrés. À l’intérieur, on place la boucle qui trace un carré. Après chaque carré, on tourne le lutin, par exemple de 20 degrés, puis on augmente la variable longueur de 10.

Le programme peut être décrit ainsi :

• effacer tout ;
• mettre longueur à 20 ;
• stylo en position d’écriture ;
• répéter 8 fois :
  • répéter 4 fois :
    • avancer de longueur ;
    • tourner de 90 degrés ;
  • tourner de 20 degrés ;
  • ajouter 10 à longueur ;

La variable longueur joue ici le rôle d’une valeur évolutive. Au début, elle vaut 20. Après le premier carré, elle vaut 30 ; puis 40, 50, 60, etc. Le compteur n’est pas forcément affiché, mais la boucle extérieure compte les 8 carrés. On pourrait ajouter une variable compteur pour afficher le numéro du carré, mais ce n’est pas indispensable.

Ce problème montre l’intérêt des variables : sans variable, il faudrait écrire séparément un carré de côté 20, puis un carré de côté 30, puis un carré de côté 40. Avec une variable et une boucle, le programme est plus court, plus clair et plus facile à modifier.

9. Erreurs classiques à éviter

• Erreur : La figure ne se ferme pas, alors que le polygone devrait être régulier. — À faire : Recalculer l’angle avec la formule 360 ÷ nombre de côtés et vérifier le bloc « tourner ».
• Erreur : Le programme trace un seul carré au lieu d’une rosace. — À faire : Ajouter une boucle extérieure autour du tracé du carré et placer une rotation après chaque carré.
• Erreur : La variable ne change pas pendant le programme. — À faire : Placer le bloc « ajouter à la variable » dans la boucle concernée, pas avant ni après.
• Erreur : Le lutin tourne trop souvent et la figure est déformée. — À faire : Distinguer la rotation qui trace le polygone et la rotation qui place le motif suivant.
• Erreur : Le programme est très long et répète les mêmes blocs. — À faire : Remplacer les blocs recopiés par une boucle « répéter ».
• Erreur : La boucle intérieure et la boucle extérieure sont inversées. — À faire : Vérifier que la boucle intérieure construit le motif de base et que la boucle extérieure répète le motif complet.

10. À retenir

• Une variable est une mémoire qui contient une valeur utilisable par le programme.
• Un compteur est une variable qui augmente ou diminue régulièrement, souvent à chaque tour de boucle.
• Une boucle permet de répéter plusieurs fois les mêmes instructions.
• Une boucle imbriquée est une boucle placée dans une autre boucle.
• Pour tracer un polygone régulier à n côtés, l’angle de rotation extérieur est 360 ÷ n.
• Dans une figure complexe, la boucle intérieure trace souvent le motif de base, tandis que la boucle extérieure répète ce motif.
• Il faut toujours vérifier l’ordre des blocs, les valeurs des variables, le nombre de répétitions et l’emplacement des rotations.
• Un bon programme Scratch doit être court, lisible, testable et facile à corriger.

11. Exercices d'application

Lien PDF : Télécharger les exercices sur les variables et les boucles imbriquées en Scratch.

Aperçu des types d’exercices proposés : reconnaître les blocs utiles pour créer une variable, répondre à des questions « vrai ou faux ? », remettre un programme Scratch dans le bon ordre, coder un polygone régulier avec une variable, prévoir le résultat d’un programme contenant une boucle imbriquée.

Les exercices permettent de vérifier plusieurs compétences : identifier correctement le rôle des variables et des blocs, comprendre et utiliser une boucle simple, comprendre le principe d’une boucle imbriquée, calculer et utiliser les angles de rotation, produire ou corriger un algorithme Scratch cohérent.

Conseil de travail : avant de lancer Scratch, il faut toujours écrire au brouillon ce qui se répète. On peut entourer le motif de base, noter le nombre de répétitions, puis calculer l’angle de rotation. Ensuite seulement, on construit le programme. Cette méthode évite les essais au hasard et aide à corriger plus rapidement les erreurs.

12. Questions fréquentes