Scratch : programmer des figures géométriques

1. Introduction et problématique

En classe de 3e, programmer une figure géométrique avec Scratch permet de relier plusieurs compétences du programme de mathématiques : construire une figure, raisonner sur les angles, utiliser une formule, écrire un algorithme et vérifier un résultat. Dans Scratch, le lutin peut se déplacer comme une « tortue » : il avance, tourne, baisse ou lève le stylo, et laisse une trace sur l’écran. L’objectif de cette leçon est de comprendre comment tracer un carré, un triangle équilatéral, puis n’importe quel polygone régulier.

La situation-problème est la suivante : on veut programmer un lutin pour qu’il trace automatiquement un polygone régulier, par exemple un hexagone, un octogone ou un dodécagone. On doit donc répondre à trois questions : combien de fois faut-il répéter les mêmes instructions ? Quelle longueur faut-il donner aux côtés ? De combien de degrés le lutin doit-il tourner après chaque côté ?

La difficulté principale vient de la différence entre l’angle de la figure et l’angle de rotation du lutin. Par exemple, dans un triangle équilatéral, chaque angle intérieur mesure 60°. Pourtant, dans Scratch, le lutin doit tourner de 120° après chaque côté. Il ne tourne pas « dans » l’angle intérieur : il change de direction à l’extérieur de la figure. Cette distinction est essentielle pour réussir les programmes.

Le mot repère de la leçon est POLYGONE, que l’on peut découper en syllabes : po - ly - gone. Un polygone est une figure fermée formée de plusieurs segments. Pour un hexagone régulier, il y a 6 côtés : le lutin répète 6 fois la même instruction et tourne de 360 ÷ 6 = 60° après chaque côté.

2. Définition

Définition : Un polygone régulier est un polygone dont tous les côtés ont la même longueur et dont tous les angles ont la même mesure. Pour le programmer dans Scratch, on choisit un nombre de côtés n, une longueur de côté L, puis on répète n fois : avancer de L pas et tourner de 360 ÷ n degrés.

Dans Scratch, les blocs importants sont les suivants : stylo en position d’écriture, avancer de L pas, tourner de 360 ÷ n degrés et répéter n fois. On peut les associer à des idées mathématiques précises.

répéter n fois correspond à la boucle. Elle évite d’écrire plusieurs fois les mêmes instructions. Si un polygone a 8 côtés, on ne recopie pas 8 fois les blocs : on place les blocs dans une boucle qui se répète 8 fois.

avancer de L pas correspond à la longueur du côté. La valeur L règle la taille de la figure, mais elle ne modifie pas la nature du polygone si elle reste constante.

tourner de 360 ÷ n degrés correspond à l’angle extérieur, c’est-à-dire l’angle de rotation du lutin. Le lutin doit faire au total un tour complet pour revenir à sa direction de départ.

stylo en position d’écriture correspond au tracé. Si le stylo est levé, le lutin se déplace sans dessiner. Si le stylo est baissé, il trace les segments.

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

Théorème : Pour tracer un polygone régulier à n côtés avec un lutin Scratch, il faut faire tourner le lutin après chaque côté d’un angle égal à 360 ÷ n degrés.

Cette propriété est la règle centrale de la leçon. Elle fonctionne pour tous les polygones réguliers : triangle équilatéral, carré, pentagone régulier, hexagone régulier, octogone régulier, etc. Le nombre n représente le nombre de côtés, donc aussi le nombre de répétitions de la boucle.

Quelques exemples importants :

• Triangle équilatéral : n = 3, donc angle de rotation = 360 ÷ 3 = 120°.
• Carré : n = 4, donc angle de rotation = 360 ÷ 4 = 90°.
• Pentagone régulier : n = 5, donc angle de rotation = 360 ÷ 5 = 72°.
• Hexagone régulier : n = 6, donc angle de rotation = 360 ÷ 6 = 60°.
• Octogone régulier : n = 8, donc angle de rotation = 360 ÷ 8 = 45°.
• Dodécagone régulier : n = 12, donc angle de rotation = 360 ÷ 12 = 30°.

Il faut aussi retenir que la longueur du côté n’intervient pas dans le calcul de l’angle. Si on trace un carré de côté 50 pas ou un carré de côté 120 pas, le lutin tourne toujours de 90°. La longueur change la taille du dessin ; l’angle dépend uniquement du nombre de côtés.

4. Démonstration

Pour comprendre pourquoi on utilise 360 ÷ n, il faut observer le mouvement du lutin. Au départ, le lutin est orienté dans une direction. Il avance pour tracer un premier côté, puis il tourne. Il avance de nouveau, puis il tourne encore. À la fin du tracé, si le polygone est bien fermé et régulier, le lutin revient à son point de départ et retrouve son orientation initiale.

