Skip to main content
Back to path

Welcome to a Grasp lesson

Create a free account to keep studying and create your own study path.

Lesson 75

Algorithme complet en pseudo-code.

Recommended resources

Bonjour !

Dans la leçon précédente, nous avons dessiné le plan de notre "Gestionnaire de Contacts Simplifié" en définissant son architecture modulaire. Nous savons maintenant quelles fonctions sont nécessaires et comment elles interagissent. C'est une étape de conception cruciale.

Aujourd'hui, nous passons de l'architecture à la construction. L'objectif est de prendre ce plan et de bâtir l'application brique par brique. Concrètement, vous allez écrire en pseudo-code l'algorithme complet, en implémentant chacune des fonctions que nous avons définies. C'est le moment où la logique prend vie et où notre projet devient un programme tangible, prêt à être testé.

À la fin de cette leçon, vous aurez un algorithme complet et fonctionnel en pseudo-code, un véritable plan directeur pour un futur codage en Java.

1. Les Règles du Jeu : Écrire un Bon Pseudo-Code

Avant de nous lancer dans l'écriture, rafraîchissons-nous la mémoire sur les conventions d'un pseudo-code clair et structuré. Un bon pseudo-code est à mi-chemin entre le langage naturel et un vrai langage de programmation. Sa clarté est essentielle pour votre objectif de "code clean".

Structure d'un Algorithme
Rappelez-vous de cette structure de base. Nous allons remplir la partie déclarative (variables, constantes, types) et le corps, qui contiendra nos fonctions et le programme principal.

Pour vous guider, je vous propose de consulter un document qui résume les bonnes pratiques.

Règles du bon pseudocode

Ce document, 'Règles du bon pseudocode', est un excellent mémento. Il formalise la syntaxe que nous allons utiliser, ce qui garantit que notre algorithme sera compréhensible et sans ambiguïté.

Survolez rapidement les sections 'Règles générales' (indentation, une instruction par ligne), 'Opérations primitives' (Lire, Écrire, ←), 'Autres opérations' (opérateurs arithmétiques, logiques), et 'Fonctions et répétitives'. Concentrez-vous sur les exemples de la colonne 'Correct'. L'objectif n'est pas de tout mémoriser, mais de vous familiariser avec la syntaxe que nous allons utiliser.

Les points clés à retenir pour notre projet :

  • Déclaration : ALGORITHME, TYPES, VARIABLES
  • Structure : DEBUT ... FIN, PROCEDURE Nom(...), FONCTION Nom(...)
  • Affectation : variable ← valeur
  • Interaction : Lire variable, Ecrire "message", variable
  • Contrôle : SI...ALORS...SINON...FINSI, TANT QUE...FAIRE...FINTANTQUE, POUR...DE...A...FAIRE...FINPOUR
  • Fonctions : Retourner valeur pour renvoyer un résultat.

2. Implémentation des Fonctions : Brique par Brique

Nous allons maintenant écrire le corps de chaque module défini dans la leçon précédente. Nous procéderons logiquement, en commençant par les fonctions utilitaires les plus simples pour finir par les plus complexes qui les utilisent.

Déclarations initiales

Commençons par définir les types et variables dont notre algorithme aura besoin. Ces déclarations sont globales à tout l'algorithme.

ALGORITHME GestionnaireDeContacts

TYPES
    Contact = ENREGISTREMENT
        nom: CHAINE
        prenom: CHAINE
        telephone: CHAINE
    FIN ENREGISTREMENT

VARIABLES
    annuaire: TABLEAU[1..100] DE Contact
    nb_contacts_actuels: ENTIER
    choix_utilisateur: CARACTERE

Module 1 : AfficherMenu

Une procédure simple qui affiche les options. Pas de logique, juste de l'affichage.

PROCEDURE AfficherMenu()
DEBUT
    Ecrire("------------------------------------")
    Ecrire("Gestionnaire de Contacts")
    Ecrire("Veuillez choisir une option :")
    Ecrire("A - Ajouter un contact")
    Ecrire("L - Lister tous les contacts")
    Ecrire("R - Rechercher un contact")
    Ecrire("S - Supprimer un contact")
    Ecrire("Q - Quitter")
    Ecrire("------------------------------------")
FIN

Module 2 : AfficherUnContact

Une autre procédure utilitaire, qui prend un contact en paramètre et affiche ses informations.

PROCEDURE AfficherUnContact(contact_a_afficher: Contact)
DEBUT
    Ecrire("Nom: ", contact_a_afficher.nom, ", Prénom: ", contact_a_afficher.prenom, ", Tel: ", contact_a_afficher.telephone)
FIN

Module 3 : RechercherContact

