Algorithmes Séquentiels Simples : Conception et Application

Introduction

Dans la leçon précédente, vous avez appris à tracer manuellement un algorithme. Vous avez endossé le rôle de l'ordinateur, exécutant les instructions pas à pas pour comprendre le comportement et la logique d'un programme. C'est une compétence d'analyse cruciale pour vérifier et déboguer du code.

Aujourd'hui, nous allons inverser les rôles. L'objectif de cette leçon est de vous faire passer d'analyste à concepteur. Vous allez apprendre à concevoir un algorithme séquentiel simple pour résoudre un problème de calcul. Nous allons établir une méthode structurée pour traduire un besoin, comme "calculer une moyenne", en une suite d'instructions logiques et non ambiguës.

C'est l'aboutissement de ce premier module : vous allez combiner votre connaissance des variables, des types de données, des opérateurs et des instructions d'entrée/sortie pour créer vos propres algorithmes. Cette approche méthodique est la première pierre de votre objectif à long terme : écrire du "code clean".

1. La méthode de conception d'un algorithme

Pour passer d'une idée à un algorithme fonctionnel, il ne suffit pas d'écrire des instructions au hasard. Une approche structurée garantit que vous n'oubliez rien et que votre logique est solide. Voici une méthode en quatre étapes que vous pouvez suivre :

1. Analyser le problème : Quelle est la tâche à accomplir ? Quel est le but final ? Il faut comprendre précisément ce que l'algorithme doit calculer.
2. Identifier les Entrées et les Sorties (E/S) :
   • Entrées : De quelles informations l'algorithme a-t-il besoin pour commencer ? Ce sont les données que l'utilisateur devra fournir (Lire).
   • Sorties : Quel est le résultat final que l'algorithme doit afficher ? C'est ce que vous communiquerez à l'utilisateur (Ecrire).
3. Définir les Variables : En fonction des entrées, des sorties et des éventuels calculs intermédiaires, listez toutes les "boîtes" (variables) dont vous aurez besoin. Pour chaque variable, donnez-lui un nom clair et déterminez son type (Entier, Réel, Caractère, etc.).
4. Écrire la Séquence d'instructions : C'est le corps de l'algorithme, entre Début et Fin. Vous écrivez dans l'ordre les actions à effectuer :
   • Demander à l'utilisateur de saisir les entrées.
   • Lire les entrées et les stocker dans des variables.
   • Effectuer les calculs à l'aide d'expressions et d'affectations.
   • Afficher le ou les résultats (les sorties).

2. Exemple guidé : Calcul de la moyenne de trois nombres

Le calcul d'une moyenne est l'exemple parfait pour appliquer notre méthode. Pour approfondir ce cas, nous allons nous baser sur un document de référence.

Analyse de la solution

L'algorithme calculs que vous venez d'étudier est un excellent exemple de conception séquentielle. Appliquons-lui notre méthode en 4 étapes pour bien le décomposer :

1. Analyse du problème : L'objectif est de prendre trois nombres, calculer leur somme, leur produit et leur moyenne, puis d'afficher ces trois résultats.

2. Entrées et Sorties :

   • Entrées : On a besoin de trois nombres fournis par l'utilisateur. Appelons-les nb1, nb2, nb3.
   • Sorties : On doit afficher trois résultats. Appelons-les somme, produit, moyenne.

3. Définition des Variables :

   • Pour les entrées : nb1, nb2, nb3. Comme une moyenne peut être un nombre à virgule, le type Réel est le plus sûr.
   • Pour les sorties : somme, produit, moyenne. Toutes de type Réel.
   • Donc : Variables somme, produit, moyenne, nb1, nb2, nb3 : réel ;

