Chapitre2 ASD1

STRUCTURE GÉNÉRALE D'UN ALGORITHME

Un ALGORITHME utilise un ensemble de mots-clés et de structure permettant de décrire de

manière complete et claire, l’ensemble des opérations à exécuter sur des données pour obtenir
des résultats ; on n’hésitera donc pas à clarifier un ALGORITHME par de nombreux
commentaires. L’avantage d’un tel langage est de pouvoir être facilement transcrit dans un
langage de programmation.

Les mots clés

Dans un Algorithmique certains mots sont réservés pour un usage bien défini, on les nomme
les mots clés. Un mot clé ne peut pas être déclaré comme identificateur. Ils ne peuvent être
utilisés comme variables

Ceux qui nous permettent de définir la structure :

- Algorithme : permet de définir ou de donner le nom à l’algorithme.

- Début : marque le commencement de l’algorithme.

- FinAlgo : marque la fin de l’algorithme

- Variables : c’est une partie de l’algorithme qui Permet de déclarer des variables ;
une variable est un objet dont le contenu peut changer au cours de l’exécution de l’algorithme.

- Constantes : c’est une partie de l’algorithme qui permet de déclarer des constantes. Une
constante est un objet dont le contenu reste invariant lors de l’exécution d’un algorithme.

- Réel, Caractères, Entiers, Chaine et Booléen sont des mots clés qui permettent de
définir des types (nous y reviendrons un peu plus loin dans cet ouvrage).

- Si, Finsi, Tantque, Fintantque, Pour, Finpour, Répéter, Jusqu ‘à… : mots clés
permettant de définir les structures itératives, conditionnelles…

- Les commentaires sont utilisés pour permettre une interprétation aisée de l’algorithme.

1
 Chapitre2 ASD1

Leur utilisation est vivement conseillée. De ce fait, tout texte placé entre les
symboles /* */ sera considéré comme un commentaire.

I- Structure générale d’un algorithme

L’entête : Cette partie permet tout simplement de donner un nom à notre algorithme. Ce
nom n’influence en rien le bon déroulement de l’algorithme. En général il faut donner des noms
significatifs à nos algorithmes, ceci pour permettre au lecteur d’avoir une idée de ce que fera
l’algorithme qu’il lira.

2
 Chapitre2 ASD1

les déclarations : c’est une liste exhaustive des objets, utilisés et manipulés dans le corps de
l’algorithme. Cette liste est placée en début d’algorithme.

le corps : dans cette partie de l’algorithme sont placées les tâches (instructions opérations …)
à exécuter par notre algorithme.

II. Variables , Constantes et Commentaires

