Algorithmique et programmation avec boucles et conditions

Un algorithme est une série finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème ou d'obtenir un résultat. C'est comme une recette de cuisine : elle décrit étape par étape comment préparer un plat.

Key Concepts:

• Définition d'un algorithme : Suite d'instructions ordonnées pour résoudre un problème.
• Séquence d'instructions : Les étapes doivent être claires et se suivre logiquement.
• Résolution de problèmes : Le but est d'arriver à un résultat précis.
• Exemples quotidiens :
  • Prendre un bus : Aller à l'arrêt, attendre, monter, payer, descendre.
  • Faire un calcul mental : Appliquer des règles précises.
  • Monter un meuble : Suivre les étapes du manuel.

Un algorithme doit être précis, fini et efficace.

Pour communiquer un algorithme, on peut utiliser différentes méthodes :

Key Concepts:

• Langage naturel : Description écrite en français (ou autre langue), facile à comprendre mais parfois ambiguë.
  • Exemple : "Si tu as faim, mange."
• Pseudo-code : Langage intermédiaire entre le langage naturel et un langage de programmation. Il utilise des mots-clés simples (LIRE, AFFICHER, SI, ALORS, POUR, TANT QUE) et une structure logique. Il est plus précis que le langage naturel et moins strict qu'un langage de programmation.
  • Exemple :

    LIRE nombre1
    LIRE nombre2
    SOMME = nombre1 + nombre2
    AFFICHER SOMME
    

• Organigrammes (introduction) : Représentation graphique de l'algorithme à l'aide de symboles normalisés (ovales pour début/fin, rectangles pour traitement, losanges pour conditions). Pratique pour visualiser le flux logique.
• Variables et constantes :
  • Une variable est un espace de stockage en mémoire qui peut contenir une valeur qui peut changer pendant l'exécution de l'algorithme (ex: prix, compteur).
  • Une constante est un espace de stockage dont la valeur ne change jamais (ex: PI = 3.14).

Créer un algorithme suit généralement un processus structuré :

Key Concepts:

• Analyse du problème : Comprendre exactement ce qui est demandé. Identifier les données d'entrée, les traitements à effectuer et les résultats attendus.
  • Exemple : Calculer la moyenne de 3 nombres. Entrées : 3 nombres. Traitement : additionner et diviser par 3. Sortie : la moyenne.
• Conception de l'algorithme : Écrire l'algorithme en pseudo-code ou le dessiner en organigramme. Définir les variables nécessaires et les étapes logiques.
• Test et validation : Vérifier que l'algorithme fonctionne correctement avec différents jeux de données (cas normaux, cas limites, cas d'erreur). On parle de "faire tourner" l'algorithme mentalement ou avec des valeurs simples.
• Optimisation : Améliorer l'algorithme pour qu'il soit plus rapide, plus court ou utilise moins de ressources, si nécessaire.

La phase d'analyse est cruciale pour éviter les erreurs de conception.

Avant d'utiliser une variable, il faut souvent la déclarer (lui donner un nom et parfois un type) et lui affecter une valeur.

Key Concepts:

• Types de données (nombre, texte, booléen) :
  • Numérique : 5, -12.5, 3.14 (entiers ou décimaux).
  • Chaîne de caractères (texte) : "Bonjour", "ordinateur" (entre guillemets).
  • Booléen : VRAI ou FAUX.
• Nommage des variables : Les noms doivent être significatifs (ex: âge, nomUtilisateur). Souvent sans espaces, sans caractères spéciaux et ne commençant pas par un chiffre.
• Opérateur d'affectation : Le symbole (= ou <-) permet de donner une valeur à une variable.
  • Exemple : âge <- 15 ou nom = "Alice".
• Initialisation : Donner une première valeur à une variable dès sa déclaration ou avant son utilisation.
  • Exemple : compteur <- 0

Les opérations de base pour les nombres.

Key Concepts:

