Lalgorithmique et la programmation

Un algorithme est une séquence d'instructions claires et non ambiguës qui, une fois exécutées dans un ordre précis, permettent de résoudre un problème à résoudre ou d'accomplir une tâche. C'est la base de tout programme informatique !

Voici quelques exemples concrets du quotidien :

• Une recette de cuisine : Pour faire un gâteau, vous suivez des étapes : mélanger les ingrédients, enfourner, attendre. Chaque étape est une instruction.
• Le montage d'un meuble : Vous suivez un manuel avec des schémas et des étapes numérotées pour assembler les pièces dans le bon ordre.
• Se brosser les dents : Prendre la brosse, mettre du dentifrice, brosser le haut, brosser le bas, rincer.

Un algorithme est toujours une suite d'actions à exécuter pour arriver à un résultat.

Pour qu'un algorithme soit utile, il doit posséder certaines qualités :

• Clarté : Chaque instruction doit être facile à comprendre. Pas de double sens !
• Précision : Les étapes doivent être exactes et détaillées.
• Finitude : L'algorithme doit se terminer après un nombre fini d'étapes. Il ne doit pas tourner en rond indéfiniment.
• Efficacité : Il doit résoudre le problème de la meilleure façon possible, en utilisant le moins de ressources (temps, énergie) possible.

On peut représenter un algorithme de différentes manières :

• Langage naturel : C'est simplement décrire les étapes avec des mots de tous les jours, comme une recette. C'est facile à comprendre pour les humains, mais parfois ambigu.
  • Exemple : "Avancer de 10 pas. Tourner à droite de 90 degrés."
• Organigramme (notions simples) : C'est une représentation graphique qui utilise des symboles pour montrer l'ordre des opérations. C'est visuel et aide à structurer les idées.
  • Exemple de symbole : un rectangle pour une action, un losange pour une décision.
• Pseudo-code (introduction) : C'est un mélange de langage naturel et de code informatique simplifié. Il permet de décrire l'algorithme de façon plus structurée avant de le traduire dans un langage de programmation.
  • Exemple :

    DEBUT
        AFFICHER "Bonjour"
        AVANCER DE 10
    FIN
    

Le processus pour créer un programme suit plusieurs étapes logiques :

1. Analyse du problème : Comprendre exactement ce que l'on veut faire. Quel est le but ? Quelles sont les informations de départ ? Quel résultat attend-on ?
2. Conception de l'algorithme : Imaginer la suite d'étapes qui permettra de résoudre le problème. On peut utiliser le langage naturel ou le pseudo-code.
3. Traduction en programme : Écrire l'algorithme dans un langage de programmation (comme Scratch, Python, etc.). Chaque instruction de l'algorithme devient une ligne de code ou un bloc.
4. Exécution et test : Faire fonctionner le programme pour voir s'il fait bien ce qu'on attend. Si ce n'est pas le cas, il faut chercher les erreurs (les "bugs").

Un programme est un algorithme écrit dans un langage que la machine peut comprendre et exécuter.

Pour débuter, nous utiliserons Scratch, un environnement de programmation visuel très intuitif.