Dans un algorithme, il faut stocker les données à traiter. Certaines de ces données sont
connues et ne varieront pas tout le long de l'algorithme : il s'agit des constantes. D'autres
données peuvent être inconnues (elle seront fonction du choix de l'utilisateur, ou du temps...)
ou susceptibles d'évoluer au cours de l'algorithme : il s'agit des variables.

Les variables

Toutes les variables ont un type. Dans chaque algorithme, toutes les variables et leurs types
sont explicitées dans le lexique. On dit que la variable est déclarée.

D'un point de vue mathématique, la déclaration revient à l'expression "Soit ... un ...".

Le lexique est noté comme suit :

Variables
identifiant_de_la_variable : type de la variable;
...

Un exemple

Variables
n : entier
a : réel
réponse : booléen
nomfamille : chaîne de caractère

Dans cet exemple, nous avons 4 variables.

Du point de vue mathématique, on aurait pu énoncer "Soit n un entier", "Soit a un réel", "Soit
reponse un booléen cad vrai ou faux ", etc.

3
 Chapitre2 ASD1

Les constantes

De la même façon, les constantes sont déclarées dans une partie Constantes de cette façon :

Constantes
nom_de_la_constante : type = valeur

Un exemple

A priori, on peut considérer que PI ne risque pas de changer de valeur pendant un algorithme.
On peut donc déclarer PI en tant que constante.

Constantes
pi = 3.14
...

Une seule constante est déclarée.

Les commentaires

Comme dit precedemment, les commentaires sont utilisés pour permettre une interprétation
aisée de l’algorithme. Leur utilisation est vivement conseillée. De ce fait, tout texte placé
entre les symboles /* */ sera considéré comme un commentaire

III. Les types simples

Un type est la façon de comprendre la signification d'une donnée. Prenons la donnée 4 : elle
peut être de type entier (de valeur 4 : 3+1), de type caractère (le caractère "4"), est-ce un
réel... ?

Chaque type a donc son ensemble de valeurs possibles et des opérateurs qui lui sont propres.
Par exemple, le type entier qui peut prendre des valeurs telles que 10 ou 12345 ...

Dans notre cours nous allons introduire cinq types, les plus couramment utilisés en
informatique :

• entier

4
 Chapitre2 ASD1

• réel
• caractère
• chaîne de caractères
• booléen (vrai ou faux)

IV. Les expressions et les opérateurs

Un opérateur transforme des données. Par exemple, la somme est un opérateur qui transforme
des données en une autre donnée.

Les opérateurs sont des fonctions mathématiques et à ce titre, ils ont un espace de départ et un
espace d'arrivée. Cette propriété s'étend aux opérateurs puisque chaque opérateur a un ou
plusieurs types de départ (fonction à une ou plusieurs variables) et un type d'arrivée.

Prenons la fonction mathématique « somme ». On pourrait noter :

somme : ℕ² → ℕ :

x,y → x+y.

De la même façon, l'opérateur somme ajoute deux données de type "entier" et renvoie
un "entier". Remarquez que "a+b" est une notation de somme(a,b).

Pour chaque opérateur que vous découvrez ou utilisez, demandez-vous toujours quels sont les
types de départ et d'arrivée. Beaucoup d'erreurs sont dues à des opérateurs mal utilisés.

Une expression est une combinaison d'opérateur et de données. Par exemple "4+3" est une
expression comportant un opérateur et deux données de type "entier". Toutes les expressions
ont une valeur, "4+3" a la valeur 7 ; 7 est une donnée de type "entier".

Une expression est donc une suite d'opérateurs et de données qui doit respecter les règles
imposées par l'usage des opérateurs.

V. Les instructions, les blocs d'instructions

Nous avons vu qu'un algorithme est une séquence d'instructions ; de quoi s'agit-il
exactement ? Les instructions sont les actions devant être effectuées par l'algorithme. Elle
peuvent requérir que l'on précise certaines informations.

5
 Chapitre2 ASD1

les instructions de base

Voici expliquées les instructions que l'on retrouvera très fréquemment dans des algorithmes.
Il s'agit des instructions Ecrire et Lire en plus de l'affectation .

L'ecriture : Ecrire

Ecrire permet d'afficher des données à l'écran et ainsi de communiquer avec l'utilisateur.

Pour cette instruction, on doit préciser une expression qui sera évaluée avant d'être affichée.

Quelques exemples :

Ecrire ("ceci est un exemple : on affiche une chaîne, sans utiliser de variables")

Ce programme affiche :

ceci est un exemple : on affiche une chaîne, sans utiliser de variables

Si l'algorithme contient

Constantes
PI = 9

Le programme

Ecrire(PI)

affiche

La lecture : Lire

6
 Chapitre2 ASD1

La fonction Lire permet de demander à l'utilisateur de fournir des informations. Chaque

information donnée par l'utilisateur est stockée dans une variable (attention au type !). Vous
précisez cette variable dans les parenthèses.

Un exemple : nous réalisons un algorithme qui demande à l'utilisateur d'entrer son âge. Tout
d'abord il apparaîtra dans le lexique :

Lexique
age : entier /* l'âge donné par l'utilisateur */

Pour demander l'âge :

Lire(age)

L'affectation : 

L'affectation est une instruction qui consiste à inscrire dans une variable une valeur calculée
depuis une expression. Attention : la nouvelle valeur affectée « écrase » la précédente.

C'est donc la deuxième façon que nous apprenons de donner une valeur à une variable. La
première était d'utiliser l'instruction Lire qui permet de demander la valeur à l'utilisateur. On

peut dire que l'instruction Lire est une forme particulière d'affectation.

Pour effectuer une affectation, on utilise l'instruction affecter . On précise entre parenthèses

la variable affectée ainsi que l'expression de la valeur de l'affectation.

On pourra également noter l'affectation ← ou := . Ce symbole peut être énoncé « prend pour

valeur ». Attention toutefois à ne pas la noter = bien que certains langages utilisent cette

notation. Ce serait un dangereux raccourci de pensée avec les mathématiques

Un exemple : voici notre lexique

Lexique
n : entier

On affecte à n la valeur 12 :

7
 Chapitre2 ASD1

affecter(n, 12)
n <- 12

A partir de maintenant la variable n vaut 12. Ainsi, l'instruction

Ecrire(n)

provoquera l'affichage suivant :

12

Dans la suite du cours, nous utiliserons la notation  , moins lourde.

Les blocs d'instructions

Souvent, l'exécution d'une seule instruction ne suffit pas pour faire un algorithme complet.
Nous pouvons faire en sorte que plusieurs instructions soient considérées comme une seule.
Pour cela, il faut créer un bloc d'instructions. Partout où l'on peut mettre une instruction, on
peut mettre un bloc d'instructions.

Concrètement, on procède ainsi : les instructions sont séparées par un saut de ligne ou par ; .

Le bloc d'instruction est précédé de Début et suivi de Fin .

Un exemple :

Début
instruction1
instruction2
Ecrire("Cet affichage est la troisième instruction")
instruction4
Fin