Algorithmique et programmation

Algorithmes et instructions : la séquence

Un ordinateur n'invente rien. Il suit des ordres qu'on lui donne, un par un, dans l'ordre exact où ils sont écrits.

Dans Scratch, chaque instruction est un bloc coloré que l'on empile. Le lutin lit les blocs de haut en bas et obéit à chacun, l'un après l'autre.

Exemple 1. Pour faire dessiner un côté d'un carré au lutin :

stylo en position d'écriture
avancer de 100 pas
tourner de 90 degrés

Le lutin pose le stylo, trace un trait de 100 pas, puis pivote d'un quart de tour. Ce sont trois instructions exécutées dans cet ordre précis.

Exemple 2. Pour tracer un carré complet à la main (sans boucle encore), on enchaîne les mêmes gestes quatre fois :

stylo en position d'écriture
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés
avancer de 100 pas
tourner de 90 degrés

Quatre fois le même geste : le lutin trace un carré et revient à son point de départ, orienté dans la même direction qu'au début (car $4\times 90\mathrm{°}=360\mathrm{°}$, un tour complet).

Méthode (exécution pas à pas). Pour comprendre ce que fait un programme, joue toi-même le rôle du lutin : lis les instructions une par une, de haut en bas, et applique chacune strictement. C'est la trace d'exécution. Ne jamais sauter d'étape, ne jamais anticiper.

Le piège de l'ordre

Karim pense que « du moment qu'on met les bonnes instructions, peu importe l'ordre ». Faux. Un programme est une séquence : changer l'ordre change le résultat.

Compare :

avancer de 100 pas
tourner de 90 degrés

versus :

tourner de 90 degrés
avancer de 100 pas

Dans le premier cas, le lutin avance puis tourne. Dans le second, il tourne d'abord, et avance ensuite dans une direction différente. Mêmes blocs, ordre différent, tracé différent.

Les variables

Pour compter les carrés du motif de zellige, le programme doit retenir un nombre qui change au fil du temps. Les variables sont faites pour ça.

On manipule une variable en trois opérations fondamentales.

Méthode (les trois opérations sur une variable).

• Créer : déclarer la variable en lui donnant un nom dans Scratch (menu « Variables »).
• Initialiser : fixer sa valeur de départ avant de l'utiliser. En Scratch : « mettre [compteur] à 0 ». Ne jamais utiliser une variable avant de l'initialiser.
• Modifier : changer sa valeur en cours d'exécution. En Scratch : « mettre [compteur] à 5 » (affectation directe) ou « ajouter 1 à [compteur] » (incrémentation).

Exemple 1. Un compteur qui compte jusqu'à 3 :

mettre [compteur] à 0
ajouter 1 à [compteur]
ajouter 1 à [compteur]
ajouter 1 à [compteur]

Trace d'exécution : après la ligne 1, compteur vaut 0. Après la ligne 2, il vaut 1. Après la ligne 3, il vaut 2. Après la ligne 4, il vaut 3.

Exemple 2. Stocker la longueur d'un côté, puis la doubler :

mettre [cote] à 50
mettre [cote] à (cote) × 2

Après la ligne 1, cote vaut 50. Après la ligne 2, cote vaut 100. La variable a été remplacée par sa nouvelle valeur.

Affectation ≠ égalité mathématique

Salma lit l'instruction « mettre [x] à (x) + 1 » et dit : « Mais $x=x+1$, c'est impossible en maths ! ». Elle confond deux choses très différentes.

En mathématiques, $x=x+1$ est une équation qui n'a pas de solution.

En programmation, « mettre [x] à (x) + 1 » est une affectation : on lit l'ancienne valeur de x, on lui ajoute 1, et on range le résultat dans x. C'est une opération sur une boîte, pas une égalité entre deux expressions. Après cette instruction, la boîte contient une valeur d'une unité de plus qu'avant.

Les boucles

Dans l'exemple du carré, les mêmes deux instructions sont répétées quatre fois. Réécrire quatre fois la même paire de blocs est long et source d'erreurs. Les boucles permettent d'éviter cette répétition.

La boucle « répéter n fois »