• Interface de Scratch : Elle est composée de plusieurs zones :
  • La zone des blocs de code (à gauche) : C'est là que vous trouvez toutes les instructions (mouvement, apparence, événements, etc.).
  • La zone de script (au centre) : C'est là que vous assemblez les blocs pour créer votre programme.
  • La scène (à droite) : C'est là que votre programme s'exécute et que vous voyez le résultat (le dessin, l'animation).
  • Les lutins (en bas à droite) : Ce sont les personnages ou objets qui agissent sur la scène.
• Blocs de code : Ce sont des pièces de puzzle colorées qui représentent des instructions. On les emboîte pour créer des scripts.
• Scène et lutins : La scène est votre "monde" où les lutins (personnages, objets) exécutent les actions que vous leur avez programmées.
• Événements : Ce sont les déclencheurs de vos programmes. Par exemple, "quand le drapeau vert est cliqué" ou "quand la touche espace est pressée".

Voici quelques types d'instructions fondamentales que l'on retrouve dans Scratch et dans de nombreux langages :

• Affichage (dire, écrire) : Permet au programme de communiquer avec l'utilisateur.
  • Bloc Scratch : dire [Bonjour !] pendant [2] secondes ou dire [Bonjour !]
• Déplacement (avancer, tourner) : Permet de faire bouger un lutin sur la scène.
  • Blocs Scratch : avancer de [10] pas, tourner [sens horaire] de [15] degrés
• Changement d'apparence : Permet de modifier l'aspect d'un lutin.
  • Blocs Scratch : changer de costume par [costume2], dire [Bonjour !]
• Attendre : Permet de marquer une pause dans l'exécution du programme.
  • Bloc Scratch : attendre [1] secondes

• Exécution séquentielle : Les instructions sont exécutées les unes après les autres, dans l'ordre où elles apparaissent dans le script, du haut vers le bas.
  • Exemple : Si vous donnez l'ordre "avancer", puis "tourner", le lutin avancera avant de tourner.
• Importance de l'ordre : Changer l'ordre des instructions peut totalement modifier le résultat du programme.
  • Exemple : "Mettre les chaussettes, puis les chaussures" donne un résultat différent de "Mettre les chaussures, puis les chaussettes".
• Déroulement pas à pas : Pour comprendre ce qui se passe, on peut imaginer exécuter le programme instruction par instruction, en notant l'état du lutin (sa position, son orientation, son costume) après chaque étape.

Pour créer un programme, il suffit d'enchaîner des blocs les uns sous les autres dans la zone de script.

• Programmes linéaires : Ce sont des programmes où les instructions s'enchaînent sans condition ni répétition.
• Exemples de tracés simples : On peut demander à un lutin de dessiner un carré ou un triangle en enchaînant des blocs avancer et tourner.
  • quand le drapeau vert est cliqué
  • stylo en position d'écriture
  • avancer de [100] pas
  • tourner [sens horaire] de [90] degrés
  • avancer de [100] pas
  • ...

Le débogage est l'art de trouver et de corriger les erreurs dans un programme, appelées bugs.

• Identifier les erreurs : Si le programme ne fait pas ce que vous attendez, il y a probablement un bug.
• Tester son programme : Il est essentiel de tester régulièrement son programme pour voir si les modifications fonctionnent correctement.
• Corriger les bugs : Une fois l'erreur identifiée, il faut modifier le code pour la corriger. Cela peut impliquer de changer l'ordre des blocs, de modifier des valeurs, ou d'ajouter/supprimer des instructions.
• Comprendre le message d'erreur : Parfois, le langage de programmation (ou l'environnement comme Scratch) peut donner des indications sur l'erreur. Il faut apprendre à les lire.

Les boucles permettent de répéter une ou plusieurs instructions un certain nombre de fois, ou jusqu'à ce qu'une condition soit remplie.

• Répétition de code : Au lieu d'écrire la même séquence d'instructions plusieurs fois, on la met dans une boucle.
• Optimisation du programme : Le programme est plus court, plus lisible et plus facile à modifier.
• Réduction des erreurs : Moins de code à écrire signifie moins de chances de faire des fautes de frappe ou des erreurs logiques.

Cette boucle exécute les instructions qu'elle contient un nombre de répétitions fixe que vous spécifiez.

• Bloc 'répéter' : Dans Scratch, c'est le bloc répéter [10] fois.
• Exemples de figures géométriques simples :
  • Dessiner un carré : Répéter 4 fois (avancer, tourner de 90 degrés).
  • Dessiner un triangle équilatéral : Répéter 3 fois (avancer, tourner de 120 degrés).

  quand le drapeau vert est cliqué
  aller à x: (0) y: (0)
  effacer tout
  stylo en position d'écriture
  répéter (4) fois
      avancer de (100) pas
      tourner (sens horaire) de (90) degrés
  

Cette boucle exécute les instructions qu'elle contient en répétition continue, sans s'arrêter, tant que le programme est en cours d'exécution.

• Bloc 'répéter indéfiniment' : Dans Scratch, c'est le bloc répéter indéfiniment.
• Applications (animations, jeux simples) : Utile pour les mouvements continus d'un personnage, un fond sonore qui tourne en boucle, ou un jeu qui attend une action du joueur.
  • Exemple : Faire bouger un lutin de gauche à droite sans arrêt.

  quand le drapeau vert est cliqué
  répéter indéfiniment
      avancer de (5) pas
      si (toucher le bord ?) alors
          rebondir si le bord est atteint
      fin
  

Une condition est une question à laquelle on peut répondre par vrai ou faux. Selon la réponse, le programme va suivre un chemin ou un autre.

