Jeu de calcul mental sur Scratch : le guide de création

Jeu de calcul mental sur Scratch: le guide de création

C’est une erreur de logique: la question affichée, la réponse attendue et le score ne correspondent plus après une itération.

Le programme doit donc suivre un ordre strict:

1. Générer les nombres.

2. Calculer la réponse correcte.

3. Afficher l’énoncé.

4. Lire la réponse du joueur.

5. Comparer les deux valeurs.

6. Modifier le score.

7. Recommencer.

Si cet ordre est inversé, le jeu peut fonctionner visuellement tout en évaluant la question précédente ou en conservant une ancienne valeur dans une variable.

Scratch convient particulièrement à ce type d’activité. Le langage, développé par le MIT, utilise des blocs visuels. Il permet de travailler les variables, les instructions conditionnelles, les boucles et les tirages aléatoires. Ces notions appartiennent directement à l’algorithmique étudiée au collège.

1. Définir le fonctionnement du jeu avant de programmer

Un programme correct commence par une règle précise. Il faut fixer le comportement du jeu avant de placer les blocs.

Un jeu simple peut fonctionner ainsi:

• le score commence à zéro;
• le programme pose plusieurs questions;
• chaque question utilise des nombres tirés au hasard;
• le joueur saisit une réponse;
• une bonne réponse augmente le score;
• une mauvaise réponse ne modifie pas le score;
• le programme affiche le résultat final.

Le nombre de questions peut être fixé à l’avance. Il peut aussi être demandé au joueur au début du programme. Pour une première activité, une boucle avec un nombre déterminé d’itérations est préférable. Elle permet de repérer clairement la variable de contrôle.

Les variables nécessaires

Créez d’abord les variables suivantes:

• score: nombre de points obtenus;
• nombre_1: premier nombre de l’opération;
• nombre_2: second nombre;
• réponse_correcte: résultat calculé par le programme;
• opération: symbole ou numéro identifiant le calcul choisi;
• compteur: nombre de questions déjà posées.

Toutes ces variables ne sont pas indispensables pour une addition unique. Elles deviennent utiles dès que le jeu propose plusieurs opérations.

La variable score doit être initialisée au début. Le bloc à utiliser est donc:

• mettre score à 0

Le même principe s’applique au compteur:

• mettre compteur à 0

Une variable non réinitialisée conserve la valeur de la précédente exécution. Si le programme est lancé une seconde fois, le joueur peut alors commencer avec un ancien score. Le résultat devient faux dès le premier affichage.

Une variable doit avoir une valeur initiale connue avant la première itération. Sinon, le programme dépend de son état précédent.

2. Construire une question aléatoire

La diversité des questions repose sur le bloc opérateur nombre aléatoire entre... et....

Pour générer une addition simple, utilisez par exemple:

• mettre nombre_1 à nombre aléatoire entre 0 et 20
• mettre nombre_2 à nombre aléatoire entre 0 et 20

Puis calculez la réponse:

• mettre réponse_correcte à nombre_1 + nombre_2

Dans Scratch, l’opération est placée dans un bloc opérateur. Il ne faut pas écrire un calcul complet dans une phrase en espérant que Scratch l’interprète comme un langage textuel. Les blocs imposent la structure du calcul.

Pour afficher la question, utilisez le bloc de dialogue:

• demander [Combien font...?] et attendre

La difficulté vient ici de l’insertion des variables dans le texte. Le message doit contenir nombre_1 et nombre_2. Il peut être construit avec plusieurs blocs regrouper.

L’ordre logique devient alors:

1. Tirer nombre_1.

2. Tirer nombre_2.

3. Calculer réponse_correcte.

4. Construire la question.

5. Demander une réponse.

Il est préférable de calculer réponse_correcte avant la saisie. Le programme connaît ainsi la solution au moment de la comparaison. La réponse du joueur est accessible avec le bloc réponse, après l’exécution de demander... et attendre.

Exemple avec une addition

Pour une addition, le mécanisme est le suivant:

• mettre nombre_1 à nombre aléatoire entre 1 et 50;
• mettre nombre_2 à nombre aléatoire entre 1 et 50;
• mettre réponse_correcte à (nombre_1 + nombre_2);
• demander [Combien font] et attendre;
• comparer réponse avec réponse_correcte.

La formulation exacte du message peut être améliorée avec le bloc dire. Le point essentiel reste la comparaison numérique. Le programme ne doit pas comparer une phrase complète avec une valeur numérique.

3. Ajouter la boucle principale

Une seule question ne constitue pas encore un jeu. Il faut répéter le même ensemble d’instructions.

Le bloc répéter permet d’exécuter une séquence un nombre défini de fois. Placez à l’intérieur:

• la génération des nombres;
• le calcul de la réponse correcte;
• la question;
• la comparaison;
• la mise à jour du score;
• l’affichage du retour.

La structure générale est donc:

1. Initialiser le score.

2. Initialiser le compteur.

3. Répéter le nombre de questions choisi:

• produire une question;
• demander la réponse;
• tester la réponse;
• modifier le score;
• augmenter le compteur.

4. Afficher le score final.

Le compteur n’est pas obligatoire si le bloc répéter suffit à contrôler le nombre de questions. Il devient utile pour afficher la progression, par exemple en indiquant le numéro de la question.

Une structure avec répéter 10 fois contient une erreur classique: le programme affiche parfois le score final à l’intérieur de la boucle. Dans ce cas, le score intermédiaire apparaît après chaque question. Ce n’est pas incorrect, mais cela ne correspond pas au comportement attendu si le résultat doit être affiché uniquement à la fin.

Placez donc l’instruction finale après la boucle:

• dire [Partie terminée. Score:...]

Le score final doit être calculé à partir de la variable score. Il ne faut pas recopier une valeur fixe dans le message.

Ordre recommandé des blocs

L’ordre suivant limite les erreurs:

1. quand drapeau vert pressé

2. mettre score à 0

3. répéter 10 fois

4. génération des nombres

5. calcul de réponse_correcte

6. demande de la réponse

7. si... alors... sinon

8. modification du score

9. message de correction

10. affichage du résultat final

Le bloc conditionnel doit être placé dans la boucle. S’il est placé après la boucle, une seule réponse sera évaluée: celle de la dernière question.

4. Utiliser les blocs conditionnels Scratch

L’instruction conditionnelle prend la forme:

• si... alors
• sinon

La condition à tester est:

• réponse = réponse_correcte

Si la condition est vraie:

• le programme annonce que la réponse est correcte;
• le score augmente.

Sinon:

• le programme indique que la réponse est incorrecte;
• la bonne réponse peut être affichée;
• le score reste inchangé.

La modification du score doit être explicite:

• ajouter 1 à score

N’utilisez pas une nouvelle affectation mal contrôlée, par exemple mettre score à 1, à l’intérieur de la boucle. Cette instruction remettrait le score à un point à chaque bonne réponse. Après plusieurs réussites, la variable ne dépasserait jamais une valeur fixe.

Le mécanisme correct est une accumulation:

• score initial: 0;
• première bonne réponse: 1;
• deuxième bonne réponse: 2;
• troisième bonne réponse: 3.

La variable représente donc un état qui évolue à chaque itération.

Comparer des nombres

Scratch peut comparer directement la réponse saisie avec une variable numérique. La condition est vraie si les deux valeurs sont égales.

Il faut éviter d’ajouter des espaces, des unités ou des caractères dans la réponse attendue. Si le joueur doit répondre par un nombre, la comparaison doit porter sur un nombre.

Le programme peut afficher le résultat avec un message distinct:

• en cas de réussite: score augmenté;
• en cas d’erreur: correction affichée.

La correction est utile pour transformer le jeu en exercice. Sans retour, l’élève sait seulement que son score est inférieur au maximum. Il ne voit pas quelle opération a posé problème.

5. Programmer plusieurs opérations

Un jeu de calcul mental devient plus intéressant lorsqu’il propose des additions, des soustractions, des multiplications ou des divisions. Il faut alors ajouter une variable opération.