4. Séquence d'instructions :

   • On commence par interagir avec l'utilisateur pour obtenir les données :

     Ecrire("Entrez vos trois nombres=") ;
     Lire(nb1, nb2, nb3) ;
     

   • Ensuite, on effectue les calculs, en utilisant des variables intermédiaires pour plus de clarté :

     somme ← nb1 + nb2 + nb3 ;
     produit ← nb1 * nb2 * nb3 ;
     moyenne ← somme / 3 ;
     

   • Enfin, on affiche les résultats de manière lisible :

     Ecrire("La somme de ces trois nombres est : ", somme) ;
     Ecrire("Le produit de ces trois nombres est : ", produit) ;
     Ecrire("La moyenne de ces trois nombres est : ", moyenne) ;
     

Le document mentionne une alternative :
Ecrire("La moyenne de ces trois nombres est : ", (nb1 + nb2 + nb3) / 3) ;

Cette version est plus compacte et économise la mémoire (pas de variable somme ou moyenne). Cependant, la première version, avec des variables intermédiaires, est souvent plus lisible et plus facile à vérifier (vous pourriez tracer la valeur de somme par exemple). Pour un "code clean", la lisibilité est une priorité.

3. À vous de concevoir !

Maintenant, c'est à votre tour d'appliquer cette méthode. Prenez une feuille et un crayon et essayez de résoudre les problèmes suivants en créant un algorithme pour chacun.

Exercice 1 : Convertisseur de Température

Concevez un algorithme qui demande à l'utilisateur une température en degrés Celsius et la convertit en degrés Fahrenheit. Affichez ensuite le résultat.

Rappel de la formule : $F=C\times 1.8+32$, où $C$ est la température en Celsius et $F$ est la température en Fahrenheit.

Algorithme ConvertisseurTemperature
  Variables
    temp_c : Réel
    temp_f : Réel
  Début
    Ecrire("Veuillez entrer la température en degrés Celsius :")
    Lire(temp_c)
    
    temp_f ← temp_c * 1.8 + 32
    
    Ecrire("La température en degrés Fahrenheit est : ", temp_f)
  Fin

Exercice 2 : Calcul du Prix TTC

Concevez un algorithme qui calcule le prix Toutes Taxes Comprises (TTC) d'un produit. L'algorithme doit demander à l'utilisateur le prix Hors Taxe (HT) et le pourcentage de la taxe (TVA).

Indice de calcul : Si le prix HT est 100 et la TVA est de 20%, le prix TTC est $100\times (1+20/100)=120$.

Algorithme CalculPrixTTC
  Variables
    prix_ht : Réel
    taux_tva : Réel
    prix_ttc : Réel
  Début
    Ecrire("Entrez le prix Hors Taxe (HT) :")
    Lire(prix_ht)
    
    Ecrire("Entrez le taux de TVA en pourcentage (ex: 20) :")
    Lire(taux_tva)
    
    prix_ttc ← prix_ht * (1 + taux_tva / 100)
    
    Ecrire("Le prix Toutes Taxes Comprises (TTC) est : ", prix_ttc)
  Fin

Résumé de la leçon

Félicitations ! Vous avez atteint l'objectif final de ce premier module. Vous êtes maintenant capable non seulement de lire et d'analyser un algorithme, mais aussi d'en créer un vous-même pour résoudre un problème simple.

• La conception d'algorithmes est une méthode : en suivant les étapes (Analyse, E/S, Variables, Séquence), vous pouvez aborder les problèmes de manière structurée.
• Un algorithme séquentiel exécute des instructions dans un ordre strict, de Début à Fin, sans déviation.
• La clarté est essentielle : bien nommer ses variables et décomposer les calculs rend un algorithme plus lisible et plus facile à maintenir, un principe fondamental du "code clean".

Et après ?

Jusqu'à présent, nos algorithmes suivent un chemin unique, comme une autoroute sans sortie. Mais que se passe-t-il si nous devons prendre une décision ? "Si l'utilisateur a plus de 18 ans, afficher 'Majeur', sinon afficher 'Mineur'".

Dans la prochaine leçon, qui marquera le début du module 2, nous introduirons les structures de contrôle conditionnelles. Vous apprendrez à utiliser le Si...Alors...Sinon pour que vos algorithmes puissent prendre des décisions et exécuter différentes actions en fonction des données. Cela ouvrira un tout nouveau champ de possibilités