Scratch 4e : listes et variables avancées

1. Introduction et problématique

En classe de 4e, l’algorithmique avec Scratch ne consiste plus seulement à déplacer un lutin ou à répéter une action. On apprend aussi à traiter des données : des notes, des scores, des longueurs, des températures, des réponses à un questionnaire. Dès qu’il y a plusieurs valeurs à mémoriser, une seule variable ne suffit plus toujours. Par exemple, si l’on veut conserver les notes 8, 12, 15 et 9, il serait peu pratique de créer quatre variables différentes : note1, note2, note3, note4. Scratch propose alors un outil très utile : la liste.

Une liste permet de ranger plusieurs valeurs sous un même nom. On peut ensuite lire une valeur précise, ajouter une nouvelle valeur, supprimer une valeur, ou parcourir toute la liste à l’aide d’une boucle. La situation-problème est la suivante : un professeur a enregistré dans Scratch la liste notes = [8 ; 12 ; 15 ; 9]. Il veut écrire un programme qui lit toutes les notes et compte combien d’élèves ont obtenu au moins 10. Comment faire sans écrire quatre fois presque la même instruction ?

Pour résoudre ce problème, il faut comprendre trois idées importantes : la liste contient plusieurs éléments, chaque élément a un rang appelé indice, et une boucle permet de passer automatiquement d’un élément au suivant. On utilisera souvent une variable appelée i, qui représente le rang de l’élément que l’on est en train de lire. Dans Scratch, le premier élément d’une liste est au rang 1, et non au rang 0. Ainsi, dans la liste notes = [8 ; 12 ; 15 ; 9], l’élément de rang 1 est 8, l’élément de rang 2 est 12, l’élément de rang 3 est 15, et l’élément de rang 4 est 9.

2. Définition

Définition : En Scratch, une liste est une structure qui permet de stocker plusieurs valeurs dans un ordre précis sous un même nom. Chaque valeur de la liste est appelée un élément. Le rang d’un élément dans la liste est appelé son indice. Dans Scratch, le premier indice est 1.

On peut donc retenir la phrase-repère : liste = plusieurs valeurs rangées. Une liste peut contenir des nombres, des mots, des réponses, des scores ou d’autres données utilisées par un programme. Par exemple, la liste notes = [8 ; 12 ; 15 ; 9] contient 4 valeurs. Sa longueur est 4. La valeur de rang 2 est 12. On dit aussi : l’élément 2 de notes vaut 12.

Une variable ne contient qu’une valeur à un instant donné, comme un compteur ou un total. Une liste, elle, contient plusieurs valeurs. Dans un programme de parcours de liste, on utilise souvent les deux : la liste contient les données à traiter, et les variables servent à organiser le traitement. Par exemple, la variable i peut indiquer le rang de l’élément lu, la variable somme peut additionner toutes les valeurs, et la variable compteur peut compter les valeurs qui vérifient une condition.

Les mots-clés à maîtriser sont : LISTE, INDICE, ÉLÉMENT, BOUCLE et TEST CONDITIONNEL. Une boucle permet de répéter des instructions. Un test conditionnel permet d’effectuer une action seulement si une condition est vraie, par exemple : si note ≥ 10 alors ajouter 1 au compteur.

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

Théorème : Pour parcourir entièrement une liste Scratch sans oublier d’élément et sans en lire un de trop, on initialise l’indice à 1, on répète les instructions autant de fois que la longueur de la liste, on lit l’élément d’indice i, puis on augmente i de 1 à chaque tour.

Cette règle peut être vue comme une propriété d’algorithmique. Si une liste contient n éléments, alors ses rangs dans Scratch sont 1, 2, 3, ..., n. Une boucle qui se répète n fois, avec un indice qui commence à 1 et augmente de 1 à chaque tour, lit successivement tous les rangs de 1 à n. C’est exactement ce qu’on cherche lorsqu’on veut traiter tous les éléments.

En pseudo-code proche de Scratch, le parcours standard est :

