Exercice Scratch au brevet : les points à vérifier

Exercice Scratch au brevet: les points à vérifier

Ce n’est donc pas une petite question ajoutée à la fin du sujet: c’est souvent une partie accessible, à condition de lire le script dans le bon ordre et de rédiger chaque réponse avec une justification visible.

Depuis 2017, un exercice d’algorithmique ou de programmation est présent de manière quasi systématique dans les sujets du DNB. Le jour de l’épreuve, tu n’as généralement pas à programmer sur ordinateur. Tu dois analyser un script imprimé, suivre ses instructions, déterminer un résultat, compléter un programme ou expliquer le tracé obtenu. La difficulté n’est pas de connaître Scratch par cœur: elle consiste à ne pas perdre le fil entre les blocs.

Voici les points de contrôle à appliquer dès que tu rencontres un exercice Scratch au brevet.

Lire le script comme une suite d’actions

Avant de calculer, commence par repérer le déclencheur du programme. Le script démarre-t-il quand le drapeau vert est cliqué? Quand une touche est pressée? Une fois que tu as identifié cet événement, descends dans le programme bloc après bloc.

Ne lis pas un script Scratch comme un texte continu. Observe l’ordre exact des instructions:

1. une valeur est demandée ou attribuée;

2. une variable reçoit éventuellement cette valeur;

3. une boucle répète une ou plusieurs actions;

4. une condition décide si une instruction doit être exécutée;

5. le programme affiche, renvoie ou utilise le résultat obtenu.

Cet ordre est déterminant. Une variable peut changer plusieurs fois au cours du programme. Si tu regardes seulement sa valeur de départ, tu risques de donner une réponse qui semble plausible mais qui ne correspond pas à la dernière instruction exécutée.

Repérer le nombre réel de répétitions

Le bloc « répéter 5 fois » ne signifie pas « aller jusqu’à 5 »: il signifie que les instructions placées à l’intérieur sont exécutées exactement cinq fois. Pour répondre, compte les passages, pas seulement les nombres visibles dans le script.

Prenons un programme qui contient les actions suivantes:

• mettre n à 2;
• répéter 4 fois;
• ajouter 3 à n.

La valeur de n évolue ainsi:

La réponse finale est donc 14. Le calcul mental 2 + 3 ne suffit pas: il faut tenir compte des quatre passages dans la boucle.

Pour éviter les erreurs, écris les valeurs dans un tableau de brouillon. Tu peux utiliser une colonne pour le numéro de répétition et une autre pour la valeur de la variable. Cette méthode paraît élémentaire, mais elle sécurise les questions où une opération est répétée six, huit ou dix fois.

Une boucle ne se devine pas: elle se déroule. Écris chaque valeur intermédiaire dès que la variable est modifiée.

Distinguer « répéter » et « répéter jusqu’à »

Les deux blocs n’ont pas le même fonctionnement.

Avec « répéter 6 fois », tu connais immédiatement le nombre d’exécutions: six.

Avec « répéter jusqu’à ce que », le programme s’arrête lorsque la condition devient vraie. Tu dois donc observer l’évolution de la variable ou de la situation à chaque passage. Si le programme ajoute 2 à une variable jusqu’à obtenir une valeur supérieure à 10, le nombre de répétitions dépend de la valeur initiale.

Dans ce type de question, note dans ton brouillon:

• la valeur de départ;
• l’opération réalisée dans la boucle;
• la condition d’arrêt;
• la première valeur qui vérifie cette condition.

Attention au dernier passage. Le programme peut dépasser la valeur recherchée. Si la variable vaut 9 et qu’on lui ajoute 2 jusqu’à ce qu’elle soit supérieure à 10, le résultat est 11, pas 10. Le script ne cherche pas nécessairement à atteindre exactement la borne: il s’arrête dès que la condition demandée est vérifiée.

Contrôler les conditions « si… alors »

