Algorithmique et programmation

Qu'est-ce qu'un programme ? La séquence

Un ordinateur ne fait rien de lui-même. Il exécute des ordres précis, qu'on appelle des instructions.

Dans Scratch, chaque instruction est un bloc que l'on empile. Le lutin lit les blocs du haut vers le bas et obéit à chacun, dans l'ordre.

L'ordre des instructions compte

Salma pense souvent que « du moment qu'on met toutes les bonnes instructions, peu importe l'ordre ». C'est faux. Un programme n'est pas une liste de courses : c'est une séquence. Changer l'ordre change le résultat.

Se déplacer dans le repère : la scène Scratch

Le lutin se déplace sur la scène. Et cette scène n'est pas un espace flou : c'est un repère, exactement comme celui que tu as étudié en repérage dans l'espace.

Deux façons de déplacer le lutin

On peut déplacer le lutin de deux manières :

• par déplacement relatif : « avancer de 100 pas » (il avance dans la direction où il regarde), « tourner de 90 degrés » (il pivote) ;
• par déplacement absolu : « aller à $x:100$, $y:50$ » (il saute directement à ce point du repère).

Exemple guidé — dessiner un carré. Un carré a 4 côtés égaux et 4 angles droits. Pour chaque côté, on avance, puis on tourne d'un quart de tour ($90\mathrm{°}$) :

avancer de 100 pas, tourner de 90° avancer de 100 pas, tourner de 90° avancer de 100 pas, tourner de 90° avancer de 100 pas, tourner de 90°

Quatre fois le même geste, et le lutin revient à son point de départ, orienté comme au début.

Le piège des angles

Karim oublie souvent que tourner de $90\mathrm{°}$ quatre fois fait un tour complet ($4\times 90\mathrm{°}=360\mathrm{°}$), ce qui ramène le lutin à son orientation initiale. C'est ce qui « ferme » le carré. Si tu tournes de $90\mathrm{°}$ seulement trois fois, la figure reste ouverte.

Répéter : les boucles

Pour dessiner le carré, tu as écrit quatre fois la même paire d'instructions. C'est long, et c'est une source d'erreurs. Les programmes offrent un outil pour ça : la boucle.

Le carré devient alors bien plus court :

Pourquoi la boucle est précieuse

Au-delà de l'économie d'écriture, la boucle rend le programme lisible et modifiable : pour dessiner un octogone (8 côtés), tu changes simplement « répéter 4 fois » en « répéter 8 fois » et l'angle. Sans boucle, il faudrait tout réécrire.

On peut représenter une boucle par un organigramme : un schéma qui montre le chemin suivi par le programme, avec un retour en arrière tant qu'il reste des répétitions à faire.

Le piège du nombre de répétitions

Salma se trompe souvent sur le nombre de tours. Pour un carré, c'est 4 répétitions (un côté + un virage, quatre fois), pas 3. Compte toujours le nombre de fois où le geste complet doit se produire.

Choisir : les instructions conditionnelles

Jusqu'ici, le lutin exécute toujours les mêmes blocs. Mais un vrai programme doit pouvoir réagir selon la situation. C'est le rôle de la condition.

Si… sinon

On peut aussi prévoir une action dans les deux cas, avec « si… sinon… » : une chose si la condition est vraie, une autre si elle est fausse. Par exemple : « si le score atteint 10, alors afficher gagné, sinon continuer ». En 5ᵉ, l'essentiel est de bien maîtriser le « si… alors » simple ; le « si… sinon » est une extension naturelle que tu approfondiras les années suivantes.

Le piège : condition n'est pas action

Karim mélange parfois la condition (le test : est-ce que le lutin touche le bord ?) et l'action (ce qu'on fait : tourner). Retiens la structure : on teste d'abord (vrai ou faux ?), on agit ensuite, et seulement si le test est vrai.

Retenir une information : les variables