Retrouver son orientation initiale signifie que le lutin a effectué un tour complet. Un tour complet mesure 360°. Or, pour un polygone régulier à n côtés, le lutin effectue n rotations identiques : une rotation après chaque côté. Si on appelle a l’angle de rotation, alors la somme des rotations vaut n × a.

Comme le lutin fait un tour complet, on obtient l’égalité : n × a = 360°. Pour trouver a, on divise 360 par n : a = 360 ÷ n. C’est l’angle extérieur du polygone, c’est-à-dire l’angle de changement de direction.

Exemple avec un carré : il possède 4 côtés. Le lutin tourne donc 4 fois du même angle. On doit avoir 4 × a = 360°, donc a = 360 ÷ 4 = 90°. Le programme répète alors 4 fois : avancer, tourner de 90°.

Exemple avec un triangle équilatéral : il possède 3 côtés. Le lutin tourne 3 fois du même angle. On doit avoir 3 × a = 360°, donc a = 120°. Même si les angles intérieurs du triangle mesurent 60°, l’angle que le lutin doit effectuer est l’angle extérieur, égal à 120°.

5. Méthode pas à pas

1. Je repère le nombre de côtés. On note ce nombre n. Par exemple, pour un hexagone, n = 6 ; pour un carré, n = 4.
2. Je choisis la longueur d’un côté. On note cette longueur L. Par exemple, L = 80 pas. Tous les côtés doivent avoir la même longueur pour obtenir un polygone régulier.
3. Je calcule l’angle de rotation. On utilise la formule : angle = 360 ÷ n. Pour un octogone, angle = 360 ÷ 8 = 45°.
4. Je prépare le dessin. Au début du programme, on peut placer les blocs : effacer tout, aller à une position de départ, s’orienter à 90°, stylo en position d’écriture.
5. Je crée la boucle. On utilise le bloc répéter n fois. À l’intérieur de cette boucle, on place les deux blocs indispensables : avancer de L pas, puis tourner de 360 ÷ n degrés.
6. Je lance le programme. On observe si la figure est fermée, régulière et propre.
7. Je vérifie et je corrige. Si la figure ne se ferme pas, on contrôle le nombre de répétitions, l’angle et la position des blocs dans la boucle.

La routine à retenir est : Je repère / J’applique / Je vérifie. Je repère le nombre de côtés n. J’applique la formule 360 ÷ n et je programme la boucle. Je vérifie que la figure se ferme et que le lutin revient à son orientation de départ.

6. Exemple résolu 1 — cas direct

Énoncé : Écrire un programme Scratch pour tracer un carré de côté 100 pas.

Analyse : Un carré est un polygone régulier à 4 côtés. On a donc n = 4. La longueur du côté est L = 100 pas. L’angle de rotation vaut 360 ÷ 4 = 90°.

Programme possible :

• quand drapeau vert est cliqué ;
• effacer tout ;
• aller à x : 0 y : 0 ;
• s’orienter à 90° ;
• stylo en position d’écriture ;
• répéter 4 fois :
  • avancer de 100 pas ;
  • tourner de 90 degrés.

Vérification : Le lutin trace 4 segments de même longueur. Après chaque segment, il tourne de 90°. La somme des rotations est 4 × 90° = 360°, donc il revient à son orientation de départ. La figure obtenue est bien un carré.

On remarque que si on change seulement la longueur, par exemple 60 pas ou 150 pas, le carré reste un carré. Il est simplement plus petit ou plus grand. En revanche, si on modifie l’angle, la figure ne sera plus un carré.

7. Exemple résolu 2 — cas inverse

Énoncé : Un programme Scratch contient l’instruction « répéter 6 fois », puis, dans la boucle, « avancer de 70 pas » et « tourner de 60 degrés ». Quelle figure est tracée ?

Analyse : Le programme répète la même construction 6 fois. Il trace donc 6 côtés de même longueur, puisque le lutin avance à chaque fois de 70 pas. Il tourne de 60° après chaque côté. On vérifie que 6 × 60° = 360°.

Conclusion : Le lutin effectue un tour complet en 6 rotations égales. La figure est un polygone régulier à 6 côtés : c’est un hexagone régulier.

Autre raisonnement : Si l’angle de rotation vaut 60°, on peut retrouver le nombre de côtés en calculant 360 ÷ 60 = 6. Le polygone possède donc 6 côtés.

Ce type de question est important, car il demande de lire un programme comme un objet mathématique. On ne se contente pas de lancer Scratch : on interprète les blocs. Le bloc « répéter » indique le nombre de côtés. Le bloc « avancer » donne la longueur des côtés. Le bloc « tourner » donne l’angle extérieur.

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

