Programmation Scratch : algorithmes et boucles

1. Introduction et problématique

Situation-problème : au Brevet, on peut te présenter un programme Scratch et te demander de prévoir le résultat affiché, de compléter un bloc manquant ou d’expliquer le rôle d’une variable. Par exemple, un lutin exécute le programme suivant : mettre score à 0, puis répéter 4 fois « ajouter 3 à score ». Quelle valeur de score obtient-on à la fin ? Pour répondre, il ne suffit pas de reconnaître les blocs : il faut lire l’algorithme dans l’ordre, comprendre la boucle, suivre l’évolution de la variable et vérifier le résultat final. Ici, score vaut d’abord 0, puis on ajoute 3 quatre fois : 0 + 3 + 3 + 3 + 3 = 12.

En classe de 3e, la programmation Scratch permet de travailler des compétences importantes du programme de mathématiques : chercher, raisonner, calculer, représenter et communiquer. Un programme Scratch est une écriture visuelle d’un algorithme. Les blocs colorés remplacent les lignes de code, mais le raisonnement reste mathématique : on identifie les données, les instructions, les répétitions, les conditions et les variables. Les mots repères sont essentiels : algorithme, boucle, condition, variable. Le mot algorithme se découpe en syllabes : al-go-rith-me. Un algorithme est une suite d’instructions. Par exemple : « mettre score à 0, répéter 4 fois ajouter 3 à score » donne 12 à la fin.

La problématique de cette leçon est donc : comment lire, exécuter et créer un algorithme Scratch utilisant des variables, des boucles et des conditions ? Pour y répondre, on va apprendre à repérer les blocs, à appliquer les instructions pas à pas et à vérifier la cohérence du résultat.

2. Définition

Définition : Un algorithme est une suite finie d’instructions précises, écrites dans un ordre déterminé, permettant de résoudre un problème ou d’obtenir un résultat. Dans Scratch, un algorithme est représenté par des blocs assemblés : blocs de départ, blocs de mouvement, blocs de variable, blocs de boucle et blocs de condition.

Une variable est une information qui peut changer pendant l’exécution du programme. Elle possède un nom et une valeur. Par exemple, la variable score peut valoir 0 au début, puis 3, puis 6, puis 9. Le bloc « mettre score à 0 » initialise la variable : il remplace l’ancienne valeur par 0. Le bloc « ajouter 3 à score » modifie la valeur actuelle : si score vaut 6, il devient 9.

Une boucle est une instruction qui répète plusieurs fois un ou plusieurs blocs. Dans Scratch, on rencontre souvent « répéter n fois » ou « répéter jusqu’à ». Une boucle « répéter 5 fois » permet d’exécuter exactement 5 fois les instructions placées à l’intérieur.

Une condition est un test qui peut être vrai ou faux. Le bloc « si condition alors » exécute une instruction seulement si la condition est vraie. Le bloc « si condition alors sinon » choisit entre deux branches : si la condition est vraie, on exécute la première branche ; si elle est fausse, on exécute l’autre branche. Les deux branches ne sont pas exécutées en même temps.

3. Propriétés et théorèmes

Théorème : Pour connaître le résultat d’un algorithme Scratch, on exécute les instructions dans l’ordre, en tenant compte des répétitions imposées par les boucles et du caractère vrai ou faux des conditions. Une variable prend toujours la dernière valeur obtenue après l’instruction exécutée.

Même si l’on parle ici de programmation, les règles de lecture sont aussi rigoureuses que dans un calcul mathématique. On ne lit pas les blocs au hasard. On commence par le bloc déclencheur, par exemple « quand drapeau vert cliqué », puis on descend bloc par bloc. Si un bloc contient une boucle, les instructions à l’intérieur sont répétées le nombre de fois indiqué. Si un bloc contient une condition, le programme choisit la branche adaptée.

On peut retenir plusieurs propriétés pratiques :

