Tu n'as jamais posé les yeux sur Scratch et on te parle de variables, de boucles imbriquées et de conditions ? Pas de panique. On va repartir de ce que tu sais déjà faire (tu vas voir, c'est juste des maths habillées en blocs), découvrir à quoi servent ces trois outils, et t'entraîner juste assez pour survivre au contrôle. On ne vise pas le 20/20, on vise que tu comprennes de quoi ça parle et que tu saches répondre aux questions les plus simples.
Les prérequis : ce que tu sais déjà faire en maths
Avant de parler Scratch, vérifions deux réflexes mathématiques que tu maîtrises sûrement sans le savoir :
- Suivre un ordre : quand on te dit « ajouter 1 à un nombre, puis encore 1, puis encore 1 », tu calcules pas à pas : 5 → 6 → 7 → 8. Un programme Scratch, c'est exactement ça : une suite d'ordres qu'on exécute les uns après les autres.
- Vérifier une condition : tu sais répondre à la question « Est-ce que 7 est plus grand que 10 ? » (non) ou « Est-ce que 3 est égal à 3 ? » (oui). En Scratch, on écrit ça sous forme de bloc si … alors : si la réponse est oui, on fait quelque chose ; si c'est non, on ne le fait pas (ou on fait autre chose).
Un dernier point : tu sais que $3 \times 4 = 12$. Ce calcul tout bête est la clé des boucles imbriquées. On y reviendra.
L'essentiel : les trois briques magiques de Scratch
Un programme Scratch, c'est une colonne de blocs qui s'empilent. Trois familles de blocs rendent le programme « intelligent » :
1. Les variables : des boîtes qui retiennent un nombre
Imagine une boîte étiquetée score. Au début, elle contient 0. Le bloc mettre score à 0 vide la boîte et y range 0 (c'est l'initialisation, toujours avant une boucle).
Le bloc ajouter 1 à score ouvre la boîte, prend ce qu'il y a dedans, ajoute 1, et referme (c'est l'incrémentation).
Une variable peut s'appeler x, compteur, total… et contenir un nombre qui évolue au fil du programme.
2. Les conditions : choisir entre deux chemins
Bloc si … alors : on teste une phrase mathématique (exemple : score > 10). Si c'est vrai, on exécute les blocs à l'intérieur. Si c'est faux, on les saute.
Avec sinon : si c'est faux, on exécute les blocs du sinon.
3. Les boucles imbriquées : une boucle dans une boucle
Une boucle répéter X fois fait faire un bloc plusieurs fois. Si on met une boucle à l'intérieur d'une autre, la boucle intérieure recommence à zéro à chaque tour de la boucle extérieure.
Nombre total d'exécutions du bloc le plus à l'intérieur = (tours extérieurs) $\times$ (tours intérieurs).
À toi de jouer
1. Complète la phrase avec les mots suivants : variable, initialisation, incrémentation.
Une $\underline{\hspace{1.1em}}$ est une case mémoire qui porte un nom et contient une valeur. Le bloc mettre score à 0 est une $\underline{\hspace{1.1em}}$ (on la place avant une boucle). Le bloc ajouter 1 à score est une $\underline{\hspace{1.1em}}$.
Corrigé
Une variable est une case mémoire qui porte un nom et contient une valeur. Le bloc mettre score à 0 est une initialisation (on la place avant une boucle). Le bloc ajouter 1 à score est une incrémentation.
2. On considère le petit programme Scratch suivant :
mettre x à 10
répéter 3 fois
ajouter 1 à x
On va faire tourner ce programme à la main, ensemble.
Valeur de départ : $x = 10$.
Tour 1 : $x = 10 + 1 = \underline{\hspace{1.1em}}$
Tour 2 : $x = \underline{\hspace{1.1em}} + 1 = \underline{\hspace{1.1em}}$
Tour 3 : $x = \underline{\hspace{1.1em}} + 1 = \underline{\hspace{1.1em}}$
Quelle est la valeur de $x$ à la fin du programme ? $\underline{\hspace{1.1em}}$
Corrigé
Tour 1 : $x = 10 + 1 = 11$
Tour 2 : $x = 11 + 1 = 12$
Tour 3 : $x = 12 + 1 = 13$
À la fin du programme, $x = 13$.
3. Un programme contient deux boucles imbriquées : la boucle externe répète $2$ fois, la boucle interne répète $5$ fois. À l'intérieur se trouve un bloc dire «Bonjour».
Complète : le bloc dire «Bonjour» est exécuté $\underline{\hspace{1.1em}} \times \underline{\hspace{1.1em}} = \underline{\hspace{1.1em}}$ fois au total.
Corrigé
Le bloc dire «Bonjour» est exécuté $2 \times 5 = 10$ fois au total.
Tu as déjà croisé ces histoires de variables et de blocs <em>si…alors</em>. Ici on va remettre tout ça en ordre avec une méthode pas-à-pas pour tracer un algorithme Scratch. L'objectif : que tu puisses, sans stress, suivre l'évolution des variables tour par tour et prédire ce que fait le programme.
Le cours structuré
Variable : une boîte nommée (exemple : score) qui contient un nombre. On la crée avec mettre … à …. On la modifie avec ajouter … à …. L'initialisation (mettre … à 0) doit être placée avant la boucle, sinon la valeur retombe à 0 à chaque tour.
Condition si … alors … sinon : le bloc teste une condition (exemple : x = 3). Si la condition est vraie, il exécute les blocs du alors. Si elle est fausse, il exécute ceux du sinon (s'il existe).
Boucles imbriquées : une boucle répéter … fois placée à l'intérieur d'une autre. À chaque tour de la boucle externe, la boucle interne redémarre à zéro et s'exécute en entier. Nombre total d'exécutions du bloc central = $n_{externe} \times n_{interne}$.
Méthode pas-à-pas : tracer l'exécution d'un algorithme Scratch
- Repérer toutes les variables et noter leur valeur initiale.
- Identifier les boucles (de l'extérieur vers l'intérieur) et leur nombre de tours.
- Construire un tableau : une ligne par tour de la boucle la plus extérieure, une colonne par variable.
- Mettre à jour chaque variable à chaque tour, dans l'ordre des blocs. Écrire la nouvelle valeur dans la case.
- Évaluer les conditions avec la valeur courante de la variable (celle que tu viens d'écrire sur la ligne).
- Conclure : combien de fois le lutin dit-il quelque chose ? Quelle est la valeur finale de la variable ?
Erreurs à éviter :
- mettre n à 0 dans la boucle (au lieu d'avant) : réinitialise $n$ à chaque tour.
- Confondre mettre (fixe la valeur) et ajouter (augmente).
- Compter les itérations imbriquées : $n_{ext} \times n_{int}$, et non $n_{ext} + n_{int}$.
À toi de jouer
1. On reprend le programme :
mettre x à 10
répéter 4 fois
ajouter -3 à x
si x < 2 alors
dire «Stop !»
Complète le tableau de valeurs. On le fait ensemble.
Initialisation : $x_0 = 10$
Tour 1 : $x_1 = 10 - 3 = \underline{\hspace{1.1em}}$ → condition $x < 2$ ? $\underline{\hspace{1.1em}}$ (oui/non)
Tour 2 : $x_2 = \underline{\hspace{1.1em}} - 3 = \underline{\hspace{1.1em}}$ → condition $x < 2$ ? $\underline{\hspace{1.1em}}$
Tour 3 : $x_3 = \underline{\hspace{1.1em}} - 3 = \underline{\hspace{1.1em}}$ → condition $x < 2$ ? $\underline{\hspace{1.1em}}$
Tour 4 : $x_4 = \underline{\hspace{1.1em}} - 3 = \underline{\hspace{1.1em}}$ → condition $x < 2$ ? $\underline{\hspace{1.1em}}$
Le lutin dit «Stop !» aux tours $\underline{\hspace{1.1em}}$ et $\underline{\hspace{1.1em}}$, donc $\underline{\hspace{1.1em}}$ fois.
Corrigé
Tour 1 : $x_1 = 10 - 3 = 7$ → condition $7 < 2$ ? non
Tour 2 : $x_2 = 7 - 3 = 4$ → condition $4 < 2$ ? non
Tour 3 : $x_3 = 4 - 3 = 1$ → condition $1 < 2$ ? oui
Tour 4 : $x_4 = 1 - 3 = -2$ → condition $-2 < 2$ ? oui
Le lutin dit «Stop !» aux tours 3 et 4, donc 2 fois.
2. Un programme contient une boucle externe qui répète $5$ fois, et une boucle interne qui répète $3$ fois. Dans la boucle interne, un bloc ajouter 2 à total. La variable total a été initialisée à $0$ avant les boucles.
Complète :
- Le bloc ajouter 2 à total est exécuté $\underline{\hspace{1.1em}} \times \underline{\hspace{1.1em}} = \underline{\hspace{1.1em}}$ fois.
- Valeur finale de total : $0 + \underline{\hspace{1.1em}} \times 2 = \underline{\hspace{1.1em}}$
Corrigé
Le bloc est exécuté $5 \times 3 = 15$ fois.
Valeur finale de total : $0 + 15 \times 2 = 30$.
3. On considère l'algorithme :
mettre note à 7
si note ≥ 10 alors
dire «Reçu»
sinon
dire «Recalé»
Complète :
- $7 \ge 10$ est $\underline{\hspace{1.1em}}$ (vrai/faux), donc la branche $\underline{\hspace{1.1em}}$ (alors/sinon) est activée. Le lutin dit « $\underline{\hspace{1.1em}}$ ».
- Pour que le lutin dise «Reçu», la valeur minimale de note est $\underline{\hspace{1.1em}}$.
- Si on remplace la condition par note > 10 et que note = 10, alors $10 > 10$ est $\underline{\hspace{1.1em}}$, donc le lutin dit « $\underline{\hspace{1.1em}}$ ».
Corrigé
- $7 \ge 10$ est faux, donc la branche sinon est activée. Le lutin dit «Recalé».
- Valeur minimale pour «Reçu» : 10.
- $10 > 10$ est faux, donc le lutin dit «Recalé».
C'est parti pour cinq micro-exercices quasiment identiques. La routine : un programme Scratch avec une variable, une boucle et une condition. Tu complètes le tableau tour par tour, puis tu réponds à une question sur ce qui s'affiche. Après ça, les boucles imbriquées n'auront plus aucun secret pour toi.
À toi de jouer
1. Programme 1 :
mettre n à 0
répéter 3 fois
ajouter 2 à n
si n = 4 alors
dire «Quatre»
Complète le tableau :
Départ : $n = 0$
Tour 1 : $n = 0 + 2 = \underline{\hspace{1.1em}}$ → condition $n = 4$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 2 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → condition $n = 4$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 3 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → condition $n = 4$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Combien de fois le lutin dit-il «Quatre» ? $\underline{\hspace{1.1em}}$
Corrigé
Tour 1 : $n = 0 + 2 = 2$ → $n = 4$ ? non → pas de message
Tour 2 : $n = 2 + 2 = 4$ → $n = 4$ ? oui → message «Quatre»
Tour 3 : $n = 4 + 2 = 6$ → $n = 4$ ? non → pas de message
Le lutin dit «Quatre» 1 fois.
2. Programme 2 :
mettre n à 0
répéter 4 fois
ajouter 3 à n
si n = 6 alors
dire «Six»
Complète le tableau :
Départ : $n = 0$
Tour 1 : $n = 0 + 3 = \underline{\hspace{1.1em}}$ → $n = 6$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 2 : $n = \underline{\hspace{1.1em}} + 3 = \underline{\hspace{1.1em}}$ → $n = 6$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 3 : $n = \underline{\hspace{1.1em}} + 3 = \underline{\hspace{1.1em}}$ → $n = 6$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 4 : $n = \underline{\hspace{1.1em}} + 3 = \underline{\hspace{1.1em}}$ → $n = 6$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Combien de fois le lutin dit-il «Six» ? $\underline{\hspace{1.1em}}$
Corrigé
Tour 1 : $n = 0 + 3 = 3$ → $n = 6$ ? non → pas de message
Tour 2 : $n = 3 + 3 = 6$ → $n = 6$ ? oui → message «Six»
Tour 3 : $n = 6 + 3 = 9$ → $n = 6$ ? non → pas de message
Tour 4 : $n = 9 + 3 = 12$ → $n = 6$ ? non → pas de message
Le lutin dit «Six» 1 fois.
3. Programme 3 :
mettre n à 0
répéter 5 fois
ajouter 2 à n
si n = 8 alors
dire «Huit»
Complète le tableau :
Départ : $n = 0$
Tour 1 : $n = 0 + 2 = \underline{\hspace{1.1em}}$ → $n = 8$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 2 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → $n = 8$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 3 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → $n = 8$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 4 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → $n = 8$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Tour 5 : $n = \underline{\hspace{1.1em}} + 2 = \underline{\hspace{1.1em}}$ → $n = 8$ ? $\underline{\hspace{1.1em}}$ → message ? $\underline{\hspace{1.1em}}$
Combien de fois le lutin dit-il «Huit» ? $\underline{\hspace{1.1em}}$
Corrigé
Tour 1 : $n = 0 + 2 = 2$ → non
Tour 2 : $n = 2 + 2 = 4$ → non
Tour 3 : $n = 4 + 2 = 6$ → non
Tour 4 : $n = 6 + 2 = 8$ → oui → «Huit»
Tour 5 : $n = 8 + 2 = 10$ → non
Le lutin dit «Huit» 1 fois.
4. Programme 4 : boucles imbriquées
Boucle externe : répéter 2 fois
Boucle interne : répéter 3 fois
Dans la boucle interne : ajouter 1 à compteur
mettre compteur à 0 est placé avant les deux boucles.
Complète :
Nombre total d'exécutions du bloc ajouter 1 à compteur : $\underline{\hspace{1.1em}} \times \underline{\hspace{1.1em}} = \underline{\hspace{1.1em}}$ fois.
Valeur finale de compteur : $0 + \underline{\hspace{1.1em}} \times 1 = \underline{\hspace{1.1em}}$
Corrigé
Nombre total d'exécutions : $2 \times 3 = 6$ fois.
Valeur finale de compteur : $0 + 6 \times 1 = 6$.
5. Programme 5 : boucles imbriquées
Boucle externe : répéter 4 fois
Boucle interne : répéter 5 fois
Dans la boucle interne : ajouter 2 à somme
mettre somme à 0 est placé avant les deux boucles.
Complète :
Nombre total d'exécutions de ajouter 2 à somme : $\underline{\hspace{1.1em}} \times \underline{\hspace{1.1em}} = \underline{\hspace{1.1em}}$ fois.
Valeur finale de somme : $0 + \underline{\hspace{1.1em}} \times 2 = \underline{\hspace{1.1em}}$
Corrigé
Nombre total d'exécutions : $4 \times 5 = 20$ fois.
Valeur finale de somme : $0 + 20 \times 2 = 40$.
On y est. Voici des exercices du type de ce que tu peux trouver en contrôle ou au brevet. Il va falloir tracer des algorithmes, compter des itérations, corriger des erreurs et résoudre un mini-problème. Tu es prêt, tu as la méthode. On lâche les trous, mais on garde le même esprit.
À toi de jouer
1. On considère l'algorithme Scratch suivant :
mettre x à 20
répéter 5 fois
ajouter -4 à x
si x < 5 alors
dire «Alerte»
1. Construis le tableau des valeurs de $x$ tour par tour (6 colonnes : valeur initiale puis tours 1 à 5).
2. À quel(s) tour(s) la condition $x < 5$ est-elle vraie ?
3. Combien de fois le lutin dit-il «Alerte» ?
4. Quelle est la valeur finale de $x$ ?
Corrigé
1. Tableau : $x_0 = 20$ ; Tour 1 : $20 - 4 = 16$ ; Tour 2 : $16 - 4 = 12$ ; Tour 3 : $12 - 4 = 8$ ; Tour 4 : $8 - 4 = 4$ ; Tour 5 : $4 - 4 = 0$.
2. $x < 5$ est vraie aux tours 4 ($4 < 5$) et 5 ($0 < 5$).
3. Le lutin dit «Alerte» 2 fois (tours 4 et 5).
4. Valeur finale de $x$ : $0$.
2. Un programme contient deux boucles imbriquées : la boucle externe répète $6$ fois, la boucle interne répète $4$ fois. À l'intérieur de la boucle interne se trouvent deux blocs : ajouter 3 à total et ajouter 1 à nbTours. Les variables total et nbTours sont initialisées à $0$ avant les boucles.
1. Combien de fois le bloc ajouter 3 à total est-il exécuté ?
2. Quelle est la valeur finale de nbTours ? Justifie.
3. Quelle est la valeur finale de total ? Déduis-la du nombre d'exécutions trouvé en 1.
Corrigé
1. Nombre d'exécutions = $6 \times 4 = 24$ fois.
2. nbTours est incrémenté de 1 à chaque exécution du bloc central (comme ajouter 3 à total), soit 24 fois. Valeur finale de nbTours = 24.
3. total est augmenté de $3$ à chaque fois, soit $24 \times 3 = 72$. Valeur finale de total = 72.
3. Un élève souhaite afficher la table de 5, de $5 \times 1$ jusqu'à $5 \times 4$. Il écrit le programme suivant :
répéter 4 fois
mettre n à 1
ajouter 1 à n
dire (n \times 5) pendant 1 seconde
Il constate que le lutin dit quatre fois la même valeur, «15».
1. Explique pourquoi $n$ vaut toujours $3$ au moment de l'affichage. Détaille ce qui se passe à chaque tour.
2. Propose une correction : quels blocs faut-il déplacer, et comment modifier l'initialisation pour que le programme affiche correctement 5, 10, 15 et 20 ?
3. Avec ta correction, donne la suite exacte des valeurs affichées.
Corrigé
1. Le bloc mettre n à 2 se trouve à l'intérieur de la boucle répéter 4 fois. À chaque tour, $n$ est d'abord remis à $2$, puis le bloc ajouter 1 à n le porte à $3$. L'affichage a donc toujours lieu quand $n = 3$, ce qui donne $3 \times 5 = 15$. Détail tour par tour :
Tour 1 : $n \leftarrow 2$, puis $n \leftarrow 2 + 1 = 3$, affiche $3 \times 5 = 15$.
Tour 2 : $n \leftarrow 2$, puis $n \leftarrow 2 + 1 = 3$, affiche $3 \times 5 = 15$.
Tour 3 : $n \leftarrow 2$, puis $n \leftarrow 2 + 1 = 3$, affiche $3 \times 5 = 15$.
Tour 4 : $n \leftarrow 2$, puis $n \leftarrow 2 + 1 = 3$, affiche $3 \times 5 = 15$.
Le lutin répète donc quatre fois la valeur $15$ : $n$ est réinitialisé à chaque tour et ne peut jamais progresser d'un tour à l'autre.
2. Pour corriger le programme, il faut :
— Placer mettre n à 0 avant le bloc répéter 4 fois, une seule fois et hors boucle.
— Conserver ajouter 1 à n à l'intérieur de la boucle, en première instruction, avant le bloc dire.
— Supprimer entièrement le bloc d'initialisation de l'intérieur de la boucle.
Ainsi, $n$ part de $0$ et s'incrémente de $1$ à chaque tour sans jamais être réinitialisé.
3. Avec cette correction, les valeurs affichées sont :
Tour 1 : $n = 0 + 1 = 1$, affiche $1 \times 5 = 5$.
Tour 2 : $n = 1 + 1 = 2$, affiche $2 \times 5 = 10$.
Tour 3 : $n = 2 + 1 = 3$, affiche $3 \times 5 = 15$.
Tour 4 : $n = 3 + 1 = 4$, affiche $4 \times 5 = 20$.
Le lutin affiche bien $5$, $10$, $15$, $20$.
4. Un lutin doit dessiner une grille rectangulaire de points en utilisant deux boucles imbriquées : une boucle pour les lignes, une boucle pour les colonnes. On souhaite placer un point par case. La variable nbPoints est initialisée à $0$ avant les boucles et incrémentée de $1$ à chaque point posé (dans la boucle interne).
La grille finale contient 35 points.
Voici quatre propositions pour les nombres de tours des boucles.
Proposition A : externe 5 fois, interne 7 fois.
Proposition B : externe 7 fois, interne 5 fois.
Proposition C : externe 35 fois, interne 1 fois.
Proposition D : externe 6 fois, interne 6 fois.
1. Quelles propositions donnent bien 35 points au total ?
2. Pour chaque proposition correcte, quelle est la valeur finale de nbPoints ?
3. Si on ajoute, juste après l'incrémentation, le bloc si nbPoints = 12 alors dire «Moitié», combien de fois ce message est-il affiché dans la proposition A ?
Corrigé
1. Nombre total de points = (tours externes) $\times$ (tours internes).
Proposition A : $5 \times 7 = 35$ → OK.
Proposition B : $7 \times 5 = 35$ → OK.
Proposition C : $35 \times 1 = 35$ → OK.
Proposition D : $6 \times 6 = 36$ → Non, un point de trop.
2. Pour A, B et C, nbPoints est incrémenté de 1 exactement 35 fois, donc valeur finale $35$.
3. Dans la proposition A, nbPoints passe en revue tous les entiers de $1$ à $35$ (dans l'ordre des exécutions). La condition nbPoints = 12 n'est vraie qu'une seule fois (quand le compteur atteint 12). Le message «Moitié» est affiché 1 fois.
5. On considère l'algorithme suivant :
mettre x à 50
répéter jusqu'à ce que x < 10
ajouter -7 à x
si x = 15 alors
dire «Quinze»
1. Combien de tours de boucle sont nécessaires pour que la condition d'arrêt x < 10 soit vraie ?
2. Construis le tableau des valeurs de $x$ tour par tour jusqu'à la sortie de la boucle.
3. Combien de fois le message «Quinze» est-il affiché ?
4. En sortie de boucle, quelle est la valeur de $x$ ?
Corrigé
1. La boucle répéter jusqu'à ce que x < 10 s'exécute tant que $x \ge 10$.
Tour 1 : $x = 50 - 7 = 43$ ($43 \ge 10$, on continue).
Tour 2 : $43 - 7 = 36$ ($36 \ge 10$).
Tour 3 : $36 - 7 = 29$ ($29 \ge 10$).
Tour 4 : $29 - 7 = 22$ ($22 \ge 10$).
Tour 5 : $22 - 7 = 15$ ($15 \ge 10$).
Tour 6 : $15 - 7 = 8$ ($8 < 10$ → on sort).
Il faut 6 tours.
2. Tableau : $x_0 = 50$ ; Tour 1 : 43 ; Tour 2 : 36 ; Tour 3 : 29 ; Tour 4 : 22 ; Tour 5 : 15 ; Tour 6 : 8.
3. La condition $x = 15$ est vraie une seule fois, au tour 5. Le message est affiché 1 fois.
4. En sortie, $x = 8$.
Tu maîtrises les variables, les conditions et les boucles imbriquées dans Scratch. L'an prochain, au lycée, tu retrouveras ces mêmes concepts dans d'autres langages (Python, notamment). Ici, on va faire un pas de côté : réfléchir sur ce que fait vraiment un algorithme, détecter des logiques cachées et même écrire un petit algorithme à partir d'une consigne. Pas de trous, pas de pitié, mais tu es paré.
À toi de jouer
1. Un programme Scratch inconnu contient une variable resultat et une boucle. On sait que :
- resultat est initialisé à $1$ avant la boucle.
- La boucle répéter 4 fois contient uniquement :
ajouter resultat à resultat
On te donne quatre propositions pour la valeur finale de resultat :
A. 4 B. 8 C. 16 D. 5
1. Sans ordinateur, trace l'évolution de resultat tour par tour.
2. Explique pourquoi la valeur double à chaque tour.
3. Déduis-en la valeur finale et dis quelle proposition est correcte.
4. Si on change la boucle en répéter 6 fois, quelle serait la valeur finale ?
Corrigé
1. Départ : $resultat = 1$.
Tour 1 : $1 + 1 = 2$ (ajouter resultat à lui-même double sa valeur).
Tour 2 : $2 + 2 = 4$.
Tour 3 : $4 + 4 = 8$.
Tour 4 : $8 + 8 = 16$.
2. « ajouter resultat à resultat » revient à faire $r \leftarrow r + r = 2r$. C'est un doublement à chaque tour.
3. Valeur finale après 4 tours : $1 \times 2^4 = 16$. Proposition C.
4. Après 6 tours : $1 \times 2^6 = 64$.
2. Un algorithme contient deux variables, a et b, et une condition. Voici son script :
mettre a à 45
mettre b à 30
répéter jusqu'à ce que a = b
si a > b alors
mettre a à a - b
sinon
mettre b à b - a
1. Écris les valeurs successives de a et b jusqu'à ce que la boucle s'arrête (tu peux faire un tableau à deux colonnes).
2. Combien de tours de boucle sont exécutés ?
3. Quelle remarque peux-tu faire sur la valeur finale de a (et b) par rapport aux nombres de départ $45$ et $30$ ? (Indice : cela s'appelle l'algorithme d'Euclide, tu le reverras en seconde.)
Corrigé
1. Tableau :
Départ : $a = 45$, $b = 30$
Tour 1 : $45 > 30$, donc $a \leftarrow 45 - 30 = 15$. État : $a = 15$, $b = 30$.
Tour 2 : $15 < 30$, donc $b \leftarrow 30 - 15 = 15$. État : $a = 15$, $b = 15$.
$a = b$ → arrêt.
2. Deux tours de boucle.
3. La valeur finale commune, $15$, est le PGCD (Plus Grand Commun Diviseur) de $45$ et $30$. Cet algorithme permet de calculer le PGCD de deux nombres sans connaître leurs diviseurs.
3. Écris, en langage Scratch (décris les blocs en français), un programme qui :
- initialise une variable somme à $0$.
- utilise deux boucles imbriquées (externe $3$ tours, interne $4$ tours).
- dans la boucle interne, multiplie somme par $2$ (indice : ce n'est pas ajouter, mais mettre somme à somme * 2).
- après les deux boucles, affiche la valeur de somme.
Quelle est la valeur affichée ? (Tu peux t'aider d'un petit calcul de puissances.)
Corrigé
Programme :
mettre somme à 0
répéter 3 fois
répéter 4 fois
mettre somme à somme * 2
dire somme
Nombre total d'exécutions de mettre somme à somme * 2 : $3 \times 4 = 12$ fois.
Mais attention : la valeur de départ est $0$. $0 \times 2 = 0$... et ça reste $0$ quel que soit le nombre de multiplications ! La valeur affichée est donc $0$.
Si on voulait un vrai calcul de puissance, il aurait fallu initialiser somme à $1$ : $1 \times 2^{12} = 4096$.