Algorithmique et programmation

Un algorithme est une série finie et non ambiguë d'instructions claires et précises qui, une fois exécutées, permettent de résoudre un problème ou d'accomplir une tâche spécifique. Imaginez une recette de cuisine : c'est un algorithme pour préparer un plat !

• Définition d'un algorithme : Une suite logique d'étapes pour atteindre un but.
• Séquence d'instructions : Les étapes doivent être ordonnées et exécutées dans un ordre précis.
• Résolution de problèmes : L'objectif final est toujours de trouver une solution à une question donnée.
• Exemples de la vie courante :
  • La notice de montage d'un meuble.
  • Le chemin le plus court pour aller d'un point A à un point B.
  • Les règles d'un jeu de société.
  • Un programme de machine à laver. Un algorithme est la "recette" pour qu'un ordinateur (ou un humain) puisse réaliser une tâche.

Concevoir un algorithme, c'est comme planifier un voyage. Il y a plusieurs étapes clés pour s'assurer que le résultat sera correct.

1. Analyse du problème :
   • Comprendre précisément ce qui est demandé.
   • Quelles sont les données de départ (entrées) ?
   • Quel est le résultat attendu (sorties) ?
   • Exemple : Calculer la moyenne de trois notes. Entrées : les trois notes. Sortie : la moyenne.
2. Définition des entrées/sorties : Identifier clairement toutes les informations nécessaires et les résultats à produire.
3. Décomposition en sous-problèmes : Si le problème est complexe, le diviser en plusieurs problèmes plus petits et plus faciles à résoudre.
   • Exemple : Pour calculer la moyenne, il faut d'abord additionner les notes, puis diviser par le nombre de notes.
4. Test et validation : Vérifier que l'algorithme fonctionne correctement avec différents jeux de données (scénarios).
   • Exemple : Si les notes sont 10, 12, 14, la moyenne doit être $(10+12+14)/3 = 12$.

Pour écrire un algorithme, on peut utiliser différentes méthodes, l'important est d'être clair.

• Langage naturel : Décrire les étapes en français courant. C'est facile à lire mais peut manquer de précision.
  • Exemple : "Demander l'âge de la personne. Si l'âge est supérieur ou égal à 18, afficher "Majeur". Sinon, afficher "Mineur"."
• Pseudo-code : Un langage intermédiaire, plus structuré que le langage naturel, mais pas aussi rigide qu'un langage de programmation. Il utilise des mots clés comme LIRE, AFFICHER, SI... ALORS... SINON..., POUR, TANT QUE. C'est la méthode la plus utilisée en algorithmique.
  • Exemple :

    DEBUT
        LIRE age
        SI age >= 18 ALORS
            AFFICHER "Majeur"
        SINON
            AFFICHER "Mineur"
        FIN SI
    FIN
    

• Organigrammes (notions) : Des schémas graphiques utilisant des symboles pour représenter les opérations et l'ordre d'exécution. Moins utilisé pour des algorithmes complexes, mais utile pour visualiser les flux simples.
  • Un rectangle pour une opération, un losange pour une décision, etc.
• Importance de la clarté : Quel que soit le mode de représentation, l'algorithme doit être compréhensible par n'importe qui (ou par une machine) sans ambiguïté. La précision est cruciale en algorithmique.

Pour qu'un algorithme puisse manipuler des informations, il a besoin de les stocker. C'est le rôle des variables.

• Définition d'une variable : Une variable est un conteneur (une sorte de boîte) qui stocke une valeur et qui possède un nom. Cette valeur peut changer au cours de l'exécution de l'algorithme.
  • Exemple : age, nom, prixHT.
• Affectation de valeur : C'est l'action de donner une valeur à une variable. On utilise souvent le symbole ← ou =.
  • Exemple : age ← 15 (la variable age contient maintenant la valeur 15).
• Types numériques :
  • Entiers : Nombres sans virgule (ex: 5, -10, 0).
  • Décimaux (ou flottants) : Nombres à virgule (ex: 3.14, -0.5, 12.0).
• Types textuels (ou chaînes de caractères) : Séquences de lettres, chiffres, symboles. Elles sont souvent entourées de guillemets.
  • Exemple : "Bonjour", "éléphant", "123 Rue de la Paix".
  • Chaque variable doit avoir un nom unique et un type de données pour savoir ce qu'elle peut contenir.

Un algorithme effectue des actions sur les données. Ces actions sont appelées opérations.

