# Algorithmique et programmation : maths 3e

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

- Cours : https://www.optitab.net/ressources-gratuites/maths/3e/algorithmique-et-programmation/
- Fiche de révision : https://www.optitab.net/ressources-gratuites/maths/3e/algorithmique-et-programmation/fiche/
- Exercices corrigés : https://www.optitab.net/ressources-gratuites/maths/3e/algorithmique-et-programmation/exercices/

## Cours

**Objectifs : - Lire, exécuter à la main, compléter et écrire un script en blocs (Scratch).**
- Utiliser des variables, des entrées (« demander ») et des sorties (« dire »).
- Écrire des instructions conditionnelles et des boucles, bornées ou conditionnelles.
- Déplacer un lutin dans le repère de la scène et tracer des figures avec le stylo.
- Créer des blocs personnalisés ; déclencher des scripts par des événements et des messages.

**Prerequis : - Calcul littéral : développer une expression comme $2(n + 3)$.**
- Résoudre une équation du premier degré.
- Repérage dans le plan : abscisse et ordonnée d'un point.

## I. Algorithme, programme et script

**Définition : Algorithme, programme, script**
- Un **algorithme** est une suite finie d'instructions précises qui, exécutées dans l'ordre, résolvent un problème.
- Un **programme** traduit un algorithme dans un langage que l'ordinateur comprend. 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 bloc « chapeau », l'**événement** qui le déclenche, et ses blocs sont exécutés **de haut en bas**.
- Les scripts sont exécutés par des **lutins**, qui se déplacent 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, Mes blocs.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_1_cours_familles.png)

**Remarque : La forme d'un bloc indique son rôle**
- Le bloc **chapeau**, arrondi en haut, démarre un script.
- Le bloc à **encoche** est une instruction, qui s'emboîte sous la précédente.
- Le bloc en forme de **C** contient d'autres blocs : boucle ou test.
- Le bloc **arrondi** est une valeur (nombre, variable, calcul) ; le bloc **hexagonal** est une condition, vraie ou fausse.

## II. Variables, entrées et sorties

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

- « mettre x à 3 » **remplace** la valeur de x par $3$ ;
- « ajouter 3 à x » **augmente** la valeur de x de $3$ : x devient $x + 3$.

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

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

On répond $5$. Tableau d'exécution :

| Bloc exécuté | n | r |
|---|---|---|
| mettre n à réponse | $5$ | — |
| mettre r à n + 3 | $5$ | $8$ |
| mettre r à r × 2 | $5$ | $16$ |

Le lutin dit $16$. Pour un nombre $n$ quelconque, il dit $(n + 3) \times 2 = 2n + 6$.

**Méthode : Exécuter un script à la main**
1. Faire un **tableau d'exécution** : une colonne par variable, une ligne par bloc (ou par tour de boucle).
2. Suivre les blocs **dans l'ordre**, en utilisant toujours la **dernière** valeur de chaque variable.
3. Lire la sortie : la valeur dite par le lutin.

**Attention : Lire une affectation**
« mettre r à r × 2 » signifie : nouvelle valeur de r $=$ ancienne valeur de r $\times\, 2$. Dans Scratch, la multiplication se note $\ast$ et la division se note /.

## III. Instructions conditionnelles

**Définition : Condition, « si … alors … sinon »**
Une **condition** (bloc hexagonal vert) est vraie ou fausse : « x < 10 », « x = 5 »…

- « si condition alors » : les blocs intérieurs ne sont exécutés que si la condition est **vraie** ;
- « si condition alors … sinon … » : **une seule** des deux branches est exécutée.