Pour compter les points d'un jeu, le programme doit mémoriser un nombre qui change au fil du temps. C'est le rôle d'une variable.

On manipule une variable en trois temps : on la crée (on lui donne un nom, par exemple score), on l'initialise (on fixe sa valeur de départ, souvent 0), puis on la modifie (on change sa valeur).

Deux pièges sur les variables

D'abord, l'initialisation. Salma croit parfois qu'une variable « part toute seule de 0 ». Non : tant que tu n'as pas écrit « mettre score à 0 », sa valeur de départ n'est pas garantie. On initialise toujours une variable avant de l'utiliser.

Ensuite, la mise à jour. Une fois qu'on a fait « ajouter 1 à score », la variable ne revient pas à sa valeur de départ : elle garde sa nouvelle valeur. Une variable retient la dernière valeur qu'on lui a donnée.

Pièges classiques

1. Croire que l'ordre des instructions n'a pas d'importance. Un programme est une séquence : « avancer puis tourner » ne donne pas le même résultat que « tourner puis avancer ». L'ordre fait partie du sens.

2. Se tromper sur l'angle d'un virage. Pour fermer un carré, on tourne de $90\mathrm{°}$ à chaque coin, et $4\times 90\mathrm{°}=360\mathrm{°}$ ramène à l'orientation de départ. Confondre « tourner de $90\mathrm{°}$ » avec un autre angle déforme la figure.

3. Mal compter les répétitions d'une boucle. Un carré, c'est « répéter 4 fois », pas 3 : un côté plus un virage, quatre fois. Compte le nombre de fois où le geste complet doit se produire.

4. Confondre la condition et l'action. Dans « si (condition) alors (action) », la condition est un test qui vaut vrai ou faux ; l'action est ce qu'on exécute. Ce sont deux choses distinctes : on teste, puis on agit si c'est vrai.

5. Oublier d'initialiser une variable. Une variable ne part pas magiquement de 0. Tant qu'on n'a pas écrit « mettre score à 0 », sa valeur de départ n'est pas fixée. On initialise toujours avant d'utiliser.

6. Croire qu'une variable garde sa valeur de départ. Après « ajouter 1 à score », la variable vaut sa nouvelle valeur, pas l'ancienne. Une variable retient sa dernière mise à jour.

Application concrète

Yasmine termine son petit jeu sur Scratch. Le lutin doit parcourir un carré, gagner un point à chaque tour, et afficher « gagné » quand il a fait les quatre côtés. Décomposons son programme.

Étape 1 — Initialiser le score (variable).

Avant tout, elle crée la variable score et la met à 0 :

mettre score à 0

Étape 2 — Parcourir le carré (boucle + déplacement).

Elle utilise une boucle pour les quatre côtés, et à chaque côté elle ajoute un point :

répéter 4 fois : avancer de 100 pas tourner de 90 degrés ajouter 1 à score

Après les quatre tours de boucle, le lutin a tracé son carré et score vaut 4.

Étape 3 — Réagir avec une condition.

À la fin, elle teste le score :

si (score = 4) alors : dire « gagné »

Comme score vaut bien 4, la condition est vraie, et le lutin affiche « gagné ».

Étape 4 — Corriger l'erreur de Karim.

Karim avait écrit un programme presque identique, mais il avait oublié d'initialiser score au début. Résultat : impossible de savoir de quelle valeur le compteur partait, et le test « score = 4 » devenait imprévisible. Yasmine ajoute la ligne « mettre score à 0 » tout en haut, et tout fonctionne.

Conclusion. En cinq notions — séquence, déplacement, boucle, condition, variable — Yasmine a construit un programme complet et fonctionnel. Ces briques ne sont pas propres à Scratch : tu les retrouveras dans tous les langages de programmation, au lycée avec Python, et bien au-delà. Programmer, c'est apprendre à décomposer une intention en instructions claires que la machine exécutera fidèlement.

À retenir