mettre i à 1
répéter longueur de notes fois
    lire élément i de notes
    traiter cette valeur
    ajouter 1 à i

Le traitement dépend de la question posée. Pour calculer une somme, on ajoute l’élément lu à une variable somme. Pour compter les valeurs supérieures ou égales à 10, on utilise un test conditionnel. Pour vérifier si une valeur appartient à un intervalle, on peut utiliser un test conditionnel imbriqué : par exemple, vérifier d’abord si une note est supérieure ou égale à 10, puis vérifier si elle est inférieure ou égale à 15.

Cette démarche s’inscrit dans les attendus du programme de mathématiques du collège : écrire, mettre au point et exécuter un programme simple, utiliser des variables, des boucles et des instructions conditionnelles, et organiser des données pour résoudre un problème.

4. Démonstration

On veut justifier que le parcours avec l’indice i lit bien tous les éléments d’une liste et seulement eux. Prenons une liste contenant n éléments. Dans Scratch, les rangs possibles sont 1, 2, 3, ..., n. Il n’existe pas d’élément de rang 0, et il n’existe pas d’élément de rang n + 1.

Au départ, on fixe i = 1. Lors du premier tour de boucle, l’instruction élément i de liste lit donc l’élément 1. À la fin du premier tour, on ajoute 1 à i, donc i devient 2. Lors du deuxième tour, on lit l’élément 2. À la fin du deuxième tour, i devient 3. Le même raisonnement continue à chaque tour.

Après k tours, on a lu les éléments 1, 2, ..., k. Si la boucle se répète exactement n fois, alors après le dernier tour on a lu les éléments 1, 2, 3, ..., n. Tous les éléments ont été lus. Aucun élément de rang supérieur à n n’est lu, car la boucle s’arrête après le n-ième tour. Aucun élément n’est oublié, car l’indice avance de 1 à chaque tour.

Cette démonstration montre aussi pourquoi certaines erreurs créent des résultats faux. Si on commence à i = 0, le premier rang n’existe pas en Scratch. Si on oublie d’ajouter 1 à i, le programme lit toujours le même élément. Si la boucle se répète n + 1 fois, le programme essaie de lire un élément qui n’existe pas. Si la boucle se répète n − 1 fois, le dernier élément n’est pas traité.

Le principe est donc très rigoureux : initialisation correcte, nombre de répétitions correct, lecture de l’élément, traitement, puis augmentation de l’indice.

5. Méthode pas à pas

1. Je repère la liste. J’identifie son nom, par exemple notes, et je regarde les valeurs qu’elle contient : [8 ; 12 ; 15 ; 9].
2. Je repère sa longueur. Ici, la liste contient 4 valeurs. Dans Scratch, on peut utiliser le bloc longueur de notes.
3. Je choisis une variable d’indice. On l’appelle souvent i. Elle sert à indiquer le rang de l’élément lu.
4. J’initialise l’indice. Je mets i à 1, car le premier élément d’une liste Scratch est au rang 1.
5. Je prépare les autres variables. Si je veux compter, je mets compteur à 0. Si je veux additionner, je mets somme à 0. Ces initialisations se placent avant la boucle.
6. Je crée la boucle. J’utilise répéter longueur de liste fois. Ainsi, le programme s’adapte même si la liste change de taille.
7. Je lis l’élément courant. Dans la boucle, j’utilise élément i de liste. Par exemple, si i = 2, on lit le deuxième élément.
8. Je traite la valeur. Selon l’objectif, j’ajoute la valeur à une somme, je la compare à un nombre, ou je déclenche une action.
9. J’augmente l’indice. À la fin de la boucle, j’ajoute 1 à i pour passer à l’élément suivant.
10. Je vérifie le résultat. Je contrôle que la boucle commence au bon rang, s’arrête au bon moment et que la réponse affichée correspond à la liste.

On peut résumer la routine par : 🔎 Je repère la liste, sa longueur et l’indice ; ⚙️ J’applique la boucle et le traitement ; ✅ Je vérifie le nombre de tours et le résultat.

6. Exemple résolu 1 — cas direct

