# Penser et programmer par blocs : maths 5e

Chapitre 20 du programme de mathématiques de 5e (thème : Algorithmique et programmation). Ressource gratuite OptiTAB.

- Cours : https://www.optitab.net/ressources-gratuites/maths/5e/penser-et-programmer-par-blocs/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/5e/penser-et-programmer-par-blocs/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/5e/penser-et-programmer-par-blocs/exercices/

## Cours

**Objectifs : - Lire un script en blocs (Scratch) et l'exécuter à la main, bloc après bloc.**
- Utiliser une variable, une entrée (« demander ») et une sortie (« dire ») ; traduire un programme de calcul.
- Déplacer un lutin et tracer une figure avec le stylo.
- Utiliser une boucle « répéter n fois » et une instruction « si … alors ».
- Déclencher un script par un événement : drapeau vert, touche du clavier.

**Prerequis : - Calculer en respectant les priorités et les parenthèses.**
- Se repérer dans le plan avec une abscisse et une ordonnée.
- Connaître les angles droits et la somme des angles d'un triangle.

## I. Programme, script et blocs

**Définition : Algorithme, programme, script**
- Un **algorithme** est une suite d'instructions précises qui, exécutées dans l'ordre, permettent de résoudre un problème.
- Un **programme** écrit cet algorithme dans un langage compris par l'ordinateur. Au collège, on programme avec **Scratch** : les instructions sont des **blocs** que l'on emboîte.
- Un **script** est une pile de blocs. Il commence par un **événement** (bloc « chapeau ») et ses blocs sont exécutés **de haut en bas**, un par un.
- Le personnage qui exécute les scripts s'appelle un **lutin** ; il se déplace sur la **scène**.
**Chaque : famille de blocs a sa couleur :**

![Les familles de blocs Scratch et leurs couleurs : Événements, Contrôle, Variables, Opérateurs, Capteurs, Apparence, Mouvement, Stylo.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_1_cours_familles.png)

