La programmation et les algorithmes

Un algorithme est une série d'instructions claires et précises, organisées dans un ordre logique, qui permet de résoudre un problème ou d'accomplir une tâche. C'est un peu comme une recette de cuisine : si vous suivez toutes les étapes dans le bon ordre, vous obtenez le plat désiré.

• Une recette de cuisine : "Prendre 2 œufs, casser dans un bol, ajouter 100g de farine, mélanger..." Chaque étape est une instruction.
• Un itinéraire : "Sortir de chez toi, tourner à droite, marcher 200m, traverser le pont..." C'est une séquence d'instructions pour aller d'un point A à un point B.
• Monter un meuble : Le manuel d'instructions est un algorithme.

Un algorithme est toujours une séquence d'instructions.

Pour qu'un algorithme soit efficace et utile, il doit avoir certaines qualités :

1. Précision des instructions : Chaque étape doit être claire et ne laisser aucune place à l'interprétation. Par exemple, "couper les légumes" n'est pas précis, mais "couper les carottes en rondelles de 2 mm d'épaisseur" l'est.
2. Ordre des étapes : Les instructions doivent être exécutées dans un ordre spécifique. Changer l'ordre peut changer le résultat (imaginez mettre le gâteau au four avant d'ajouter la farine !).
3. Finitude : Un algorithme doit toujours se terminer après un nombre fini d'étapes. Il ne doit pas être une boucle infinie sans fin.

Un bon algorithme est clair, ordonné et se termine toujours.

Les ordinateurs sont des machines puissantes, mais ils ne "pensent" pas. Ils exécutent simplement les instructions qu'on leur donne. Ces instructions sont des algorithmes !

• Comment les ordinateurs suivent des algorithmes : Un programme informatique est un algorithme écrit dans un langage que l'ordinateur comprend. L'ordinateur lit chaque instruction et l'exécute.
• Le rôle de l'humain dans la création : C'est nous, les humains, qui créons les algorithmes. Nous réfléchissons à la manière de résoudre un problème, puis nous traduisons cette solution en une série d'étapes pour l'ordinateur.
• Langage compréhensible par la machine : Les ordinateurs ne comprennent pas le français. Il faut donc traduire nos algorithmes dans un langage de programmation que la machine peut exécuter.

C'est la manière la plus simple de commencer : écrire les instructions en utilisant notre langue de tous les jours, le français.

Exemple : Algorithme pour allumer une lampe

1. Me diriger vers la lampe.
2. Vérifier si le bouton est en position "arrêt".
3. Si oui, appuyer sur le bouton "marche".
4. Si non, la lampe est déjà allumée.

• Clarté et simplicité : C'est facile à comprendre pour un humain.
• Limites du langage naturel : Il peut y avoir des ambiguïtés. Par exemple, "appuyer sur le bouton" peut vouloir dire le pousser, le tourner... Un ordinateur a besoin de plus de précision. De plus, il est difficile de représenter des choix ou des répétitions de manière structurée.

Les organigrammes sont des représentations graphiques d'un algorithme. Ils utilisent des symboles standardisés pour montrer les différentes étapes et l'ordre d'exécution.

