---
# System prepended metadata

title: Le pseudo-code représentation d'un algorithme
tags: [algorithmie]

---

---
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.

<br><br>

## 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.

<br><br>

## 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 */

<br><br>

## 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 }`

---

<br><br><br><br>

# 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
```

---

<br><br><br><br>

## 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.

<br><br>

## La boucle TANT QUE (WHILE)

```
// Declaration
i: INTEGER <- 20

WHILE i < 10
  PRINT("The value of 'i' is: " + i)
  i <- i + 1

END WHILE
```

<br><br>

## 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__.

---

<br><br><br><br>

# 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)
```