Les conditions sont souvent courtes à lire et faciles à mal interpréter. Dans un bloc « si… alors », tu dois d’abord évaluer la comparaison, puis seulement décider si l’action située à l’intérieur est exécutée.

Observe avec attention les signes:

• = signifie que les deux valeurs sont égales;
• < signifie que la première valeur est strictement inférieure à la seconde;
• > signifie qu’elle est strictement supérieure;
• ≤ et ≥ incluent la valeur limite;
• « et » impose que les deux conditions soient vraies;
• « ou » accepte qu’une seule des deux conditions soit vraie.

Un programme peut par exemple demander un nombre, puis afficher un message uniquement si ce nombre est supérieur ou égal à 10. Pour une valeur égale à 10, la condition est vraie. Si le script utilise seulement « supérieur à 10 », la même valeur ne déclenche pas l’action.

Cette nuance rapporte parfois un point très simple. Elle en fait aussi perdre lorsque tu lis rapidement le symbole ou que tu remplaces mentalement « supérieur ou égal » par « supérieur ».

La condition imbriquée dans une boucle

Lorsque le bloc « si… alors » se trouve à l’intérieur d’une boucle, la condition est testée à chaque répétition. Elle ne l’est pas seulement au début ou à la fin.

Supposons que le programme:

• mette x à 1;
• répète 5 fois;
• ajoute 2 à x;
• affiche x si x est supérieur à 5.

Les valeurs successives de x sont 3, 5, 7, 9 et 11. Le message est donc affiché pour les trois dernières valeurs, pas uniquement à la fin.

Pour analyser ce genre de script, trace une ligne par répétition. Dans chaque ligne, indique:

1. la valeur de la variable après modification;

2. le résultat de la condition;

3. l’action exécutée ou non.

Ne te contente pas d’écrire « la condition est vraie ». Le correcteur cherche à comprendre à quel moment elle le devient et quelle conséquence cela produit.

Le piège du « sinon »

Avec un bloc « si… alors… sinon », une des deux branches est toujours choisie. Si la condition est vraie, le programme exécute la première action. Si elle est fausse, il exécute l’action placée dans « sinon ».

Il ne faut pas laisser les deux branches agir en même temps. Tu dois également éviter de conclure que le programme ne fait rien lorsque la condition est fausse: le bloc « sinon » indique précisément ce qui se passe dans ce cas.

Pour vérifier ton raisonnement, prends une valeur simple qui rend la condition vraie, puis une valeur qui la rend fausse. Ce contrôle visuel permet de repérer rapidement une inversion entre les deux actions.

Suivre les variables et les programmes de calcul

Une variable Scratch est une boîte dont le contenu peut changer. Au brevet, tu dois souvent suivre cette boîte, exprimer son contenu en fonction d’un nombre choisi ou expliquer le résultat final du programme.

La première question à te poser est toujours: quelle est la valeur de la variable au moment où l’instruction commence? Ne réutilise pas automatiquement sa valeur initiale. Une instruction comme « mettre résultat à 7 » remplace l’ancienne valeur. Une instruction comme « ajouter 7 à résultat » la conserve et la modifie.

Cette différence entre « mettre » et « ajouter » est fondamentale:

• « mettre x à 5 » donne directement x = 5;
• « ajouter 5 à x » transforme x en x + 5;
• « multiplier x par 5 » transforme x en 5x;
• « mettre x à la réponse » remplace le contenu précédent par la réponse saisie.

Passer du calcul numérique à l’expression littérale

Les programmes de calcul demandent fréquemment d’exprimer le résultat sous la forme d’une expression algébrique. Si le nombre choisi est noté x, tu dois traduire chaque bloc dans l’ordre.

Exemple:

• choisir un nombre x;
• multiplier par 3;
• ajouter 4;
• soustraire le nombre de départ.

Le résultat s’écrit:

\[

3x + 4 - x

\]

Puis, si la question demande une expression réduite:

\[

2x + 4

\]

Ne saute pas directement à la forme finale. Écris d’abord la traduction de chaque étape. Cette rédaction montre que tu as compris le fonctionnement du programme et évite les erreurs de signe.