Cette variable peut prendre une valeur aléatoire. Chaque valeur correspond à une branche du programme:

• 1 pour l’addition;
• 2 pour la soustraction;
• 3 pour la multiplication;
• 4 pour la division.

Le programme tire d’abord le type de calcul. Ensuite, une série de blocs si... alors sélectionne la formule adaptée.

La génération des nombres doit dépendre de l’opération. C’est un point technique. Une même méthode aléatoire ne convient pas à tous les calculs.

Addition

Pour l’addition, deux nombres entiers positifs suffisent. La réponse est toujours entière.

Soustraction

Si l’objectif est de travailler les résultats positifs, il faut imposer un ordre entre les deux nombres. Une méthode simple consiste à générer d’abord le plus grand nombre, puis le plus petit.

Par exemple:

• nombre_1 est tiré entre 1 et 50;
• nombre_2 est tiré entre 1 et nombre_1.

La réponse nombre_1 - nombre_2 est alors positive ou nulle.

Si les nombres sont tirés indépendamment, le programme produira aussi des résultats négatifs. Ce n’est pas une erreur de programmation. C’est une décision mathématique qui doit être prévue dans la consigne.

Multiplication

La multiplication exige un réglage plus strict des bornes. Avec des nombres trop grands, le calcul mental devient rapidement disproportionné par rapport au niveau visé.

Le choix des intervalles doit donc correspondre à l’objectif:

• petites tables pour un entraînement automatisé;
• facteurs plus grands pour un niveau avancé;
• séries ciblées sur une table précise pour une activité de remédiation.

Le programme reste identique. Seules les bornes du bloc nombre aléatoire entre... et... changent.

Division

La division est la source de nombreuses erreurs. Deux nombres aléatoires ne produisent pas nécessairement un quotient entier. Le jeu peut alors demander une réponse décimale ou une division avec reste, sans que cette difficulté ait été annoncée.

Pour obtenir une division exacte, il est préférable de générer:

1. un diviseur;

2. un quotient;

3. le dividende en multipliant le diviseur par le quotient.

La relation devient:

• dividende = diviseur × quotient;
• réponse_correcte = dividende ÷ diviseur.

Le diviseur ne doit jamais être égal à zéro. Cette contrainte doit être intégrée à la génération des données. Une division par zéro ne produit pas une question difficile: elle produit une question invalide.

La difficulté d’un exercice vient des valeurs choisies, pas du hasard lui-même. Le tirage aléatoire doit respecter la règle mathématique de l’opération.

6. Gérer les priorités opératoires

Dès qu’une opération comporte plusieurs calculs, la priorité opératoire intervient.

Prenons une expression de type:

• nombre_1 + nombre_2 × nombre_3

La multiplication doit être effectuée avant l’addition. Dans Scratch, les blocs imbriqués rendent l’ordre visible. Il est donc préférable de construire le calcul avec des blocs séparés plutôt que d’afficher une expression ambiguë.

Pour imposer une addition avant une multiplication, placez l’addition dans un bloc intérieur:

• (nombre_1 + nombre_2) × nombre_3

La parenthèse n’est pas décorative. Elle modifie le résultat.

Un jeu de calcul mental peut entraîner explicitement cette compétence. Le programme génère une expression. La variable réponse_correcte contient le résultat obtenu selon les priorités opératoires. Le message présente la même structure que le calcul.

La difficulté est double:

• comprendre l’expression affichée;
• produire la réponse sans confondre l’ordre des opérations.

Pour éviter une surcharge, commencez par une seule opération. Ajoutez ensuite des expressions à deux opérations. Enfin, introduisez les parenthèses.

Trois niveaux de progression

1. Niveau 1: une opération

• additions, soustractions ou multiplications;
• nombres entiers;
• correction immédiate.

2. Niveau 2: opérations variées

• choix aléatoire de l’opération;
• score commun;
• bornes adaptées à chaque calcul.

3. Niveau 3: priorités opératoires

