# Algorithmique et programmation : maths 4e

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

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

## Cours

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

**Prerequis : - Calculer avec des nombres relatifs ; développer une expression comme $5(n - 2)$.**
- Résoudre une équation simple comme $3x - 5 = 10$.
- 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 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 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_n290_co289_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 : il s'emboîte sous la précédente.
- Le bloc en forme de **C** contient d'autres blocs : c'est une boucle ou un test.
- Le bloc **arrondi** est une valeur (nombre, variable, calcul) ; le bloc **hexagonal** est une condition, vraie ou fausse.

## II. Variables et programmes de calcul

**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$. Avec « ajouter −3 à x », x diminue de $3$.

**Définition : Entrée et sortie**
- **Entrée** : « demander … et attendre » pose une question ; le nombre tapé est rangé 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 − 2, mettre r à r * 5, dire r.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_2_cours_calcul.png)

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

| Bloc exécuté | n | r |
|---|---|---|
| mettre n à réponse | $7$ | — |
| mettre r à n − 2 | $7$ | $5$ |
| mettre r à r × 5 | $7$ | $25$ |

Le lutin dit $25$. Pour un nombre $n$ quelconque, il dit $(n - 2) \times 5 = 5n - 10$.

**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.

**Méthode : Traduire un programme de calcul par une expression**
On exécute le script avec une lettre ($x$, $n$…) au lieu d'un nombre, puis on réduit l'expression obtenue. Elle permet de prévoir le résultat pour **tous** les nombres, ou de trouver le nombre de départ en résolvant une équation.

**Attention : Lire une affectation**
« mettre r à r × 5 » signifie : nouvelle valeur de r $=$ ancienne valeur de r $\times\, 5$. 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 », « x > 17 »…

- « 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 la note sur 20 ; si note < 10 alors dire « À retravailler » sinon dire « Validé ! ».](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_3_cours_si.png)

**Exemple : - Réponse $9$ : la condition $9 < 10$ est vraie, le lutin dit « À retravailler ».**
- Réponse $10$ : la condition $10 < 10$ est fausse, le lutin dit « Validé ! ».

**Propriété : Conditions composées**
- « A et B » est vraie quand les deux conditions sont vraies ;
- « A ou B » est vraie quand au moins l'une des deux est vraie ;
- « non A » est vraie quand A est fausse.

**Attention : Tester la valeur frontière**
$10 < 10$ est faux. Scratch n'a pas de bloc « inférieur ou égal » : pour « note $\leqslant 10$ », on écrit « (note < 10) ou (note = 10) », ou bien « non (note > 10) ».

## 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 3 à x, puis dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_4_cours_repeter.png)

| Tour | x à la fin du tour |
|---|---|
| 1 | $0 + 3 = 3$ |
| 2 | $3 + 3 = 6$ |
| 3 | $9$ |
| 4 | $12$ |
| 5 | $15$ |

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

**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 à 100, répéter jusqu'à x < 0 : ajouter −30 à x, puis dire x.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_5_cours_jusqua.png)

| Tour | x avant le tour | x < 0 ? | x à la fin du tour |
|---|---|---|---|
| 1 | $100$ | faux | $70$ |
| 2 | $70$ | faux | $40$ |
| 3 | $40$ | faux | $10$ |
| 4 | $10$ | faux | $-20$ |

Avant un 5e tour, $-20 < 0$ est vrai : la boucle s'arrête après $4$ tours et le lutin dit $-20$.

**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 < 0 » ne s'arrête pas « à 0 » : elle s'arrête à la **première** valeur qui rend la condition vraie (ici $-20$).
- Si la variable testée 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_n290_co289_6_cours_scene.png)

**Propriété : Blocs de mouvement et de stylo**
- « aller à x : … y : … » place le lutin en un point.
- « s'orienter à 90 » donne au lutin l'orientation $90$, quelle que soit son orientation avant : l'orientation est **imposée**.
- « tourner ↻ de 90 degrés » : quart de tour dans le sens des aiguilles d'une montre ; « tourner ↺ » : dans le sens **inverse**. La rotation **s'ajoute** à l'orientation actuelle.
- « avancer de 50 pas » déplace le lutin de $50$ dans la direction où il regarde.
- « 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é 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 vers la gauche.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_7_cours_carre.png)

