# Pseudo-code > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/rKkxWayZPHM?si=qLXksHSXpGKqW9wi" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## Introduction Après avoir exploré la logique combinatoire et les algorigrammes pour représenter des séquences d'opérations, nous abordons le pseudo-code. Le pseudo-code constitue une étape cruciale dans la conception d'algorithmes, offrant une description textuelle structurée, plus détaillée que l'algorigramme, mais sans les contraintes syntaxiques d'un langage de programmation spécifique. Il sert de pont entre la pensée logique et l'implémentation concrète. ## 1. Qu'est-ce que le Pseudo-code ? > [!definition] Définition > Le **pseudo-code** est une description informelle et de haut niveau d'un algorithme ou d'un programme informatique. Il utilise les conventions structurelles d'un langage de programmation, mais est destiné à la lecture humaine plutôt qu'à l'exécution par une machine. Le pseudo-code est un langage universel et agnostique à la technologie, permettant aux concepteurs de se concentrer sur la logique algorithmique sans se soucier des spécificités d'un langage de programmation particulier. Il est plus précis qu'une description en langage naturel et plus flexible qu'un algorigramme, qui peut devenir complexe pour des algorithmes de grande taille. > [!note] Remarque > Contrairement aux algorigrammes qui sont visuels et utilisent des symboles standardisés, le pseudo-code n'a pas de norme syntaxique universelle stricte. Cependant, des conventions communes facilitent sa compréhension. ## 2. Syntaxe et Conventions de Base Bien qu'il n'y ait pas de norme unique, certaines conventions sont largement adoptées pour rendre le pseudo-code clair et concis. ### 2.1. Déclaration et Affectation de Variables * **Déclaration :** Les variables sont généralement déclarées avec leur type (facultatif mais recommandé pour la clarté). * `VARIABLE nom_variable : TYPE` * Ex: `VARIABLE compteur : ENTIER`, `VARIABLE estValide : BOOLEEN` * **Affectation :** L'opérateur d'affectation est souvent représenté par une flèche gauche ou le signe égal. * `nom_variable <- valeur` ou `nom_variable = valeur` * Ex: `compteur <- 0`, `message <- "Bonjour"` ### 2.2. Opérateurs Les opérateurs sont similaires à ceux rencontrés en mathématiques et en logique combinatoire : * **Arithmétiques :** `+`, `-`, `*`, `/`, `%` (modulo) * **Comparaison :** `=`, `!=` (différent de), `<`, `>`, `<=`, `>=` * **Logiques :** `ET`, `OU`, `NON` ### 2.3. Structures de Contrôle Les structures de contrôle définissent le flux d'exécution de l'algorithme. #### 2.3.1. Structures Conditionnelles > [!example] Structure `SI...ALORS...FIN_SI` > ```pseudo > SI condition ALORS > { > // Instructions si la condition est vraie > } > ``` > [!example] Structure `SI...ALORS...SINON...FIN_SI` > ```pseudo > SI condition ALORS > { > // Instructions si la condition est vraie > } > SINON > { > // Instructions si la condition est fausse > } > ``` #### 2.3.2. Structures Itératives (Boucles) > [!example] Boucle `POUR...DE...A...FAIRE...` > ```pseudo > POUR variable DE debut A fin [PAR pas] FAIRE > { > // Instructions à répéter > } > ``` > Ex: `POUR i DE 1 A 10 FAIRE { AFFICHER i } > [!example] Boucle `TANT_QUE...FAIRE...` > ```pseudo > TANT_QUE condition FAIRE > { > // Instructions à répéter tant que la condition est vraie > } > ``` ### 2.4. Fonctions et Procédures Le pseudo-code permet de définir et d'appeler des sous-programmes. > [!example] Définition de fonction/procédure > ```pseudo > FONCTION NomFonction(parametre1 : TYPE, parametre2 : TYPE) : TYPE_RETOUR > { > // Corps de la fonction > RETOURNER valeur > } > ``` > ```pseudo > PROCEDURE NomProcedure(parametre1 : TYPE) > { > // Corps de la procédure (ne retourne pas de valeur) > } > ``` > [!example] Appel de fonction/procédure > `resultat <- NomFonction(argument1, argument2)` > `NomProcedure(argument)` ## 3. Exemple Complet : Calcul de la Factorielle Calculons la factorielle d'un nombre entier $n$ ($n! = n \times (n-1) \times \dots \times 1$). > [!example] Algorithme de la Factorielle en pseudo-code > ```pseudo > ALGORITHME CalculFactorielle(n : ENTIER) : ENTIER > { > SI n < 0 ALORS > { > AFFICHER "Erreur : La factorielle n'est définie que pour les nombres positifs." > RETOURNER -1 // Indicateur d'erreur > } > SI n = 0 ALORS > { > RETOURNER 1 // 0! = 1 par convention > } > > VARIABLE resultat : ENTIER > resultat <- 1 > > POUR i DE 1 A n FAIRE > { > resultat <- resultat * i > } > > RETOURNER resultat > } > ``` ## 4. Avantages et Limites ### 4.1. Avantages * **Clarté et Lisibilité :** Facilite la compréhension de la logique algorithmique par des humains. * **Indépendance du Langage :** Permet de concevoir des algorithmes sans être lié à la syntaxe d'un langage spécifique, préparant ainsi le terrain pour des langages comme Python. * **Focus sur la Logique :** Aide à se concentrer sur la résolution du problème plutôt que sur les détails d'implémentation. * **Outil de Communication :** Facilite la collaboration entre développeurs et non-développeurs. * **Facilite le Débogage :** Permet de détecter des erreurs logiques avant l'implémentation. ### 4.2. Limites * **Pas de Standard Strict :** L'absence de norme universelle peut parfois mener à des ambiguïtés si les conventions ne sont pas clairement établies au sein d'une équipe. * **Non Exécutable :** Le pseudo-code ne peut pas être exécuté directement par une machine ; il doit être traduit en un langage de programmation. * **Moins Visuel :** Moins intuitif que les algorigrammes pour visualiser le flux de contrôle pour des algorithmes très simples ou pour les débutants. ## Résumé Le pseudo-code est un outil fondamental en algorithmique, permettant de décrire un algorithme de manière structurée et compréhensible, sans les contraintes d'un langage de programmation. Il sert de passerelle essentielle entre la conception logique (parfois initiée par des algorigrammes) et l'implémentation concrète. La maîtrise du pseudo-code est cruciale pour traduire efficacement une idée en un programme fonctionnel, et facilitera grandement l'apprentissage de langages de programmation comme Python. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]