• Opérations arithmétiques : Pour les calculs numériques.
  • + (addition)
  • - (soustraction)
  • * (multiplication)
  • / (division)
  • Exemple : resultat ← (note1 + note2) / 2
• Opérations de comparaison : Pour comparer des valeurs et obtenir un résultat VRAI ou FAUX.
  • < (inférieur à)
  • > (supérieur à)
  • = (égal à) - Attention, en programmation, on utilise souvent == pour l'égalité afin de le distinguer de l'affectation.
  • ≠ (différent de) - Souvent écrit != ou <>.
  • <= (inférieur ou égal à)
  • >= (supérieur ou égal à)
  • Exemple : age >= 18 (peut être VRAI ou FAUX).
• Opérations logiques : Pour combiner des conditions et obtenir un résultat VRAI ou FAUX.
  • ET (AND) : VRAI si toutes les conditions sont VRAIES.
  • OU (OR) : VRAI si au moins une condition est VRAIE.
  • NON (NOT) : Inverse la valeur de vérité (NON VRAI = FAUX, NON FAUX = VRAI).
  • Exemple : (age >= 18) ET (permisValide = VRAI)

Un algorithme doit pouvoir communiquer avec l'utilisateur ou avec d'autres parties du système.

• Instruction d'affichage (sortie) : Permet de montrer des informations à l'utilisateur. En pseudo-code, on utilise souvent AFFICHER ou ECRIRE.
  • Exemple : AFFICHER "Bonjour"
  • Exemple : AFFICHER "La moyenne est : ", moyenne
• Instruction de saisie (entrée) : Permet à l'utilisateur de fournir des informations à l'algorithme. En pseudo-code, on utilise souvent LIRE ou SAISIR.
  • Exemple : LIRE age (l'algorithme attend que l'utilisateur entre une valeur qui sera stockée dans la variable age).
• Interaction avec l'utilisateur : Ces instructions sont essentielles pour rendre un programme interactif.
• Messages clairs : Il est important de guider l'utilisateur avec des messages explicites.
  • Mauvais : LIRE nom (l'utilisateur ne sait pas ce qu'il doit saisir).
  • Bon : AFFICHER "Veuillez saisir votre nom : " puis LIRE nom.

C'est la forme la plus simple de décision.

• Condition simple : Une expression qui peut être VRAIE ou FAUSSE (par exemple, age >= 18).
• Exécution conditionnelle : Un bloc d'instructions est exécuté seulement si la condition est VRAIE.
• Syntaxe en pseudo-code :

  SI condition ALORS
      // Instructions à exécuter si la condition est VRAIE
  FIN SI
  

• Exemples pratiques :
  • Exemple 1 : Si un élève a une note supérieure à 10, afficher "Admis".

    SI note > 10 ALORS
        AFFICHER "Admis"
    FIN SI
    

  • Exemple 2 : Si la lumière est éteinte, l'allumer.

Cette structure offre une alternative : un bloc d'instructions si la condition est VRAIE, et un autre bloc si elle est FAUSSE.

• Alternative : Deux chemins possibles pour l'exécution de l'algorithme.
• Deux blocs d'instructions :
  • Un bloc pour le cas VRAI (après ALORS).
  • Un bloc pour le cas FAUX (après SINON).
• Gestion de tous les cas : Cette structure assure qu'une action sera toujours effectuée, quelle que soit la condition.
• Syntaxe en pseudo-code :

  SI condition ALORS
      // Instructions si la condition est VRAIE
  SINON
      // Instructions si la condition est FAUSSE
  FIN SI
  

• Exemples de choix :
  • Exemple 1 : Si un nombre est pair, afficher "Pair", sinon afficher "Impair".

    LIRE nombre
    SI nombre MOD 2 = 0 ALORS // MOD donne le reste de la division
        AFFICHER "Pair"
    SINON
        AFFICHER "Impair"
    FIN SI
    

  • Exemple 2 : Si j'ai faim, je mange, sinon je travaille. Cette structure gère les situations où il y a deux possibilités distinctes.

On peut combiner des conditions ou les imbriquer pour des décisions plus complexes.