Tu peux organiser ton brouillon de cette manière:

Si le programme comporte un carré, une division ou une parenthèse, conserve exactement la structure de l’instruction avant de simplifier. « Ajouter 5 puis multiplier par 2 » donne \(2(x+5)\), et non \(2x+5\). L’ordre des blocs est aussi important que le calcul lui-même.

Dans un programme de calcul, chaque bloc devient une ligne de calcul. Si tu sautes une ligne, tu risques de perdre à la fois le résultat et la justification.

Vérifier avec une valeur test

Une fois ton expression trouvée, remplace x par une valeur simple, par exemple 2 ou 5, et exécute le programme à la main. Le résultat obtenu avec l’expression doit être le même que celui obtenu en suivant les blocs.

Cette vérification ne remplace pas la démonstration. Elle sert à contrôler ton brouillon avant de recopier. Si les deux résultats diffèrent, reprends le programme depuis le début et cherche l’instruction mal traduite.

Évite cependant de tester uniquement avec une valeur particulière qui annule un terme ou rend deux expressions identiques par hasard. Pour vérifier une expression, une valeur positive simple est généralement plus informative.

Anticiper les tracés géométriques et l’orientation du lutin

Les exercices Scratch de géométrie demandent souvent de prévoir une figure, de compléter un script ou de déterminer la position finale du lutin. Ici, le calcul des longueurs ne suffit pas. Tu dois suivre le déplacement et l’orientation.

Avant de tracer, identifie quatre éléments:

• la position de départ du lutin;
• la direction dans laquelle il regarde;
• la longueur de chaque déplacement;
• le sens et la mesure de chaque rotation.

L’orientation initiale est un point de contrôle crucial. Un lutin qui avance de 50 pas vers la droite ne produit pas le même tracé s’il est tourné vers le haut. De même, « tourner à droite de 90 degrés » et « tourner à gauche de 90 degrés » donnent des directions opposées.

Ne pas confondre déplacement et rotation

Le bloc « avancer de 40 pas » déplace le lutin dans la direction où il regarde. Il ne modifie pas cette orientation.

Le bloc « tourner de 90 degrés » modifie l’orientation, mais ne déplace pas le lutin.

Dans ton brouillon, sépare donc les deux informations. Tu peux noter:

Cette séparation t’empêche de tracer un segment au mauvais endroit ou d’ajouter une rotation qui n’existe pas dans le script.

Calculer la rotation totale

Lorsque plusieurs rotations apparaissent, additionne-les en tenant compte du sens. Quatre rotations de 90 degrés dans le même sens ramènent le lutin dans sa direction initiale. Trois rotations de 90 degrés ne donnent pas un tour complet: elles l’orientent dans une direction perpendiculaire ou opposée selon son point de départ.

Pour une figure fermée, observe également le nombre de côtés et les angles de rotation. Un carré est souvent construit avec quatre déplacements identiques et quatre rotations de 90 degrés. Un triangle équilatéral nécessite des rotations extérieures de 120 degrés dans le tracé classique. Mais ne reconnais jamais une figure uniquement à son apparence: vérifie les instructions.

Un tracé peut sembler fermé sur ton dessin alors que le script ne revient pas exactement au point de départ. La vérification doit porter sur:

1. le nombre de segments;

2. la longueur de chaque segment;

3. la direction après chaque rotation;

4. la position finale du lutin.

Utiliser le dessin comme outil de contrôle

Le brouillon géométrique n’a pas besoin d’être une figure parfaite. Il doit rendre les directions lisibles. Trace les premiers segments, marque les angles de rotation et indique les longueurs lorsque cela aide.

Si le dessin devient confus, recommence avec une flèche pour chaque direction. Écris D, H, G ou B dans la marge si le lutin se déplace horizontalement ou verticalement. L’objectif n’est pas de produire une œuvre graphique: il est de contrôler le déroulement du script.