Le lutin part de $(0\ ;\ 0)$ vers la droite. Il passe par $(60\ ;\ 0)$, $(60\ ;\ 60)$, $(0\ ;\ 60)$ 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 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_n290_co289_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** et fait un tour complet en tout. 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 ». Son **paramètre** (ovale rose) reçoit une valeur à chaque **appel** : « triangle (60) » exécute la définition avec côté $= 60$.

![Bloc personnalisé « définir triangle (côté) » qui répète 3 fois avancer de côté et tourner de 120 degrés, et script principal qui appelle triangle 30, triangle 60 et triangle 90.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_9_cours_bloc.png)

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

![Tracé obtenu : trois triangles équilatéraux de côtés 30, 60 et 90 qui ont le sommet (0 ; 0) en commun, bases sur l'axe des abscisses.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_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 et messages

**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**.

![Deux scripts : 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_n290_co289_11_cours_touches.png)

**Exemple : À chaque appui sur la flèche droite, le lutin se déplace de $10$ vers la droite ; à chaque appui sur la flèche gauche, de $10$ vers la gauche. Partant de $x = 0$, après « droite, droite, droite, gauche », il est en $x = 20$.**

**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 total à 0, envoie « compter » et attend, puis dit total ; le Chien, quand il reçoit « compter », ajoute 4 à total trois fois.](https://optitab-media.s3.eu-north-1.amazonaws.com/cours_images/v1_n290_co289_12_cours_messages.png)

**Exemple : Le Chat met total à $0$, puis envoie « compter » et attend : le Chien ajoute $4$ trois fois. Le Chat dit ensuite $12$. Sans « et attendre », il pourrait dire le total avant la fin du comptage.**

**À 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.
- Un programme de calcul se traduit par une expression littérale.
- « 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 ; les messages coordonnent 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_n290_fi224_1_cours_familles.png)

- « mettre x à … » **remplace** la valeur de x ; « ajouter … à x » la **modifie** (« ajouter −5 » la diminue).
- **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.
- **Programme de calcul** : l'exécuter avec une lettre $x$ donne une expression ; on la réduit pour démontrer, on résout une équation pour retrouver le nombre de départ.

## II. Instructions conditionnelles

- « si condition alors … sinon … » : **une seule** branche est exécutée.
- Conditions : « < », « = », « > » ; « et », « ou », « non ».
- Toujours tester la **valeur frontière** : $10 < 10$ est faux. « $x \geqslant 18$ » s'écrit « non (x < 18) ».
- Plusieurs cas : des tests placés les uns dans les autres.

## 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.
- Boucles imbriquées : on **multiplie** les nombres de tours.
- 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_n290_fi224_2_cours_scene.png)

