Le pseudo-code représentation d'un algorithme

--- title: Le pseudo-code représentation d'un algorithme tags: algorithmie robots: noindex, nofollow author: Julien Noyer --- # Le pseudo-code : représentation d'un algorithme ![](https://i.imgur.com/SIrAfJx.png) En algorithmie, le pseudo-code - ou LDA pour Langage de Description d'Algorithmes - est une façon de décrire un algorithme dans un langage presque naturel et limitant un maximum les références propres à tel ou tel langage de programmation : le but d'un algorithme est de pouvoir être traduit dans n'importe quel langage. L'écriture en pseudo-code permet de prendre toute la mesure de la difficulté de la mise en œuvre de l'algorithme, et de développer une démarche structurée dans la construction de celui-ci. Son aspect descriptif permet de décrire en détail l'algorithme et permet une vision qui passe outre certains aspects complexes propre à la programmation informatique. Dans la mesure où il n'existe pas réellement de règles ou de convention établie pour l'écriture en pseudo-code, il est néanmoins nécessaire d'établir une structure - ou vocabulaire - qui puisse être compris par le plus grand nombre. Nous allons définir dans ce document la convention à suivre dans le cadre de la session de cours. ## Structure d'un algorithme en pseudo-code Dans la mesure ou notre pseudo-code doit représenter notre algorithme qui a pour but d'être développé et installer sur une machine, il faut respecter une structure informatique pour organiser le pseudo-code. Tous les pseudo-code doivent absolument respecter la structure suivante : ```bash ALGORITHME <name_algo> // Déclarer les variables START // Effectuer les functions END ``` > Quel que soit votre algorithme, il doit toujours contenir cette structure. ## Règles générales Chaque mot-clef et en majuscule - __FUNCTION__ (FONCTION) - __WHILE__ (TANT QUE) - __IF, ELSE, ELSE IF__ (SI, ET SI, SINON) - __SWITCH__ (SELON) - __FOR__ (POUR) Les fonction natives sont également en majuscule : - __PRINT__ (AFFICHER) - __RETURN__ (ENVOYER) Les noms des variables et des fonctions sont en ASCII, sans espaces et en anglais: - user_age - user_name > Interdiction formelle de déclarer une variable __var_1__, __VAR_1__ Les commentaire sont écrit : - // De cette manière - /* De cette manière - multi-ligne */ ## Typer une variable En algorithmie, il est primordial de typer les variables pour rendre la lecture du pseudo-code efficace. Les types possibles utilisables sont : - __INTEGER__ : 14, -345 - __FLOAT__ : 1.4, -76.98 - __BOOLEAN__ : True/False - __CHAR__ : "a", "T" - __STRING__ : "Hello", "bonjour" - __ARRAY__ : ["algorithmie", true, 18] - __<OBJECT_TYPE>__ : USER, SKILLS Pour déclarer une variable et la typer, il faut donner un nom à la variable et ajouter le type après le symbole `:` comme dans les exemples ci-dessous : - user_age: __INTEGER__ - user_name: __STRING__ Pour affecter une valeur à une variable, il faut utiliser une flèche droite/gauche de cette manière : - user_age __<- 39__ - user_name __<- "Julien"__ > Il est possible de déclarer une variable, son type et son contenu d'une seule fois : `user_age: INTEGER <- 39` Les __tableaux__ sont des collections permettant de stocker des données afin d'effectuer des boucles sur ces données. Les tableaux peuvent être de type unique ou multiple : ```bash // Déclaration notes: ARRAY<Number> options: ARRAY<STRING | BOOLEAN> // Affectation notes <- [12, 15, 9] options <- [ true, "Off" ] ``` Un __<OBJECT_TYPE>__ est une notion qui reprend la logique objet des langage de programmation. Selon notre programme nous pouvons avoir besoin de variables spécifiques que nous créerons de la manière suivante : ```bash // Création OBJECT User: name: STRING age: INTEGER END OBJECT // Affectation newUser: User // Assignation newUser <- { "Juien", 39 } ``` > L'affectation et l'assignation peuvent être fait en une fois : `newUser: User <- { "Juien", 39 }` --- # Les conditions En programmation une condition __IF / ELSE IF / ELSE__ permet de tester une ou plusieurs variables pour lancer une ou des fonctions spécifiques : ``` IF user_age < 12 THEN PRINT("User is a Kid") ELSE IF user_age < 18 THEN PRINT("User is a teenager") ELSE PRINT("USer is major") END IF ``` Lorsque qu'une condition comprend plusieurs possibilités pré-établie, il faut utiliser la condifiotn __SWITCH__ : ``` // Declaration user_gender: INTEGER <- 2 SWITCH user_gender 1 : PRINT("User is a woman") 2 : PRINT("User is a man") 3 : PRINT("User is a bot") DEFAULT PRINT("User gender unknow") END SWITCH ``` --- ## Les boucles En programmation, une boucle permet de réaliser une même opération plusieurs fois sur une collection de données, cette notion est essentielle, car elle est présente dans tous les langages de programmation informatique. ## La boucle TANT QUE (WHILE) ``` // Declaration i: INTEGER <- 20 WHILE i < 10 PRINT("The value of 'i' is: " + i) i <- i + 1 END WHILE ``` ## La boucle POUR (FOR) La boucle __POUR__ permet également de faire des boucles, mais avec une syntaxe différentes, plus proche des langages de programmation : ``` // Declaration i: INTEGER <- 20 FOR i FROM 0 TO 10 [ i <- i + 1 ] PRINT("The value of 'i' is: " + i) END FOR ``` > Il est conseiller de s'habituer à la syntaxe de la boucle __FOR__. --- # Les fonctions Une **fonction** est un ensemble de d'instructions regroupées en une méthode qu'il est possible de déclencher à tout moment dans notre pseudo-code - dans la mesure ou la déclaration précède l'exécution. Une fonction et un petit algorithme à elle toute seule, il est donc possible d'y déclarer des variables, mais elles ne seront disponible hors de la fonction que si elles sont retournées - avec le mot clef __RETURN__. ``` FUNCTION add( a: INTEGER, b: INTEGER ): STRING // Declare result: STRING START result <- a + b RETURN "La somme de a + b est " + result END /FUNCTION // Appeler la fonction somme: STRING <- add(12, 34) ```