• Addition : + (ex: 5 + 3 = 8)
• Soustraction : - (ex: 10 - 4 = 6)
• Multiplication : * (ex: 2 * 6 = 12)
• Division : / (ex: 15 / 3 = 5)
• Priorité des opérations : Comme en maths (PEMDAS/Priorités : Parenthèses, Exposants, Multiplication/Division, Addition/Soustraction).
  • Exemple : 2 + 3 * 4 = 14 (car $3 \times 4 = 12$, puis $2 + 12 = 14$)
• Modulo (reste de la division) : % ou MOD. Donne le reste d'une division entière. Utile pour savoir si un nombre est pair ou impair.
  • Exemple : 10 MOD 3 = 1 (car $10 = 3 \times 3 + 1$)
  • Exemple : 12 MOD 2 = 0 (12 est pair)
• Puissance : ^ ou ** (ex: 2^3 = 8)

Ces opérations permettent de prendre des décisions dans l'algorithme.

Key Concepts:

• Opérateurs de comparaison :
  • Égalité : <mark> (attention, </mark> pour comparer, = ou <- pour affecter)
  • Inégalité : != ou <>
  • Supérieur à : >
  • Inférieur à : <
  • Supérieur ou égal à : >=
  • Inférieur ou égal à : <=
• Valeurs booléennes (Vrai/Faux) : Le résultat d'une comparaison est toujours VRAI ou FAUX.
  • Exemple : 5 > 3 est VRAI. 10 == 7 est FAUX.
• Opérateurs logiques (ET, OU, NON) : Permettent de combiner plusieurs conditions.
  • ET (AND) : condition1 ET condition2 est VRAI seulement si condition1 EST VRAI ET condition2 EST VRAI.
  • OU (OR) : condition1 OU condition2 est VRAI si au moins une des conditions est VRAI.
  • NON (NOT) : NON condition inverse la valeur booléenne de la condition.
  • Exemple : (âge > 12) ET (âge < 18) (pour un adolescent).
  • Exemple : (couleur <mark> "rouge") OU (couleur </mark> "bleu").
• Combinaison d'opérations : On peut lier plusieurs comparaisons avec des opérateurs logiques.

Les opérateurs de comparaison et logiques sont la base des structures conditionnelles.

Comment l'algorithme interagit avec l'utilisateur ou l'environnement.

Key Concepts:

• Fonction d'entrée (lire) : Permet à l'algorithme de recevoir des données.
  • Exemple : LIRE nomUtilisateur (l'algorithme attend que l'utilisateur tape quelque chose).
• Fonction de sortie (afficher) : Permet à l'algorithme de communiquer des informations ou des résultats.
  • Exemple : AFFICHER "Bonjour" ou AFFICHER resultatCalcul.
• Interaction utilisateur : C'est ainsi que l'utilisateur peut "parler" à l'algorithme et vice-versa.
• Messages clairs : Il est important d'afficher des messages explicites pour l'utilisateur (ex: "Veuillez entrer votre âge :").

Les structures conditionnelles permettent à un algorithme de prendre des décisions et d'adapter son comportement en fonction de certaines situations.

Key Concepts:

• Prise de décision : L'algorithme choisit un chemin d'exécution parmi plusieurs possibles.
• Exécution sélective : Certaines instructions ne sont exécutées que si une condition est remplie.
• Test d'une proposition : La condition est une proposition qui peut être VRAI ou FAUX.
• Chemins alternatifs : L'algorithme peut suivre différentes branches en fonction du résultat du test.

C'est la forme la plus simple de condition.

Key Concepts:

• Syntaxe de base :

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

• Condition simple : Une seule comparaison (ex: âge > 18).

• Bloc d'instructions : L'ensemble des lignes de code qui sont exécutées si la condition est VRAI. L'indentation (décalage vers la droite) est souvent utilisée pour indiquer ce bloc.

• Exécution conditionnelle : Si la condition est FAUX, les instructions du bloc ALORS sont ignorées et l'algorithme continue après le FIN SI.

  • Exemple :

    SI note >= 10 ALORS
        AFFICHER "Admis !"
    FIN SI
    AFFICHER "Fin du programme."
    

    Si note vaut 12, "Admis !" est affiché. Si note vaut 8, rien n'est affiché entre le SI et le FIN SI, l'algorithme passe directement à "Fin du programme.".