• expressions comportant deux opérations;
• parenthèses éventuelles;
• réponse calculée par une formule structurée.

Le passage d’un niveau au suivant doit modifier la logique du programme de manière contrôlée. Ajouter des blocs sans revoir les variables augmente le risque d’erreur.

7. Ajouter un système de difficulté

La difficulté peut être contrôlée par une variable niveau. Cette variable agit sur les bornes des nombres, le type d’opération ou le nombre de calculs dans une expression.

Exemple de fonctionnement:

• niveau 1: additions avec des nombres compris dans un petit intervalle;
• niveau 2: additions et soustractions;
• niveau 3: multiplications et divisions exactes;
• niveau 4: opérations combinées avec priorités.

Le programme peut demander le niveau avant de démarrer. Il peut aussi l’augmenter après un certain nombre de bonnes réponses. Dans ce second cas, une nouvelle condition est nécessaire.

Il faut séparer les responsabilités:

• niveau définit la difficulté;
• nombre_1, nombre_2 et éventuellement nombre_3 construisent la question;
• réponse_correcte contient la solution;
• score mesure la réussite.

Une variable ne doit pas avoir plusieurs fonctions contradictoires. Utiliser score pour contrôler en même temps le niveau, le nombre de questions et le résultat final rend le programme difficile à vérifier.

Score et pénalité

Le système le plus lisible est le suivant:

• bonne réponse: ajouter 1 à score;
• mauvaise réponse: aucune modification;
• score maximal: égal au nombre de questions.

Une pénalité peut être ajoutée, mais elle change l’interprétation du score. Si une mauvaise réponse retire un point, le score peut devenir négatif. Cette règle doit être annoncée au joueur et intégrée au test final.

Pour un exercice de collège, un score simple est souvent préférable. Il permet de vérifier immédiatement la relation suivante:

score ≤ nombre de questions

Si le score dépasse ce nombre, le bloc d’initialisation ou le bloc d’incrémentation contient une erreur.

8. Transformer le programme en activité pédagogique

Le jeu ne doit pas seulement produire un résultat. Il doit rendre visibles les notions d’algorithmique.

Un exercice Scratch sur le calcul mental peut demander aux élèves de:

• repérer les variables;
• expliquer le rôle de la boucle;
• identifier la condition;
• prévoir la valeur d’une variable après plusieurs itérations;
• corriger une erreur dans le programme;
• compléter un bloc manquant;
• déterminer la réponse correcte produite par une séquence donnée.

Cette dernière compétence est importante. Au brevet, les exercices portant sur des algorithmes Scratch sont réalisés sur papier. L’élève ne programme donc pas nécessairement sur ordinateur pendant l’épreuve. Il doit lire les instructions, suivre les valeurs des variables et comprendre l’exécution du programme.

La partie consacrée aux automatismes de l’épreuve de mathématiques du brevet dure 20 minutes et compte pour 6 points. Le calcul mental et la lecture d’algorithmes ne sont donc pas des activités périphériques. Ils mobilisent des automatismes évalués dans un cadre formel.

Questions possibles autour du projet

Un enseignant peut demander:

1. Quelle est la valeur de score au début du programme?

2. Combien de fois la boucle s’exécute-t-elle?

3. Quelle valeur prend réponse_correcte pour les nombres tirés?

4. Quelle branche du bloc conditionnel est exécutée?

5. Le score est-il modifié?

6. Quel est le nombre maximal de points?

7. Que se passe-t-il si nombre_2 vaut zéro dans une division?

8. Le programme produit-il toujours un résultat entier?

9. Quelle instruction doit être déplacée pour corriger le programme?

10. Quelle variable doit être réinitialisée avant une nouvelle partie?

Ces questions vérifient le mécanisme. Elles ne demandent pas seulement de cliquer sur des blocs.

9. Les erreurs typiques dans un jeu de calcul mental Scratch

La réponse correcte n’est pas recalculée

Le programme tire de nouveaux nombres, mais conserve l’ancienne valeur de réponse_correcte.