C'est la plus simple. On sait à l'avance combien de fois on veut répéter.

Exemple 1. Le carré avec une boucle :

stylo en position d'écriture
répéter 4 fois :
  avancer de 100 pas
  tourner de 90 degrés

Ces 4 lignes font exactement la même chose que les 9 lignes de la séquence précédente. La boucle les remplace de façon plus concise et plus lisible.

Exemple 2. Un hexagone régulier (6 côtés, angle extérieur $60\mathrm{°}$) :

répéter 6 fois :
  avancer de 80 pas
  tourner de 60 degrés

Pour changer de polygone, on ne modifie que le nombre de répétitions et l'angle — le reste du code ne change pas.

La boucle « tant que »

On ne sait pas toujours à l'avance combien de répétitions il faudra. La boucle « tant que » s'adapte.

Exemple 3. Le lutin avance jusqu'à toucher le bord :

répéter jusqu'à ce que (le lutin touche le bord) :
  avancer de 10 pas

On ne sait pas à l'avance combien de pas il faudra pour toucher le bord : ça dépend de la position initiale. La boucle « tant que » gère cette incertitude.

Exemple 4. Compter en s'arrêtant quand compteur atteint 5 :

mettre [compteur] à 0
répéter jusqu'à ce que (compteur) = 5 :
  ajouter 1 à [compteur]

Trace d'exécution : compteur vaut 0, puis 1, 2, 3, 4, et au début du 5ᵉ tour la condition « compteur = 5 » est fausse (car compteur vaut 4), donc on entre encore dans la boucle, on ajoute 1 : compteur vaut 5. Au début du tour suivant, la condition est vraie, on sort. Résultat final : compteur vaut 5.

Le piège de l'erreur de un (off-by-one)

Amine veut dessiner un carré. Il écrit « répéter 3 fois » au lieu de « répéter 4 fois ». Le lutin trace seulement 3 côtés : la figure reste ouverte. Ce type d'erreur — se tromper de 1 dans le nombre de répétitions — est si courant qu'il a un nom : l'erreur de un (en anglais : off-by-one). Avant de lancer, demande-toi : combien de fois le geste complet doit-il se produire ?

Les instructions conditionnelles

Jusqu'ici, le lutin exécute toujours les mêmes blocs. Mais un programme intelligent doit réagir selon la situation : afficher « gagné » si le score est suffisant, rebondir si le bord est touché, changer de couleur si le compteur est impair. C'est le rôle des conditions.

si (condition) alors :
  [instructions A]

si (condition) alors :
  [instructions A]
sinon :
  [instructions B]

Dans la forme « si… alors… sinon », si la condition est vraie, le programme exécute A ; si elle est fausse, il exécute B. Les instructions A et B s'excluent mutuellement.

Exemple 1. Faire rebondir le lutin sur le bord :

si (le lutin touche le bord) alors :
  tourner de 180 degrés

Tant que le lutin ne touche pas le bord, rien ne se passe. Dès qu'il le touche, la condition est vraie et il fait demi-tour.

Exemple 2. Afficher le résultat d'un score :

si (score) > 10 alors :
  dire « Bien joué »
sinon :
  dire « Continue d'essayer »

Exemple 3. Combiner boucle et condition — le lutin avance en rebondissant :

répéter 20 fois :
  avancer de 15 pas
  si (le lutin touche le bord) alors :
    tourner de 180 degrés

La boucle répète 20 fois le geste (avancer, puis éventuellement rebondir). C'est la combinaison boucle + condition qui donne vie aux comportements complexes.

Combiner les conditions : les comparaisons

Une condition peut utiliser des comparaisons ($=$, $>$, $<$, $\ge$, $\le$, $\mathrm{\ne }$) ou des opérateurs logiques (« et », « ou », « non »).

Exemple 4. Tester si une valeur est entre deux bornes :

si (x) > 0 et (x) < 10 alors :
  dire « x est entre 0 et 10 »

Le piège : la condition n'est pas l'action