**Méthode : Exécuter un script à la main**
1. Repérer l'événement qui démarre le script.
2. Lire les blocs **dans l'ordre**, de haut en bas, sans en sauter.
3. Noter après chaque bloc ce qui change (valeur d'une variable, position du lutin) dans un **tableau d'exécution**.

## II. Variables et programmes de calcul

**Définition : Variable**
Une **variable** est une case de la mémoire qui porte un nom et contient une valeur. Cette valeur peut changer pendant l'exécution du script.

- « mettre résultat à 7 » **remplace** la valeur de résultat par $7$ ;
- « ajouter 3 à résultat » **augmente** la valeur de résultat de $3$.

**Définition : Entrée et sortie**
- **Entrée** : « demander … et attendre » pose une question ; le nombre tapé au clavier est rangé dans le bloc **réponse**.
- **Sortie** : « dire … » fait afficher par le lutin un nombre, un texte ou la valeur d'une variable.

**Exemple : Un programme de calcul**
![Script Scratch : demander un nombre, mettre nombre à réponse, mettre résultat à nombre + 5, mettre résultat à résultat * 2, dire résultat.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_2_cours_calcul.png)

On clique sur le drapeau et on répond $7$. Tableau d'exécution :

| Bloc exécuté | nombre | résultat |
|---|---|---|
| mettre nombre à réponse | $7$ | — |
| mettre résultat à nombre + 5 | $7$ | $7 + 5 = 12$ |
| mettre résultat à résultat ∗ 2 | $7$ | $12 \times 2 = 24$ |

Le lutin dit $24$. Pour un nombre $x$ quelconque, il dit $(x + 5) \times 2$.

**Attention : Lire « mettre résultat à résultat ∗ 2 »**
On calcule d'abord avec l'**ancienne** valeur : nouvelle valeur de résultat $=$ ancienne valeur $\times\, 2$. Dans Scratch, la multiplication se note $\ast$ et la division se note /.

### Blocs opérateurs emboîtés

Un bloc opérateur (vert) peut contenir un autre bloc opérateur. Le bloc **le plus à l'intérieur** est calculé **en premier** : il joue le rôle des parenthèses.

![Deux blocs opérateurs emboîtés : bloc 1 « (n * 2) + 1 » et bloc 2 « (n + 1) * 2 ».](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_3_cours_emboites.png)

| Bloc | Calcul effectué | Pour $n = 6$ |
|---|---|---|
| Bloc 1 | $(n \times 2) + 1$ | $12 + 1 = 13$ |
| Bloc 2 | $(n + 1) \times 2$ | $7 \times 2 = 14$ |

**Attention : Erreur fréquente**
Les deux blocs utilisent les mêmes nombres et les mêmes opérations, mais pas dans le même ordre : ils ne donnent pas le même résultat. On lit toujours le bloc intérieur d'abord.

## III. Déplacer le lutin et tracer

**Définition : La scène et l'orientation**
- La scène est un **repère** : l'abscisse $x$ va de $-240$ à $240$, l'ordonnée $y$ de $-180$ à $180$ ; le centre a pour coordonnées $(0\ ;\ 0)$.
- L'**orientation** du lutin est un angle en degrés : $0$ vers le haut, $90$ vers la droite, $180$ vers le bas, $-90$ vers la gauche.

![La scène de Scratch : repère de −240 à 240 en abscisse et de −180 à 180 en ordonnée, centre (0 ; 0), et les orientations 0 (haut), 90 (droite), 180 (bas), −90 (gauche).](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_4_cours_scene.png)

**Propriété : Blocs de mouvement et de stylo**
- « aller à x : … y : … » place le lutin en un point de la scène.
- « s'orienter à 90 » tourne le lutin vers la droite, quelle que soit son orientation avant.
- « avancer de 50 pas » déplace le lutin de $50$ pas **dans la direction où il regarde**.
- « tourner ↻ de 90 degrés » : quart de tour dans le sens des aiguilles d'une montre ; « tourner ↺ de 90 degrés » : quart de tour dans l'autre sens. Une rotation ne trace rien.
- « stylo en position d'écriture » : le lutin trace ses déplacements ; « relever le stylo » : il ne trace plus ; « effacer tout » efface les dessins.

**Exemple : Tracer la lettre L**
![Script Scratch : effacer tout, aller à (0 ; 80), s'orienter à 180, stylo en position d'écriture, avancer de 80 pas, tourner ↺ de 90 degrés, avancer de 40 pas.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_5_cours_L.png)

| Bloc exécuté | Position | Orientation |
|---|---|---|
| aller à x : 0 y : 80 | $(0\ ;\ 80)$ | — |
| s'orienter à 180 | $(0\ ;\ 80)$ | $180$ (bas) |
| avancer de 80 pas | $(0\ ;\ 0)$ | $180$ (bas) |
| tourner ↺ de 90 degrés | $(0\ ;\ 0)$ | $90$ (droite) |
| avancer de 40 pas | $(40\ ;\ 0)$ | $90$ (droite) |

![Tracé obtenu en vert : la lettre L, de (0 ; 80) à (0 ; 0) puis à (40 ; 0) ; flèche orange vers la droite à l'arrivée.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_6_cours_L_trace.png)

Le lutin a tracé deux segments, de $80$ et $40$ pas. La flèche orange indique son orientation à la fin.

## IV. Répéter des instructions : la boucle

**Définition : Boucle « répéter n fois »**
Le bloc « répéter 4 fois » exécute **4 fois de suite** tous les blocs qu'il contient, dans l'ordre. Un bloc placé **après** la boucle n'est exécuté qu'une fois.

**Exemple : Tracer un carré de côté 60**
![Script Scratch qui trace un carré : aller à (0 ; 0), s'orienter à 90, stylo en position d'écriture, répéter 4 fois avancer de 60 pas et tourner ↺ de 90 degrés.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_7_cours_carre.png)

| Tour | Position après « avancer » | Orientation après « tourner ↺ » |
|---|---|---|
| 1 | $(60\ ;\ 0)$ | $0$ (haut) |
| 2 | $(60\ ;\ 60)$ | $-90$ (gauche) |
| 3 | $(0\ ;\ 60)$ | $180$ (bas) |
| 4 | $(0\ ;\ 0)$ | $90$ (droite) |

![Tracé obtenu en vert : carré de côté 60 de sommets (0 ; 0), (60 ; 0), (60 ; 60), (0 ; 60) ; flèche orange vers la droite au départ.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_8_cours_carre_trace.png)

Sans boucle, il aurait fallu écrire $8$ blocs de mouvement au lieu de $2$.

**Propriété : Polygone régulier**
Pour tracer un polygone régulier à $n$ côtés, on répète $n$ fois « avancer ; tourner de $360 \div n$ degrés ». En tout, le lutin fait un tour complet ($360^\circ$). Carré : $360 \div 4 = 90^\circ$ ; triangle équilatéral : $360 \div 3 = 120^\circ$.

**Attention : Angle du polygone ou angle de rotation ?**
Le lutin tourne de l'angle qui **prolonge** sa direction, pas de l'angle intérieur de la figure. Pour un triangle équilatéral (angles de $60^\circ$), il tourne de $180^\circ - 60^\circ = 120^\circ$.

## V. L'instruction conditionnelle « si … alors »

**Définition : Condition**
Une **condition** (bloc hexagonal vert) est **vraie** ou **fausse** : « score > 50 », « réponse < 12 », « x = 5 »…

Dans « si condition alors », les blocs intérieurs ne sont exécutés **que si la condition est vraie** ; sinon, le script passe directement au bloc suivant.

![Script Scratch : demander le nombre de points, mettre score à réponse ; si score > 50 alors dire « Niveau réussi ! » ; puis dire « Fin de la partie ».](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_9_cours_si.png)

**Exemple : | Réponse | score > 50 ? | Ce que dit le lutin |**
|---|---|---|
| $72$ | vrai | « Niveau réussi ! » puis « Fin de la partie » |
| $50$ | faux | « Fin de la partie » seulement |

**Attention : Tester la valeur frontière**
$50 > 50$ est **faux** : avec exactement $50$ points, le niveau n'est pas réussi. Pour l'accepter, on écrit « score > 49 » (les scores sont entiers).

## VI. Les événements

**Définition : Événement**
Un script démarre quand son **événement** se produit : « quand le drapeau est cliqué », « quand la touche … est pressée »… Un même lutin peut avoir plusieurs scripts : chacun attend son propre événement.

![Trois scripts : quand le drapeau est cliqué, aller à (0 ; 0) ; quand la touche flèche droite est pressée, ajouter 10 à x ; quand la touche flèche gauche est pressée, ajouter −10 à x.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n280_co275_10_cours_touches.png)

**Exemple : On clique sur le drapeau : le lutin va en $(0\ ;\ 0)$. Puis on appuie sur « flèche droite », « flèche droite », « flèche gauche », « flèche droite » : l'abscisse du lutin vaut successivement $10$, $20$, $10$ et $20$. Il termine en $(20\ ;\ 0)$.**

**À retenir : - Un script commence par un événement et s'exécute de haut en bas ; on le suit avec un **tableau d'exécution**.**
- « mettre » remplace la valeur d'une variable ; « ajouter » l'augmente.
- Dans des blocs emboîtés, le bloc intérieur est calculé en premier.
- Orientation : $0$ haut, $90$ droite, $180$ bas, $-90$ gauche ; « avancer » suit la direction du lutin.
- « répéter n fois » exécute $n$ fois tout son contenu ; polygone régulier à $n$ côtés : tourner de $360 \div n$ degrés.
- « si … alors » : les blocs intérieurs ne s'exécutent que si la condition est vraie ; tester la valeur frontière.

## Fiche de révision

**Objectifs : Lire, exécuter, compléter et corriger un script en blocs : variables, tracés, boucles, conditions, événements.**

## I. Script et variables

- Un script commence par un **événement** (drapeau, touche) et s'exécute **de haut en bas**.
- « demander … » : le nombre tapé va dans **réponse** ; « dire … » : le lutin affiche.
- « mettre x à 5 » **remplace** la valeur de x ; « ajouter 5 à x » l'**augmente** de $5$.

**Méthode : Tableau d'exécution**
Une ligne par bloc (ou par tour de boucle), une colonne par variable ; on utilise toujours la **dernière** valeur.

| Bloc exécuté (réponse $3$) | n | r |
|---|---|---|
| mettre n à réponse | $3$ | — |
| mettre r à n ∗ 4 | $3$ | $12$ |
| ajouter 1 à r | $3$ | $13$ |

Programme de calcul : le lutin dit $4n + 1$. Blocs emboîtés : le bloc **intérieur** est calculé en premier, comme une parenthèse.

## II. Lutin et stylo

![La scène de Scratch : repère de −240 à 240 en abscisse et de −180 à 180 en ordonnée, centre (0 ; 0), et les orientations 0 (haut), 90 (droite), 180 (bas), −90 (gauche).](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n280_fi195_1_cours_scene.png)

| Bloc | Effet |
|---|---|
| aller à x : … y : … | place le lutin en un point |
| s'orienter à 90 | regarde vers la droite ($0$ haut, $180$ bas, $-90$ gauche) |
| avancer de 50 pas | se déplace dans la direction où il regarde |
| tourner ↻ / ↺ de 90 degrés | quart de tour (sens des aiguilles / sens inverse) |
| stylo en position d'écriture | trace ses déplacements |

## III. Boucles et conditions

- « répéter n fois » : tout le contenu est exécuté $n$ fois, dans l'ordre.
- Polygone régulier à $n$ côtés : répéter $n$ fois « avancer ; tourner de $360 \div n$ ». Carré $90^\circ$, triangle équilatéral $120^\circ$, hexagone $60^\circ$.
- « si condition alors » : les blocs intérieurs ne s'exécutent que si la condition est **vraie**.

**Attention : Erreurs classiques**
- Confondre « mettre » et « ajouter ».
- Oublier le stylo : le lutin bouge sans rien tracer.
- Tourner de l'angle intérieur ($60^\circ$) au lieu de $120^\circ$ pour un triangle équilatéral.
- Oublier la valeur frontière : $50 > 50$ est faux.
- Placer dans la boucle un bloc qui ne doit être exécuté qu'une fois.

## Exercices corrigés

### Exercice 1 : Exécuter un programme de calcul

Voici un programme de calcul écrit avec Scratch. Le symbole « $\ast$ » est celui de la multiplication.

![Script Scratch : demander un nombre, mettre nombre à réponse, mettre résultat à nombre * 4, ajouter 6 à résultat, dire résultat.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3104_1_ex3104_script.png)

1. Quel bloc démarre le script ? Quel bloc permet de saisir un nombre ? Quelles sont les deux variables utilisées ?
2. On choisit $5$. Présenter un tableau d'exécution et donner le nombre dit par le lutin.
3. Quel nombre le lutin dit-il si l'on choisit $2{,}5$ ? Et si l'on choisit $0$ ?
4. On choisit un nombre $x$. Exprimer en fonction de $x$ le nombre dit par le lutin.
5. Quel nombre faut-il choisir pour que le lutin dise $50$ ?
6. Remplacer le bloc « ajouter 6 à résultat » par un bloc « mettre résultat à … » qui fait exactement la même chose.

#### Correction détaillée

## Question 1 : Les blocs du script

**Méthode : On regarde la couleur et le rôle de chaque bloc : jaune pour les événements, bleu clair pour les capteurs, orange pour les variables.**

**Etape : Lecture du script**
- « quand le drapeau est cliqué » (jaune) démarre le script.
- « demander Choisis un nombre et attendre » permet de saisir un nombre ; il est rangé dans **réponse**.
- Les blocs orange utilisent deux variables : **nombre** et **résultat**.

**Resultat : Le script démarre avec le drapeau vert ; on saisit le nombre avec « demander » ; les variables sont nombre et résultat.**

## Question 2 : Avec le nombre 5

**Méthode : On suit les blocs dans l'ordre et on note, après chaque bloc, la valeur des variables.**

**Etape : Tableau d'exécution**
| Bloc exécuté | nombre | résultat |
|---|---|---|
| demander … (on tape $5$) | — | — |
| mettre nombre à réponse | $5$ | — |
| mettre résultat à nombre ∗ 4 | $5$ | $5 \times 4 = 20$ |
| ajouter 6 à résultat | $5$ | $20 + 6 = 26$ |
| dire résultat | $5$ | $26$ |

**Resultat : Le lutin dit $26$.**

## Question 3 : Avec 2,5 puis avec 0

**Etape : Avec $2{,}5$**
résultat vaut $2{,}5 \times 4 = 10$, puis $10 + 6 = 16$.

**Etape : Avec $0$**
résultat vaut $0 \times 4 = 0$, puis $0 + 6 = 6$.

**Resultat : Le lutin dit $16$, puis $6$.**

## Question 4 : L'expression en fonction de x

**Méthode : On exécute le script avec la lettre $x$ à la place d'un nombre.**

**Etape : résultat vaut d'abord $x \times 4 = 4x$, puis on lui ajoute $6$.**

**Resultat : Le lutin dit $4x + 6$.**

## Question 5 : Pour obtenir 50

**Méthode : On remonte le programme en faisant les opérations inverses, en partant de la fin.**

**Etape : On remonte le calcul**
- Avant « ajouter 6 », résultat valait $50 - 6 = 44$.
- Avant « ∗ 4 », le nombre valait $44 \div 4 = 11$.

**Etape : Vérification**
$11 \times 4 + 6 = 44 + 6 = 50$.

**Resultat : Il faut choisir $11$.**

## Question 6 : « mettre » à la place de « ajouter »

**Etape : « ajouter 6 à résultat » donne à résultat sa valeur **augmentée de 6**. Avec « mettre », il faut écrire ce calcul : nouvelle valeur $=$ ancienne valeur $+ 6$.**

![Script modifié : le bloc « ajouter 6 à résultat » est remplacé par « mettre résultat à résultat + 6 », entouré de vert.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3104_2_ex3104_mettre.png)

**Resultat : On écrit « mettre résultat à résultat + 6 » (bloc entouré de vert).**

**Attention : Erreur fréquente**
Écrire « mettre résultat à 6 » : la valeur $20$ serait **remplacée** par $6$, et le lutin dirait $6$ quel que soit le nombre choisi.

#### Réponses

1. Le drapeau vert ; « demander » ; les variables nombre et résultat
2. $26$
3. $16$ ; $6$
4. $4x + 6$
5. $11$
6. « mettre résultat à résultat + 6 »

### Exercice 2 : La tirelire de Lina

Lina a $30$ € dans sa tirelire et y ajoute $15$ € chaque semaine. Elle simule ses économies avec ce script.

![Script Scratch : mettre semaine à 0, mettre tirelire à 30, répéter 8 fois ajouter 1 à semaine et ajouter 15 à tirelire ; dire tirelire ; si tirelire > 150 alors dire « Objectif atteint ! ».](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3115_1_ex3115_script.png)

1. Présenter un tableau d'exécution de la boucle (valeurs de semaine et de tirelire à la fin de chaque tour).
2. Que dit le lutin ? Lina a pourtant atteint son objectif de $150$ € : expliquer le problème et corriger la condition.
3. Exprimer la somme contenue dans la tirelire après $n$ semaines.
4. Lina veut acheter un vélo à $200$ €. Combien de semaines doit-elle économiser ? Modifier le script pour que le lutin annonce l'objectif atteint au bon moment.

#### Correction détaillée

## Question 1 : Tableau d'exécution

**Méthode : Avant la boucle : semaine $= 0$ et tirelire $= 30$. À chaque tour, semaine augmente de $1$ et tirelire de $15$.**

**Etape : | Tour | semaine | tirelire |**
|---|---|---|
| avant la boucle | $0$ | $30$ |
| 1 | $1$ | $45$ |
| 2 | $2$ | $60$ |
| 3 | $3$ | $75$ |
| 4 | $4$ | $90$ |
| 5 | $5$ | $105$ |
| 6 | $6$ | $120$ |
| 7 | $7$ | $135$ |
| 8 | $8$ | $150$ |

**Resultat : Après la boucle, semaine vaut $8$ et tirelire vaut $150$.**

## Question 2 : Ce que dit le lutin

**Etape : Le lutin dit $150$. Puis il teste la condition « tirelire > 150 » : $150 > 150$ est **faux**, donc il ne dit pas « Objectif atteint ! ».**

**Etape : Correction**
L'objectif est atteint dès que tirelire vaut $150$ **ou plus**. Les sommes sont des nombres entiers d'euros : « tirelire > 149 » convient.

![Script corrigé : la condition devient tirelire > 149, le nombre 149 écrit en vert.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3115_2_ex3115_149.png)

**Resultat : Le lutin dit seulement $150$. Avec la condition « tirelire > 149 » (en vert), il dit $150$ puis « Objectif atteint ! ».**

## Question 3 : L'expression

**Etape : Au départ, $30$ € ; chaque semaine, $15$ € de plus. Après $n$ semaines, on a ajouté $n$ fois $15$ €.**

**Etape : Vérification avec $n = 8$**
$30 + 15 \times 8 = 30 + 120 = 150$.

**Resultat : Après $n$ semaines, la tirelire contient $30 + 15 \times n$ euros.**

## Question 4 : Le vélo à 200 €

**Méthode : On cherche le premier nombre de semaines pour lequel $30 + 15 \times n$ atteint $200$.**

**Etape : Essais**
- $n = 11$ : $30 + 15 \times 11 = 30 + 165 = 195$, pas assez.
- $n = 12$ : $30 + 15 \times 12 = 30 + 180 = 210$, c'est suffisant.

**Etape : Modification du script**
On répète $12$ fois et on teste « tirelire > 199 » (au moins $200$ €).

![Script pour le vélo : répéter 12 fois et condition tirelire > 199, nombres écrits en vert.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3115_3_ex3115_velo.png)

**Resultat : Il faut $12$ semaines. Le lutin dit alors $210$, puis « Objectif atteint ! » (modifications en vert).**

**Attention : Erreur fréquente**
Diviser $200$ par $15$ sans tenir compte des $30$ € de départ. Il faut d'abord calculer ce qui manque : $200 - 30 = 170$ €, puis $170 \div 15 \approx 11{,}3$, donc $12$ semaines entières.

#### Réponses

1. tirelire : $45$, $60$, $75$, $90$, $105$, $120$, $135$, $150$
2. Il dit $150$ seulement, car $150 > 150$ est faux ; condition « tirelire > 149 »
3. $30 + 15 \times n$
4. $12$ semaines ; répéter 12 fois et condition « tirelire > 199 »

### Exercice 3 : Un escalier

Le lutin trace un escalier. La scène va de $-240$ à $240$ en abscisse et de $-180$ à $180$ en ordonnée.

![Script Scratch : aller à (0 ; 0), s'orienter à 90, stylo baissé, répéter 4 fois avancer de 30, tourner ↺ de 90, avancer de 20, tourner ↻ de 90.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3122_1_ex3122_script.png)

1. Exécuter pas à pas le premier tour de boucle : donner la position et l'orientation du lutin après chacun des quatre blocs.
2. Donner la position du lutin à la fin de chaque tour, puis représenter le tracé.
3. Quelle longueur le stylo a-t-il tracée ?
4. On veut un escalier qui monte jusqu'à la hauteur $140$. Quel nombre faut-il écrire dans « répéter » ? Combien de marches peut-on tracer au plus sans sortir de la scène ?
5. Un élève remplace le bloc « tourner ↻ de 90 degrés » par « tourner ↺ de 90 degrés ». Quel tracé obtient-il ?

#### Correction détaillée

## Question 1 : Le premier tour, pas à pas

**Méthode : Le lutin part de $(0\ ;\ 0)$, tourné vers la droite (orientation $90$). On suit les quatre blocs de la boucle.**

**Etape : Tableau d'exécution**
| Bloc exécuté | Position | Orientation |
|---|---|---|
| avancer de 30 pas | $(30\ ;\ 0)$ | $90$ (droite) |
| tourner ↺ de 90 degrés | $(30\ ;\ 0)$ | $0$ (haut) |
| avancer de 20 pas | $(30\ ;\ 20)$ | $0$ (haut) |
| tourner ↻ de 90 degrés | $(30\ ;\ 20)$ | $90$ (droite) |

**Resultat : Après un tour, le lutin est en $(30\ ;\ 20)$ et regarde de nouveau vers la droite : il a tracé une marche.**

## Question 2 : Les quatre marches

**Etape : Chaque tour recommence dans la même direction : il ajoute $30$ à l'abscisse et $20$ à l'ordonnée.**

| Fin du tour | Position |
|---|---|
| 1 | $(30\ ;\ 20)$ |
| 2 | $(60\ ;\ 40)$ |
| 3 | $(90\ ;\ 60)$ |
| 4 | $(120\ ;\ 80)$ |

![Tracé en vert : escalier de 4 marches, de (0 ; 0) à (120 ; 80), en passant par (30 ; 20), (60 ; 40), (90 ; 60).](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3122_2_ex3122_trace.png)

**Resultat : Un escalier de $4$ marches (en vert), de $(0\ ;\ 0)$ à $(120\ ;\ 80)$.**

## Question 3 : La longueur tracée

**Etape : Calcul**
Chaque marche mesure $30 + 20 = 50$ pas ; $4 \times 50 = 200$.

**Resultat : Le stylo a tracé $200$ pas.**

## Question 4 : Un escalier plus haut

**Etape : Hauteur 140**
Chaque marche monte de $20$ : $140 \div 20 = 7$ marches.

![Script modifié : répéter 7 fois, le nombre 7 écrit en vert.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3122_3_ex3122_7.png)

**Etape : Sans sortir de la scène**
Après $n$ marches, le lutin est en $(30n\ ;\ 20n)$.
- Abscisse : $30n \leqslant 240$ donne $n \leqslant 8$.
- Ordonnée : $20n \leqslant 180$ donne $n \leqslant 9$.

Avec $8$ marches, le lutin arrive en $(240\ ;\ 160)$, encore sur la scène ; avec $9$, il arriverait en $(270\ ;\ 180)$, hors de la scène.

**Resultat : Il faut écrire $7$ (case en vert). On peut tracer au plus $8$ marches.**

## Question 5 : Toujours tourner à gauche

**Etape : Tableau d'exécution (deux premiers tours)**
| Bloc exécuté | Position | Orientation |
|---|---|---|
| avancer de 30 pas | $(30\ ;\ 0)$ | $90$ (droite) |
| tourner ↺ de 90 degrés | $(30\ ;\ 0)$ | $0$ (haut) |
| avancer de 20 pas | $(30\ ;\ 20)$ | $0$ (haut) |
| tourner ↺ de 90 degrés | $(30\ ;\ 20)$ | $-90$ (gauche) |
| avancer de 30 pas | $(0\ ;\ 20)$ | $-90$ (gauche) |
| tourner ↺ de 90 degrés | $(0\ ;\ 20)$ | $180$ (bas) |
| avancer de 20 pas | $(0\ ;\ 0)$ | $180$ (bas) |
| tourner ↺ de 90 degrés | $(0\ ;\ 0)$ | $90$ (droite) |

![Script de l'élève : le dernier bloc de la boucle devient tourner ↺ de 90 degrés, entouré de vert.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3122_4_ex3122_gauche.png)

![Tracé en vert : rectangle de 30 sur 20 de sommets (0 ; 0), (30 ; 0), (30 ; 20), (0 ; 20).](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n280_ex3122_5_ex3122_gauche_trace.png)

**Resultat : Après deux tours, le lutin est revenu au départ : il trace un rectangle de $30$ sur $20$ (en vert). Les tours 3 et 4 repassent sur ce même rectangle.**

**Attention : Erreur fréquente**
Penser que les deux rotations d'un tour s'annulent toujours. Ici, « ↺ puis ↻ » laisse le lutin dans sa direction de départ (escalier), mais « ↺ puis ↺ » le fait tourner d'un demi-tour à chaque tour.

#### Réponses

1. $(30\ ;\ 0)$ droite ; $(30\ ;\ 0)$ haut ; $(30\ ;\ 20)$ haut ; $(30\ ;\ 20)$ droite
2. $(30\ ;\ 20)$, $(60\ ;\ 40)$, $(90\ ;\ 60)$, $(120\ ;\ 80)$
3. $200$ pas
4. $7$ ; au plus $8$ marches
5. Un rectangle de $30$ sur $20$, parcouru deux fois