• Ordre des instructions : changer l’ordre des blocs peut changer le résultat final.
• Initialisation : le bloc « mettre variable à ... » fixe une valeur de départ ou remplace la valeur précédente.
• Modification : le bloc « ajouter ... à variable » modifie la valeur actuelle de la variable.
• Boucle bornée : « répéter n fois » signifie que les blocs internes sont exécutés exactement n fois.
• Condition exclusive : dans « si alors sinon », une seule des deux branches est exécutée.
• Trace de calcul : pour éviter les erreurs, on peut construire un tableau avec le numéro du tour, la valeur de la variable avant l’instruction et la valeur après l’instruction.

Ces propriétés sont particulièrement utiles pour les exercices de Brevet algorithmique : on peut demander d’identifier le rôle d’un bloc, de prévoir une variable, de remettre un algorithme dans l’ordre, d’écrire un programme Scratch ou de justifier une condition.

4. Démonstration

On veut justifier pourquoi le programme « mettre score à 0 ; répéter 4 fois ajouter 3 à score » donne 12. La justification se fait en suivant exactement les instructions du programme.

Au départ, le bloc « mettre score à 0 » initialise la variable. Cela signifie que score vaut 0, même s’il avait une autre valeur avant. Ensuite, la boucle « répéter 4 fois » indique que l’instruction « ajouter 3 à score » sera exécutée quatre fois. On peut écrire les étapes :

• Avant la boucle : score = 0.
• Tour 1 : on ajoute 3, donc score = 0 + 3 = 3.
• Tour 2 : on ajoute encore 3, donc score = 3 + 3 = 6.
• Tour 3 : on ajoute encore 3, donc score = 6 + 3 = 9.
• Tour 4 : on ajoute encore 3, donc score = 9 + 3 = 12.

Après la quatrième répétition, la boucle est terminée. Le programme ne revient pas une cinquième fois dans la boucle. La valeur finale de la variable est donc 12. On peut aussi écrire le calcul directement : score final = 0 + 4 × 3 = 12. Le facteur 4 vient du nombre de répétitions et le facteur 3 vient de la quantité ajoutée à chaque répétition.

Cette démonstration montre une idée importante : une boucle peut souvent être traduite par une multiplication. Répéter 4 fois « ajouter 3 » revient à ajouter 4 × 3. Mais il faut rester prudent : si les instructions à l’intérieur de la boucle sont plus complexes, ou si elles dépendent d’une condition, un tableau de suivi est plus sûr.

5. Méthode pas à pas

1. Je repère 🔎 : j’identifie les blocs importants : variable, boucle, condition, opération, affichage. Je repère aussi le bloc de départ, par exemple « quand drapeau vert cliqué ».
2. Je lis les instructions dans l’ordre : je commence en haut du programme et je descends bloc par bloc. Je ne saute pas une instruction parce qu’elle paraît évidente.
3. J’initialise les variables : si je vois « mettre score à 0 », j’écris immédiatement score = 0. Si plusieurs variables existent, je note chacune d’elles.
4. J’applique ▶️ : j’exécute les instructions dans l’ordre, en notant les valeurs qui changent à chaque étape. Pour une boucle « répéter n fois », je fais n tours.
5. Je construis un tableau si nécessaire : pour une variable qui change souvent, je peux écrire les colonnes « tour », « valeur avant », « calcul », « valeur après ».
6. Je traite les conditions : pour un bloc « si condition alors sinon », je teste si la condition est vraie ou fausse. J’entoure uniquement la branche exécutée.
7. Je vérifie ✅ : je contrôle le résultat final et je vérifie que la condition a été testée au bon moment. Je regarde si le nombre de répétitions est correct.
8. Je communique : dans une réponse de Brevet, je ne donne pas seulement le résultat. J’explique brièvement : valeur initiale, nombre de répétitions, calcul final ou branche choisie.