Une erreur d’orientation se repère souvent visuellement avant même de terminer le calcul. Si le dernier segment part dans une direction impossible, relis la rotation précédente. Le programme ne change pas de direction spontanément.

Analyser un script sans ordinateur

Le jour du brevet, tu dois savoir analyser un programme Scratch imprimé. Tu n’as pas besoin de cliquer sur les blocs ni de lancer le script. Tu dois transformer les instructions en une suite d’actions vérifiables.

Commence par repérer les informations qui commandent le programme:

• la valeur demandée à l’utilisateur;
• les variables créées;
• les valeurs initiales;
• le nombre de répétitions;
• la condition d’arrêt;
• l’événement qui lance le script.

Ensuite, sépare les instructions principales des instructions internes. Une boucle contient ses propres actions. Une condition peut se trouver dans cette boucle. Pour ne pas mélanger les niveaux, décale tes notes dans le brouillon ou utilise une nouvelle ligne à chaque passage.

La méthode en cinq lectures

Pour un exercice Scratch au brevet, applique cette séquence:

1. Lire le déclenchement

Détermine ce qui lance le programme et si une donnée est saisie par l’utilisateur.

2. Entourer les variables

Repère les blocs qui mettent une variable à une valeur, l’augmentent, la diminuent ou la multiplient.

3. Compter les boucles

Note le nombre exact de répétitions ou cherche la condition qui provoque l’arrêt.

4. Évaluer les conditions

Pour chaque passage, écris « vraie » ou « fausse », puis indique la branche exécutée.

5. Contrôler la sortie

Vérifie ce que le programme affiche, renvoie ou dessine à la fin.

Cette méthode fonctionne pour une question courte comme pour un script plus long. Elle évite surtout de répondre à partir de la forme générale du programme. Deux scripts peuvent se ressembler tout en donnant des résultats différents à cause d’une seule valeur initiale ou d’un seul signe de comparaison.

Quand le programme comporte une entrée

Si le script demande de choisir un nombre, ne remplace pas cette valeur par une valeur au hasard lorsque la question demande une expression générale. Utilise une lettre, souvent x, et traduis les blocs.

En revanche, si le sujet donne un nombre précis, conserve cette valeur et déroule les opérations dans l’ordre. Tu peux effectuer les calculs sur le côté, mais laisse apparaître les étapes principales dans ta réponse lorsque la question demande une justification.

Si plusieurs valeurs sont proposées, traite-les séparément. Ne garde pas la première valeur dans la variable pour analyser la deuxième: un nouveau lancement du programme remet généralement les variables dans leur état initial prévu par le script. Cette remise à zéro doit être lue dans les instructions, pas supposée.

Les erreurs classiques qui font perdre des points

Les erreurs sur Scratch au collège ne viennent pas toujours d’un manque de compréhension. Elles apparaissent souvent lorsque tu vas trop vite ou que tu rédiges une réponse impossible à corriger précisément.

1. Donner le résultat sans dérouler le programme

Écrire uniquement une valeur finale peut suffire pour une question qui demande explicitement le résultat, mais pas pour une question de justification. Si le barème prévoit plusieurs points, le correcteur doit pouvoir retrouver ton raisonnement.

Écris les valeurs intermédiaires lorsque la variable évolue. Une ligne de calcul claire peut faire gagner le point de méthode même si une erreur apparaît ensuite.

2. Oublier une répétition

C’est l’erreur la plus fréquente dans les boucles numériques. Pour l’éviter, numérote les passages dans ton brouillon. Si le bloc indique « répéter 10 fois », ne t’arrête pas à la neuvième valeur, même si la condition semble déjà satisfaite dans ta tête: un bloc de répétition fixe s’exécute jusqu’au nombre annoncé.

3. Tester la condition avant la modification

Dans un script, l’ordre des blocs est impératif. Si le programme ajoute 1 à n, puis vérifie si n est supérieur à 5, tu dois utiliser la nouvelle valeur pour la condition. Tu ne peux pas vérifier l’ancienne valeur et modifier ensuite.

