Algorithmique et programmation : boucles, tests et variables avec Scratch

1. Les bases de l'algorithmique et les variables

L'algorithmique est l'étude et la conception d'algorithmes. Un algorithme est une suite finie et ordonnée d'instructions claires et précises permettant de résoudre un problème donné. Un programme est la traduction d'un algorithme dans un langage de programmation (comme Scratch) pour qu'il puisse être exécuté par un ordinateur.

Une variable est un espace de stockage en mémoire qui permet de conserver une information (un nombre, un texte, une valeur logique Vrai/Faux) et de la modifier au cours de l'exécution du programme. Chaque variable a un nom unique pour être identifiée et utilisée.

Méthode
Comprendre le problème : Avant de programmer, il faut bien comprendre ce que l'on veut faire et comment le résoudre étape par étape.
Écrire l'algorithme : Décrire les étapes de résolution du problème de manière logique et précise, sans ambiguïté.
Identifier les données : Déterminer quelles informations le programme aura besoin de stocker ou de manipuler. Ce sont les futures variables.
Déclarer et utiliser une variable dans Scratch :
• Dans la catégorie "Variables" de Scratch, cliquer sur "Créer une variable".
• Donner un nom clair à la variable (par exemple, `score`, `nombre1`, `resultat`).
• Utiliser les blocs "mettre [ma_variable] à [valeur]" pour lui donner une valeur initiale ou la modifier.
• Utiliser le bloc "ajouter [valeur] à [ma_variable]" pour augmenter ou diminuer sa valeur.

Exemple
Écrire un programme Scratch qui demande à l'utilisateur deux nombres, les stocke dans des variables, puis affiche leur somme.

Corrigé pas à pas
Voici l'algorithme :
1. Demander à l'utilisateur le premier nombre.
2. Stocker ce nombre dans une variable appelée `nombre1`.
3. Demander à l'utilisateur le deuxième nombre.
4. Stocker ce nombre dans une variable appelée `nombre2`.
5. Calculer la somme de `nombre1` et `nombre2`.
6. Stocker le résultat dans une variable appelée `somme`.
7. Afficher la valeur de `somme`.

Traduction en blocs Scratch (description textuelle) :
• `quand le drapeau vert est cliqué`
• `demander Quel est le premier nombre ? et attendre`
• `mettre [nombre1] à (réponse)`
• `demander Quel est le deuxième nombre ? et attendre`
• `mettre [nombre2] à (réponse)`
• `mettre [somme] à ((nombre1) + (nombre2))`
• `dire (regrouper La somme est : (somme)) pendant 2 secondes`

Erreurs fréquentes
Oublier d'initialiser une variable : Une variable doit souvent avoir une valeur de départ (par exemple, 0 pour un score) avant d'être utilisée ou modifiée. Sinon, le programme risque de partir d'une valeur imprévue.
Utiliser un nom de variable incorrect : Faire attention à l'orthographe exacte du nom de la variable. Si vous avez créé `nombre1`, vous ne pouvez pas l'appeler `nombre_1` dans un autre bloc.
Confondre le nom de la variable et sa valeur : Le nom est l'étiquette, la valeur est ce qu'elle contient. Par exemple, `nombre1` est le nom, et `5` peut être sa valeur.

2. Les boucles (répétitions)

Une boucle est une structure de contrôle qui permet de répéter un bloc d'instructions plusieurs fois. Cela évite de copier-coller les mêmes instructions et rend le programme plus court et plus facile à modifier. Dans Scratch, on utilise principalement le bloc `répéter ... fois` ou `répéter indéfiniment`.

Méthode
Identifier les actions répétitives : Repérer les séquences d'instructions qui se répètent plusieurs fois dans un algorithme.
Déterminer le nombre de répétitions : Savoir combien de fois ces actions doivent être exécutées. Si le nombre est fixe, utiliser `répéter [nombre] fois`.
Placer les instructions dans la boucle : Mettre les blocs d'instructions à répéter à l'intérieur du bloc de boucle.
Exemple de bloc Scratch : Le bloc `répéter 10 fois` exécutera les instructions qu'il contient 10 fois de suite.

Exemple
Écrire un programme Scratch pour que le lutin dessine un carré de 100 pas de côté.

Corrigé pas à pas
Pour dessiner un carré, le lutin doit avancer d'une certaine distance, puis tourner de 90 degrés, et répéter ces deux actions 4 fois (car un carré a 4 côtés égaux et 4 angles droits).

Voici l'algorithme :
1. Préparer le stylo (abaisser le stylo pour dessiner).
2. Répéter 4 fois :
a. Avancer de 100 pas.
b. Tourner de 90 degrés (vers la droite ou la gauche).