• Utilisation de ET, OU : Pour former des conditions complexes.
  • SI (age >= 18 ET permis = VRAI) ALORS ... (Il faut être majeur ET avoir le permis).
  • SI (jour = "Samedi" OU jour = "Dimanche") ALORS ... (C'est le week-end).
• Conditions complexes : Permettent de gérer des scénarios plus nuancés.
• Imbrication de 'Si' : Placer une structure SI... ALORS... à l'intérieur d'une autre.
  • Exemple :

    SI meteo = "Pluie" ALORS
        SI temperature < 10 ALORS
            AFFICHER "Mettre un manteau et prendre un parapluie"
        SINON
            AFFICHER "Prendre un parapluie"
        FIN SI
    SINON
        AFFICHER "Profiter du beau temps"
    FIN SI
    

• Logique de décision : L'imbrication permet de prendre des décisions successives, affinant le choix à chaque étape.

La boucle POUR est utilisée lorsque l'on sait à l'avance combien de fois on doit répéter une action.

• Nombre de répétitions connu : On spécifie un nombre fixe de tours.
• Compteur de boucle : Une variable (souvent i) qui compte les tours de la boucle.
• Initialisation, condition, incrémentation :
  • Le compteur commence à une valeur (DE 1).
  • Il continue tant qu'une condition est vraie (A JUSQU'A 10).
  • Il change après chaque tour (PAR PAS DE 1 ou implicitement +1).
• Syntaxe en pseudo-code :

  POUR compteur DE debut A fin PAR PAS de pas ALORS
      // Instructions à répéter
  FIN POUR
  

  Ou plus simplement :

  POUR i DE 1 A 10 ALORS
      // Instructions répétées 10 fois
  FIN POUR
  

• Exemples (parcourir une liste) :
  • Afficher les nombres de 1 à 5 :

    POUR i DE 1 A 5 ALORS
        AFFICHER i
    FIN POUR
    

  • Calculer la somme des 10 premiers nombres entiers. La boucle POUR est parfaite quand on connaît le nombre d'itérations.

La boucle TANT QUE est utilisée lorsque le nombre de répétitions n'est pas connu à l'avance. Elle continue tant qu'une certaine condition reste VRAIE.

• Condition de continuation : La boucle s'exécute tant que la condition est VRAIE.
• Répétition jusqu'à ce que la condition soit fausse : Dès que la condition devient FAUSSE, la boucle s'arrête.
• Risque de boucle infinie : Si la condition ne devient jamais FAUSSE, la boucle ne s'arrêtera jamais ! Il faut s'assurer que quelque chose dans la boucle modifie la condition.
• Syntaxe en pseudo-code :

  TANT QUE condition EST VRAIE ALORS
      // Instructions à répéter
      // Une instruction DOIT modifier la condition pour éviter une boucle infinie
  FIN TANT QUE
  

• Exemples (saisie valide) :
  • Demander à l'utilisateur de saisir un nombre entre 1 et 10, et répéter tant que la saisie est incorrecte.

    LIRE nombre
    TANT QUE (nombre < 1 OU nombre > 10) ALORS
        AFFICHER "Saisie incorrecte. Veuillez entrer un nombre entre 1 et 10."
        LIRE nombre
    FIN TANT QUE
    AFFICHER "Nombre valide : ", nombre
    

  • Un jeu de devinette où on répète la saisie jusqu'à trouver le bon nombre.

Comprendre quand utiliser POUR ou TANT QUE est essentiel pour écrire des algorithmes efficaces.

• Quand utiliser 'Pour' :
  • Lorsque le nombre d'itérations est connu avant le début de la boucle (ex: parcourir tous les éléments d'une liste, répéter une action 5 fois).
  • Quand on a besoin d'un compteur qui avance de manière régulière.
• Quand utiliser 'Tant que' :
  • Lorsque le nombre d'itérations est inconnu et dépend d'une condition qui peut changer au cours de l'exécution (ex: lire une saisie jusqu'à ce qu'elle soit valide, attendre un événement).
  • Quand on veut répéter une action tant qu'une situation persiste.
• Efficacité de l'algorithme : Le bon choix de boucle rend l'algorithme plus clair et parfois plus performant.
• Exemples comparatifs :
  • Afficher "Hello" 3 fois : POUR i DE 1 A 3 ... est plus direct.
  • Continuer à jouer tant que le joueur n'a pas perdu : TANT QUE joueurGagne = VRAI ... est plus approprié.

• Traduction d'un algorithme : Une fois l'algorithme bien défini en pseudo-code, on le traduit dans un langage de programmation spécifique (comme Python, Scratch, JavaScript, etc.).
• Rôle de l'interpréteur/compilateur :
  • Un interpréteur lit et exécute le code ligne par ligne (ex: Python, Scratch).
  • Un compilateur traduit tout le code en une fois en langage machine avant de l'exécuter.