Correction: placer l’affectation de réponse_correcte dans la boucle, après chaque nouveau tirage.

Le score revient à zéro

Le bloc mettre score à 0 a été placé dans la boucle.

Correction: initialiser le score avant la boucle. Dans la boucle, utiliser seulement ajouter... à score.

Une seule question est évaluée

Le bloc si... alors est situé après répéter.

Correction: placer le test dans la boucle, immédiatement après la réponse du joueur.

Le programme pose des divisions impossibles

Les deux valeurs sont tirées indépendamment. Le diviseur peut être nul ou le quotient non entier.

Correction: construire la division à partir d’un diviseur et d’un quotient, puis calculer le dividende.

Le résultat de la soustraction est négatif

Les deux nombres sont aléatoires sans contrainte.

Correction: imposer nombre_1 ≥ nombre_2, ou accepter explicitement les nombres négatifs dans la consigne.

Le message ne correspond pas au calcul testé

Le texte affiche les nouveaux nombres, mais la réponse correcte correspond aux anciens.

Correction: générer les nombres, calculer la réponse et construire le message dans la même itération, dans cet ordre.

La boucle ne s’arrête pas

Le bloc répéter indéfiniment a été utilisé alors que le jeu devait comporter un nombre limité de questions.

Correction: utiliser répéter... fois, ou ajouter une condition d’arrêt contrôlée par un compteur.

10. Procédure complète de construction

Suivez cette séquence pour créer une première version fiable.

Étape 1: choisir une opération

Commencez par l’addition. Ne programmez pas immédiatement quatre opérations. Une seule branche permet de vérifier la structure.

Étape 2: créer les variables

Créez score, nombre_1, nombre_2 et réponse_correcte.

Étape 3: initialiser le programme

Sous quand drapeau vert pressé:

• mettre score à 0;
• lancer une boucle avec un nombre défini de répétitions.

Étape 4: générer les données

Dans la boucle:

• tirer nombre_1;
• tirer nombre_2;
• calculer réponse_correcte.

Étape 5: demander la réponse

Construire le message avec les deux nombres, puis utiliser demander... et attendre.

Étape 6: comparer

Ajouter un bloc si... alors... sinon.

La condition est:

réponse = réponse_correcte

Étape 7: mettre à jour le score

Dans la branche correcte:

• ajouter 1 à score.

Dans la branche incorrecte:

• afficher la correction;
• ne pas modifier le score.

Étape 8: afficher le résultat final

Après la boucle, afficher la valeur de score.

Étape 9: ajouter les opérations

Créer la variable opération. Ajouter les branches une par une. Tester chaque opération avant d’en ajouter une autre.

Étape 10: vérifier les contraintes mathématiques

Contrôler:

• les bornes des nombres;
• le signe des résultats;
• la division par zéro;
• l’intégralité des quotients;
• les priorités opératoires.

Cette procédure évite de confondre l’interface du jeu avec son algorithme. Un décor, un son ou un personnage ne corrigent pas une variable mal utilisée.

Test de vérification rapide

Prenez une partie de trois questions et imposez mentalement les résultats suivants:

• première question correcte;
• deuxième question incorrecte;
• troisième question correcte.

Le score final doit être égal à 2.

Si le score vaut 1, une bonne réponse n’est pas comptée.

S’il vaut 3, le programme compte aussi une réponse incorrecte.

S’il vaut 0, le bloc d’initialisation ou le test conditionnel est mal placé.

Vérifiez ensuite une division avec un diviseur nul, une soustraction avec deux nombres inversés et une seconde partie lancée immédiatement après la première. Si le programme conserve l’ancien score, produit une division invalide ou évalue la mauvaise question, l’algorithme n’est pas encore stable.

Un jeu de calcul mental sur Scratch est donc un exercice complet d’algorithmique: les variables mémorisent l’état, le hasard génère les données, la boucle organise les itérations et la condition prend la décision. Le programme devient correct lorsque chaque bloc possède une fonction unique et que l’ordre d’exécution ne laisse aucune valeur implicite.