Traduction en blocs Scratch (description textuelle) :
• `quand le drapeau vert est cliqué`
• `effacer tout` (pour nettoyer la scène avant de dessiner)
• `aller à x: (0) y: (0)` (pour commencer au centre)
• `s'orienter à 90` (pour commencer à regarder vers la droite)
• `abaisser le stylo`
• `répéter 4 fois`
• `avancer de 100 pas`
• `tourner de 90 degrés` (vers la droite, bloc `tourner sens horaire`)

Erreurs fréquentes
Boucle infinie : Utiliser `répéter indéfiniment` sans condition d'arrêt peut bloquer le programme. Il faut savoir quand la boucle doit s'arrêter.
Nombre de répétitions incorrect : Si le nombre de répétitions est faux, le dessin sera incomplet ou incorrect (par exemple, répéter 3 fois pour un carré).
Instructions mal placées : Mettre des instructions qui ne doivent pas être répétées à l'intérieur de la boucle, ou inversement.

3. Les tests (conditions)

Un test (ou condition) est une structure de contrôle qui permet au programme de prendre des décisions. Il exécute un bloc d'instructions seulement si une certaine condition est vraie. Sinon, il peut exécuter un autre bloc d'instructions ou ne rien faire. Dans Scratch, on utilise les blocs `si ... alors` et `si ... alors ... sinon`.

Méthode
Identifier la décision à prendre : Déterminer à quel moment le programme doit faire un choix en fonction d'une situation.
Formuler la condition : Écrire la condition qui doit être vraie pour que l'action se produise. Les conditions utilisent des opérateurs de comparaison (comme $<$, $>$, $=$, $\neq$) et des opérateurs logiques (comme `et`, `ou`, `non`).
Choisir le bon bloc Scratch :
Utiliser `si [condition] alors` si des actions doivent être faites seulement* si la condition est vraie.
• Utiliser `si [condition] alors ... sinon` si des actions différentes doivent être faites selon que la condition est vraie ou fausse.
Placer les instructions : Mettre les blocs d'instructions à exécuter dans la partie `alors` et/ou `sinon` du test.

Exemple
Écrire un programme Scratch qui demande un nombre à l'utilisateur et indique si ce nombre est positif ou négatif (ou nul).