C'est notre première fonction avec une vraie logique. Elle parcourt le tableau et retourne l'indice du contact trouvé, ou -1 s'il n'existe pas.

FONCTION RechercherContact(ann: TABLEAU DE Contact, nb: ENTIER, nom_recherche: CHAINE, prenom_recherche: CHAINE) : ENTIER
VAR
    i: ENTIER
DEBUT
    POUR i DE 1 A nb FAIRE
        SI ann[i].nom = nom_recherche ET ann[i].prenom = prenom_recherche ALORS
            Retourner i // Contact trouvé, on retourne son indice
        FINSI
    FINPOUR
    Retourner -1 // Le contact n'a pas été trouvé après avoir tout parcouru
FIN

Module 4 : ListerContacts

Cette procédure utilise une boucle pour parcourir l'annuaire et appelle AfficherUnContact pour chaque entrée. C'est un bel exemple d'interaction entre modules.

PROCEDURE ListerContacts(ann: TABLEAU DE Contact, nb: ENTIER)
VAR
    i: ENTIER
DEBUT
    Ecrire("--- Liste des contacts ---")
    SI nb = 0 ALORS
        Ecrire("L'annuaire est vide.")
    SINON
        POUR i DE 1 A nb FAIRE
            AfficherUnContact(ann[i])
        FINPOUR
    FINSI
    Ecrire("--------------------------")
FIN

Module 5 : AjouterContact

La logique se complexifie. Cette procédure doit gérer l'ajout, vérifier les doublons et l'espace disponible. Notez l'utilisation du mot-clé VAR devant les paramètres ann et nb pour indiquer qu'ils sont passés par référence et que la procédure peut les modifier.

PROCEDURE AjouterContact(VAR ann: TABLEAU DE Contact, VAR nb: ENTIER)
VAR
    nouveau_nom, nouveau_prenom, nouveau_tel: CHAINE
    indice_trouve: ENTIER
DEBUT
    SI nb >= 100 ALORS
        Ecrire("Erreur : L'annuaire est plein.")
        Retourner // On quitte la procédure
    FINSI

    Ecrire("Saisir le nom :")
    Lire nouveau_nom
    Ecrire("Saisir le prénom :")
    Lire nouveau_prenom

    // On vérifie si le contact existe déjà
    indice_trouve ← RechercherContact(ann, nb, nouveau_nom, nouveau_prenom)

    SI indice_trouve <> -1 ALORS
        Ecrire("Erreur : Ce contact existe déjà.")
    SINON
        Ecrire("Saisir le numéro de téléphone :")
        Lire nouveau_tel
        
        nb ← nb + 1 // On incrémente le nombre de contacts
        ann[nb].nom ← nouveau_nom
        ann[nb].prenom ← nouveau_prenom
        ann[nb].telephone ← nouveau_tel
        Ecrire("Contact ajouté avec succès.")
    FINSI
FIN

Module 6 : SupprimerContact

Cette procédure recherche un contact et, s'il est trouvé, le supprime en décalant les éléments suivants pour combler le vide. C'est une manipulation classique de tableau.

PROCEDURE SupprimerContact(VAR ann: TABLEAU DE Contact, VAR nb: ENTIER)
VAR
    nom_a_supprimer, prenom_a_supprimer: CHAINE
    indice_a_supprimer: ENTIER
    i: ENTIER
DEBUT
    Ecrire("Saisir le nom du contact à supprimer :")
    Lire nom_a_supprimer
    Ecrire("Saisir le prénom du contact à supprimer :")
    Lire prenom_a_supprimer

    indice_a_supprimer ← RechercherContact(ann, nb, nom_a_supprimer, prenom_a_supprimer)

    SI indice_a_supprimer = -1 ALORS
        Ecrire("Erreur : Ce contact n'existe pas.")
    SINON
        // On décale tous les éléments situés après l'indice à supprimer
        POUR i DE indice_a_supprimer A nb - 1 FAIRE
            ann[i] ← ann[i + 1]
        FINPOUR

        nb ← nb - 1 // On décrémente le nombre total de contacts
        Ecrire("Contact supprimé avec succès.")
    FINSI
FIN

Remarque : nous pourrions aussi créer une procédure RechercherEtAfficherContact pour l'option 'R' du menu, mais pour rester simple, nous réutiliserons les briques existantes dans le programme principal.

3. L'Orchestration : Le Programme Principal

Maintenant que toutes nos briques sont prêtes, il nous faut un "maître d'œuvre" : le programme principal. Son rôle est d'initialiser les variables, puis de lancer une boucle qui affiche le menu, lit le choix de l'utilisateur et appelle la bonne procédure.

// Début du corps principal de l'algorithme