• Syntaxe spécifique du langage : Chaque langage a ses propres règles de grammaire (syntaxe) et ses mots-clés. Il faut les respecter scrupuleusement.
  • AFFICHER "Bonjour" en pseudo-code devient print("Bonjour") en Python ou dire "Bonjour" en Scratch.
• Exemple avec Scratch ou Python :
  • Scratch : Utilise des blocs visuels à assembler, ce qui est très intuitif pour débuter. Les boucles répéter X fois (POUR) et répéter jusqu'à ce que (TANT QUE) sont des blocs.
  • Python : Un langage textuel, très populaire pour sa simplicité et sa lisibilité.

    # Exemple Python pour "Si... Alors... Sinon..."
    age = int(input("Quel est votre âge ? ")) # LIRE age
    if age >= 18:  # SI age >= 18 ALORS
        print("Majeur") # AFFICHER "Majeur"
    else:          # SINON
        print("Mineur") # AFFICHER "Mineur"
    

  Le langage de programmation est la "langue" de l'ordinateur.

Un IDE (Integrated Development Environment) est un logiciel qui facilite l'écriture de programmes.

• Éditeur de code : Une zone où vous écrivez votre code (souvent avec coloration syntaxique pour mieux lire).
• Console d'exécution : Une fenêtre où le programme s'exécute et affiche ses résultats.
• Débogage simple : Des outils pour trouver et corriger les erreurs dans le code.
• Interface utilisateur : L'ensemble des outils offerts par l'IDE pour développer.
  • Exemples : IDLE (pour Python), l'éditeur de Scratch en ligne, Thonny.

Commencer par des programmes simples permet de bien comprendre les bases.

• Afficher un message : Le "Hello World!" est souvent le premier programme.

  print("Bonjour le monde !")
  

• Calculer une somme :

  nombre1 = 5
  nombre2 = 3
  somme = nombre1 + nombre2
  print("La somme est :", somme) # Affiche "La somme est : 8"
  

• Utiliser une variable :

  nom = input("Quel est votre nom ? ")
  print("Bonjour", nom)
  

• Interpréter des erreurs simples : Apprendre à lire les messages d'erreur de l'interpréteur pour comprendre ce qui ne va pas (faute de frappe, erreur de logique, etc.). C'est une compétence essentielle en programmation.

• Problèmes mathématiques :
  • Calculer l'aire d'un cercle, le volume d'un cube.
  • Résoudre une équation du premier degré.
  • Convertir des unités (longueur, température).
• Jeux simples (devinette) :
  • L'ordinateur choisit un nombre, l'utilisateur doit le deviner en un minimum de coups.
  • Un jeu de "Pierre, Feuille, Ciseaux" contre l'ordinateur.
• Simulations basiques :
  • Simuler le lancer d'un dé plusieurs fois pour voir la répartition des résultats.
  • Simuler une file d'attente simple.
• Projets guidés : Travailler sur des projets avec des étapes définies pour apprendre progressivement.

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

• Identifier les erreurs (bugs) :
  • Erreurs de syntaxe : Fautes de frappe, parenthèses manquantes, mots-clés mal orthographiés (le programme ne démarre pas).
  • Erreurs logiques : Le programme s'exécute mais ne fait pas ce qu'on attend (ex: le calcul est faux, la boucle ne s'arrête pas).
• Tester son programme : Exécuter le programme avec différentes entrées pour voir s'il se comporte correctement dans tous les cas.
• Optimisation simple : Une fois que ça marche, essayer de rendre le code plus efficace (plus rapide) ou plus court, si possible, sans sacrifier la lisibilité.
• Lisibilité du code : Un code bien écrit est facile à lire et à comprendre par d'autres personnes (et par soi-même plus tard !). Utiliser des commentaires, des noms de variables clairs.

C'est l'aboutissement de tout ce que vous avez appris.

• Définition des spécifications : Bien comprendre ce que le programme doit faire (ses fonctionnalités, ses entrées, ses sorties).
• Conception de l'algorithme : Écrire l'algorithme en pseudo-code, en utilisant les structures conditionnelles et répétitives nécessaires.
• Codage et tests : Traduire le pseudo-code dans un langage de programmation et tester rigoureusement toutes les fonctionnalités.
• Présentation du projet : Expliquer ce que fait le programme, comment il fonctionne, et éventuellement le montrer en action. C'est une étape importante pour partager son travail.