Problème : On considère la liste Scratch notes = [8 ; 12 ; 15 ; 9]. On veut afficher chaque note, l’une après l’autre.

Analyse : La liste contient 4 éléments. Le premier rang est 1. Il faut donc lire successivement les éléments de rang 1, 2, 3 et 4. Pour éviter d’écrire quatre blocs presque identiques, on utilise une boucle.

Programme en langage naturel :

mettre i à 1
répéter longueur de notes fois
    dire élément i de notes pendant 1 seconde
    ajouter 1 à i

Déroulement : Au début, i = 1, donc le lutin affiche 8. Puis i devient 2, donc il affiche 12. Ensuite i devient 3, donc il affiche 15. Enfin i devient 4, donc il affiche 9. La boucle s’arrête après 4 tours, car la longueur de la liste est 4.

Conclusion : Le programme a parcouru toute la liste sans oublier de valeur. La variable i a joué le rôle d’indice. Le bloc élément i de notes a permis de lire la valeur correspondant au rang courant.

Ce premier exemple est le cas direct : on parcourt simplement la liste du début à la fin. C’est la base de nombreux programmes plus avancés : calculer une moyenne, chercher un maximum, compter des réussites, filtrer des valeurs ou tester des conditions.

7. Exemple résolu 2 — cas inverse

Problème : On sait que la liste notes = [8 ; 12 ; 15 ; 9] a été parcourue. Le programme affiche successivement 8, 12, 15, 9. On veut retrouver les valeurs prises par l’indice i et expliquer le fonctionnement de la boucle.

Analyse : Les valeurs affichées sont celles de la liste dans l’ordre. On en déduit que le programme a lu l’élément 1, puis l’élément 2, puis l’élément 3, puis l’élément 4. L’indice a donc pris les valeurs 1, 2, 3 et 4 pendant les lectures.

On peut construire un tableau de suivi :

Tour 1 : i = 1, élément 1 de notes = 8
Tour 2 : i = 2, élément 2 de notes = 12
Tour 3 : i = 3, élément 3 de notes = 15
Tour 4 : i = 4, élément 4 de notes = 9

Après chaque lecture, l’instruction ajouter 1 à i fait avancer l’indice. À la fin du quatrième tour, i devient 5, mais la boucle est terminée. Le programme ne lit donc pas l’élément 5, qui n’existe pas.

Conclusion : Retrouver les valeurs de i permet de vérifier qu’un programme de parcours est correct. Si les valeurs de i sont 1, 2, 3, ..., longueur de la liste, alors tous les éléments sont lus exactement une fois. Si i reste toujours égal à 1, c’est que l’instruction ajouter 1 à i a été oubliée. Si i commence à 0, le programme ne respecte pas le fonctionnement des listes Scratch.

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

Problème : Dans la liste notes = [8 ; 12 ; 15 ; 9], on veut compter le nombre de notes supérieures ou égales à 10. Puis on veut compter le nombre de notes comprises entre 10 et 15 inclus.

Première question : compter les notes au moins égales à 10. On crée une variable compteur. Elle commence à 0. Chaque fois qu’une note vérifie la condition note ≥ 10, on ajoute 1 au compteur.

Programme :

mettre compteur à 0
mettre i à 1
répéter longueur de notes fois
    si élément i de notes ≥ 10 alors
        ajouter 1 à compteur
    ajouter 1 à i
dire compteur

Calcul : 8 n’est pas ≥ 10, donc on ne compte pas. 12 est ≥ 10, on compte. 15 est ≥ 10, on compte. 9 n’est pas ≥ 10. Le compteur vaut donc 2.

Deuxième question : compter les notes comprises entre 10 et 15 inclus. Il faut vérifier deux conditions : la note doit être supérieure ou égale à 10 et inférieure ou égale à 15. On peut utiliser un test imbriqué.

Programme avec test imbriqué :

mettre compteur à 0
mettre i à 1
répéter longueur de notes fois
    si élément i de notes ≥ 10 alors
        si élément i de notes ≤ 15 alors
            ajouter 1 à compteur
    ajouter 1 à i