Cette routine « Je repère / J’applique / Je vérifie » permet d’éviter les erreurs fréquentes. Elle est utile aussi bien pour lire un programme existant que pour créer son propre algorithme.

6. Exemple résolu 1 — cas direct

On considère le programme Scratch suivant : quand le drapeau vert est cliqué, mettre x à 2, puis répéter 5 fois « ajouter 4 à x », puis dire x.

On cherche la valeur affichée à la fin. On commence par l’initialisation : le bloc « mettre x à 2 » donne x = 2. Ensuite, la boucle se répète 5 fois. À chaque tour, on ajoute 4 à la valeur actuelle de x.

• Avant la boucle : x = 2.
• Tour 1 : x = 2 + 4 = 6.
• Tour 2 : x = 6 + 4 = 10.
• Tour 3 : x = 10 + 4 = 14.
• Tour 4 : x = 14 + 4 = 18.
• Tour 5 : x = 18 + 4 = 22.

La valeur affichée est donc 22. On peut vérifier avec un calcul direct : 2 + 5 × 4 = 2 + 20 = 22. Le résultat est cohérent : comme on ajoute un nombre positif, la variable augmente à chaque tour.

Ce cas est direct car le nombre de répétitions est connu et l’instruction répétée est toujours la même. Il faut cependant bien distinguer « mettre x à 2 » et « ajouter 4 à x ». Le premier bloc fixe la valeur de départ ; le second modifie cette valeur pendant la boucle.

7. Exemple résolu 2 — cas inverse

On veut créer un programme Scratch qui part de 7 et obtient 31 en répétant plusieurs fois l’instruction « ajouter 6 à nombre ». On cherche combien de répétitions sont nécessaires.

On traduit la situation par un calcul. La valeur initiale est 7. La valeur finale souhaitée est 31. L’augmentation totale est donc 31 − 7 = 24. À chaque répétition, on ajoute 6. Il faut donc chercher combien de fois 6 est contenu dans 24 : 24 ÷ 6 = 4.

Le programme peut être écrit ainsi :

• quand drapeau vert cliqué ;
• mettre nombre à 7 ;
• répéter 4 fois ;
• ajouter 6 à nombre ;
• dire nombre.

Vérification pas à pas : au départ, nombre = 7. Après le premier tour, nombre = 13. Après le deuxième tour, nombre = 19. Après le troisième tour, nombre = 25. Après le quatrième tour, nombre = 31. La valeur finale est bien celle demandée.

Ce cas est inverse parce que le résultat final est donné, mais pas le nombre de répétitions. On doit donc raisonner à rebours : on calcule l’écart entre la valeur finale et la valeur initiale, puis on divise par l’ajout effectué à chaque répétition. Si la division ne tombe pas juste, cela signifie qu’on ne peut pas atteindre exactement la valeur finale avec cette instruction répétée un nombre entier de fois.

8. Exemple résolu 3 — problème concret

Une association organise une collecte. Au départ, la caisse contient 15 €. Chaque participant ajoute 4 €. Le programme Scratch doit calculer la somme obtenue après 12 participants. Si la somme finale est supérieure ou égale à 60 €, le lutin doit dire « objectif atteint », sinon il doit dire « objectif non atteint ».

On définit une variable caisse. Le programme peut être :

• quand drapeau vert cliqué ;
• mettre caisse à 15 ;
• répéter 12 fois ;
• ajouter 4 à caisse ;
• si caisse ≥ 60 alors dire « objectif atteint » ;
• sinon dire « objectif non atteint ».

On calcule la valeur finale. La caisse commence à 15 €. On ajoute 4 € pour chacun des 12 participants, donc l’augmentation totale est 12 × 4 = 48 €. La somme finale est 15 + 48 = 63 €. On teste ensuite la condition : 63 ≥ 60 est vrai. Le programme exécute donc la première branche et affiche « objectif atteint ».