Exemple simple : Allumer une lampe

  DÉBUT
    |
    v
  [Me diriger vers la lampe]
    |
    v
  [Vérifier l'état du bouton]
    |
    v
(Lampe éteinte ?) -- (Oui) --> [Appuyer sur le bouton "marche"]
    |                                   |
  (Non)                                 |
    |                                   v
    +----------------------------------> FIN

• Représentation visuelle : Très utile pour visualiser le déroulement et les branchements.
• Séquence et direction : Les flèches montrent clairement l'ordre.

Le pseudo-code est une façon d'écrire un algorithme qui ressemble à un langage de programmation, mais en utilisant des mots simples et compréhensibles par un humain. C'est une étape intermédiaire entre le langage naturel et un vrai langage de programmation.

Exemple : Algorithme pour allumer une lampe en pseudo-code

DEBUT
  ALLER_A_LA_LAMPE
  SI LAMPE_EST_ETEINTE ALORS
    APPUYER_BOUTON_MARCHE
  FIN SI
FIN

• Écriture structurée : Utilise des mots-clés comme SI... ALORS... FIN SI, RÉPÉTER... FIN RÉPÉTER pour structurer l'algorithme.
• Passerelle vers la programmation : Il est plus facile de traduire du pseudo-code en un langage de programmation que du langage naturel.

• Définition et principe : Au lieu d'écrire du code textuel, on utilise des "blocs" qui représentent des instructions. On les glisse et on les emboîte les uns dans les autres pour construire un programme.
• Environnements visuels : Des plateformes comme Scratch (très populaire en 6ème) ou Blockly utilisent ce principe.
• Facilité d'apprentissage : C'est une excellente façon de commencer car elle évite les erreurs de syntaxe (fautes de frappe) et permet de se concentrer sur la logique de l'algorithme.

Prenons l'exemple de Scratch :

1. Palette de blocs : C'est là que l'on trouve tous les blocs d'instructions, classés par catégories (Mouvement, Apparence, Son, Événements, Contrôle, etc.).
2. Zone de script : C'est l'espace central où l'on assemble les blocs pour créer le programme.
3. Zone d'exécution / Scène : C'est la zone où l'on voit le résultat du programme, avec les personnages (appelés "sprites") et l'arrière-plan.
4. Liste des sprites / Arrière-plans : Pour gérer les différents éléments graphiques.

Dans Scratch, un personnage est appelé un sprite. Le plus souvent, c'est le chat Scratch.

Pour le déplacer :

• On utilise des blocs de mouvement (catégorie "Mouvement").
• Le plan de la scène est un repère avec des coordonnées (x, y). $x$ représente la position horizontale et $y$ la position verticale. Le centre est $(0,0)$.
  • aller à x: (0) y: (0) : place le sprite au centre.
  • avancer de (10) pas : déplace le sprite dans la direction où il est orienté.
  • ajouter (10) à x : déplace le sprite de 10 unités vers la droite.

quand (drapeau vert) est cliqué
  aller à x:(0) y:(0)
  avancer de (100) pas

Ce programme déplacera le chat de 100 pas depuis le centre, après avoir cliqué sur le drapeau vert.

La base de tout programme est la séquence d'instructions. C'est simplement l'ordre dans lequel les blocs sont exécutés.

• Ordre d'exécution des blocs : Les blocs sont exécutés du haut vers le bas, un par un.
• Exécution linéaire : Sauf indication contraire (comme des boucles ou des conditions), le programme suit un chemin droit.
• Importance de l'ordre : L'ordre est crucial. Inverser deux blocs peut complètement changer le comportement du programme. Par exemple, "lever le bras" puis "sauter" n'est pas la même chose que "sauter" puis "lever le bras".

Un programme doit souvent répéter plusieurs fois la même action. Pour éviter de copier-coller les mêmes blocs, on utilise les boucles.

• Répéter un ensemble d'instructions : Une boucle permet d'exécuter plusieurs fois une série de blocs.
• Bloc 'répéter X fois' : Dans Scratch, le bloc répéter (10) fois est très courant. Il exécute les blocs à l'intérieur 10 fois.

  quand (drapeau vert) est cliqué
    répéter (4) fois
      avancer de (100) pas
      tourner (90) degrés (sens horaire)
    fin répéter
  

  Ce script fera dessiner un carré au sprite.
• Optimisation du code : Les boucles rendent le code plus court, plus propre et plus facile à modifier.

Les programmes doivent souvent prendre des décisions en fonction de certaines situations. C'est le rôle des conditions.

• Bloc 'si... alors...' : Ce bloc permet d'exécuter des instructions seulement si une certaine condition est vraie.

  si (touche [espace] pressée ?) alors
    dire [Bonjour !] pendant (2) secondes
  fin si
  

  Ici, le personnage ne dit "Bonjour !" que si la touche "espace" est pressée.
• Prise de décision : Les conditions permettent au programme de réagir différemment selon les événements ou les données.
• Réagir à des événements : On peut aussi avoir un bloc si... alors... sinon... pour faire une action si la condition est vraie, et une autre action si elle est fausse.

Les événements sont des actions qui déclenchent l'exécution d'une partie du programme.

• Déclencheurs : Ce sont les blocs "quand..." de Scratch.
  • quand (drapeau vert) est cliqué : démarre le programme.
  • quand touche [espace] est pressée : réagit à la pression d'une touche.
  • quand ce sprite est cliqué : réagit au clic de la souris sur le personnage.
• Interactions utilisateur : Les événements permettent au programme de répondre aux actions de l'utilisateur.
• Réponse du programme : Chaque événement peut déclencher un script différent, rendant le programme dynamique.

Pour rendre un programme plus vivant et amusant, on peut modifier l'apparence des sprites et ajouter des sons.

• Changer de costume/apparence : Les sprites peuvent avoir plusieurs "costumes" (images différentes). Le bloc basculer sur le costume [costume2] permet de les changer, créant une animation.
• Jouer des sons : On peut ajouter des sons (jouer le son [miaou]) ou des musiques (démarrer le son [musique]).
• Rendre le programme plus vivant : Ces éléments graphiques et sonores améliorent l'expérience utilisateur.

Pour des programmes plus complexes, on a besoin de stocker des informations et de "sentir" l'environnement.

• Variables : Une variable est comme une petite boîte dans laquelle on peut stocker une information (un nombre, un mot...). Par exemple, un score de jeu, le nom d'un joueur.
  • mettre [score] à (0) : initialise la variable.
  • ajouter (1) à [score] : augmente le score.
• Capteurs : Les capteurs permettent au programme de détecter des choses dans son environnement, comme la position de la souris, si un sprite touche un autre, ou une couleur.
  • souris x et souris y : donnent la position de la souris.
  • [couleur #FF0000] est touchée ? : détecte si une couleur est touchée.
  • [sprite2] est touché ? : détecte si deux sprites se touchent.
• Programmes plus complexes : Les variables et les capteurs sont essentiels pour créer des jeux interactifs et des simulations.

• Qu'est-ce qu'un bug ? Un bug est une erreur dans le programme qui l'empêche de fonctionner comme prévu. Cela peut être une erreur de logique, un bloc mal placé, une valeur incorrecte.
• Observer le comportement du programme : La première étape est de bien regarder ce que fait le programme et de comparer avec ce qu'il devrait faire. Est-ce qu'il ne se déplace pas ? Est-ce qu'il ne dit pas la bonne chose ?
• Messages d'erreur simples : Dans la programmation par blocs, il y a rarement des messages d'erreur complexes, mais le programme peut simplement ne rien faire ou faire quelque chose d'inattendu.

Quand un programme ne marche pas, voici quelques astuces :

1. Tester étape par étape : Exécutez de petites parties de votre programme. Si vous avez un long script, essayez de le tester bloc par bloc, ou en retirant temporairement des parties pour voir d'où vient le problème.
2. Vérifier l'ordre des blocs : L'ordre est très important ! Assurez-vous que les blocs sont emboîtés dans la bonne séquence.
3. Vérifier les valeurs : Avez-vous mis le bon nombre de pas, la bonne direction, la bonne condition ? Regardez les valeurs des variables.
4. Modifier et re-tester : C'est un cycle. Changez une petite chose, puis relancez le programme pour voir si le problème est résolu. La persévérance est la clé du débogage !

Une fois que le programme fonctionne, on peut toujours l'améliorer :

• Rendre le code plus clair : Bien organiser ses blocs, ajouter des commentaires (si le logiciel le permet) pour expliquer ce que fait chaque partie.
• Ajouter des fonctionnalités : Pensez à de nouvelles idées ! Que pourrait faire d'autre votre personnage ? Comment rendre le jeu plus intéressant ?
• Partager et obtenir des retours : Montrez votre programme à vos amis ou à votre professeur. Leurs retours peuvent vous donner des idées d'amélioration ou vous aider à voir des problèmes que vous n'aviez pas remarqués.