• Décision : La capacité du programme à choisir quelle suite d'instructions exécuter.
• Choix : C'est la base de l'intelligence des programmes.
  • Exemple : "S'il pleut, prendre un parapluie." La condition est "s'il pleut".

Cette structure exécute un bloc d'instructions seulement si une condition est vraie.

• Bloc 'si... alors' : Dans Scratch, c'est le bloc si () alors.
• Opérateurs de comparaison (<, >, =) : Permettent de créer des conditions en comparant des valeurs.
  • [nombre1] < [nombre2] (est-ce que nombre1 est plus petit que nombre2 ?)
  • [nombre1] > [nombre2] (est-ce que nombre1 est plus grand que nombre2 ?)
  • [nombre1] = [nombre2] (est-ce que nombre1 est égal à nombre2 ?)
• Capteurs (souris, couleur) : Permettent de détecter des événements ou des états.
  • souris pressée ?
  • couleur [couleur1] est touchée par [couleur2] ?
  • touche [espace] pressée ?
  • Exemple : si (souris pressée ?) alors avancer de (10) pas

Cette structure permet de choisir entre deux chemins possibles : un si la condition est vraie, un autre si elle est fausse.

• Bloc 'si... alors... sinon' : Dans Scratch, c'est le bloc si () alors sinon.
• Deux chemins possibles :
  • Si la condition est vraie, les instructions du "alors" sont exécutées.
  • Si la condition est fausse, les instructions du "sinon" sont exécutées.
• Exemples de réactions différentes :
  • si (score > 100) alors dire [Bravo !] sinon dire [Continue !]
  • si (touche [espace] pressée ?) alors changer de costume par [costume2] sinon changer de costume par [costume1]

Les tests permettent à un programme de réagir différemment selon les circonstances.

Une variable est comme une petite boîte ou une étiquette dans la mémoire de l'ordinateur qui peut stocker des informations.

• Nom de variable : Chaque boîte a un nom unique pour qu'on puisse la retrouver facilement (par exemple, "score", "nomJoueur", "vitesse").
• Valeur de variable : Le contenu de la boîte à un moment donné. Cette valeur peut changer au cours du programme.
• Utilisation simple : On peut y stocker des nombres, du texte, ou d'autres types d'informations.
  • Exemple : Si score = 0 au début, on peut ensuite ajouter 1 à score.

Scratch simplifie la gestion des variables :

• Créer une variable : Dans l'onglet "Variables", cliquez sur "Créer une variable". Donnez-lui un nom clair.
• Modifier la valeur (mettre, ajouter) :
  • mettre [ma variable] à [0] : initialise ou change la valeur de la variable.
  • ajouter [1] à [ma variable] : augmente (ou diminue si le nombre est négatif) la valeur de la variable.
• Afficher la variable : Vous pouvez cocher la case à côté de la variable dans l'onglet "Variables" pour que sa valeur s'affiche sur la scène.
• Exemples (score, compteur) :
  • Un jeu peut avoir une variable score qui augmente à chaque bonne réponse.
  • Un programme peut utiliser un compteur pour savoir combien de fois une action a été répétée.

quand le drapeau vert est cliqué
mettre [score] à [0]
répéter indéfiniment
    si <souris pressée ?> alors
        ajouter (1) à [score]
        attendre (0.2) secondes // Pour éviter d'ajouter trop vite
    fin

Les programmes peuvent aussi "parler" avec l'utilisateur et lui demander des informations.

• Bloc 'demander et attendre' : Dans l'onglet "Capteurs", le bloc demander [Quel est ton nom ?] et attendre affiche une question sur la scène et attend que l'utilisateur tape une réponse.
• Récupérer la réponse : La réponse de l'utilisateur est stockée automatiquement dans une variable spéciale appelée réponse (aussi dans l'onglet "Capteurs").
• Utiliser la réponse dans le programme : On peut ensuite utiliser cette réponse pour personnaliser le programme.
  • Exemple : dire [Bonjour ] et [réponse]
• Programmes interactifs simples : Cela permet de créer des jeux où le joueur entre son nom, ou des quiz où il donne des réponses.

quand le drapeau vert est cliqué
demander [Quel est ton nom ?] et attendre
dire (joindre [Bonjour ] (réponse)) pendant (2) secondes

Les variables et les interactions permettent de créer des programmes plus dynamiques et personnalisés.