Cours Algorithme : Langage Algorithmique - Exercices Algorithmiques

INTRODUCTION

Pour réaliser un traitement exécutable sur ordinateur, il faut distinguer deux étapes :

• Définir la logique du traitement en vue d’obtenir le résultat souhaité
• traduire cette logique à l’aide d’un langage de programmation compréhensible de l’ordinateur (formules de calcul sur tableur, langage de macro-commandes des logiciels outils ou langage de programmation)

 

I/ DEFINITION ET REPRESENTATION D’UN  ALGORITHME

A/ Définition

Un algorithme c’est « l’ensemble des règles opératoires et des procédés définis en vue d’obtenir un résultat déterminé au moyen d’un nombre finis d’opérations » (selon l’ AFNOR)

Il faut donc définir une succession logique de tâches à automatiser.

B/ Représentation des algorithmes

Pour représenter un algorithme, on peut recourir à diverses méthodes :

• organigramme de programmation
• Langage structuré (pseudo code)

Exemple :

II/ COMPOSANTS D’UN ALGORITHME

A/ Structure générale d’un algorithme

Un algorithme comprend deux parties :

• l’entête qui contient la déclaration des variables : pour chaque variable utilisée, on définit le type de données qu’elle contient (voir B) : entier, réel, logique ou alphanumérique (pour éviter tous problèmes, les variables doivent être déclarées préalablement à leur utilisation)
• le corps : contient l’ensemble des actions.

-----------------------------------
ALGO NOM_DE_L’ALGO
Déclaration des variables
DEBUT
     Actions et conditions
FIN
-----------------------------------

B/ Constantes et variables
 

1) Définition

Les variables et les constantes correspondent à des zones de stockage de la mémoire vive.  Elles permettent de conserver des valeurs en vue d’ un traitement.
Une variable peut être mise à jour par l’utilisateur (par l’action SAISIR) exemple : SAISIR Caff ou être modifiée par une action exemple : Rist <- Caff*0,12 : la variable Rist est affectée par le calcul Caff * 0,12

La saisie peut être précédée d’une phrase explicative :

Forme 1
--------------------------------------------------
AFFICHER « Saisissez le chiffre d’affaires »
SAISIR Caff
--------------------------------------------------

Forme 2 (plus pratique car on gagne une ligne)
----------------------------------------------------
SAISIR(« Saisissez le chiffre d’affaires », Caff)
----------------------------------------------------

Une constante, en revanche, est définie une fois pour toute à l’intérieur du « programme »  (avant les déclarations de variables) et ne peut pas être modifiée par l’utilisateur. Une constante correspond à un paramètre.

Exemple : même exemple que ci dessus mais cette fois on décide que le taux de remise de 12% constitue une constante :
-----------------------------------------------------------------
CONSTANTES
         TxRist =0,12
    VARIABLES
        Caff : Réel simple
        Rist  : Réel simple
DEBUT
       SAISIR(« Saisissez le chiffre d’affaires », Caff)
               SI Caff >12000
                    ALORS Rist<-Caff*TxRist
                    SINON Rist <- 0
               FIN SI
    AFFICHER « La ristourne est de » ; Rist
FIN
-----------------------------------------------------------------

2) Types de données
 

Les types de données utilisables sont les suivants :

• Réel : nombre à virgule
• Entier
• Chaîne : texte de longueur fixe (CHAINE DE 15 CARACTERES) ou de longueur variable (mot clé CHAINE utilisée sans rien)
• Caractère : Un seul caractère « 0 », « 1 »,…  « a », « A » par exemple
• Booléen : valeur logique pouvant être .VRAI. ou .FAUX.

Le type des données est défini dans la section Déclaration de variables. Lorsque plusieurs variables sont de même type, on peut les regrouper sur une même ligne. Exemple :
------------------------------------------------------------------
Caff, Rist : Réel
------------------------------------------------------------------
Revient au même que
------------------------------------------------------------------
      Caff : Réel simple
      Rist  : Réel simple
     ------------------------------------------------------------------

3) Assignation de valeurs à des variables

L’opérateur d’affectation est le suivant :  <-

Exemples :

L’opérateur & permet de concaténer des chaînes de caractères

Remarques :

