Boucles de répétition Scratch : créer des figures géométriques

Boucles de répétition Scratch: créer des figures géométriques

Pour un triangle équilatéral, ce n’est pas 60°. C’est 120°. Pour un carré, 90°. Pour un hexagone régulier, 60°.

La règle est fixe:

Angle de rotation = 360° ÷ nombre de côtés.

La boucle répéter transforme cette règle géométrique en algorithme. Une séquence « avancer, tourner » est exécutée autant de fois qu’il y a de côtés. Le tracé devient court, contrôlable et généralisable.

La boucle inconditionnelle: une séquence, un nombre fixé d’itérations

Le bloc répéter appartient aux blocs de contrôle. Il exécute un ensemble d’instructions un nombre déterminé de fois.

Sa structure est la suivante:

1. Scratch lit le nombre placé dans le bloc répéter.

2. Il exécute les blocs contenus dans la boucle.

3. Il recommence jusqu’à atteindre le nombre prévu.

4. Il passe à l’instruction suivante.

Le nombre d’itérations est connu avant l’exécution. C’est donc une boucle inconditionnelle simple.

Pour tracer un carré, écrire quatre fois les mêmes blocs est possible. Ce n’est pas correct du point de vue algorithmique. Le programme contient alors une répétition inutile.

La structure efficace est:

• répéter 4 fois;
• avancer de 90 pas;
• tourner de 90 degrés.

Le nombre 4 correspond au nombre de côtés. La valeur 90 dans le bloc avancer correspond à la longueur d’un côté. La seconde valeur 90 correspond à l’angle extérieur.

Ces trois nombres ont des rôles différents. Les confondre produit une erreur de programme, non une erreur de dessin.

Le programme de cycle 4 publié au Bulletin officiel le 5 mars 2026 prévoit notamment, en cinquième, l’exécution d’une boucle inconditionnelle simple pour répéter une séquence linéaire un nombre précis de fois. Son application est progressive: cinquième à la rentrée 2026-2027, quatrième en 2027-2028, troisième en 2028-2029.

Le principe est donc élémentaire, mais il doit être maîtrisé. Une boucle n’est pas un décor dans le programme. Elle exprime une régularité.

Construire le programme de tracé dans le bon ordre

Un tracé Scratch comporte deux parties distinctes:

• le placement du lutin;
• le tracé de la figure.

Si ces parties sont mélangées, le résultat comporte souvent un trait parasite. Le lutin se déplace pour se placer, mais le stylo est déjà baissé. Scratch dessine donc un segment qui ne fait pas partie du polygone.

La procédure doit être stricte.

1. Effacer les tracés précédents.

2. Placer le lutin au point de départ.

3. Choisir sa direction initiale.

4. Mettre le stylo en position d’écriture.

5. Exécuter la boucle de tracé.

6. Relever le stylo avant tout déplacement final.

Pour un carré de côté 90 pas, la logique est la suivante:

• effacer tout;
• relever le stylo;
• aller au point de départ;
• s’orienter dans la direction choisie;
• mettre le stylo en position d’écriture;
• répéter 4 fois:
• avancer de 90 pas;
• tourner de 90 degrés;
• relever le stylo.

Le bloc relever le stylo ne modifie pas la position du lutin. Il empêche seulement l’écriture pendant les déplacements suivants.

Cette séparation est fondamentale. Le déplacement est une instruction de position. Le stylo est une instruction de tracé. Les deux mécanismes sont indépendants.

Un polygone correct peut être précédé d’un mauvais déplacement. Le stylo décide si ce déplacement devient visible.

Le sens de rotation peut être choisi librement:

• tourner ↻ produit une rotation dans un sens;
• tourner ↺ produit une rotation dans l’autre sens.

Avec le même angle et la même longueur de côté, la figure reste régulière. Elle est simplement orientée autrement. Un carré tourné vers la droite ou vers la gauche reste un carré.

Pourquoi l’angle extérieur vaut 360 ÷ n

Le lutin revient à sa direction initiale après avoir fait un tour complet. Un tour complet mesure 360 degrés.

Supposons un polygone régulier à n côtés. Après chaque côté, le lutin doit tourner du même angle. Après n rotations, la somme des rotations doit être égale à 360 degrés.

Donc:

\[

n \times \text{angle de rotation} = 360

\]

Donc:

\[

\text{angle de rotation} = \frac{360}{n}

\]

Dans Scratch, il n’est pas nécessaire d’écrire cette démonstration. Il faut toutefois comprendre ce que le programme exécute.