- « s'orienter à » **impose** l'orientation ; « tourner ↻ » (sens des aiguilles d'une montre) ou « tourner ↺ » (sens inverse) **ajoute** un angle.
- 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, événements, messages

- Bloc personnalisé : « définir nom (paramètre) » ; chaque appel donne une valeur au paramètre.
- Événements : drapeau, touche pressée, message reçu ; un script ne démarre qu'à **son** événement.
- « envoyer à tous … » déclenche les scripts « quand je reçois … » ; avec « et attendre », l'envoyeur attend qu'ils soient terminés.

**Attention : Les erreurs classiques**
1. Confondre « mettre » (remplacer) et « ajouter » (modifier).
2. Croire que « répéter jusqu'à x > 100 » s'arrête à $100$ : elle s'arrête à la première valeur qui dépasse $100$.
3. Tourner de l'angle **intérieur** d'un polygone au lieu de l'angle extérieur.
4. Oublier « stylo en position d'écriture » : rien n'est tracé.
5. Conclure qu'un programme est toujours juste après un ou deux essais : seul le calcul littéral le démontre.

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

## Exercices corrigés

### Exercice 1 : Lire un script de tracé

On rappelle que l'orientation $90$ est vers la droite et que « tourner ↻ » fait tourner le lutin dans le sens des aiguilles d'une montre.

![Script Scratch : effacer tout, aller à (0 ; 0), s'orienter à 90, stylo en position d'écriture, répéter 4 fois avancer de 100 pas et tourner de 90 degrés dans le sens des aiguilles d'une montre.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3713_1_ex3713_script.png)

1. Que font les cinq premiers blocs, avant la boucle ?
2. Combien de fois les blocs « avancer de 100 pas » et « tourner ↻ de 90 degrés » sont-ils exécutés ?
3. Donner la position et l'orientation du lutin à la fin de chaque tour de boucle. Quelle figure est tracée ?
4. Quelle longueur le stylo a-t-il tracée ?
5. On remplace « tourner ↻ de 90 degrés » par « tourner ↺ de 90 degrés ». Quelle figure obtient-on ? Donner ses sommets.

#### Correction détaillée

## Question 1 : Avant la boucle

**Méthode : Un script s'exécute de haut en bas : on lit les blocs un par un.**

**Etape : Les cinq premiers blocs**
- « quand le drapeau est cliqué » : le script démarre ;
- « effacer tout » : les anciens dessins sont effacés ;
- « aller à x : 0 y : 0 » : le lutin est placé au centre de la scène ;
- « s'orienter à 90 » : il regarde vers la droite ;
- « stylo en position d'écriture » : ses déplacements seront tracés.

**Resultat : Le lutin est prêt à dessiner : en $(0\ ;\ 0)$, tourné vers la droite, stylo baissé.**

## Question 2 : Le nombre d'exécutions

**Etape : Les deux blocs sont **à l'intérieur** de « répéter 4 fois » : ils sont exécutés à chaque tour.**

**Resultat : Chacun des deux blocs est exécuté $4$ fois.**

## Question 3 : La figure tracée

**Méthode : À chaque tour : « avancer » change la position (dans la direction où le lutin regarde), puis « tourner ↻ de 90 » ajoute $90$ à l'orientation.**

**Etape : Tableau d'exécution, tour par tour**
| Tour | Position après « avancer » | Orientation après « tourner » |
|---|---|---|
| 1 | $(100\ ;\ 0)$ | $180$ (bas) |
| 2 | $(100\ ;\ -100)$ | $-90$ (gauche) |
| 3 | $(0\ ;\ -100)$ | $0$ (haut) |
| 4 | $(0\ ;\ 0)$ | $90$ (droite) |

![Tracé en vert : carré de côté 100 sous l'axe des abscisses, de sommets (0 ; 0), (100 ; 0), (100 ; −100), (0 ; −100).](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3713_2_ex3713_trace.png)

**Resultat : Un carré de côté $100$, de sommets $(0\ ;\ 0)$, $(100\ ;\ 0)$, $(100\ ;\ -100)$ et $(0\ ;\ -100)$, situé **sous** l'axe des abscisses. Le lutin revient à son point de départ, orienté vers la droite.**

## Question 4 : La longueur tracée

**Etape : Calcul**
Le stylo trace $4$ segments de $100$ pas : $4 \times 100 = 400$.

**Resultat : Le stylo a tracé $400$ pas : c'est le périmètre du carré.**

## Question 5 : En tournant dans l'autre sens

**Etape : Après le premier côté, le lutin tourne d'un quart de tour dans le sens **inverse** des aiguilles d'une montre : il regarde vers le **haut** au lieu du bas. Il passe ensuite par $(100\ ;\ 100)$ et $(0\ ;\ 100)$.**

![Avec tourner ↺ : carré de côté 100 en vert au-dessus de l'axe, sommets (0 ; 0), (100 ; 0), (100 ; 100), (0 ; 100) ; l'ancien carré en pointillés gris.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3713_3_ex3713_gauche.png)

**Resultat : On obtient encore un carré de côté $100$, mais **au-dessus** de l'axe des abscisses (en vert ; l'ancien carré est en pointillés), de sommets $(0\ ;\ 0)$, $(100\ ;\ 0)$, $(100\ ;\ 100)$ et $(0\ ;\ 100)$.**

**Attention : Erreur fréquente**
Penser que « tourner ↻ » et « tourner ↺ » donnent le même dessin : le sens de rotation décide de quel côté la figure est tracée.

#### Réponses

1. Efface la scène, place le lutin en $(0\ ;\ 0)$, l'oriente vers la droite, baisse le stylo
2. $4$ fois chacun
3. $(100\ ;\ 0)$, $(100\ ;\ -100)$, $(0\ ;\ -100)$, $(0\ ;\ 0)$ : un carré de côté $100$
4. $400$ pas
5. Un carré de côté $100$ au-dessus de l'axe : $(0\ ;\ 0)$, $(100\ ;\ 0)$, $(100\ ;\ 100)$, $(0\ ;\ 100)$

### Exercice 2 : Un bloc personnalisé « polygone »

On a créé un bloc personnalisé « polygone » qui a deux paramètres : le nombre n de côtés et la longueur côté d'un côté. Le symbole « / » est celui de la division.

![Bloc personnalisé « définir polygone (n) (côté) » : répéter n fois avancer de côté et tourner de 360 / n degrés ; script principal qui appelle polygone 5 80.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3720_1_ex3720_scripts.png)

1. Que dessine le script principal ? De quel angle le lutin tourne-t-il à chaque sommet ?
2. De quel angle tourne-t-il avec « polygone 6 70 » ? Et avec « polygone 8 55 » ?
3. Calculer la longueur tracée par « polygone 5 80 ».
4. De combien de degrés le lutin a-t-il tourné en tout, quel que soit n ? Dans quelle orientation finit-il ?
5. Que dessine « polygone 36 10 » ? Quelle longueur est tracée ?
6. Quelle est la mesure d'un angle intérieur du pentagone régulier ?

#### Correction détaillée

## Question 1 : Le script principal

**Méthode : À l'appel « polygone 5 80 », le paramètre n prend la valeur $5$ et le paramètre côté la valeur $80$ : on exécute la définition avec ces valeurs.**

**Etape : Le lutin répète $5$ fois « avancer de $80$ ; tourner ↺ de $\dfrac{360}{5}$ degrés », avec $\dfrac{360}{5} = 72$.**

![Tracé en vert : pentagone régulier de côté 80 partant de (0 ; 0) vers la droite.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3720_2_ex3720_trace.png)

**Resultat : Un pentagone régulier de côté $80$ (en vert) ; le lutin tourne de $72^\circ$ à chaque sommet.**

## Question 2 : Hexagone et octogone

**Etape : Calculs**
$\dfrac{360}{6} = 60$ et $\dfrac{360}{8} = 45$.

**Resultat : $60^\circ$ pour l'hexagone, $45^\circ$ pour l'octogone.**

## Question 3 : La longueur tracée

**Etape : $5$ côtés de $80$ : $5 \times 80 = 400$.**

**Resultat : $400$ pas (le périmètre du pentagone).**

## Question 4 : L'angle total

**Etape : $n$ rotations de $\dfrac{360}{n}$ degrés : $n \times \dfrac{360}{n} = 360$.**

**Resultat : $360^\circ$ : un tour complet. Le lutin revient à son point de départ dans son orientation de départ, $90$.**

## Question 5 : Trente-six côtés

**Etape : $36$ côtés de $10$ pas ; à chaque sommet, le lutin tourne de $\dfrac{360}{36} = 10^\circ$ seulement.**

![Tracé en vert : polygone régulier à 36 côtés de 10, qui ressemble à un cercle passant par (0 ; 0).](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3720_3_ex3720_36.png)

**Resultat : Un polygone régulier à $36$ côtés, qui ressemble à un cercle ; longueur tracée $36 \times 10 = 360$ pas.**

## Question 6 : L'angle intérieur

**Etape : Le lutin tourne de l'angle **extérieur** ($72^\circ$) ; l'angle intérieur et l'angle extérieur forment un angle plat.**
$$180^\circ - 72^\circ = 108^\circ$$

**Resultat : Un angle intérieur du pentagone régulier mesure $108^\circ$.**

**Attention : Erreur fréquente**
Confondre l'angle dont tourne le lutin ($72^\circ$) avec l'angle du polygone ($108^\circ$).

**À retenir : Un bloc personnalisé évite de réécrire les mêmes blocs : on l'appelle avec des valeurs différentes de ses paramètres.**

#### Réponses

1. Un pentagone régulier de côté $80$ ; $72^\circ$
2. $60^\circ$ ; $45^\circ$
3. $400$ pas
4. $360^\circ$ ; orientation $90$
5. Presque un cercle ; $360$ pas
6. $108^\circ$

### Exercice 3 : Le nombre mystère

Ce jeu choisit au hasard un nombre mystère entier entre $1$ et $100$ ; le joueur propose des nombres jusqu'à le trouver.

![Script du nombre mystère : mettre mystère à un nombre aléatoire entre 1 et 100, mettre essais à 0, répéter jusqu'à réponse = mystère (demander, ajouter 1 à essais, dire Trop petit ! ou Trop grand !), puis dire Gagné !.](https://optitab-media.s3.eu-north-1.amazonaws.com/exercice_images/v1_n290_ex3727_1_ex3727_script.png)

1. À quoi sert la variable essais ?
2. Le nombre mystère est $37$. Le joueur propose $50$, puis $25$, puis $37$. Quels messages s'affichent ? Combien vaut essais à la fin ?
3. Stratégie « par moitié » : on propose toujours le milieu des nombres encore possibles (arrondi à l'unité inférieure). Le nombre mystère est $81$. Quelles propositions fait-on ? Combien d'essais faut-il ?
4. Avec cette stratégie, combien d'essais faut-il au maximum pour un nombre entre $1$ et $100$ ? Justifier.
5. Expliquer ce résultat avec les puissances de $2$.
6. Combien d'essais faudrait-il au maximum pour un nombre entre $1$ et $1\,000$ ?

#### Correction détaillée

## Question 1 : La variable essais

**Etape : essais est mise à $0$ au début, puis on lui ajoute $1$ à chaque passage dans la boucle, c'est-à-dire à chaque proposition.**

**Resultat : essais compte le nombre de propositions du joueur.**

## Question 2 : La partie avec 37

**Etape : Tableau d'exécution**
| Proposition | essais | Message |
|---|---|---|
| $50$ | $1$ | Trop grand ! |
| $25$ | $2$ | Trop petit ! |
| $37$ | $3$ | aucun |

**Etape : Les tests**
- $50 > 37$ : seul le second test est vrai, « Trop grand ! » ;
- $25 < 37$ : seul le premier test est vrai, « Trop petit ! » ;
- $37$ : ni $37 < 37$ ni $37 > 37$ ne sont vrais, aucun message.

**Etape : Fin de la boucle**
Avant un nouveau tour, la condition « réponse = mystère » est vraie : la boucle s'arrête et le lutin dit « Gagné ! ».

**Resultat : « Trop grand ! », « Trop petit ! », puis « Gagné ! » ; essais vaut $3$.**

## Question 3 : La stratégie avec 81

**Méthode : À chaque réponse, on élimine la moitié des nombres et l'on propose le milieu de ceux qui restent.**

**Etape : Les propositions**
- nombres possibles $1$ à $100$ : on propose $50$, « Trop petit ! » ;
- possibles $51$ à $100$ : on propose $75$, « Trop petit ! » ;
- possibles $76$ à $100$ : on propose $88$, « Trop grand ! » ;
- possibles $76$ à $87$ : on propose $81$, « Gagné ! ».

**Resultat : $50$, $75$, $88$ puis $81$ : $4$ essais.**

## Question 4 : Le maximum d'essais

**Etape : Après chaque proposition fausse, il reste au plus la moitié des nombres possibles :**
$$100 \to 50 \to 25 \to 12 \to 6 \to 3 \to 1$$
Après $6$ propositions fausses, il ne reste plus qu'un nombre possible : la $7$e proposition est la bonne.

**Resultat : Au maximum $7$ essais (le script, joué pour les $100$ nombres mystères possibles, le confirme).**

**Attention : Erreur fréquente**
Penser qu'il faut jusqu'à $100$ essais : c'est vrai si l'on essaie les nombres un par un, pas avec la stratégie par moitié.

## Question 5 : Les puissances de 2

**Etape : Avec $k$ essais, on peut départager jusqu'à $2^k$ nombres. Or $2^6 = 64 < 100$ et $2^7 = 128 \geqslant 100$.**

**Resultat : Il faut le plus petit $k$ tel que $2^k \geqslant 100$ : $k = 7$.**

## Question 6 : Entre 1 et 1 000

**Etape : $2^9 = 512 < 1\,000$ et $2^{10} = 1\,024 \geqslant 1\,000$.**

**Resultat : Au maximum $10$ essais.**

**À retenir : Cette méthode s'appelle la **dichotomie** : elle permet de chercher très vite dans une grande liste rangée dans l'ordre.**

#### Réponses

1. Compter les propositions
2. Trop grand !, Trop petit !, Gagné ! ; essais $= 3$
3. $50$ ; $75$ ; $88$ ; $81$ : $4$ essais
4. $7$ essais
5. $2^6 = 64 < 100 \leqslant 2^7 = 128$
6. $10$ essais