Lis chaque ligne en commençant par le verbe: mettre, ajouter, multiplier, avancer, tourner, dire, demander. Ces verbes indiquent l’action réellement effectuée.

4. Inverser la droite et la gauche

Dans un tracé, une rotation à droite ne se corrige pas parce que la figure « devrait » ressembler à un carré. Suis l’orientation du lutin. Si nécessaire, dessine une petite flèche à côté de sa position à chaque étape.

Un changement de sens peut aussi apparaître dans un programme qui alterne deux rotations. Ne simplifie pas les angles sans noter leur direction.

5. Confondre une variable avec sa valeur précédente

Le bloc « mettre la variable à… » écrase son contenu. Le bloc « ajouter… à la variable » s’appuie sur le contenu existant. Cette différence doit apparaître dans tes calculs.

6. Répondre par une phrase trop courte

Une réponse comme « oui » ou « le programme trace un carré » n’est pas toujours suffisante. Ajoute la propriété qui justifie ta conclusion: quatre côtés de même longueur, quatre rotations de 90 degrés, retour au point de départ, ou valeur finale obtenue après les répétitions.

Le but n’est pas d’écrire un paragraphe pour chaque bloc. Le but est de rendre la preuve lisible.

La vérification finale avant de rendre la copie

Garde quelques minutes pour relire uniquement les exercices d’algorithmique. Cette relecture doit être ciblée, pas générale.

Vérifie successivement:

• le nombre de répétitions;
• la valeur initiale de chaque variable;
• le sens des opérations;
• les signes =, <, >, ≤ et ≥;
• la présence éventuelle d’un bloc « sinon »;
• l’ordre entre modification et condition;
• l’orientation initiale du lutin;
• le sens des rotations;
• les unités ou les longueurs indiquées;
• la justification écrite sous le résultat.

Pour un programme de calcul, remplace ton expression par une valeur test. Pour un tracé, regarde si la position finale correspond à ton dessin. Pour une boucle, recompte les lignes de ton tableau. Ces vérifications sont rapides et peuvent faire apparaître une erreur de lecture avant qu’elle ne coûte plusieurs points.

Ne gomme pas systématiquement ton brouillon dès que tu as trouvé le résultat. Il peut t’aider à expliquer une étape demandée dans la question. En revanche, la copie finale doit contenir une rédaction propre, avec les calculs utiles et une conclusion identifiable.

Le correcteur ne peut attribuer un point de justification qu’à une justification qu’il voit. Un résultat juste, mais posé sans explication, reste fragile au barème.

La rédaction qui rapporte le dernier point

Dans un exercice Scratch, la dernière étape n’est pas le calcul: c’est la formulation de la réponse. Tu dois relier le programme à sa conséquence.

Pour un programme numérique, rédige par exemple:

• « Après les quatre répétitions, la variable vaut… »
• « L’expression obtenue est…, car le programme multiplie d’abord le nombre choisi puis ajoute… »
• « La condition devient vraie lorsque…, donc le programme affiche… »

Pour un tracé géométrique:

• « Le lutin avance de … puis tourne de … degrés vers la droite. »
• « Il effectue … segments de même longueur et … rotations de … degrés; le tracé est donc… »
• « Après la dernière instruction, le lutin revient à sa position initiale, ce qui montre que la figure est fermée. »

Évite les formulations vagues comme « on voit que » si le dessin n’est pas accompagné d’une propriété précise. Observe le tracé, oui, mais transforme ton observation en argument: longueur, angle, nombre de répétitions, direction ou position finale.

L’exercice Scratch au brevet récompense une lecture organisée plus qu’une virtuosité informatique. Tu dois tracer lorsque le script déplace un lutin, projeter les valeurs dans un tableau lorsque la boucle évolue, observer les conditions avant de conclure, puis rédiger la propriété ou le calcul qui justifie ta réponse. En suivant cet ordre, tu réduis les erreurs classiques et tu rends chaque point du barème accessible.