• Pour additionner des  nombres ou concaténer du texte, les types de données doivent être compatibles (ex : on ne peut pas additionner des chiffres avec du texte
• Pour rendre compatible des données entre elles, on peut utiliser des fonctions de conversion (CVCHAINE et CVNOMBRE)

C/ Procédures et fonctions

Pour alléger l’écriture du programme, il est possible de rédiger des procédures qui sont appelées dans le corps du programme et des fonctions personnalisées chargées d’effectuer des calculs plus ou moins complexes

-    Une procédure exécute un traitement mais ne renvoie pas de valeur
-    Une fonction renvoie des valeurs pouvant être exploitées dans le corps du programme

Une procédure comme une fonction peut accepter des paramètres d’entrée. La valeur de ces paramètres est alors utilisée à l’intérieur de la procédure ou de la fonction.

Par ailleurs, le pseudo langage algorithmique comporte des fonctions dites génériques qu’on peut utiliser en l’état. Exemple : la fonction CVCHAINE(Argument)

Algorithme
-----------------------------------------------------------------------------------------------
    Corps de l’algorithme
    NomProcédure(variable) ‘la procédure est appelée et le contenu de variable est passé en
                 paramètres
    …
    ResultatFonction <- NomFonction(variable2)  ‘le contenu de variable2 est passé en paramètre
                                 de la fonction
FIN

PROCEDURE NomProcédure(paramètre1 : type)
    Actions internes à la procédure
FIN PROCEDURE
FONCTION NomFonction(Param1, Param2 : type) : Type
    Actions internes à la fonction
FIN FONCTION
-----------------------------------------------------------------------------------------------

Concrétisons :

A partir de l’exemple initial, on veut identifier l’utilisateur du programme (prénom) et afficher un message de bienvenue (procédure Accueil)   on veut créer une fonction calculant la ristourne (CalcRistourne).  L’algorithme devient alors :

-----------------------------------------------------------------------------------------------
VARIABLES
    ChiffAffaires : Réel
       
DEBUT
    Accueil()   
     SAISIR(« Saisissez le chiffre d’affaires », ChiffAffaires)
     AFFICHER « La ristourne est de » & CVCHAINE(CalcRistourne(ChiffAffaires))
FIN

     PROCEDURE Accueil() ‘cette procédure ne comporte aucun argument
        VARIABLES
        Pren : CHAINE
            SAISIR (« Saisissez votre prénom », Pren)
            AFFICHER « Bonjour » & Pren
    FIN PROCEDURE

            FONCTION CalcRistourne(Caff : Réel) : Réel
        CONSTANTES
             TxRist =0,12
                   SI Caff >12000
                                ALORS CalcRistourne<-Caff*TxRist
                                SINON CalcRistourne <- 0
                       FIN SI
    FIN FONCTION
-----------------------------------------------------------------------------------------------

Commentaires :

• L’algorithme est beaucoup plus facile à lire et à « déboguer »
• Le corps du programme est allégé (3 lignes)
• Les procédures et les fonctions personnalisées pourront être réutilisées à divers endroits du programme ce qui permet d’économiser du temps
• Attention : les variables déclarées à l’intérieur d’une procédure ou d’une fonction ont une portée locale (c’est à dire limitée à la procédure ou à la fonction)

III/ LES STRUCTURES ALTERNATIVES

Elles permettent d’exécuter des actions obéissant à une condition déterminée

A/ La structure SI …FIN SI (abordée en 1ère année)
--------------------------------------------------------------------
SI Condition
    ALORS
        Exécuter les actions si la condition est VRAIE
    SINON
        Exécuter les conditions si la condition est FAUSSE
FIN SI
--------------------------------------------------------------------

La condition fait intervenir les opérateurs de comparaison suivant :

• < ; <= ; = ; > ; >= ; <>
• Pour les valeurs booléennes, on peut aussi utiliser l’opérateur NON
• Il est possible d’imbriquer les SI.
• On peut combiner les conditions avec les opérateurs ET ou OU

Exemple : SI Notes<12 ET Notes>8 : la condition sera vraie si notes est comprise entre 8 et 12

Exemple :

Présentez l’algorithme permettant de déterminer le taux de ristourne à appliquer au chiffre d’affaires en fonction des conditions suivantes :

Caff <= 1 500 € => ristourne = 1%
1 500 €< Caff <= 2 000 € => ristourne = 2%
2 000 €< Caff <3 000 € => ristourne = 3%
Caff>=2000 € => ristourne=4%

----------------------------------------------------------------------------------------------
ALGO Calcul_ristourne
    VARIABLES
        Caff : Réel
        TxRist : Réel
    DEBUT
        SAISIR(« Saisissez le CA ? », CA)
        SI CA<1500
            ALORS TxRist<- 0,01
            SINON SI CA <=2000
                    ALORS TxRist<- 0,02
                    SINON SI CA<= 3000
                            ALORS TxRist<-0,03
                            SINON TxRist<- 0,04
                        FIN SI
                FIN SI
        FIN SI
        AFFICHER « Taux de ristourne : » ; TxRist
    FIN
----------------------------------------------------------------------------------------------

B/ La structure SELON … CAS … FIN SELON
 

Les SI imbriqués deviennent vite lourd à gérer et à présenter. Pour palier cet inconvénient, on peut recourir à la structure SELON … CAS… FIN SELON

-----------------------------------------------------------------------------------------------
SELON Variable
    CAS Valeur1 :
        Action si Variable contient la valeur Valeur1
    CAS Valeur2, Valeur3 :
        Action si Variable contient la valeur Valeur2 ou valeur3
    CAS SINON :
        Action si Variable ne contient aucune des valeurs figurant dans les CAS précédent
FIN SELON
-----------------------------------------------------------------------------------------------

Remarque : à la ligne CAS on peut aussi utiliser le mot clé EST (du verbe être) et A

Exemple : CAS EST<1000
        CAS 1000 A 1500 (correspond à un intervalle continue de valeurs)

Exemple : Reprenons l’exemple précédent

-----------------------------------------------------------------------------------------------
ALGO Calcul_ristourne_avec_SELON
    VARIABLES
        Caff : Réel
        TxRist : Réel
    DEBUT
        SAISIR(« Saisissez le CA ? », Caff)
        SELON Caff
            CAS EST <1500 :
                TxRist<- 0,01
            CAS EST <2000 :
                TxRist<-0,02
            CAS EST<3000 :
                TxRist<- 0,03
            CAS SINON :
                TxRist <- 0,04
        FIN SELON
        AFFICHER « Taux de ristourne : » ; TxRist
    FIN
-----------------------------------------------------------------------------------------------

IV/ LES STRUCTURES ITERATIVES
 

A/ La boucle REPETER ... JUSQU’A Condition

Elle vise à décrire des traitements répétitifs qui s’arrêtent lorsqu’une condition déterminée est remplie. Les actions sont exécutées au moins une fois quelque soit la condition
----------------------------------------------
REPETER
    Actions à exécuter
JUSQU'A Condition
----------------------------------------------

Exemple :

On souhaite imprimer un état comprenant :

• le nom des clients
• le chiffre d’affaires
• le taux de ristourne
• le montant de la ristourne (arrondi à 2 décimales)

(on ne se souciera pas de la mise en forme)
Exemple de résultat à obtenir :

Ecran :
---------------------------------------------------------------------------------
Nom du client ?  Dupont
Chiffres d’affaires ? 1000
Taux de ristourne ? 20%
Voulez-vous saisir un autre client ? Oui : Tapez 1 – Non : taper 2 : 2
---------------------------------------------------------------------------------

Impression
---------------------------------------------------------------------------------
Nom Client    |    Caff      |  % Ristourne   |  Montant ristourne
LALOU        500        10%        50
DURAND    700          5%        35
…..        ….        …..        ….
DUPONT    1000        20%        200
---------------------------------------------------------------------------------

Par simplification, on considérera que l’impression se fait parallèlement à la saisie. Dès que l’utilisateur saisit le taux de ristourne, la ligne est imprimée. L’état comporte au moins une ligne de valeur.

-----------------------------------------------------------------------------------------------
Algo Impression_etat
VARIABLES
    Caff : Réel
    TxRist : réel
    MontantRist : Réel
    NomCli : chaîne(25)  ‘La variable NomCli contiendra au maximum 25 lettres
    Encore : Entier
DEBUT
IMPRIMER « ETAT DES RISTOURNES »
IMPRIMER « Nom Client    |    Caff      |  % Ristourne   |  Montant ristourne »
     REPETER
        SAISIR (« Nom du client ? », NomCli)
        SAISIR (« Chiffres d’affaires ? », Caff)
        SAISIR (« Taux de ristourne ? », TxRist
        MontantRistourne<-ARRONDI(Caff*TxRist,2)
        IMPRIMER NomCli, Caff, TxRist, MontantRistourne
        SAISIR(« Voulez-vous saisir un autre client ? Oui : Tapez 1 – Non : taper 2 », Encore)
    JUSQU'A Encore :=2
-----------------------------------------------------------------------------------------------

La boucle s’arrêtera aussitôt que l’utilisateur aura saisi la valeur 2.
   
B/ La boucle TANT QUE Condition ... FIN TANT QUE
 

Tant que la condition est vraie, les actions à l’intérieur de la boucle sont exécutées. Contrairement à la boucle REPETER … JUSQU'A, les actions peuvent ne pas être exécutées si la condition n’est pas remplie au début.
----------------------------------------------------------------------------------------------
TANT QUE Condition
    Actions à exécuter tant que la condition est vraie
FIN TANT QUE
----------------------------------------------------------------------------------------------

Exemple : Reprise de l’exemple précédent mais en utilisant une boucle TANT QUE – FIN TANT QUE
-----------------------------------------------------------------------------------------------
Algo Impression_etat
VARIABLES
    Caff : Réel
    TxRist : réel
    MontantRist : Réel
    NomCli : chaîne(25)  ‘La variable NomCli contiendra au maximum 25 lettres
    Encore : Entier
DEBUT
IMPRIMER « ETAT DES RISTOURNES »
IMPRIMER « Nom Client    |    Caff      |  % Ristourne   |  Montant ristourne »
    Encore <-1 ‘Initialisation de la variable Encore à 1
     TANT QUE Encore :=1
        SAISIR (« Nom du client ? », NomCli)
        SAISIR (« Chiffres d’affaires ? », Caff)
        MontantRistourne<-ARRONDI(Caff*TxRist,2)
        IMPRIMER NomCli, Caff, TxRist, MontantRistourne
        SAISIR(« Voulez-vous saisir d’autres clients ? Oui : Tapez 1 – Non : taper 2 », Encore)
    FIN TANT QUE
-----------------------------------------------------------------------------------------------

Remarque : pour que la boucle soit exécutée au moins une fois, on « force » la valeur de la variable Encore à

1. On constate par ailleurs que les conditions sont inversées par rapport à celle définie dans la structure REPETER … JUSQU’A

C/ La boucle POUR... FIN POUR
 

Elle permet d’exécuter une suite d’actions un nombre déterminé de fois. Le nombre d’itérations est connu à l’avance

Exemple 1

On veut afficher la table de multiplication de 1

Résultat à obtenir :

1 X 1 = 1
1 X 2 = 2
…
1 X 10 =10
----------------------------------------------------------------------------------------
Algo table_multiplication_de_1
VARIABLES
        I : entier
DEBUT
    POUR I :=1 JUSQU'A 10
        AFFICHER CVCHAINE(I) & « X 1 = » & CVCHAINE(I*1)
    FIN POUR
FIN
----------------------------------------------------------------------------------------

Exemple2 : Boucle imbriquée
 

Cette fois ci on souhaite afficher plusieurs tables de multiplication. On demande à l’utilisateur de saisir la première table qu’il souhaite et la dernière Résultat à obtenir
-------------------------------------
1ère table ? 3
Dernière table ? 5
Table de multiplication de 3
3 X 1= 3
3 X 2= 6
…
3 X 10 = 30
Table de multiplication de 4
4 X 1= 4
…
4 X 10 = 40
Table de multiplication de 5
5 X 1 = 5
…
5 X 10 = 50
-------------------------------------
---------------------------------------------------------------------------------------------
VARIABLES
        I,J : entier
        PremTable, DerTable: entier
DEBUT
    SAISIR(« 1ère table ? », PremTable)
    SAISIR(« Dernière table ? », DerTable)
    POUR I :=PremTable JUSQU'A DerTable)
    AFFICHER « Table de multiplication de » & CVCHAINE(I)
        POUR J :=1 JUSQU'A 10
    AFFICHER CVCHAINE(J) & « X » &CVCHAINE(I) &  « = » & CVCHAINE(J*I)
    FIN POUR
    FIN POUR
FIN
---------------------------------------------------------------------------------------------