Ce problème concret montre l’intérêt de combiner variable, boucle et condition. La variable garde en mémoire la somme. La boucle répète l’ajout pour chaque participant. La condition compare la somme finale à l’objectif. Attention : la condition est testée après la boucle dans ce programme. Si on plaçait le test à l’intérieur de la boucle, le programme vérifierait l’objectif après chaque participant, ce qui ne produirait pas exactement le même comportement.

9. Erreurs classiques à éviter

• Erreur : ajouter une seule fois dans une boucle « répéter n fois » — À faire : écrire une ligne de calcul par répétition ou utiliser un tableau de suivi.
• Erreur : confondre « mettre score à 0 » et « ajouter 5 à score » — À faire : retenir que « mettre à » remplace la valeur, tandis que « ajouter à » modifie la valeur actuelle.
• Erreur : appliquer les deux branches du « si alors sinon » — À faire : tester la condition et entourer uniquement la branche exécutée.
• Erreur : oublier de mettre à jour le compteur dans une boucle — À faire : utiliser un tableau avec les colonnes « tour », « compteur », « somme ».
• Erreur : donner le bon résultat sans justification — À faire : écrire une trace courte : valeur initiale, nombre de répétitions, opération répétée, valeur finale.
• Erreur : croire que Scratch lit tous les blocs visibles à l’écran — À faire : suivre uniquement la pile de blocs reliée au déclencheur utilisé.
• Erreur : tester une condition au mauvais moment — À faire : vérifier si le bloc conditionnel est placé avant, dans ou après la boucle.

10. À retenir

• Un algorithme est une suite finie d’instructions précises, exécutées dans un ordre déterminé.
• Dans Scratch, les blocs représentent les instructions d’un algorithme.
• Une variable est une valeur nommée qui peut changer pendant l’exécution du programme.
• Le bloc « mettre variable à ... » initialise ou remplace la valeur de la variable.
• Le bloc « ajouter ... à variable » augmente ou diminue la valeur actuelle de la variable.
• Une boucle « répéter n fois » exécute exactement n fois les blocs placés à l’intérieur.
• Une condition est un test vrai ou faux. Dans « si alors sinon », une seule branche est exécutée.
• Pour prévoir un résultat, on peut utiliser la routine : Je repère, J’applique, Je vérifie.
• Pour une boucle simple, on peut souvent utiliser un calcul du type : valeur finale = valeur initiale + nombre de répétitions × ajout.
• Au Brevet, il faut savoir lire un programme, compléter un bloc, prévoir une variable et justifier clairement sa réponse.

11. Exercices d'application

Télécharger la fiche d’exercices au format PDF : entraînement progressif sur la lecture et la création d’algorithmes Scratch en 3e.

Aperçu des types d’exercices proposés : identifier le rôle des blocs, prévoir la valeur d’une variable, remettre un algorithme dans l’ordre, écrire un programme Scratch, résoudre une question de type Brevet avec condition. Les exercices commencent par des programmes courts, puis introduisent des boucles et des tests conditionnels. Certains demandent une justification écrite, car la communication du raisonnement fait partie des compétences évaluées.

Barème possible sur 20 points : identifier les blocs Scratch, 4 points, en reconnaissant variable, boucle, condition et affichage ; exécuter un programme, 5 points, en suivant correctement les valeurs successives d’une variable ; recomposer un algorithme, 4 points, en ordonnant les blocs dans une suite logique ; créer un programme, 5 points, en utilisant des variables et une boucle adaptées à la situation ; justifier et communiquer, 2 points, en expliquant clairement les calculs et le choix de la condition.

Conseil de travail : pour chaque exercice, commence par écrire la valeur initiale de chaque variable. Ensuite, indique le nombre de répétitions. Enfin, teste les conditions seulement au moment où elles apparaissent dans le programme. Cette méthode évite la plupart des erreurs en algorithmique.

12. Questions fréquentes