![Script Scratch : demander l'âge ; si âge < 18 alors dire « Tu es mineur. » sinon dire « Tu es majeur. ».](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_3_cours_si.png)

**Exemple : - Réponse $17$ : la condition $17 < 18$ est vraie, le lutin dit « Tu es mineur. ».**
- Réponse $18$ : la condition $18 < 18$ est fausse, le lutin dit « Tu es majeur. ».

**Propriété : Conditions composées et reste**
- « A et B » est vraie quand les deux conditions sont vraies ; « A ou B » quand au moins l'une est vraie ; « non A » quand A est fausse.
- « a modulo b » donne le **reste** de la division euclidienne de $a$ par $b$. La condition « (n modulo d) = 0 » teste si $d$ divise $n$ ; « (n modulo 2) = 0 » teste si $n$ est pair.

**Attention : Tester la valeur frontière**
$18 < 18$ est faux. Pour « inférieur ou égal à 18 », on écrit « (âge < 18) ou (âge = 18) ».

## IV. Les boucles

**Définition : Boucle bornée**
« répéter n fois » exécute les blocs qu'elle contient exactement $n$ fois.

![Script Scratch : mettre x à 0, répéter 5 fois ajouter 2 à x, puis dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_4_cours_repeter.png)

| Tour | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| x à la fin du tour | $2$ | $4$ | $6$ | $8$ | $10$ |

Le bloc « dire x », placé **après** la boucle, est exécuté une seule fois : le lutin dit $10$.

**Définition : Boucle conditionnelle**
« répéter jusqu'à condition » : la condition est testée **avant chaque tour** ; la boucle s'arrête dès qu'elle est **vraie**. Le nombre de tours n'est pas connu à l'avance.

![Script Scratch : mettre x à 1, répéter jusqu'à x > 100 : mettre x à x * 3, puis dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_5_cours_jusqua.png)

| Tour | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| x avant le tour | $1$ | $3$ | $9$ | $27$ | $81$ |
| x à la fin du tour | $3$ | $9$ | $27$ | $81$ | $243$ |

Avant le 6e tour, $243 > 100$ est vrai : la boucle s'arrête et le lutin dit $243$.

**Remarque : « répéter indéfiniment » ne s'arrête jamais : on l'utilise pour une animation ou un jeu.**

**Attention : Erreurs fréquentes**
- Un bloc placé **dans** la boucle est exécuté à chaque tour ; un bloc placé **après** la boucle, une seule fois.
- « répéter jusqu'à x > 100 » ne s'arrête pas « à 100 » : elle s'arrête à la **première** valeur qui rend la condition vraie (ici $243$).
- Si la variable n'évolue pas vers la condition d'arrêt, la boucle ne s'arrête jamais : c'est une **boucle infinie**.

## V. 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_n248_co243_6_cours_scene.png)

**Propriété : Blocs de mouvement et de stylo**
- « aller à x : … y : … » place le lutin en un point ; « s'orienter à 90 » le tourne vers la droite.
- « avancer de 50 pas » le déplace de $50$ dans la direction où il regarde.
- « tourner ↺ de 90 degrés » : quart de tour dans le sens **inverse** des aiguilles d'une montre ; « tourner ↻ » : dans le sens des aiguilles.
- « ajouter 30 à x » : déplacement horizontal de $30$ ; « ajouter 30 à y » : déplacement vertical.
- « stylo en position d'écriture » : le lutin trace ses déplacements ; « relever le stylo » : il ne trace plus ; « effacer tout » efface la scène.

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

Le lutin part de $(0\ ;\ 0)$ vers la droite. Il passe par $(50\ ;\ 0)$, $(50\ ;\ 50)$, $(0\ ;\ 50)$ et revient en $(0\ ;\ 0)$ : quatre quarts de tour, soit $4 \times 90^\circ = 360^\circ$. La flèche orange indique l'orientation finale.

![Tracé obtenu : carré de côté 50 de sommets (0 ; 0), (50 ; 0), (50 ; 50), (0 ; 50), en vert sur le repère.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_8_cours_carre_trace.png)

**Propriété : Polygone régulier**
Pour tracer un polygone régulier à $n$ côtés, on répète $n$ fois « avancer ; tourner de $\dfrac{360}{n}$ degrés » : le lutin tourne de l'angle **extérieur**. Carré : $90^\circ$ ; triangle équilatéral : $120^\circ$ ; hexagone régulier : $60^\circ$.

**Attention : Angle intérieur ou angle extérieur**
Pour un triangle équilatéral, tourner de $60^\circ$ (l'angle intérieur) ne referme pas la figure : le lutin doit tourner de $180^\circ - 60^\circ = 120^\circ$.

## VI. Blocs personnalisés

**Définition : Bloc personnalisé, paramètre**
Un **bloc personnalisé** (famille « Mes blocs », en rose) donne un nom à une suite d'instructions ; on l'écrit sous le bloc « définir ». Ses **paramètres** (ovales roses) reçoivent une valeur à chaque **appel** : « carré (40) » exécute la définition avec côté $= 40$.

![Bloc personnalisé « définir carré (côté) » et script principal qui appelle carré (20), carré (40) et carré (60).](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_9_cours_bloc.png)

**Exemple : Le bloc « carré » trace un carré et ramène le lutin à son point de départ, avec la même orientation. Les trois appels tracent donc trois carrés de côtés $20$, $40$ et $60$ qui ont le sommet $(0\ ;\ 0)$ en commun.**

![Tracé obtenu : trois carrés de côtés 20, 40 et 60 qui ont le sommet (0 ; 0) en commun.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_10_cours_bloc_trace.png)

**Conseil : Découper un problème en blocs personnalisés rend le script plus court, plus lisible et plus facile à corriger.**

## VII. Événements, messages et hasard

**Définition : Événements**
Un script démarre par un événement : « quand le drapeau est cliqué », « quand la touche … est pressée », « quand je reçois … ». Plusieurs scripts peuvent s'exécuter **en même temps**.

**Définition : Messages**
« envoyer à tous [message] » déclenche tous les scripts « quand je reçois [message] », de tous les lutins. Avec « envoyer à tous … et attendre », le script qui envoie le message attend que ces scripts soient **terminés** avant de continuer.

![Deux lutins : le Chat met score à 0, envoie « compter » et attend, puis dit score ; la Balle, quand elle reçoit « compter », ajoute 5 à score quatre fois.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n248_co243_11_cours_messages.png)

**Exemple : Le Chat met score à $0$, puis envoie « compter » et attend : la Balle ajoute $5$ quatre fois. Le Chat dit ensuite $20$. Sans « et attendre », il pourrait dire le score avant la fin du comptage.**

**Propriété : Simuler une expérience aléatoire**
- « nombre aléatoire entre 1 et 6 » simule le lancer d'un dé équilibré.
- Pour estimer une probabilité : mettre un compteur à $0$ **avant** la boucle, lui ajouter $1$ à chaque succès, puis calculer la fréquence « compteur / nombre d'essais » **après** la boucle.
- Sur un grand nombre d'essais, la fréquence obtenue est proche de la probabilité.

**À retenir : - Un script s'exécute de haut en bas ; on le suit avec un tableau d'exécution.**
- « mettre » remplace la valeur d'une variable ; « ajouter » la modifie.
- « si … alors … sinon » : une seule branche est exécutée ; tester la valeur frontière.
- « répéter n fois » : $n$ tours ; « répéter jusqu'à » : arrêt dès que la condition est vraie.
- Orientation : $0$ haut, $90$ droite, $180$ bas, $-90$ gauche ; polygone régulier à $n$ côtés : tourner de $\dfrac{360}{n}$ degrés.
- Un bloc personnalisé a des paramètres ; « envoyer à tous … et attendre » synchronise les lutins.

## Fiche de révision

## I. Scripts et variables

- Un **script** est une pile de blocs, déclenchée par un **événement** et exécutée **de haut en bas**.
- 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, Mes blocs.](https://optitab-media.s3.eu-north-1.amazonaws.com/synthesis_images/v1_n248_fi163_1_cours_familles.png)

- « mettre x à … » **remplace** la valeur de x ; « ajouter … à x » la **modifie**.
- **Entrée** : « demander … et attendre » range la valeur tapée dans **réponse**. **Sortie** : « dire … ».
- Exécuter à la main : un **tableau d'exécution**, une colonne par variable, une ligne par bloc ou par tour.

## II. Instructions conditionnelles

- « si condition alors … sinon … » : **une seule** branche est exécutée.
- Conditions : « < », « = », « > » ; « et », « ou », « non ».
- « (n modulo d) = 0 » : $d$ divise $n$ (le reste est nul).
- Toujours tester la **valeur frontière** : $10 < 10$ est faux.

## III. Les boucles

| Boucle | Fonctionnement |
|---|---|
| répéter n fois | exactement $n$ tours |
| répéter jusqu'à condition | condition testée avant chaque tour ; arrêt dès qu'elle est vraie |
| répéter indéfiniment | ne s'arrête jamais |

- Bloc **dans** la boucle : exécuté à chaque tour ; bloc **après** : une seule fois.
- Une variable qui n'évolue pas vers la condition d'arrêt donne une **boucle infinie**.

## IV. Le lutin et le stylo

- Scène : x de $-240$ à $240$, y de $-180$ à $180$, centre $(0\ ;\ 0)$.
- Orientation : $0$ haut, $90$ droite, $180$ bas, $-90$ 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/synthesis_images/v1_n248_fi163_2_cours_scene.png)

- « tourner ↺ » : sens inverse des aiguilles d'une montre ; « tourner ↻ » : sens des aiguilles.
- Le lutin ne trace que si le stylo est **en position d'écriture**.
- Polygone régulier à $n$ côtés : répéter $n$ fois « avancer ; tourner de $\dfrac{360}{n}$ degrés » (angle **extérieur**) : carré $90^\circ$, triangle équilatéral $120^\circ$, hexagone $60^\circ$.

## V. Blocs personnalisés, messages, hasard

- Bloc personnalisé : « définir nom (paramètres) » ; chaque appel donne une valeur aux paramètres.
- « envoyer à tous … et attendre » : attend la fin des scripts « quand je reçois … ».
- « nombre aléatoire entre 1 et 6 » simule un dé ; fréquence $=$ compteur / nombre d'essais, proche de la probabilité.

**Attention : Les erreurs classiques**
1. Exécuter une seule fois un bloc placé **dans** une boucle (ou plusieurs fois un bloc placé **après**).
2. Croire que « répéter jusqu'à x > 20 » s'arrête à $20$ : elle s'arrête à la première valeur qui dépasse $20$.
3. Tourner de l'angle **intérieur** d'un polygone au lieu de l'angle extérieur.
4. Oublier les parenthèses : « ajouter 5 », puis « × 2 » donne $(x + 5) \times 2$.
5. Oublier de mettre un compteur à $0$ **avant** la boucle.

**Conseil : Réflexe brevet**
Pour un script de calcul, noter les valeurs des variables pas à pas, puis écrire l'expression avec une lettre pour démontrer une conjecture. Pour un tracé, noter à chaque étape la **position** et l'**orientation** du lutin.

## Exercices corrigés

### Exercice 1 : Suivre un script pas à pas

On considère le script suivant.

![Script Scratch : mettre x à 3, ajouter 5 à x, mettre x à x * 2, dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n248_ex2443_1_ex2443_script.png)

1. Donner la valeur de x après chacun des trois blocs de la famille « Variables » (en orange).
2. Quelle valeur le lutin dit-il ?
3. On échange les blocs « ajouter 5 à x » et « mettre x à x × 2 ». Quelle valeur le lutin dit-il alors ?
4. Dans le script de départ, on remplace $3$ par un nombre $a$. Exprimer la valeur dite en fonction de $a$, puis développer.
5. Par quel nombre faut-il remplacer $3$ pour que le lutin dise $30$ ?

#### Correction détaillée

## Question 1 : La valeur de x après chaque bloc

**Méthode : On exécute les blocs de haut en bas, en partant toujours de la **dernière** valeur de x, et on note tout dans un tableau d'exécution.**

**Etape : Tableau d'exécution**
| Bloc exécuté | Calcul | x |
|---|---|---|
| mettre x à 3 | — | $3$ |
| ajouter 5 à x | $3 + 5$ | $8$ |
| mettre x à x × 2 | $8 \times 2$ | $16$ |

**Resultat : x vaut successivement $3$, $8$, puis $16$.**

## Question 2 : La valeur dite

**Etape : Le bloc « dire x »**
C'est le dernier bloc : il affiche la valeur de x à ce moment-là, donc après les trois blocs de la question 1.

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

## Question 3 : Les blocs échangés

**Méthode : On refait le tableau d'exécution avec le nouvel ordre des blocs (en vert).**

![Script avec les deux blocs échangés, en vert : mettre x à x * 2 puis ajouter 5 à x.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n248_ex2443_2_ex2443_echange.png)

**Etape : Tableau d'exécution**
| Bloc exécuté | Calcul | x |
|---|---|---|
| mettre x à 3 | — | $3$ |
| mettre x à x × 2 | $3 \times 2$ | $6$ |
| ajouter 5 à x | $6 + 5$ | $11$ |

**Resultat : Le lutin dit $11$ : l'ordre des instructions change le résultat.**

## Question 4 : La valeur dite en fonction de $a$

**Méthode : On suit les blocs avec $a$ à la place de $3$. Le bloc « mettre x à x × 2 » multiplie **tout** le résultat précédent par $2$ : il faut des parenthèses.**

**Etape : Suivre les blocs avec $a$**
- Après « ajouter 5 à x » : x vaut $a + 5$.
- Après « mettre x à x × 2 » : x vaut $(a + 5) \times 2$.

**Etape : Développer**
$$(a + 5) \times 2 = a \times 2 + 5 \times 2 = 2a + 10$$

**Resultat : Le lutin dit $(a + 5) \times 2 = 2a + 10$.**

## Question 5 : Obtenir 30

**Etape : Résoudre l'équation $2a + 10 = 30$**
$$
\begin{aligned}
2a + 10 &= 30 \\
2a &= 20 \\
a &= 10
\end{aligned}
$$

**Point : Vérification**
$(10 + 5) \times 2 = 15 \times 2 = 30$.

**Resultat : Il faut remplacer $3$ par $10$.**

**Attention : Erreur fréquente**
Écrire $a + 5 \times 2$ : le script ajoute $5$ **avant** de multiplier, donc on écrit $(a + 5) \times 2$, avec des parenthèses.

#### Réponses

1. $3$ ; $8$ ; $16$
2. $16$
3. $11$
4. $(a + 5) \times 2 = 2a + 10$
5. $10$

### Exercice 2 : Une boucle « répéter jusqu'à »

On considère le script suivant.

![Script Scratch : mettre x à 0, répéter jusqu'à x > 20 : ajouter 6 à x, puis dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n248_ex2450_1_ex2450_script.png)

1. Donner les valeurs successives de x.
2. Combien de tours la boucle effectue-t-elle ?
3. Quelle valeur le lutin dit-il ?
4. On remplace « ajouter 6 à x » par « ajouter 5 à x ». Combien de tours la boucle fait-elle ? Quelle valeur est dite ?
5. On remplace par « ajouter 0 à x ». Que se passe-t-il ?

#### Correction détaillée

## Question 1 : Les valeurs de x

**Méthode : La condition « x > 20 » est testée **avant** chaque tour : si elle est fausse, on fait un tour ; dès qu'elle est vraie, la boucle s'arrête.**

**Etape : Tableau d'exécution**
| Tour | x avant le tour | x > 20 ? | x à la fin du tour |
|---|---|---|---|
| 1 | $0$ | non | $6$ |
| 2 | $6$ | non | $12$ |
| 3 | $12$ | non | $18$ |
| 4 | $18$ | non | $24$ |
| — | $24$ | oui : arrêt | — |

**Resultat : x vaut $0$, puis $6$, $12$, $18$ et $24$.**

## Question 2 : Le nombre de tours

**Etape : On compte les lignes « non » du tableau : $18 > 20$ est faux, mais $24 > 20$ est vrai.**

**Resultat : La boucle fait $4$ tours.**

## Question 3 : La valeur dite

**Etape : Le bloc « dire x » est exécuté à la sortie de la boucle, avec la première valeur qui a rendu la condition vraie.**

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

## Question 4 : Avec « ajouter 5 à x »

**Etape : Valeurs successives**
$0$, $5$, $10$, $15$, $20$, $25$. Attention : $20 > 20$ est **faux**, il faut donc encore un tour.

**Resultat : $5$ tours ; le lutin dit $25$.**

## Question 5 : Avec « ajouter 0 à x »

**Etape : x reste égal à $0$ : la condition $0 > 20$ est toujours fausse.**

**Resultat : La boucle ne s'arrête jamais : c'est une boucle infinie, le lutin ne dit rien.**

**Attention : Erreur fréquente**
Croire que la boucle s'arrête « à 20 » : elle s'arrête à la **première** valeur qui rend la condition vraie ($24$, ou $25$ à la question 4).

#### Réponses

1. $0$ ; $6$ ; $12$ ; $18$ ; $24$
2. $4$ tours
3. $24$
4. $5$ tours ; $25$
5. Boucle infinie

### Exercice 3 : Deux lutins qui communiquent

Un projet comporte deux lutins, Guide et Joueur, dont voici les scripts. La variable score est commune aux deux lutins.

![Lutin Guide : mettre score à 0, envoyer à tous départ et attendre, dire score. Lutin Joueur : quand je reçois départ, répéter 10 fois ajouter 1 à score.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n248_ex2457_1_ex2457_scripts.png)

1. Quel événement démarre le script de chaque lutin ?
2. Décrire l'ordre dans lequel les blocs sont exécutés après un clic sur le drapeau. Quelle valeur le lutin Guide dit-il ?
3. Quel est le rôle de « et attendre » dans le bloc « envoyer à tous départ et attendre » ?
4. Que pourrait-il se passer avec le simple bloc « envoyer à tous départ » ?
5. On ajoute un troisième lutin qui a exactement le même script que Joueur. Quelle valeur Guide dit-il alors ?

#### Correction détaillée

## Question 1 : Les événements

**Méthode : Chaque script commence par un bloc chapeau qui indique son événement déclencheur.**

**Resultat : Guide démarre au clic sur le drapeau vert ; Joueur démarre quand il reçoit le message « départ ».**

## Question 2 : L'ordre d'exécution

**Etape : Tableau d'exécution**
| Étape | Lutin | Bloc | score |
|---|---|---|---|
| 1 | Guide | mettre score à 0 | $0$ |
| 2 | Guide | envoyer à tous départ et attendre | $0$ |
| 3 | Joueur | répéter 10 fois : ajouter 1 à score | $1$, $2$, …, $10$ |
| 4 | Guide | dire score | $10$ |

**Resultat : Guide dit $10$.**

## Question 3 : Le rôle de « et attendre »

**Resultat : Le script de Guide est suspendu jusqu'à ce que le script de Joueur, déclenché par « départ », soit **terminé** : le bloc « dire score » n'est exécuté qu'ensuite.**

## Question 4 : Sans attente

**Etape : Sans attente, Guide continue tout de suite après l'envoi : son bloc « dire score » s'exécute en même temps que le comptage de Joueur.**

**Resultat : Guide pourrait dire le score avant la fin du comptage : $0$ ou une valeur incomplète.**

## Question 5 : Avec un troisième lutin

**Etape : Le message « départ » déclenche les **deux** scripts identiques, et « et attendre » attend la fin des deux. Chacun ajoute $1$ dix fois au même score : $10 + 10 = 20$.**

**Resultat : Guide dit $20$.**

**À retenir : Les messages servent à **synchroniser** les lutins ; « envoyer à tous … et attendre » garantit l'ordre des opérations.**

#### Réponses

1. Guide : drapeau vert ; Joueur : réception de « départ »
2. Guide met score à $0$, Joueur ajoute $1$ dix fois, puis Guide dit $10$.
3. Attendre la fin du script de Joueur
4. Le score pourrait être dit avant la fin du comptage.
5. $20$