Énoncé : On veut créer dans Scratch une rosace composée de 12 octogones réguliers. Chaque octogone a des côtés de 40 pas. Après chaque octogone, le lutin doit tourner pour répartir les 12 octogones autour d’un point. Écrire l’idée du programme.

Étape 1 : tracer un octogone. Un octogone régulier possède 8 côtés. On calcule l’angle de rotation : 360 ÷ 8 = 45°. Pour tracer un octogone de côté 40 pas, on répète 8 fois : avancer de 40 pas, tourner de 45°.

Étape 2 : répéter l’octogone. On veut obtenir 12 octogones répartis autour d’un point. Le lutin doit donc changer d’orientation 12 fois sur un tour complet. L’angle entre deux octogones vaut 360 ÷ 12 = 30°.

Programme possible :

• quand drapeau vert est cliqué ;
• effacer tout ;
• aller à x : 0 y : 0 ;
• stylo en position d’écriture ;
• répéter 12 fois :
  • répéter 8 fois :
    • avancer de 40 pas ;
    • tourner de 45 degrés ;
  • tourner de 30 degrés.

Vérification : La première boucle trace un octogone. La deuxième boucle répète cette construction 12 fois. On obtient une figure plus complexe, mais construite avec la même méthode : repérer, calculer, répéter, vérifier.

9. Erreurs classiques à éviter

• Erreur : Programmer un triangle équilatéral avec un angle de 60°. — À faire : Utiliser l’angle extérieur : 360 ÷ 3 = 120°.
• Erreur : La figure ne se ferme pas parce que le nombre de répétitions ne correspond pas au nombre de côtés. — À faire : Relier systématiquement n côtés à « répéter n fois ».
• Erreur : Obtenir une spirale ou une figure irrégulière parce que la longueur ou l’angle change dans la boucle. — À faire : Garder la même longueur et le même angle pour un polygone régulier.
• Erreur : Le programme trace une seule ligne. — À faire : Placer les blocs « avancer » et « tourner » à l’intérieur du bloc « répéter ».
• Erreur : L’écran contient plusieurs tracés superposés. — À faire : Ajouter « effacer tout » au début du programme.
• Erreur : Confondre angle intérieur et angle de rotation du lutin. — À faire : Penser au déplacement du lutin : il tourne à l’extérieur de la figure.

10. À retenir

• Dans Scratch, le lutin peut tracer une figure si le stylo est en position d’écriture.
• Un polygone régulier a tous ses côtés de même longueur et tous ses angles de même mesure.
• Pour tracer un polygone régulier à n côtés, on répète n fois les mêmes instructions.
• La structure générale est : répéter n fois, avancer de L pas, tourner de 360 ÷ n degrés.
• L’angle utilisé dans Scratch est l’angle extérieur, c’est-à-dire l’angle de rotation du lutin.
• Pour un triangle équilatéral, le lutin tourne de 120°, et non de 60°.
• Pour un carré, le lutin tourne de 90°.
• Pour un hexagone régulier, le lutin tourne de 60°.
• La longueur du côté change la taille de la figure, mais pas l’angle de rotation.
• La vérification consiste à contrôler que la figure est fermée, régulière et que le lutin a effectué un tour complet de 360°.

11. Exercices d'application

Un lien PDF d’exercices peut accompagner cette leçon : Télécharger la fiche d’exercices sur Scratch et les figures géométriques en 3e. La fiche permet de s’entraîner progressivement, depuis la lecture de programmes simples jusqu’à l’écriture complète d’algorithmes Scratch.

Les exercices proposés peuvent porter sur les thèmes suivants : compléter le tableau des polygones, vrai ou faux : comprendre le programme, remettre les blocs dans l’ordre, écrire un programme Scratch et déboguer un programme.

Exemple de tableau à compléter : pour chaque polygone, indiquer le nombre de côtés, le nombre de répétitions et l’angle de rotation. Pour un pentagone régulier, on attend : 5 côtés, répéter 5 fois, angle 360 ÷ 5 = 72°. Pour un décagone régulier, on attend : 10 côtés, répéter 10 fois, angle 360 ÷ 10 = 36°.

Dans les exercices de débogage, on peut donner un programme qui ne fonctionne pas correctement. L’élève doit repérer l’erreur : mauvais angle, mauvais nombre de répétitions, blocs placés hors de la boucle, oubli du stylo ou oubli d’effacer l’écran. Cette activité développe la capacité à vérifier et corriger un algorithme.

Barème possible sur 20 points : calcul correct des angles de rotation, 4 points ; utilisation correcte de la boucle répéter, 4 points ; ordre logique des instructions Scratch, 4 points ; programmes complets et lisibles, 4 points ; capacité à vérifier et corriger une erreur, 4 points.

12. Questions fréquentes