Prenons le pentagone régulier.

• Il possède 5 côtés.
• La boucle doit donc être répétée 5 fois.
• L’angle extérieur vaut 360 ÷ 5.
• Donc Scratch doit tourner de 72 degrés.

Le programme devient:

• répéter 5 fois;
• avancer de 70 pas;
• tourner de 72 degrés.

Le choix de 70 pas est un exemple de longueur. Il n’existe pas de longueur obligatoire dans Scratch. Si la figure sort de la scène ou devient trop petite, on modifie la valeur du déplacement. L’angle, lui, dépend uniquement du nombre de côtés.

Voici les valeurs utiles pour les exercices classiques.

Le triangle équilatéral révèle immédiatement les erreurs de raisonnement. L’angle intérieur d’un triangle équilatéral vaut 60 degrés. Mais le lutin ne doit pas tourner de 60 degrés. Avec trois rotations de 60 degrés, il ne totalise que 180 degrés. Il ne retrouve donc pas sa direction initiale et la figure ne se ferme pas.

Avec trois rotations de 120 degrés:

\[

3 \times 120 = 360

\]

La condition est satisfaite.

Programmer un polygone avec des variables

Un programme devient réellement réutilisable lorsqu’il ne contient plus des valeurs figées partout. Les variables permettent de modifier une figure sans réécrire l’algorithme.

Créer trois variables:

• nombre de côtés;
• longueur du côté;
• angle.

Puis initialiser:

• mettre nombre de côtés à la valeur choisie;
• mettre longueur du côté à la valeur choisie;
• mettre angle à 360 / nombre de côtés.

La boucle devient alors:

• répéter nombre de côtés fois;
• avancer de longueur du côté pas;
• tourner de angle degrés.

Le programme ne dépend plus d’un carré ou d’un hexagone. Il dépend d’une donnée: le nombre de côtés.

Si nombre de côtés = 4, Scratch trace un carré.

Si nombre de côtés = 6, Scratch trace un hexagone régulier.

Si nombre de côtés = 10, Scratch trace un décagone.

Cette modification est essentielle dans un exercice de boucle répétition Scratch avec tracé. La boucle ne change pas. Les variables changent. C’est le principe même de la généralisation algorithmique.

Attention aux priorités opératoires

Dans Scratch, le calcul de l’angle doit correspondre exactement à la formule:

• 360 / nombre de côtés.

Il ne faut pas multiplier la longueur du côté par l’angle. Il ne faut pas placer la longueur dans le calcul de rotation. Ces grandeurs sont indépendantes.

• La longueur agit sur la taille du polygone.
• Le nombre de côtés agit sur le nombre d’itérations.
• Le nombre de côtés agit aussi sur l’angle.
• L’angle assure la fermeture de la figure.

Donc, si un programme trace une figure ouverte, le premier calcul à vérifier est 360 ÷ nombre de côtés.

Exercices progressifs: du triangle à l’hectogone

Un algorithme de répétition Scratch doit être testé avec des figures dont les résultats sont connus. Il ne faut pas commencer par un motif complexe. Il faut vérifier une règle sur des cas simples.

1. Tracer un triangle équilatéral

Paramètres:

• nombre de répétitions: 3;
• longueur: 100 pas, par exemple;
• angle: 120 degrés.

Dans la boucle:

• avancer de 100 pas;
• tourner de 120 degrés.

Erreur classique: tourner de 60 degrés. Cette valeur est géométriquement connue, mais elle ne correspond pas à l’instruction exécutée par le lutin.

2. Tracer un carré

Paramètres:

• nombre de répétitions: 4;
• longueur: 90 pas;
• angle: 90 degrés.

Le carré est l’exercice de référence. Il permet de contrôler simultanément:

• le fonctionnement du bloc répéter;
• la position du stylo;
• la fermeture de la figure;
• l’orientation du lutin après le tracé.

Après quatre itérations, le lutin doit revenir au point de départ. Il doit aussi retrouver sa direction initiale, car:

\[

4 \times 90 = 360

\]

3. Tracer un pentagone régulier

Paramètres:

• nombre de répétitions: 5;
• longueur: 70 pas;
• angle: 72 degrés.

Le pentagone oblige à calculer. L’élève ne peut pas se contenter d’une valeur mémorisée comme 90 degrés.

Le raisonnement est direct:

1. Le polygone a 5 côtés.

2. La boucle doit exécuter 5 itérations.

3. Le total des rotations vaut 360 degrés.

4. Donc une rotation vaut 360 ÷ 5.