DEBUT
    // Initialisation
    nb_contacts_actuels ← 0
    choix_utilisateur ← ''

    // Boucle principale du programme
    TANT QUE choix_utilisateur <> 'Q' FAIRE
        AfficherMenu()
        Ecrire("Votre choix ?")
        Lire choix_utilisateur

        // SELON (ou SI/SINONSI) pour gérer les options
        SI choix_utilisateur = 'A' ALORS
            AjouterContact(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'L' ALORS
            ListerContacts(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'S' ALORS
            SupprimerContact(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'R' ALORS
            // Pour rechercher, on combine les briques existantes
            VAR nom_rech, prenom_rech: CHAINE
            VAR indice: ENTIER
            Ecrire("Saisir le nom à rechercher :")
            Lire nom_rech
            Ecrire("Saisir le prénom à rechercher :")
            Lire prenom_rech
            indice ← RechercherContact(annuaire, nb_contacts_actuels, nom_rech, prenom_rech)
            SI indice = -1 ALORS
                Ecrire("Contact non trouvé.")
            SINON
                Ecrire("Contact trouvé :")
                AfficherUnContact(annuaire[indice])
            FINSI
        SINONSI choix_utilisateur = 'Q' ALORS
            Ecrire("Au revoir !")
        SINON
            Ecrire("Choix invalide. Veuillez réessayer.")
        FINSI
    FINTANTQUE
FIN

4. L'Algorithme Complet

Pour une vue d'ensemble, voici l'intégralité de notre pseudo-code. Vous pouvez voir comment les déclarations, les procédures/fonctions et le programme principal s'agencent pour former un tout cohérent. C'est l'aboutissement de notre travail de conception et d'implémentation.

Pour vous inspirer de la structure finale, vous pouvez regarder l'Exercice VIII du document suivant, qui organise un programme de gestion de menu de manière très similaire.

[PDF] CORRIGE : Les procédures et les fonctions - CNRS

Le document 'CORRIGE : Les procédures et les fonctions' propose dans son Exercice VIII un exemple complet de programme modulaire avec un menu. C'est un excellent modèle pour voir comment assembler les différentes parties.

Regardez la structure de l'Exercice VIII. Notez comment le programme principal est une simple boucle Répéter...Jusqu'à qui appelle des procédures comme Voir, Supprimer, Ajouter. Observez aussi comment ces procédures en appellent d'autres (ex: Ajouter appelle Existe et Insérer).

Voici donc notre projet finalisé en pseudo-code :

Cliquez ici pour voir le pseudo-code complet du Gestionnaire de Contacts 
ALGORITHME GestionnaireDeContacts

TYPES
    Contact = ENREGISTREMENT
        nom: CHAINE
        prenom: CHAINE
        telephone: CHAINE
    FIN ENREGISTREMENT

VARIABLES
    annuaire: TABLEAU[1..100] DE Contact
    nb_contacts_actuels: ENTIER
    choix_utilisateur: CARACTERE

---------------------------------------------------------------------
PROCEDURE AfficherMenu()
DEBUT
    Ecrire("------------------------------------")
    Ecrire("Gestionnaire de Contacts")
    Ecrire("Veuillez choisir une option :")
    Ecrire("A - Ajouter un contact")
    Ecrire("L - Lister tous les contacts")
    Ecrire("R - Rechercher un contact")
    Ecrire("S - Supprimer un contact")
    Ecrire("Q - Quitter")
    Ecrire("------------------------------------")
FIN

---------------------------------------------------------------------
PROCEDURE AfficherUnContact(contact_a_afficher: Contact)
DEBUT
    Ecrire("Nom: ", contact_a_afficher.nom, ", Prénom: ", contact_a_afficher.prenom, ", Tel: ", contact_a_afficher.telephone)
FIN

---------------------------------------------------------------------
FONCTION RechercherContact(ann: TABLEAU DE Contact, nb: ENTIER, nom_recherche: CHAINE, prenom_recherche: CHAINE) : ENTIER
VAR
    i: ENTIER
DEBUT
    POUR i DE 1 A nb FAIRE
        SI ann[i].nom = nom_recherche ET ann[i].prenom = prenom_recherche ALORS
            Retourner i
        FINSI
    FINPOUR
    Retourner -1
FIN

---------------------------------------------------------------------
PROCEDURE ListerContacts(ann: TABLEAU DE Contact, nb: ENTIER)
VAR
    i: ENTIER
DEBUT
    Ecrire("--- Liste des contacts ---")
    SI nb = 0 ALORS
        Ecrire("L'annuaire est vide.")
    SINON
        POUR i DE 1 A nb FAIRE
            AfficherUnContact(ann[i])
        FINPOUR
    FINSI
    Ecrire("--------------------------")
FIN

---------------------------------------------------------------------
PROCEDURE AjouterContact(VAR ann: TABLEAU DE Contact, VAR nb: ENTIER)
VAR
    nouveau_nom, nouveau_prenom, nouveau_tel: CHAINE
    indice_trouve: ENTIER
DEBUT
    SI nb >= 100 ALORS
        Ecrire("Erreur : L'annuaire est plein.")
        Retourner
    FINSI

    Ecrire("Saisir le nom :")
    Lire nouveau_nom
    Ecrire("Saisir le prénom :")
    Lire nouveau_prenom

    indice_trouve ← RechercherContact(ann, nb, nouveau_nom, nouveau_prenom)

    SI indice_trouve <> -1 ALORS
        Ecrire("Erreur : Ce contact existe déjà.")
    SINON
        Ecrire("Saisir le numéro de téléphone :")
        Lire nouveau_tel
        
        nb ← nb + 1
        ann[nb].nom ← nouveau_nom
        ann[nb].prenom ← nouveau_prenom
        ann[nb].telephone ← nouveau_tel
        Ecrire("Contact ajouté avec succès.")
    FINSI
FIN

---------------------------------------------------------------------
PROCEDURE SupprimerContact(VAR ann: TABLEAU DE Contact, VAR nb: ENTIER)
VAR
    nom_a_supprimer, prenom_a_supprimer: CHAINE
    indice_a_supprimer: ENTIER
    i: ENTIER
DEBUT
    Ecrire("Saisir le nom du contact à supprimer :")
    Lire nom_a_supprimer
    Ecrire("Saisir le prénom du contact à supprimer :")
    Lire prenom_a_supprimer

    indice_a_supprimer ← RechercherContact(ann, nb, nom_a_supprimer, prenom_a_supprimer)

    SI indice_a_supprimer = -1 ALORS
        Ecrire("Erreur : Ce contact n'existe pas.")
    SINON
        POUR i DE indice_a_supprimer A nb - 1 FAIRE
            ann[i] ← ann[i + 1]
        FINPOUR

        nb ← nb - 1
        Ecrire("Contact supprimé avec succès.")
    FINSI
FIN

---------------------------------------------------------------------
// Programme Principal
---------------------------------------------------------------------
DEBUT
    nb_contacts_actuels ← 0
    choix_utilisateur ← ''

    TANT QUE choix_utilisateur <> 'Q' FAIRE
        AfficherMenu()
        Ecrire("Votre choix ?")
        Lire choix_utilisateur

        SI choix_utilisateur = 'A' ALORS
            AjouterContact(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'L' ALORS
            ListerContacts(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'S' ALORS
            SupprimerContact(annuaire, nb_contacts_actuels)
        SINONSI choix_utilisateur = 'R' ALORS
            VAR nom_rech, prenom_rech: CHAINE
            VAR indice: ENTIER
            Ecrire("Saisir le nom à rechercher :")
            Lire nom_rech
            Ecrire("Saisir le prénom à rechercher :")
            Lire prenom_rech
            indice ← RechercherContact(annuaire, nb_contacts_actuels, nom_rech, prenom_rech)
            SI indice = -1 ALORS
                Ecrire("Contact non trouvé.")
            SINON
                Ecrire("Contact trouvé :")
                AfficherUnContact(annuaire[indice])
            FINSI
        SINONSI choix_utilisateur = 'Q' ALORS
            Ecrire("Au revoir !")
        SINON
            Ecrire("Choix invalide. Veuillez réessayer.")
        FINSI
    FINTANTQUE
FIN

Conclusion

Félicitations ! Vous avez transformé une conception modulaire en un algorithme complet et fonctionnel. C'est une étape majeure qui concrétise tout ce que nous avons appris jusqu'ici.

Points clés à retenir :

  • L'implémentation suit la conception : nous avons écrit le code de chaque fonction en respectant la signature définie.
  • Les fonctions s'appuient les unes sur les autres : AjouterContact appelle RechercherContact, ListerContacts appelle AfficherUnContact, etc. C'est la force de la modularité.
  • Le programme principal agit comme un chef d'orchestre, initialisant le système et coordonnant les appels aux fonctions en fonction des entrées de l'utilisateur.
  • Ce pseudo-code est maintenant une recette précise, prête à être traduite dans n'importe quel langage de programmation.

Notre algorithme est écrit, mais est-il correct ? Fonctionne-t-il comme prévu dans tous les cas ? Dans la prochaine leçon, nous allons jouer le rôle de l'ordinateur et valider la logique de notre algorithme en le traçant manuellement avec des jeux de données de test. C'est l'étape de vérification, indispensable pour garantir la qualité de notre travail.