Permet de gérer deux cas : quand la condition est VRAI et quand elle est FAUX.

Key Concepts:

• Alternative double : Deux blocs d'instructions possibles.

  SI condition ALORS
      // Instructions si la condition est VRAI
  SINON
      // Instructions si la condition est FAUX
  FIN SI
  

• Cas Vrai et cas Faux : Un bloc est exécuté, jamais les deux.
• Gestion de toutes les situations : Cette structure assure qu'une action sera toujours entreprise, quelle que soit la condition.
• Exemples pratiques :
  • Exemple :

    SI âge >= 18 ALORS
        AFFICHER "Vous êtes majeur."
    SINON
        AFFICHER "Vous êtes mineur."
    FIN SI
    

Pour des décisions plus complexes, on peut combiner les conditions.

Key Concepts:

• Si dans un Si : Une structure SI peut se trouver à l'intérieur du bloc ALORS ou SINON d'une autre structure SI.

  SI estMajeur ALORS
      SI aPermis ALORS
          AFFICHER "Peut conduire."
      SINON
          AFFICHER "Est majeur mais ne peut pas conduire."
      FIN SI
  SINON
      AFFICHER "Est mineur."
  FIN SI
  

• Utilisation des opérateurs logiques (ET, OU) : Souvent, il est plus simple d'utiliser ET ou OU pour combiner des conditions plutôt que d'imbriquer des SI.
  • Exemple : Au lieu de SI estMajeur ALORS SI aPermis ALORS ..., on peut écrire SI estMajeur ET aPermis ALORS ....
• Complexité des décisions : Les conditions imbriquées peuvent devenir difficiles à lire et à maintenir si elles sont trop nombreuses.
• Lisibilité du code : Privilégier les opérateurs logiques lorsque c'est possible pour améliorer la clarté.

Bien choisir entre imbrication et opérateurs logiques simplifie l'algorithme.

Les boucles permettent de répéter un bloc d'instructions plusieurs fois. C'est essentiel pour automatiser des tâches répétitives.

Key Concepts:

• Répétition d'instructions : Exécuter le même code plusieurs fois.
• Automatisation des tâches : Éviter de copier-coller du code.
• Gain de temps : L'algorithme peut traiter de grandes quantités de données rapidement.
• Éviter la répétition de code (DRY - Don't Repeat Yourself) : Rendre l'algorithme plus concis et plus facile à modifier.

Elle répète un bloc d'instructions TANT QU'UNE condition est VRAI.

Key Concepts:

• Condition de continuation : La boucle continue tant que la condition est VRAI. Dès qu'elle devient FAUX, la boucle s'arrête.

  TANT QUE condition EST VRAI FAIRE
      // Instructions à répéter
  FIN TANT QUE
  

• Initialisation avant la boucle : La variable utilisée dans la condition doit être initialisée avant le début de la boucle.

• Mise à jour dans la boucle : Il est crucial de modifier la variable de la condition À L'INTÉRIEUR de la boucle, sinon la condition pourrait rester toujours VRAI.

• Boucle infinie (danger) : Si la condition ne devient jamais FAUX, la boucle ne s'arrêtera jamais. Le programme "plante".

  • Exemple :

    compteur <- 0
    TANT QUE compteur < 5 FAIRE
        AFFICHER "Le compteur est à " + compteur
        compteur <- compteur + 1 // Incrémentation du compteur
    FIN TANT QUE
    AFFICHER "Boucle terminée."
    

    Affichera 0, 1, 2, 3, 4 puis "Boucle terminée.".

Elle est utilisée quand le nombre de répétitions est connu d'avance ou que l'on veut parcourir une séquence.

Key Concepts:

• Itération sur une séquence : Répéter pour chaque élément d'une liste ou pour un intervalle de nombres.

  POUR variable DE debut À fin FAIRE
      // Instructions à répéter
  FIN POUR
  

• Compteur ou indice : Une variable (souvent i ou j) qui prend successivement les valeurs de debut à fin.

• Nombre de répétitions connu : C'est la principale différence avec TANT QUE. On sait combien de fois la boucle va s'exécuter.

• Plage de valeurs : Il est possible de spécifier un pas (ex: POUR i DE 0 À 10 PAR PAS DE 2).

  • Exemple :

    POUR i DE 1 À 3 FAIRE
        AFFICHER "Tour numéro " + i
    FIN POUR
    AFFICHER "Fini !"
    

    Affichera "Tour numéro 1", "Tour numéro 2", "Tour numéro 3", puis "Fini !".

Le choix entre TANT QUE et POUR dépend du problème.

Key Concepts:

• Quand utiliser Tant que :
  • Quand le nombre de répétitions n'est pas connu à l'avance.
  • Quand la répétition dépend d'une condition qui peut changer à tout moment (ex: "TANT QUE l'utilisateur n'a pas entré un nombre valide").
• Quand utiliser Pour :
  • Quand le nombre de répétitions est connu précisément.
  • Quand on doit parcourir tous les éléments d'une collection (liste, tableau).
  • Exemple : "POUR chaque élève de la classe".
• Exemples comparatifs :
  • Calculer la somme des N premiers entiers : POUR i DE 1 À N.
  • Demander un mot de passe jusqu'à ce qu'il soit correct : TANT QUE motDePasse != "secret".
• Optimisation : Utiliser la boucle la plus appropriée rend l'algorithme plus clair et souvent plus efficace.

POUR quand on sait combien de fois, TANT QUE quand on ne sait pas.

Un algorithme est une idée, un langage de programmation est l'outil pour la concrétiser.

Key Concepts:

• Traduction des algorithmes : Transcrire le pseudo-code (ou l'organigramme) dans un langage que l'ordinateur peut comprendre et exécuter.
• Syntaxe spécifique : Chaque langage de programmation a ses propres règles d'écriture (ponctuation, mots-clés, structure).
• Environnement de développement : Logiciels (éditeurs de texte, IDE) qui aident à écrire, tester et exécuter le code.
• Langages courants (ex: Python) :
  • Python est un langage populaire pour les débutants car sa syntaxe est proche du pseudo-code, ce qui facilite la transition.
  • Exemple Python :

    age = int(input("Entrez votre âge : "))
    if age >= 18:
        print("Vous êtes majeur.")
    else:
        print("Vous êtes mineur.")
    

Mettre le programme en marche et corriger les erreurs.

Key Concepts:

• Interprétation du code : Un programme spécial (interpréteur ou compilateur) traduit le code source en instructions machine.
• Erreurs de syntaxe : Fautes de frappe ou non-respect des règles du langage. Le programme ne peut pas démarrer. Faciles à identifier car l'interpréteur les signale.
• Erreurs logiques : Le programme s'exécute, mais ne fait pas ce qu'on attend de lui. Plus difficiles à trouver car le programme ne "plante" pas, il donne juste un mauvais résultat.
• Techniques de débogage :
  • Afficher des messages intermédiaires (print ou AFFICHER) pour suivre l'état des variables.
  • Utiliser un "débogueur" (outil qui permet d'exécuter le code pas à pas).
  • Tester avec des valeurs simples et connues.

Appliquer les concepts pour créer des mini-projets.

Key Concepts:

• Calcul de sommes/moyennes : Utiliser une boucle POUR pour additionner des nombres, puis diviser pour la moyenne.
• Jeux simples (devinette) : Utiliser une boucle TANT QUE pour demander des tentatives, et des SI pour vérifier la réponse.
• Traitement de listes : Parcourir une liste d'éléments avec une boucle POUR et appliquer des conditions à chaque élément.
• Mini-projets :
  • Un programme qui demande 5 notes et calcule la moyenne.
  • Un programme qui demande un nombre et dit s'il est pair ou impair.
  • Un programme qui simule un distributeur de boissons (choix avec SI, stock avec variables).