5. Scratch tourne de 72 degrés.

4. Tracer un hexagone régulier

Paramètres:

• nombre de répétitions: 6;
• angle: 60 degrés.

Ici, une confusion est possible. L’angle extérieur vaut 60 degrés. Or l’angle intérieur d’un hexagone régulier vaut 120 degrés. Les deux valeurs sont inversées par rapport au triangle équilatéral.

Il ne faut donc pas retenir des angles isolés. Il faut recalculer la formule.

5. Tracer un hectogone

Un hectogone possède 100 côtés.

• nombre de répétitions: 100;
• angle: 360 ÷ 100, soit 3,6 degrés.

Le résultat paraît presque circulaire. Ce n’est pas un cercle. C’est un polygone régulier à 100 côtés. Scratch trace toujours des segments successifs.

Cet exercice montre une limite visuelle utile: plus le nombre de côtés augmente, plus l’angle extérieur diminue et plus la ligne polygonale ressemble à une courbe.

Créer un motif géométrique sans perdre la logique

Un motif géométrique Scratch ajoute une seconde répétition. Il ne faut pas modifier la boucle qui trace le polygone avant de l’avoir validée. On conserve d’abord une boucle interne correcte, puis on répète la figure entière.

Exemple: tracer plusieurs carrés en tournant légèrement entre chaque carré.

La structure logique est alors:

1. Une boucle interne trace un carré.

2. Une rotation supplémentaire change l’orientation.

3. Une boucle externe répète l’ensemble.

La boucle interne contient:

• répéter 4 fois;
• avancer de 60 pas;
• tourner de 90 degrés.

Après cette boucle, ajouter une rotation, par exemple de 10 degrés. Puis répéter l’ensemble plusieurs fois.

Il faut distinguer les deux niveaux:

• la boucle interne construit une figure fermée;
• la boucle externe construit le motif.

Si le carré interne ne se ferme pas, le motif entier est faux. Si la rotation externe est erronée, les carrés sont corrects mais leur agencement ne correspond pas à l’objectif.

Cette hiérarchie des boucles est une règle de programmation. On teste d’abord l’instruction la plus petite. Ensuite seulement, on répète le bloc complet.

Les erreurs qui faussent le tracé

Les erreurs de tracé ne sont pas aléatoires. Elles correspondent presque toujours à une variable, une itération ou une instruction de stylo mal réglée.

• Le nombre de répétitions est différent du nombre de côtés. Un hexagone programmé avec 5 itérations ne peut pas être fermé correctement. La boucle doit contenir autant de passages que le polygone contient de côtés.
• L’angle intérieur est utilisé à la place de l’angle extérieur. C’est l’erreur principale. Le calcul à programmer est toujours 360 ÷ n.
• La longueur et l’angle sont confondus. Augmenter le nombre de pas agrandit la figure. Cela ne corrige jamais un mauvais angle.
• Le stylo est baissé pendant le placement. Le programme dessine alors un segment supplémentaire avant le premier côté. Il faut relever le stylo avant de déplacer le lutin.
• Le programme n’efface pas les tracés précédents. Une nouvelle exécution se superpose à l’ancienne. L’erreur semble alors géométrique alors qu’elle est seulement visuelle.
• La figure est trop grande pour la scène. Les côtés sortent de l’écran. Il faut réduire la variable longueur du côté, sans toucher au nombre de répétitions ni à l’angle.
• La boucle est utilisée alors que le nombre de répétitions est inconnu. Le bloc répéter convient lorsque le nombre d’itérations est fixé ou calculé avant l’exécution. Ce n’est pas la réponse à toutes les situations algorithmiques.

Une figure régulière exige trois cohérences: même longueur, même rotation, même nombre d’itérations que de côtés.

Test de vérification rapide

Avant de considérer le programme comme terminé, effectuer quatre contrôles.

1. Compter les côtés demandés. Le nombre doit être identique à la valeur du bloc répéter.

2. Calculer 360 ÷ nombre de côtés. Cette valeur doit être placée dans le bloc de rotation.

3. Vérifier que le stylo est baissé avant la boucle et relevé avant les déplacements sans tracé.

4. Contrôler la fermeture: après la dernière itération, le lutin doit revenir au point de départ et retrouver sa direction initiale.

Si ces quatre conditions sont satisfaites, l’algorithme de répétition Scratch est cohérent. Le programme ne dessine pas seulement une forme. Il traduit exactement la propriété géométrique du polygone régulier: une succession de côtés identiques et une somme de rotations égale à 360 degrés.