Corrigé pas à pas
Voici l'algorithme :
1. Demander à l'utilisateur un nombre.
2. Stocker ce nombre dans une variable appelée `mon_nombre`.
3. Si `mon_nombre` est supérieur à 0, alors afficher "Le nombre est positif."
4. Sinon (si `mon_nombre` n'est pas supérieur à 0) :
a. Si `mon_nombre` est égal à 0, alors afficher "Le nombre est nul."
b. Sinon (si `mon_nombre` n'est ni supérieur à 0, ni égal à 0), afficher "Le nombre est négatif."

Traduction en blocs Scratch (description textuelle) :
• `quand le drapeau vert est cliqué`
• `demander Entrez un nombre : et attendre`
• `mettre [mon_nombre] à (réponse)`
• `si <(mon_nombre) > 0> alors`
• `dire Le nombre est positif. pendant 2 secondes`
• `sinon`
• `si <(mon_nombre) = 0> alors`
• `dire Le nombre est nul. pendant 2 secondes`
• `sinon`
• `dire Le nombre est négatif. pendant 2 secondes`

Erreurs fréquentes
Condition mal formulée : Une condition doit être précise et sans ambiguïté. Par exemple, pour vérifier si un nombre est entre 0 et 10, il faut utiliser `<(nombre > 0) et (nombre < 10)>` et non juste `(nombre > 0 et < 10)`.
Oublier le cas 'sinon' : Parfois, il est important de prévoir ce qui se passe si la condition n'est pas remplie, même si aucune action spécifique n'est requise.
Conditions imbriquées complexes : Trop de `si ... alors ... sinon` imbriqués peuvent rendre le programme difficile à lire et à déboguer. Il faut essayer de simplifier les conditions si possible.

Utiliser une variable pour stocker une valeur

1. 1. Créer la variable : Dans la catégorie "Variables" de Scratch, cliquez sur "Créer une variable". Donnez-lui un nom clair, par exemple `compteur` ou `taille_cote`.
2. 2. Initialiser la variable : Au début du programme (souvent sous le bloc `quand le drapeau vert est cliqué`), utilisez le bloc `mettre [nom_de_la_variable] à [valeur]` pour lui donner une valeur de départ. Par exemple, `mettre [compteur] à 0`.
3. 3. Modifier la variable : Pendant l'exécution du programme, utilisez le bloc `mettre [nom_de_la_variable] à [nouvelle_valeur]` pour lui attribuer une nouvelle valeur, ou `ajouter [valeur] à [nom_de_la_variable]` pour augmenter ou diminuer sa valeur (par exemple, `ajouter 1 à [compteur]` pour l'incrémenter).

Exemple
Stocker le résultat d'un calcul (par exemple $2 \times 3 + 4$) dans une variable `resultat` et l'afficher.

Corrigé pas à pas
1. Créer une variable nommée `resultat`.
2. `quand le drapeau vert est cliqué`
3. `mettre [resultat] à ((2 * 3) + 4)`
4. `dire (resultat) pendant 2 secondes`

Après exécution, le lutin affichera `10`.

Créer une boucle pour répéter des actions

1. 1. Identifier les actions à répéter : Déterminez quels blocs d'instructions doivent être exécutés plusieurs fois.
2. 2. Déterminer le nombre de répétitions : Comptez combien de fois ces actions doivent être faites. Si le nombre est fixe, c'est le plus simple pour commencer.
3. 3. Utiliser le bloc `répéter ... fois` : Glissez le bloc `répéter [nombre] fois` depuis la catégorie "Contrôle".
4. 4. Placer les instructions : Insérez les blocs d'instructions identifiés à l'étape 1 à l'intérieur du bloc `répéter ... fois`.

Exemple
Faire dire "Bonjour !" au lutin 5 fois de suite.

Corrigé pas à pas
1. Identifier l'action : `dire Bonjour !`
2. Nombre de répétitions : 5 fois.
3. `quand le drapeau vert est cliqué`
4. `répéter 5 fois`
• `dire Bonjour ! pendant 1 seconde`

Le lutin dira "Bonjour !" cinq fois, avec une seconde d'attente entre chaque.

Mettre en place un test pour prendre une décision

1. 1. Identifier la condition : Déterminez la question à laquelle le programme doit répondre (par exemple, "Est-ce que le nombre est plus grand que 10 ?").
2. 2. Choisir le bloc de test :
   Si une action doit être faite seulement* si la condition est vraie, utilisez `si [condition] alors`.
   Si une action doit être faite si la condition est vraie, et une autre* action si elle est fausse, utilisez `si [condition] alors ... sinon`.
3. 3. Construire la condition : Dans la catégorie "Opérateurs", utilisez des blocs de comparaison (comme `< >`, `< = >`, `< =>`) et des variables ou des nombres pour former la condition logique (qui sera Vrai ou Faux). Par exemple, `(nombre) > 10`.
4. 4. Placer les actions : Insérez les blocs d'instructions à exécuter dans la section `alors` (et `sinon` si vous avez choisi ce bloc).

Exemple
Demander un nombre. Si ce nombre est supérieur à 10, le lutin doit dire "C'est un grand nombre !". Sinon, il doit dire "C'est un petit nombre."

Corrigé pas à pas
1. Condition : Le nombre est-il supérieur à 10 ?
2. Bloc de test : `si ... alors ... sinon`.
3. `quand le drapeau vert est cliqué`
4. `demander Entrez un nombre : et attendre`
5. `mettre [nombre_saisi] à (réponse)`
6. `si <(nombre_saisi) > 10> alors`
• `dire C'est un grand nombre ! pendant 2 secondes`
7. `sinon`
• `dire C'est un petit nombre. pendant 2 secondes`

Vocabulaire essentiel

• Algorithme : Suite d'instructions pour résoudre un problème.
• Programme : Traduction d'un algorithme dans un langage de programmation (ex: Scratch).
• Variable : Espace de stockage pour une valeur qui peut changer (nombre, texte, etc.).

Blocs Scratch clés

• Variables :
  • `mettre [ma_variable] à [valeur]` : attribue une valeur à la variable.
  • `ajouter [valeur] à [ma_variable]` : modifie la valeur de la variable.
• Boucles :
  • `répéter [nombre] fois` : exécute les blocs internes le nombre de fois indiqué.
• Tests (conditions) :
  • `si [condition] alors` : exécute les blocs internes si la condition est vraie.
  • `si [condition] alors ... sinon` : exécute les premiers blocs si la condition est vraie, les seconds sinon.
• Opérateurs :
  • Comparaison : `< >` (plus grand que), `< = >` (égal à), `< < >` (plus petit que).
  • Logiques : `et`, `ou`, `non` (pour combiner ou inverser des conditions).
  Arithmétiques : `+`, `-`, ``, `/`, `mod` (modulo, donne le reste d'une division).