Karim confond la condition (le test, ce qu'on évalue) et l'action (ce qu'on exécute si c'est vrai). La structure est toujours : on teste d'abord (vrai ou faux ?), puis on agit selon le résultat. La condition « le lutin touche le bord » est un test ; « tourner de 180 degrés » est l'action. Les deux sont des choses distinctes.

Pièges classiques

1. Croire que l'ordre des instructions n'a pas d'importance. Un programme est une séquence : « avancer de 100 puis tourner de 90° » ne trace pas la même chose que « tourner de 90° puis avancer de 100 ». L'ordre est fondamental.

2. Confondre affectation et égalité mathématique. « Mettre [x] à (x) + 1 » n'est pas l'équation $x=x+1$ : c'est une opération sur une boîte. On lit l'ancienne valeur, on lui ajoute 1, et on range le résultat. L'affectation remplace la valeur précédente.

3. Oublier d'initialiser une variable. Une variable ne part pas de 0 toute seule. Tant qu'on n'a pas écrit « mettre [compteur] à 0 », sa valeur de départ est inconnue. Toujours initialiser avant d'utiliser.

4. Erreur de un dans une boucle (off-by-one). « Répéter 3 fois » au lieu de « répéter 4 fois » laisse le carré ouvert. Compte le nombre exact de fois que le geste complet doit se produire.

5. Confondre la condition et l'action dans un « si ». La condition est un test (vrai ou faux) ; l'action est l'instruction exécutée si ce test est vrai. Ce sont deux rôles distincts dans la structure conditionnelle.

6. Croire qu'une boucle « tant que » s'exécute toujours au moins une fois. Si la condition est déjà vraie avant d'entrer dans la boucle, on n'exécute pas le corps une seule fois : on sort immédiatement (en Scratch, « répéter jusqu'à ce que » fonctionne ainsi). Toujours vérifier la valeur initiale avant la boucle.

Application concrète

Yasmine veut programmer un motif de zellige sur Scratch : le lutin doit dessiner plusieurs carrés de taille décroissante, compter le nombre de carrés tracés, et s'arrêter automatiquement quand il en a dessiné 4.

Étape 1 — Initialiser les variables.

Yasmine crée deux variables : compteur (pour compter les carrés) et cote (pour la longueur du côté). Elle les initialise avant tout dessin :

mettre [compteur] à 0
mettre [cote] à 100

Étape 2 — La boucle principale (« tant que »).

Elle veut dessiner des carrés tant que compteur est inférieur à 4 :

répéter jusqu'à ce que (compteur) = 4 :
  [dessiner un carré de côté (cote)]
  ajouter 1 à [compteur]
  mettre [cote] à (cote) - 20

À chaque tour, elle dessine un carré, incrémente le compteur, et réduit le côté de 20 pas.

Étape 3 — La sous-boucle : dessiner un carré (boucle « répéter 4 fois »).

Le bloc « dessiner un carré » est lui-même une boucle :

stylo en position d'écriture
répéter 4 fois :
  avancer de (cote) pas
  tourner de 90 degrés
relever le stylo

La boucle imbriquée s'exécute 4 fois à l'intérieur de chaque tour de la boucle principale.

Étape 4 — Condition de fin avec message.

À la sortie de la boucle principale :

si (compteur) = 4 alors :
  dire « Motif terminé ! »

Étape 5 — Trace d'exécution complète.

Au début du 5ᵉ tour, compteur vaut 4 : la condition « compteur = 4 » est vraie, on sort de la boucle. La condition finale est vraie, le lutin dit « Motif terminé ! ».

Erreur de Karim corrigée. Karim avait oublié d'écrire « mettre [compteur] à 0 » au début. Résultat : la valeur initiale de compteur était inconnue, et la boucle « tant que » pouvait s'arrêter immédiatement ou ne jamais s'arrêter. Avec l'initialisation, tout est prévisible.

Conclusion. Avec ces quatre briques — séquence, variable, boucle, condition — Yasmine a construit un programme non trivial : boucle imbriquée, variable qui évolue, condition de sortie. Ces structures ne sont pas propres à Scratch : en 2nde, tu les retrouveras mot pour mot en Python, sous une syntaxe différente mais une logique identique. Programmer, c'est apprendre à décomposer une intention en instructions claires ; cette compétence se transfère à tous les langages.

À retenir