dire compteur

Ici, les notes 12 et 15 sont comptées. La note 8 est trop petite, la note 9 aussi. Le résultat est encore 2. Le test conditionnel imbriqué est utile lorsqu’une action ne doit se produire que si plusieurs conditions sont vérifiées.

9. Erreurs classiques à éviter

• Erreur : commencer le parcours à i = 0 — À faire : se rappeler que, dans Scratch, le premier élément d’une liste est au rang 1.
• Erreur : répéter la boucle une fois de trop ou pas assez — À faire : utiliser le bloc longueur de la liste pour obtenir exactement le bon nombre de tours.
• Erreur : oublier d’augmenter la variable i dans la boucle — À faire : placer ajouter 1 à i à la fin de chaque tour.
• Erreur : remettre le compteur à zéro dans la boucle — À faire : initialiser le compteur avant la boucle, puis l’augmenter seulement quand la condition est vraie.
• Erreur : confondre l’indice et la valeur — À faire : distinguer i, qui est le rang, et élément i de liste, qui est la valeur lue.
• Erreur : écrire un test imbriqué incomplet — À faire : verbaliser les deux conditions, par exemple : supérieur ou égal à 10 et inférieur ou égal à 15.
• Erreur : modifier la liste pendant qu’on la parcourt sans réfléchir — À faire : éviter d’ajouter ou de supprimer des éléments pendant le parcours, sauf si l’algorithme a été précisément prévu pour cela.

La plupart des erreurs se repèrent en faisant un tableau de suivi avec les colonnes : numéro du tour, valeur de i, élément lu, condition vraie ou fausse, valeur du compteur ou de la somme. Cette méthode permet de comprendre ce que fait réellement le programme.

10. À retenir

• Une liste Scratch permet de ranger plusieurs valeurs sous un même nom.
• Chaque valeur de la liste est un élément.
• Le rang d’un élément est son indice.
• Dans Scratch, le premier élément d’une liste est au rang 1.
• La liste notes = [8 ; 12 ; 15 ; 9] contient 4 valeurs : sa longueur est 4.
• Dans cette liste, l’élément 2 vaut 12.
• Pour parcourir une liste, on utilise souvent une variable i.
• Le schéma essentiel est : mettre i à 1, répéter longueur de liste fois, traiter élément i de liste, ajouter 1 à i.
• Un test conditionnel permet d’agir seulement si une condition est vraie.
• Un test conditionnel imbriqué est un test placé dans un autre test.
• Les variables comme compteur ou somme doivent être initialisées avant la boucle.
• Un tableau de suivi aide à vérifier un programme et à corriger les erreurs.

11. Exercices d'application

Lien PDF : Télécharger la fiche d’exercices « Scratch 4e : listes et variables avancées » avec énoncés, programmes à compléter et corrigé détaillé.

Les exercices proposés permettent de s’entraîner progressivement. Dans Lire une liste Scratch, il faut identifier la longueur d’une liste, le rang d’un élément et la valeur correspondant à un rang donné. Dans Vrai ou faux ?, il faut vérifier des affirmations sur les indices, les variables et les boucles. Dans Remettre les blocs dans l’ordre, l’objectif est de reconstituer un programme qui parcourt correctement une liste.

L’exercice Écrire un programme Scratch demande de créer un algorithme avec une boucle, une variable d’indice et une variable comme somme ou compteur. Enfin, l’exercice Condition imbriquée fait travailler les tests conditionnels : par exemple, compter les valeurs comprises dans un intervalle ou sélectionner des scores selon deux critères.

Barème conseillé sur 20 points : lecture correcte d’une liste et de ses rangs, 4 points ; compréhension du rôle de l’indice et de la longueur de liste, 4 points ; recomposition correcte d’un algorithme de parcours, 4 points ; écriture d’un programme avec boucle, somme ou compteur, 5 points ; utilisation correcte d’un test conditionnel ou imbriqué, 3 points.

12. Questions fréquentes