Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

INTRODUCTION
Le but de la programmation est de fournir à l’ordinateur une liste d’instructions qui lui
permettent de résoudre un problème.
Avant d’écrire le programme, il est primordial de comprendre le problème, savoir quoi
faire et aussi savoir comment le faire faire à l’ordinateur.

Problème à Enoncé du Algorithme Programme

résoudre problème

Compréhension Résolution Codification

du problème du problème

 La compréhension du problème
L’étude de l’énoncé porte principalement sur la recherche des données fournies et
des résultats attendus.
 La résolution du problème
Il s’agit de trouver les structures de données adaptées ainsi que les structures de
traitement qui permettront de trouver les résultats à partir des données ; on aboutit à
un algorithme.
 La codification
C’est la traduction de l’algorithme en un programme écrit dans un langage
compréhensible par l’ordinateur.

N.B : Il est absolument nécessaire de tester algorithme et programme afin de les

valider. Pour cela, on réalise un jeu d’essai.

1
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre I : Généralités sur l’algorithme

I.1. Définition de l’algorithme

Avez-vous déjà ouvert un livre de recettes de cuisine ? Avez- vous déjà déchiffré un
mode d’emploi traduit directement du coréen pour faire fonctionner un magnétoscope
ou un répondeur téléphonique réticent ? Si oui, sans le savoir, vous avez déjà
exécuté des algorithmes.
Plus fort : avez-vous déjà indiqué un chemin à un touriste égaré ? Avez- vous fait
chercher un objet à quelqu’un par téléphone ? Ecrit une lettre anonyme stipulant
comment procéder à une remise de rançon ? Si oui, vous avez déjà fabriqué – et fait
exécuter – des algorithmes.
Un algorithme, c’est une suite d’instructions, qui une fois exécutée
correctement, conduit à un résultat donné. Si l’algorithme est juste, le résultat est
le résultat voulu, et le touriste se retrouve là où il voulait aller. Si l’algorithme est faux,
le résultat est, disons, aléatoire, et décidément, cette saloperie de répondeur ne veut
rien savoir.
Complétons toutefois cette définition. Après tout, en effet, si l’algorithme, comme on
vient de le dire, n’est qu’une suite d’instructions menant celui qui l’exécute à résoudre
un problème, pourquoi ne pas donner comme instruction unique : « résous le
problème », et laisser l’interlocuteur se débrouiller avec ça ? A ce tarif, n’importe qui
serait champion d’algorithmique sans faire aucun effort. Pas de ça Helena, ce serait
trop facile.
Le malheur (ou le bonheur, tout dépend du point de vue) est que justement, si le
touriste vous demande son chemin, c’est qu’il ne le connaît pas. Donc, si on n’est
pas un goujat intégral, il ne sert à rien de lui dire de le trouver tout seul. De même les
modes d’emploi contiennent généralement (mais pas toujours) un peu plus
d’informations que « débrouillez- vous pour que ça marche ».
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions
compréhensibles par celui qui devra l’exécuter. C’est d’ailleurs l’un des points
délicats pour les rédacteurs de modes d’emploi : les références culturelles, ou
lexicales, des utilisateurs, étant variables, un même mode d’emploi peut être très
clair pour certains et parfaitement abscons pour d’autres.

I.2. Les qualités d’un bon Algorithme

Nous le savons tous que l'algorithme est un moyen pour le programmeur de

présenter son approche du problème à d'autres personnes. En effet, un algorithme
est l'énoncé dans un langage bien défini d'une suite d'opérations permettant de
répondre au problème. A cet effet, un algorithme doit donc être :

 Lisible: l'algorithme doit être compréhensible même par un non-informaticien ;

 de haut niveau: l'algorithme doit pouvoir être traduit en n'importe quel langage
de programmation, il ne doit donc pas faire appel à des notions techniques
relatives à un programme particulier ou bien à un système d'exploitation
donné ;

2
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

 précis: chaque élément de l'algorithme ne doit pas porter à confusion, il est

donc important de lever toute ambiguïté ;
 concis: un algorithme ne doit pas dépasser une page. Si c'est le cas, il faut
décomposer le problème en plusieurs sous-problèmes ;
 structuré: un algorithme doit être composé de différentes parties facilement
identifiables

I.3. L’algorithme et la Programmation

Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En quoi a-t-on

besoin d’un langage spécial, distinct des langages de programmation
compréhensibles par les ordinateurs ?
Parce que l’algorithmique exprime les instructions résolvant un problème donné
indépendamment des particularités de tel ou tel langage. Pour prendre une
image, si un programme était une dissertation, l’algorithmique serait le plan, une fois
mis de côté la rédaction et l’orthographe. Or, vous savez qu’il vaut mieux faire
d’abord le plan et rédiger ensuite que l’inverse…
Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un
programme informatique. Cette dimension est présente quelle que soit le langage de
programmation ; mais lorsqu’on programme dans un langage (en C, en Visual Basic,
etc.) on doit en plus se colleter les problèmes de syntaxe, ou de types d’instructions,
propres à ce langage. Apprendre l’algorithmique de manière séparée, c’est donc
sérier les difficultés pour mieux les vaincre.
A cela, il faut ajouter que des générations de programmeurs, souvent autodidactes
(mais pas toujours, hélas !), ayant directement appris à programmer dans tel ou tel
langage, ne font pas mentalement clairement la différence entre ce qui relève de la
structure logique générale de toute programmation (les règles fondamentales de
l’algorithmique) et ce qui relève du langage particulier qu’ils ont appris. Ces
programmeurs, non seulement ont beaucoup plus de mal à passer ensuite à un
langage différent, mais encore écrivent bien souvent des programmes qui même s’ils
sont justes, restent laborieux. Car on n’ignore pas impunément les règles
fondamentales de l’algorithmique… Alors, autant l’apprendre en tant que telle !

I.4. Conventions d’écriture d’un algorithme

Historiquement, plusieurs types de notations ont représenté des algorithmes.

Il y a eu notamment une représentation graphique, avec des carrés, des losanges,
etc. qu’on appelait des organigrammes. Aujourd’hui, cette représentation est
quasiment abandonnée, pour deux raisons. D’abord, parce que dès que l’algorithme
commence à grossir un peu, ce n’est plus pratique du tout. Ensuite parce que cette
représentation favorise le glissement vers un certain type de programmation, dite non
structurée (nous définirons ce terme plus tard), que l’on tente au contraire d’éviter.
C’est pourquoi on utilise généralement une série de conventions appelée « pseudo-
code », qui ressemble à un langage de programmation authentique dont on aurait

3
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

évacué la plupart des problèmes de syntaxe. Ce pseudo-code est susceptible de

varier légèrement d’un livre (ou d’un enseignant) à un autre. C’est bien normal : le
pseudo-code, encore une fois, est purement conventionnel ; aucune machine n’est
censée le reconnaître. Donc, chaque cuisinier peut faire sa sauce à sa guise, avec
ses petites épices bien à lui, sans que cela prête à conséquence.

4
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre II. Les variables

II.1. Rôle des variables

Dans un programme informatique, on va avoir en permanence besoin de stocker

provisoirement des valeurs. Il peut s’agir de données issues du disque dur, fournies
par l’utilisateur (frappées au clavier), ou que sais-je encore. Il peut aussi s’agir de
résultats obtenus par le programme, intermédiaires ou définitifs. Ces données
peuvent être de plusieurs types (on en reparlera) : elles peuvent être des nombres,
du texte, etc. Toujours est-il que dès que l’on a besoin de stocker une information au
cours d’un programme, on utilise une variable.
Pour employer une image, une variable est une boîte, que le programme
(l’ordinateur) va repérer par une étiquette. Pour avoir accès au contenu de la boîte, il
suffit de la désigner par son étiquette.

II.2. Déclaration des variables

La première chose à faire avant de pouvoir utiliser une variable est de créer la boîte
et de lui coller une étiquette. Ceci se fait tout au début de l’algorithme, avant même
les instructions proprement dites. C’est ce qu’on appelle la déclaration des
variables.
Le nom de la variable (l’étiquette de la boîte) obéit à des impératifs changeant selon
les langages. Toutefois, une règle absolue est qu’un nom de variable peut comporter
des lettres et des chiffres, mais qu’il exclut la plupart des signes de ponctuation, en
particulier les espaces. Un nom de variable correct commence également
impérativement par une lettre. Quant au nombre maximal de signes pour un nom de
variable, il dépend du langage utilisé.
En pseudo-code algorithmique, on est bien sûr libre du nombre de signes pour un
nom de variable, même si pour des raisons purement pratiques, on évite
généralement les noms à rallonge.
Lorsqu’on déclare une variable, il ne suffit pas de créer une boîte (réserver un
emplacement mémoire) ; encore doit-on préciser ce que l’on voudra mettre dedans,
car de cela dépendent la taille de la boîte (de l’emplacement mémoire) et le type de
codage (autrement dit, le type de variable) utilisé.

5
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

II.2.1. Types de variables

II.2.1.1. Type Numérique classique

Commençons par le cas très fréquent, celui d’une variable destinée à recevoir des
nombres.
Si l’on réserve un octet pour coder un nombre, je rappelle qu’on ne pourra coder que
8
2 = 256 valeurs différentes. Cela peut signifier par exemple les nombres entiers de 1
à 256, ou de 0 à 255, ou de –127 à +128… Si l’on réserve deux octets, on a droit à
65 536 valeurs ; avec trois octets, 16 777 216, etc. Et là se pose un autre problème :
ce codage doit-il représenter des nombres décimaux ? des nombres négatifs ?
Bref, le type de codage choisi pour un nombre va déterminer :
 Les valeurs maximales et minimales des nombres pouvant être stockés dans
la variable ;
 La précision de ces nombres (dans le cas de nombres décimaux).
Tous les langages, quels qu’ils soient offrent un « bouquet » de types numériques,
dont le détail est susceptible de varier légèrement d’un langage à l’autre. Grosso
modo, on retrouve cependant les types suivants :

Type Numérique Plage

Byte (octet) 0 à 255

Entier simple -32 768 à 32 767

Entier long -2 147 483 648 à 2 147 483 647

38 45 -45
Réel simple -3,40x10 à -1,40x10 pour les valeurs négatives 1,40x10 à
38
3,40x10 pour les valeurs positives

308 -324
Réel double 1,79x10 à -4,94x10 pour les valeurs négatives

N.B : En algorithmique, on ne se tracassera pas trop avec les sous-types de

variables numériques. On se contentera donc de préciser qu'il s'agit d'un nombre, en
gardant en tête que dans un vrai langage, il faudra être plus précis.

En pseudo-code, une déclaration de variables aura ainsi cette tête :

Variable g en Numérique
Ou encore
Variables PrixHT, TauxTVA, PrixTTC en Numérique.

6
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

II.2.1.2. Autres types numériques

Certains langages autorisent d’autres types numériques, notamment :

 Le type monétaire (avec strictement deux chiffres après la virgule)
 Le type date (jour/mois/année).
Nous n’emploierons pas ces types en algorithme ; mais je les signale, car vous ne
manquerez pas de les rencontrer en programmation proprement dite.

II.2.1.3. Type alphanumérique

Fort heureusement, les boîtes que sont les variables peuvent contenir bien d’autres
informations que des nombres. Sans cela, on serait un peu embêté dès que l’on
devrait stocker un nom de famille, par exemple.
On dispose donc également du type alphanumérique (également appelé type
caractère, type chaîne ou en anglais, le type string).
Dans une variable de ce type, on stocke des caractères, qu’il s’agisse de lettres, de
signes de ponctuation, d’espaces, ou même de chiffres. Le nombre maximal de
caractères pouvant être stockés dans une seule variable string dépend du langage
utilisé.
Un groupe de caractères (y compris un groupe de un, ou de zéro caractères), qu’il
soit ou non stocké dans une variable, d’ailleurs, est donc souvent appelé chaîne de
caractères.
En pseudo-code, une chaîne de caractères est toujours notée entre
guillemets Pour éviter deux sources principales de possibles confusions :
 La confusion entre des nombres et des suites de chiffres. Par exemple, 423
peut représenter le nombre 423 (quatre cent vingt-trois), ou la suite de
caractères 4, 2, et 3. Et ce n’est pas du tout la même chose ! Avec le premier,
on peut faire des calculs, avec le second, point du tout. Dès lors, les
guillemets permettent d’éviter toute ambiguïté : s’il n’y en a pas, 423 est
quatre cent vingt-trois. S’il y en a, "423" représente la suite des chiffres 4, 2, 3.
 Mais ce n'est pas le pire. L'autre confusion, bien plus grave, et bien plus
fréquente, consiste à se mélanger les pinceaux entre le nom d'une variable et
son contenu. Pour parler simplement, cela consiste à confondre l'étiquette
d'une boîte et ce qu'il y a à l'intérieur.

[Link] booléen

Le dernier type de variables est le type booléen : on y stocke uniquement les valeurs
logiques VRAI et FAUX.
On peut représenter ces notions abstraites de VRAI et de FAUX par tout ce qu'on
veut : de l'anglais (TRUE et FALSE) ou des nombres (0 et 1). Peu importe. Ce qui
compte, c'est de comprendre que le type booléen est très économique en termes de
place mémoire occupée, puisque pour stocker une telle information binaire, un seul
bit suffit.

7
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre III : Instructions, Expressions et opérateurs

III.1.L’instruction d’affectation

III.1.1. signification et Syntaxe

Notons que la variable (la boîte) n'est pas un outil bien sorcier à manipuler ; car, on
ne peut pas faire trente-six mille choses avec elle, mais seulement une et une seule.
Cette seule chose qu’on puisse faire avec une variable, c’est l’affecter, c’est-à-dire lui
attribuer une valeur. Pour poursuivre la superbe métaphore filée déjà employée, on
peut remplir la boîte.
En pseudo-code, l'instruction d'affectation se note avec le signe ←
Ainsi :
Toto ← 24
Attribue la valeur 24 à la variable Toto.
Ceci, soit dit en passant, sous-entend impérativement que Toto soit une variable de
type numérique. Si Toto a été défini dans un autre type, il faut bien comprendre que
cette instruction provoquera une erreur. C’est un peu comme si, en donnant un ordre
à quelqu’un, on accolait un verbe et un complément incompatibles, du genre «
Epluchez la casserole ». Même dotée de la meilleure volonté du monde, la ménagère
lisant cette phrase ne pourrait qu’interrompre dubitativement sa tâche. Alors, un
ordinateur, vous pensez bien…
On peut en revanche sans aucun problème attribuer à une variable la valeur d’une
autre variable, telle quelle ou modifiée. Par exemple :
Tutu ← Toto
Signifie que la valeur de Tutu est maintenant celle de Toto.

Notez bien que cette instruction n’a en rien modifié la valeur de Toto : une instruction
d’affectation ne modifie que ce qui est situé à gauche de la flèche.
Tutu ← Toto + 4
Si Toto contenait 12, Tutu vaut maintenant 16. De même que précédemment, Toto
vaut toujours 12.
Tutu ← Tutu + 1
Si Tutu valait 6, il vaut maintenant 7. La valeur de Tutu est modifiée, puisque Tutu est
la variable située à gauche de la flèche.
Pour revenir à présent sur le rôle des guillemets dans les chaînes de caractères et
sur la confusion numéro 2 signalée plus haut, comparons maintenant deux
algorithmes suivants :

8
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Exemple n°1
Début
Riri ← "Loulou"
Fifi ← "Riri"
Fin
Exemple n°2
Début
Riri ← "Loulou"
Fifi ← Riri
Fin
La seule différence entre les deux algorithmes consiste dans la présence ou dans
l’absence des guillemets lors de la seconde affectation. Et l'on voit que cela change
tout !
Dans l'exemple n°1, ce que l'on affecte à la variable Fifi, c'est la suite de caractères
R – i – r - i. Et à la fin de l’algorithme, le contenu de la variable Fifi est donc « Riri ».
Dans l'exemple n°2, en revanche, Riri étant dépourvu de guillemets, n'est pas
considéré comme une suite de caractères, mais comme un nom de variable. Le sens
de la ligne devient donc : « affecte à la variable Fifi le contenu de la variable Riri ». A
la fin de l’algorithme n°2, la valeur de la variable Fifi est donc « Loulou ». Ici, l’oubli
des guillemets conduit certes à un résultat, mais à un résultat différent.
A noter, car c’est un cas très fréquent, que généralement, lorsqu’on oublie les
guillemets lors d’une affectation de chaîne, ce qui se trouve à droite du signe
d’affectation ne correspond à aucune variable précédemment déclarée et affectée.
Dans ce cas, l’oubli des guillemets se solde immédiatement par une erreur
d’exécution.
Ceci est une simple illustration. Mais elle résume l’ensemble des problèmes qui
surviennent lorsqu’on oubli la règle des guillemets aux chaines de caractères.

9
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

III.1.2. Ordre des instructions

Il va de soi que l’ordre dans lequel les instructions sont écrites va jouer un rôle
essentiel dans le résultat final. Considérons les deux algorithmes suivants :
Exemple 1
Variable A en Numérique
Début
A ← 34
A ← 12
Fin
Exemple 2
Variable A en Numérique
Début
A ← 12
A ← 34
Fin
Il est clair que dans le premier cas la valeur finale de A est 12, dans l’autre elle est 34
Il est tout aussi clair que ceci ne doit pas nous étonner. Lorsqu’on indique le chemin
à quelqu’un, dire « prenez tout droit sur 1km, puis à droite » n’envoie pas les gens au
même endroit que si l’on dit « prenez à droite puis tout droit pendant 1 km ».
Enfin, il est également clair que si l’on met de côté leur vertu pédagogique, les deux
algorithmes ci-dessus sont parfaitement idiots ; à tout le moins ils contiennent une
incohérence. Il n’y a aucun intérêt à affecter une variable pour l’affecter différemment
juste après. En l’occurrence, on aurait tout aussi bien atteint le même résultat en
écrivant simplement :

Exemple 1
Variable A en Numérique
Début
A ← 12
Fin
Exemple 2
Variable A en Numérique
Début
A ← 34
Fin

10
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

III.2. Expressions et opérateurs

[Link]

Si on fait le point, on s’aperçoit que dans une instruction d’affectation, on trouve :

 à gauche de la flèche, un nom de variable, et uniquement cela. En ce monde
empli de doutes qu’est celui de l’algorithmique, c’est une des rares règles d’or
qui marche à tous les coups : si on voit à gauche d’une flèche d’affectation
autre chose qu’un nom de variable, on peut être certain à 100% qu’il s’agit
d’une erreur.

 à droite de la flèche, ce qu’on appelle une expression. Voilà encore un mot

qui est trompeur ; en effet, ce mot existe dans le langage courant, où il revêt
bien des significations. Mais en informatique, le terme d’expression ne
désigne qu’une seule chose, et qui plus est une chose très précise :

Une expression est un ensemble de valeurs, reliées par des opérateurs,

et équivalent à une seule valeur

Cette définition vous paraît peut-être obscure. Mais réfléchissez-y quelques minutes,
et vous verrez qu’elle recouvre quelque chose d’assez simple sur le fond. Par
exemple, voyons quelques expressions de type numérique. Ainsi :
7

5+4

123-45+844

Toto-12+5-Riri

…sont toutes des expressions valides, pour peu que Toto et Riri soient bien des
nombres. Car dans le cas contraire, la quatrième expression n’a pas de sens. En
l’occurrence, les opérateurs que j’ai employés sont l’addition (+) et la soustraction (-).
Revenons pour le moment sur l’affectation. Une condition supplémentaire (en plus
des deux précédentes) de validité d’une instruction d’affectation est que :
 L’expression située à droite de la flèche soit du même type que la variable
située à gauche. C’est très logique : on ne peut pas ranger convenablement
des outils dans un sac à provision, ni des légumes dans une trousse à outils…
sauf à provoquer un résultat catastrophique.

Si l’un des trois points énumérés ci-dessus n’est pas respecté, la machine sera
incapable d’exécuter l’affectation, et déclenchera une erreur (est-il besoin de dire que
si aucun de ces points n’est respecté, il y aura aussi erreur !)

11
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

III.2.2. Opérateurs

Par définition, un opérateur est un signe qui relie deux valeurs, pour produire
un résultat.

[Link]érateurs numériques

Il s’agit des quatre opérateurs arithmétiques :

 + : Addition ;
 - : Soustraction ;
 * : Multiplication ;
 / : Division
On peut également mentionner le ^ qui signifie « puissance ».Par exemple, 5 à la
puissance 5 s’écrira donc 5 ^ 5.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en
mathématiques. La multiplication et la division ont « naturellement » priorité sur
l’addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour modifier
cette priorité naturelle.
Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent strictement la même
chose, à savoir 41. Pourquoi dès lors se fatiguer à mettre des parenthèses inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile là-dedans, que du
normal.

[Link]érateur alphanumérique : &

Cet opérateur permet de concaténer, autrement dit d’agglomérer, deux chaînes de

caractères. Par exemple :
Variables A, B, C en Caractère
Début
A ← "Gloubi"
B ← "Boulga"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "GloubiBoulga"

II.3.2.3. Opérateurs de comparaison

Les opérateurs de comparaison sont :

 égal à…
 différent de…
 strictement plus petit que…
 strictement plus grand que…

12
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

 plus petit ou égal à…

 plus grand ou égal à…

[Link]érateurs logiques (ou booléens) :

Il s’agit du ET, du OU, du NON et du mystérieux (mais rarissime) XOR.

Le ET a le même sens en informatique que dans le langage courant. Pour que

"Condition1 ET Condition2" soit VRAI, il faut impérativement que Condition1 soit
VRAI et que Condition2 soit VRAI. Dans tous les autres cas, "Condition 1 et
Condition2" sera faux.
Il faut se méfier un peu plus du OU. Pour que "Condition1 OU Condition2" soit VRAI,
il suffit que Condition1 soit VRAIE ou que Condition2 soit VRAIE. Le point important
est que si Condition1 est VRAIE et que Condition2 est VRAIE aussi, Condition1 OU
Condition2 reste VRAIE. Le OU informatique ne veut donc pas dire « ou bien »
Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que "Condition1
XOR Condition2" soit VRAI, il faut que soit Condition1 soit VRAI, soit que Condition2
soit VRAI. Si toutes les deux sont fausses, ou que toutes les deux sont VRAI, alors le
résultat global est considéré comme FAUX. Le XOR est donc l'équivalent du "ou
bien" du langage courant.
J’insiste toutefois sur le fait que le XOR est une rareté, dont il n’est pas strictement
indispensable de s’encombrer en programmation.
Enfin, le NON inverse une condition : NON (Condition1) est VRAI si Condition1 est
FAUX, et il sera FAUX si Condition1 est VRAI. C'est l'équivalent pour les booléens
du signe "moins" que l'on place devant les nombres.
Alors, vous vous demandez peut-être à quoi sert ce NON. Après tout, plutôt qu’écrire
NON (Prix > 20), il serait plus simple d’écrire tout bonnement Prix=<20. Dans ce cas
précis, c’est évident qu’on se complique inutilement la vie avec le NON. Mais si le
NON n'est jamais indispensable, il y a tout de même des situations dans lesquelles il
s'avère bien utile.

On représente fréquemment tout ceci dans des tables de vérité (C1 et C2

représentent deux conditions, et on envisage à chaque fois les quatre cas
possibles) :

C1 et C2 C2 Vrai C2 Faux

C1 Vrai Vrai Faux

C1 Faux Faux Faux

13
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

C1 ou C2 C2 Vrai C2 Faux

C1 Vrai Vrai Vrai

C1 Faux Vrai Faux

C1 xor C2 C2 Vrai C2 Faux

C1 Vrai Faux Vrai

C1 Faux Vrai Faux

Non C1

C1 Vrai Faux

C1 Faux Vrai

[Link] instructions de Lecture et d’Ecriture

Les instructions de Lecture et d’Ecriture sont des instructions qui permettent à la

machine de dialoguer avec l’utilisateur.
Dans un sens, ces instructions permettent à l’utilisateur de rentrer des valeurs au
clavier pour qu’elles soient utilisées par le programme. Cette opération est la lecture.
Dans l’autre sens, d’autres instructions permettent au programme de communiquer
des valeurs à l’utilisateur en les affichant à l’écran. Cette opération est l’écriture.

Tout simplement, pour que l’utilisateur entre la (nouvelle) valeur de Helena, on mettra
: Lire Helena
Dès que le programme rencontre une instruction Lire, l’exécution
s’interrompt, attendant la frappe d’une valeur au clavier
Dès lors, aussitôt que la touche Entrée (Enter) a été frappée, l’exécution reprend.
Dans le sens inverse, pour écrire quelque chose à l’écran, c’est aussi simple que :
Ecrire Stany
Avant de Lire une variable, il est très fortement conseillé d’écrire des libellés à
l’écran, afin de prévenir l’utilisateur de ce qu’il doit frapper (sinon, le pauvre utilisateur
passe son temps à se demander ce que l’ordinateur attend de lui… et c’est très
désagréable !) :
Ecrire "Entrez votre nom : "
Lire NomFamille

14
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Lecture et Ecriture sont des instructions algorithmiques qui ne présentent pas de

difficultés particulières, une fois qu’on a bien assimilé ce problème du sens du
dialogue (homme → machine, ou machine ← homme).

Remarque :

A première vue, on peut avoir l’impression que les informaticiens étaient beurrés
comme des petits lus lorsqu’ils ont baptisé ces opérations ; puisque quand
l’utilisateur doit écrire au clavier, on appelle ça la lecture, et quand il doit lire sur
l’écran on appelle ça l’écriture. Mais avant d’agonir d’insultes une digne corporation,
il faut réfléchir un peu plus loin. Un algorithme, c’est une suite d’instructions qui
programme la machine, pas l’utilisateur ! Donc quand on dit à la machine de lire une
valeur, cela implique que l’utilisateur va devoir écrire cette valeur. Et quand on
demande à la machine d’écrire une valeur, c’est pour que l’utilisateur puisse la lire.
Lecture et écriture sont donc des termes qui comme toujours en programmation,
doivent être compris du point de vue de la machine qui sera chargée de les exécuter.
Et là, tout devient parfaitement logique.

15
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre IV : Les Tests

[Link] quoi s’agit-il ?

Prenons l’exemple de notre algorithme d’un touriste égaré ; que nous présentons de
la manière suivante : « Allez tout droit jusqu’au prochain carrefour et là regardez à
droite. Si la rue est autorisée à la circulation, alors prenez la et ensuite c’est la
deuxième à gauche. Mais si en revanche elle est en sens interdit, alors continuez
jusqu’à la prochaine à droite, prenez celle-là, et ensuite la première à droite ».
Cet algorithme prévoit une situation pouvant se présenter de deux façons
différentes, deux façons différentes d’agir. Cela suppose que l’interlocuteur (le
touriste) sache analyser la condition que nous avons fixée à son comportement (« la
rue est-elle en sens interdit ? ») pour effectuer la série d’actions correspondante.

Eh bien, les ordinateurs possèdent aussi cette aptitude, sans laquelle d’ailleurs nous
aurions bien du mal à les programmer. Nous allons donc pouvoir parler à notre
ordinateur comme à notre touriste, et lui donner des séries d’instructions à effectuer
selon que la situation se présente d’une manière ou d’une autre. Cette structure
logique répond au doux nom de test ou de structure alternative.

IV.2 Structure d’un test

Il n’y a que deux formes possibles pour un test à savoir :

 La forme simple ;
Syntaxe :
Si booléen Alors
Instructions
Finsi

 La forme complexe
Syntaxe :

Si booléen Alors
Instructions 1
Sinon Instructions 2
Finsi
Toujours est-il que la structure d’un test est relativement claire. Dans la forme la plus
simple, arrivé à la première ligne (Si… Alors) la machine examine la valeur du
booléen. Si ce booléen a pour valeur VRAI, elle exécute la série d’instructions. Cette
série d’instructions peut être très brève comme très longue, cela n’a aucune
importance. En revanche, dans le cas où le booléen est faux, l'ordinateur saute
directement aux instructions situées après le FinSi.
Dans le cas de la structure complexe, c'est à peine plus compliqué. Dans le cas où le
booléen est VRAI, et après avoir exécuté la série d'instructions 1, au moment où elle
arrive au mot « Sinon », la machine saute directement à la première instruction

16
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

située après le « FinSi ». De même, au cas où le booléen a comme valeur « Faux »,

la machine saute directement à la première ligne située après le « Sinon » et exécute
l’ensemble des « instructions 2 ». Dans tous les cas, les instructions situées juste
après le FinSi seront exécutées normalement.

En fait, la forme simplifiée correspond au cas où l’une des deux « branches » du Si

est vide. Dès lors, plutôt qu’écrire « sinon ne rien faire du tout », il est plus simple de
ne rien écrire. Et laisser un Si... complet, avec une des deux branches vides, est
considéré comme une très grosse maladresse pour un programmeur, même si cela
ne constitue pas à proprement parler une faute.
Exprimé sous forme de pseudo-code, la programmation de notre touriste de tout à
l’heure donnerait donc quelque chose du genre :
Allez tout droit jusqu’au prochain carrefour
Si la rue à droite est autorisée à la circulation Alors
Tournez à droite
Avancez
Prenez la deuxième à gauche
Sinon
Continuez jusqu’à la prochaine rue à droite
Prenez cette rue
Prenez la première à droite
Finsi

IV.2.1. Booléen

Un booléen est une expression dont la valeur est VRAI ou FAUX. Cela peut donc
être (il n’y a que deux possibilités) :
• une variable (ou une expression) de type booléen
• une condition

IV.2.2. Condition

Nous définissons essentiellement une condition comme une comparaison.

Cette définition signifie qu’une condition est composée de trois éléments :
• une valeur ;
• un opérateur de comparaison ;
• une autre valeur ;
Remarque : Les valeurs peuvent être a priori de n’importe quel type (numériques,
caractères…). Mais si l’on veut que la comparaison ait un sens, il faut que les deux
valeurs de la comparaison soient du même type !

N.B : L’ensemble des trois éléments constituant la condition constitue donc, si l’on
veut, une affirmation, qui a un moment donné est VRAIE ou FAUSSE.

17
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

IV.2.3. Conditions composées

Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas
être exprimées sous la forme simple exposée ci-dessus. Reprenons le cas « Toto est
inclus entre 5 et 8 ». En fait cette phrase cache non une, mais deux conditions. Car
elle revient à dire que « Toto est supérieur à 5 et Toto est inférieur à 8 ». Il y a donc
bien là deux conditions, reliées par ce qu’on appelle un opérateur logique, le mot
ET.

IV.3. Tests imbriqués

Graphiquement, on peut très facilement représenter un SI comme un aiguillage de

chemin de fer (ou un aiguillage de train électrique, c’est moins lourd à porter). Un SI
ouvre donc deux voies, correspondant à deux traitements différents. Mais il y a des
tas de situations où deux voies ne suffisent pas. Par exemple, un programme devant
donner l’état de l’eau selon sa température doit pouvoir choisir entre trois réponses
possibles (solide, liquide ou gazeuse).
Une première solution serait la suivante :

Variable Temp en Entier

Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
FinSi
Si Temp > 0 Et Temp < 100 Alors
Ecrire "C’est du liquide"
Finsi
Si Temp > 100 Alors
Ecrire "C’est de la vapeur"
Finsi
Fin

Vous constaterez que c’est un peu laborieux. Les conditions se ressemblent plus ou
moins, et surtout on oblige la machine à examiner trois tests successifs alors que
tous portent sur une même chose, la température de l'eau (la valeur de la variable
Temp).

Il serait ainsi bien plus rationnel d’imbriquer les tests de cette manière :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
Sinon
Si Temp < 100 Alors

18
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Ecrire "C’est du liquide"

Sinon
Ecrire "C’est de la vapeur"
Finsi
Finsi
Fin

Nous avons fait des économies : au lieu de devoir taper trois conditions, dont une
composée, nous n’avons plus que deux conditions simples. Mais aussi, et surtout,
nous avons fait des économies sur le temps d’exécution de l’ordinateur. Si la
température est inférieure à zéro, celui-ci écrit dorénavant « C’est de la glace » et
passe directement à la fin, sans être ralenti par l’examen d’autres possibilités (qui
sont forcément fausses).
Cette deuxième version n’est donc pas seulement plus simple à écrire et plus lisible,
elle est également plus performante à l’exécution.
Les structures de tests imbriqués sont donc un outil indispensable à la simplification
et à l’optimisation des algorithmes.

IV.4. De l’aiguillage à la gare de tri

Dans un programme, une structure SI peut être facilement comparée à un aiguillage

de train. La voie principale se sépare en deux, le train devant rouler ou sur l’une, ou
sur l’autre, et les deux voies se rejoignant tôt ou tard pour ne plus en former qu’une
seule, lors du FinSi. On peut schématiser cela ainsi :

Mais dans certains cas, ce ne sont pas deux voies qu’il nous faut, mais trois, ou
même plus. Dans le cas de l’état de l’eau, il nous faut trois voies pour notre « train »,
puisque l’eau peut être solide, liquide ou gazeuse. Alors, nous n’avons pas eu le
choix : pour deux voies, il nous fallait un aiguillage, pour trois voies il nous en faut
deux, imbriqués l’un dans l’autre.
Cette structure (telle que nous l’avons programmée à la page précédente) devrait
être schématisée comme suit :

19
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Soyons bien clairs : cette structure est la seule possible du point de vue logique
(même si on peut toujours mettre le bas en haut et le haut en bas). Mais du point de
vue de l’écriture, le pseudo-code algorithmique admet une simplification
supplémentaire.

Ainsi, il est possible (mais non obligatoire), que l’algorithme initial :

Variable Temp en Entier

Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C'est de la glace"
Sinon Si Temp < 100 Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Finsi
Fin

devienne :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
SinonSi Temp < 100 Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Fin
N.B : Dans le cas de tests imbriqués, le Sinon et le Si peuvent être fusionnés
en un SinonSi. On considère alors qu’il s’agit d’un seul bloc de test, conclu par
un seul FinSi.

20
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Le SinonSi permet en quelque sorte de créer (en réalité, de simuler) des aiguillages
à plus de deux branches. On peut ainsi enchaîner les SinonSi les uns derrière les
autres pour simuler un aiguillage à autant de branches que l’on souhaite.

IV.5. Variables Booléennes

Jusqu’ici, pour écrire nos des tests, nous avons utilisé uniquement des conditions.
Mais vous vous rappelez qu’il existe un type de variables (les booléennes)
susceptibles de stocker les valeurs VRAI ou FAUX. En fait, on peut donc entrer des
conditions dans ces variables, et tester ensuite la valeur de ces variables.
Reprenons l’exemple de l’eau. On pourrait le réécrire ainsi :
Variable Temp en Entier
Variables A, B en Booléen
Début
Ecrire "Entrez la température de l’eau :"
Lire Temp
A ← Temp =< 0
B ← Temp < 100
Si A Alors
Ecrire "C’est de la glace"
SinonSi B Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Finsi
Fin
A priori, cette technique ne présente guère d’intérêt : on a alourdi plutôt qu’allégé
l’algorithme de départ, en ayant recours à deux variables supplémentaires.

21
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre V : LES BOUCLES.

V.1. Introduction

Les boucles également appelés structures répétitives, voire carrément structures

itératives, c'est généralement le point douloureux de l'apprenti programmeur. C'est
là que ça coince, car autant il est assez facile de comprendre comment fonctionnent
les boucles, autant il est souvent long d'acquérir les réflexes qui permettent de les
élaborer judicieusement pour traiter un problème donné.
On peut dire en fait que les boucles constituent la seule vraie structure logique
caractéristique de la programmation. Si vous avez utilisé un tableur comme Excel,
par exemple, vous avez sans doute pu manier des choses équivalentes aux
variables (les cellules, les formules) et aux tests (la fonction SI…). Mais les boucles,
ça, ça n'a aucun équivalent. Cela n'existe que dans les langages de programmation
proprement dits.
Le maniement des boucles, s'il ne différencie certes pas l'homme de la bête (il ne
faut tout de même pas exagérer), est tout de même ce qui sépare en informatique le
programmeur de l'utilisateur, même averti.

V.2. A quoi cela sert-il ?

Prenons le cas d’une saisie au clavier (une lecture), où par exemple, le programme
pose une question à laquelle l’utilisateur doit répondre par O (Oui) ou N (Non). Mais
tôt ou tard, l’utilisateur, facétieux ou maladroit, risque de taper autre chose que la
réponse attendue. Dès lors, le programme peut planter soit par une erreur
d’exécution (parce que le type de réponse ne correspond pas au type de la variable
attendu) soit par une erreur fonctionnelle (il se déroule normalement jusqu’au bout,
mais en produisant des résultats fantaisistes).

Alors, dans tout programme un tant soit peu sérieux, on met en place ce qu’on
appelle un contrôle de saisie, afin de vérifier que les données entrées au clavier
correspondent bien à celles attendues par l’algorithme.
A vue de nez, on pourrait essayer avec un SI. Voyons voir ce que ça donne :

Variable Rep en Caractère

Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
Si Rep <> "O" et Rep <> "N" Alors
Ecrire "Saisie erronnée. Recommencez"
Lire Rep
FinSi
Fin
C’est impeccable. Du moins tant que l’utilisateur a le bon goût de ne se tromper
qu’une seule fois, et d’entrer une valeur correcte à la deuxième demande. Si l’on
veut également bétonner en cas de deuxième erreur, il faudrait rajouter un SI. Et

22
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

ainsi de suite, on peut rajouter des centaines de SI, et écrire un algorithme aussi
lourd qu’une blague des Grosses Têtes, on n’en sortira pas, il y aura toujours moyen
qu’un acharné flanque le programme par terre.
La solution consistant à aligner des SI… en pagaille est donc une impasse. La seule
issue est donc de flanquer une structure de boucle, qui se présente ainsi :

TantQue booléen
…
Instructions
…
FinTantQue
Le principe est simple : le programme arrive sur la ligne du TantQue. Il examine alors
la valeur du booléen (qui, je le rappelle, peut être une variable booléenne ou, plus
fréquemment, une condition). Si cette valeur est VRAI, le programme exécute les
instructions qui suivent, jusqu’à ce qu’il rencontre la ligne FinTantQue. Il retourne
ensuite sur la ligne du TantQue, procède au même examen, et ainsi de suite. Le
manège enchanté ne s’arrête que lorsque le booléen prend la valeur FAUX.

Illustration avec notre problème de contrôle de saisie. Une première approximation

de la solution consiste à écrire :

Variable Rep en Caractère

Début
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
FinTantQue
Fin
Là, on a le squelette de l’algorithme correct. Mais de même qu’un squelette ne suffit
pas pour avoir un être vivant viable, il va nous falloir ajouter quelques muscles et
organes sur cet algorithme pour qu’il fonctionne correctement.
Son principal défaut est de provoquer une erreur à chaque exécution. En effet,
l’expression booléenne qui figure après le TantQue interroge la valeur de la variable
Rep. Malheureusement, cette variable, si elle a été déclarée, n’a pas été affectée
avant l’entrée dans la boucle. On teste donc une variable qui n’a pas de valeur, ce
qui provoque une erreur et l’arrêt immédiat de l’exécution. Pour éviter ceci, on n’a
pas le choix : il faut que la variable Rep ait déjà été affectée avant qu’on en arrive au
premier tour de boucle. Pour cela, on peut faire une première lecture de Rep avant la
boucle. Dans ce cas, celle-ci ne servira qu’en cas de mauvaise saisie lors de cette
première lecture. L’algorithme devient alors :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
TantQue Rep <> "O" et Rep <> "N"
Lire Rep

23
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

FinTantQue
Fin
Une autre possibilité, fréquemment employée, consiste à ne pas lire, mais à affecter
arbitrairement la variable avant la boucle. Arbitrairement ? Pas tout à fait, puisque
cette affectation doit avoir pour résultat de provoquer l’entrée obligatoire dans la
boucle. L’affectation doit donc faire en sorte que le booléen soit mis à VRAI pour
déclencher le premier tour de la boucle. Dans notre exemple, on peut donc affecter
Rep avec n’importe quelle valeur, hormis « O » et « N » : car dans ce cas, l’exécution
sauterait la boucle, et Rep ne serait pas du tout lue au clavier.

Cela donnera par exemple :

Variable Rep en Caractère
Début
Rep ← "X"
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
FinTantQue
Fin
Cette manière de procéder est à connaître, car elle est employée très fréquemment.
Il faut remarquer que les deux solutions (lecture initiale de Rep en dehors de la
boucle ou affectation de Rep) rendent toutes deux l’algorithme satisfaisant, mais
présentent une différence assez importante dans leur structure logique.
En effet, si l’on choisit d’effectuer une lecture préalable de Rep, la boucle ultérieure
sera exécutée uniquement dans l’hypothèse d’une mauvaise saisie initiale. Si
l’utilisateur saisit une valeur correcte à la première demande de Rep, l’algorithme
passera sur la boucle sans entrer dedans.
En revanche, avec la deuxième solution (celle d’une affectation préalable de Rep),
l’entrée de la boucle est forcée, et l’exécution de celle-ci, au moins une fois, est
rendue obligatoire à chaque exécution du programme. Du point de vue de
l’utilisateur, cette différence est tout à fait mineure ; et à la limite, il ne la remarquera
même pas. Mais du point de vue du programmeur, il importe de bien comprendre
que les cheminements des instructions ne seront pas les mêmes dans un cas et
dans l’autre.
Pour terminer, remarquons que nous pourrions peaufiner nos solutions en ajoutant
des affichages de libellés qui font encore un peu défaut. Ainsi, si l’on est un
programmeur zélé, la première solution (celle qui inclut deux lectures de Rep, une en
dehors de la boucle, l’autre à l’intérieur) pourrait devenir :
Variable Rep en Caractère
Début
Ecrire "Voulez vous un café ? (O/N)"
Lire Rep
TantQue Rep <> "O" et Rep <> "N"
Ecrire "Vous devez répondre par O ou N. Recommencez"

24
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Lire Rep
FinTantQue
Ecrire "Saisie acceptée"
Fin

Quant à la deuxième solution, elle pourra devenir :

Variable Rep en Caractère
Début
Rep ← "X"
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" et Rep <> "N"
Lire Rep
Si Rep <> "O" et Rep <> "N" Alors
Ecrire "Saisie Erronée, Recommencez"
FinSi
FinTantQue
Fin

V.3. Boucler en comptant, ou compter en bouclant

Dans le dernier exercice, vous avez remarqué qu’une boucle pouvait être utilisée
pour augmenter la valeur d’une variable. Cette utilisation des boucles est très
fréquente, et dans ce cas, il arrive très souvent qu’on ait besoin d’effectuer un
nombre déterminé de passages. Or, a priori, notre structure TantQue ne sait pas à
l’avance combien de tours de boucle elle va effectuer (puisque le nombre de tours
dépend de la valeur d’un booléen).
C’est pourquoi une autre structure de boucle est à notre disposition :
Variable Truc en Entier
Début
Truc ← 0
TantQue Truc < 15
Truc ← Truc + 1
Ecrire "Passage numéro : ", Truc
FinTantQue
Fin

Equivaut à :
Variable Truc en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Passage numéro : ", Truc
Truc Suivant
Fin
Insistons : la structure « Pour … Suivant » n’est pas du tout indispensable ; on
pourrait fort bien programmer toutes les situations de boucle uniquement avec un «
Tant Que ». Le seul intérêt du « Pour » est d’épargner un peu de fatigue au

25
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

programmeur, en lui évitant de gérer lui-même la progression de la variable qui lui

sert de compteur (on parle d’incrémentation, encore un mot qui fera forte
impression sur votre entourage).
Dit d’une autre manière, la structure « Pour … Suivant » est un cas particulier de
TantQue : celui où le programmeur peut dénombrer à l’avance le nombre de tours de
boucles nécessaires.
Il faut noter que dans une structure « Pour … Suivant », la progression du compteur
est laissée à votre libre disposition. Dans la plupart des cas, on a besoin d’une
variable qui augmente de 1 à chaque tour de boucle. On ne précise alors rien à
l’instruction « Pour » ;

celle-ci, par défaut, comprend qu’il va falloir procéder à cette incrémentation de 1 à

chaque passage, en commençant par la première valeur et en terminant par la
deuxième.
Mais si vous souhaitez une progression plus spéciale, de 2 en 2, ou de 3 en 3, ou en
arrière, de –1 en –1, ou de –10 en –10, ce n’est pas un problème : il suffira de le
préciser à votre instruction « Pour » en lui rajoutant le mot « Pas » et la valeur de ce
pas (Le « pas » dont nous parlons, c’est le « pas » du marcheur, « step » en
anglais).
Naturellement, quand on stipule un pas négatif dans une boucle, la valeur initiale du
compteur doit être supérieure à sa valeur finale si l’on veut que la boucle tourne !
Dans le cas contraire, on aura simplement écrit une boucle dans laquelle le
programme ne rentrera jamais.
Nous pouvons donc maintenant donner la formulation générale d’une structure «
Pour ». Sa syntaxe générale est :
Pour Compteur ← Initial à Final Pas ValeurDuPas
…
Instructions
…
Compteur suivant
Les structures TantQue sont employées dans les situations où l’on doit procéder à
un traitement systématique sur les éléments d’un ensemble dont on ne connaît pas
d’avance la quantité, comme par exemple :
• le contrôle d’une saisie
• la gestion des tours d’un jeu (tant que la partie n’est pas finie, on recommence)
• la lecture des enregistrements d’un fichier de taille inconnue.
Les structures Pour sont employées dans les situations où l’on doit procéder à un
traitement systématique sur les éléments d’un ensemble dont le programmeur
connaît d’avance la quantité.
Nous verrons dans les chapitres suivants des séries d’éléments appelés tableaux
(parties 7 et 8) et chaînes de caractères (partie 9). Selon les cas, le balayage

26
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

systématique des éléments de ces séries pourra être effectué par un Pour ou par un
TantQue : tout dépend si la quantité d’éléments à balayer (donc le nombre de tours
de boucles nécessaires) peut être dénombrée à l’avance par le programmeur ou non.

V.4. Des boucles dans des boucles (« tout est dans tout... et
réciproquement »)

On rigole, on rigole !
De même que les poupées russes contiennent d’autres poupées russes, de même
qu’une structure SI … ALORS peut contenir d’autres structures SI … ALORS, une
boucle peut tout à fait contenir d’autres boucles. Y a pas de raison.
Variables Truc, Trac en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Il est passé par ici"
Pour Trac ← 1 à 6
Ecrire "Il repassera par là"
Trac Suivant
Truc Suivant
Fin
Dans cet exemple, le programme écrira une fois "il est passé par ici" puis six fois de
suite "il repassera par là", et ceci quinze fois en tout. A la fin, il y aura donc eu 15 x 6
= 90 passages dans la deuxième boucle (celle du milieu), donc 90 écritures à l’écran
du message « il repassera par là ». Notez la différence marquante avec cette
structure :
Variables Truc, Trac en Entier
Début
Pour Truc ← 1 à 15
Ecrire "Il est passé par ici"
Truc Suivant
Pour Trac ← 1 à 6
Ecrire "Il repassera par là"
Trac Suivant
Fin
Ici, il y aura quinze écritures consécutives de "il est passé par ici", puis six écritures
consécutives de "il repassera par là", et ce sera tout.

Des boucles peuvent donc être imbriquées (cas n°1) ou successives (cas n°2).
Cependant, elles ne peuvent jamais, au grand jamais, être croisées. Cela n’aurait
aucun sens logique, et de plus, bien peu de langages vous autoriseraient ne serait-
ce qu’à écrire cette structure aberrante.
Variables Truc, Trac en Entier
Pour Truc ← …
Instructions
Pour Trac ← …

27
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Instructions
Truc Suivant
instructions
Trac Suivant

Pourquoi imbriquer des boucles ? Pour la même raison qu’on imbrique des tests. La
traduction en bon français d’un test, c’est un « cas ». Eh bien un « cas » (par
exemple, « est-ce un homme ou une femme ? ») peut très bien se subdiviser en
d’autres cas (« a-t-il plus ou moins de 18 ans ? »).
De même, une boucle, c’est un traitement systématique, un examen d’une série
d’éléments un par un (par exemple, « prenons tous les employés de l’entreprise un
par un »). Eh bien, on peut imaginer que pour chaque élément ainsi considéré (pour
chaque employé), on doive procéder à un examen systématique d’autre chose («
prenons chacune des commandes que cet employé a traitées »). Voilà un exemple
typique de boucles imbriquées : on devra programmer une boucle principale (celle
qui prend les employés un par un) et à l’intérieur, une boucle secondaire (celle qui
prend les commandes de cet employé une par une).
Dans la pratique de la programmation, la maîtrise des boucles imbriquées est
nécessaire, même si elle n’est pas suffisante. Tout le contraire d’Alain Delon, en
quelque sorte.

Remarque :
Examinons l’algorithme suivant :
Variable Truc en Entier
Début
Pour Truc ← 1 à 15
Truc ← Truc * 2
Ecrire "Passage numéro : ", Truc
Truc Suivant
Fin
Vous remarquerez que nous faisons ici gérer « en double » la variable Truc, ces
deux gestions étant contradictoires. D’une part, la ligne
Pour…
augmente la valeur de Truc de 1 à chaque passage. D’autre part la ligne
Truc ← Truc * 2
double la valeur de Truc à chaque passage. Il va sans dire que de telles
manipulations perturbent complètement le déroulement normal de la boucle, et sont
causes, sinon de plantages, tout au moins d’exécutions erratiques.

28
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

Chapitre VI : Les tableaux

VI.1 Utilité des tableaux

Imaginons que dans un programme, nous ayons besoin simultanément de 12 valeurs

(par exemple, des notes pour calculer une moyenne). Evidemment, la seule solution
dont nous disposons à l’heure actuelle consiste à déclarer douze variables, appelées
par exemple Notea, Noteb, Notec, etc. Bien sûr, on peut opter pour une notation un
peu simplifiée, par exemple N1, N2, N3, etc. Mais cela ne change pas
fondamentalement notre problème, car arrivé au calcul, et après une succession de
douze instructions « Lire » distinctes, cela donnera obligatoirement une atrocité du
genre :
Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12
Ouf ! C’est tout de même bigrement laborieux. Et pour un peu que nous soyons dans
un programme de gestion avec quelques centaines ou quelques milliers de valeurs à
traiter, alors là c’est le suicide direct.
Cerise sur le gâteau, si en plus on est dans une situation on l’on ne peut pas savoir
d’avance combien il y aura de valeurs à traiter, là on est carrément cuits.
C’est pourquoi la programmation nous permet de rassembler toutes ces variables
en une seule, au sein de laquelle chaque valeur sera désignée par un numéro. En
bon français, cela donnerait donc quelque chose du genre « la note numéro 1 », « la
note numéro 2 », « la note numéro 8 ». C’est largement plus pratique, vous vous en
doutez.

Un ensemble de valeurs portant le même nom de variable et repérées par un

nombre, s’appelle un tableau, ou encore une variable indicée.
Le nombre qui, au sein d’un tableau, sert à repérer chaque valeur s’appelle
l’indice.
Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le nom du
tableau, suivi de l’indice de l’élément, entre parenthèses.

VI.2. Notation et utilisation algorithmique

Dans notre exemple, nous créerons donc un tableau appelé Note. Chaque note
individuelle (chaque élément du tableau Note) sera donc désignée Note(0), Note(1),
etc. Eh oui, attention, les indices des tableaux commencent généralement à 0, et non
à 1.
Un tableau doit être déclaré comme tel, en précisant le nombre et le type de valeurs
qu’il contiendra (la déclaration des tableaux est susceptible de varier d'un langage à
l'autre. Certains langages réclament le nombre d'éléments, d'autre le plus grand
indice... C'est donc une affaire de conventions).

29
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

En nous calquant sur les choix les plus fréquents dans les langages de
programmations, nous déciderons ici arbitrairement et une bonne fois pour toutes
que :
• les "cases" sont numérotées à partir de zéro, autrement dit que le plus petit
indice est zéro.
• lors de la déclaration d'un tableau, on précise la plus grande valeur de l'indice
(différente, donc, du nombre de cases du tableau, puisque si on veut 12
emplacements, le plus grand indice sera 11). Au début, ça déroute, mais vous
verrez, avec le temps, on se fait à tout, même au pire.

Tableau Note(11) en Entier

On peut créer des tableaux contenant des variables de tous types : tableaux de
numériques, bien sûr, mais aussi tableaux de caractères, tableaux de booléens,
tableaux de tout ce qui existe dans un langage donné comme type de variables. Par
contre, hormis dans quelques rares langages, on ne peut pas faire un mixage de
types différents de valeurs au sein d’un même tableau.

L’énorme avantage des tableaux, c’est qu’on va pouvoir les traiter en faisant des
boucles. Par exemple, pour effectuer notre calcul de moyenne, cela donnera par
exemple :
Tableau Note(11) en Numérique
Variables Moy, Som en Numérique
Début
Pour i ← 0 à 11
Ecrire "Entrez la note n°", i
Lire Note(i)
i Suivant
Som ← 0
Pour i ← 0 à 11
Som ← Som + Note(i)
i Suivant
Moy ← Som / 12
Fin
NB : On a fait deux boucles successives pour plus de lisibilité, mais on aurait tout
aussi bien pu n’en écrire qu’une seule dans laquelle on aurait tout fait d’un seul coup.
Remarque générale : l’indice qui sert à désigner les éléments d’un tableau peut être
exprimé directement comme un nombre en clair, mais il peut être aussi une variable,
ou une expression calculée.

Dans un tableau, la valeur d’un indice doit toujours :

• être égale au moins à 0 (dans quelques rares langages, le premier élément
d’un tableau porte l’indice 1). Mais comme je l'ai déjà écrit plus haut, nous
avons choisi ici de commencer la numérotation des indices à zéro, comme

30
Cours d’Algorithmique ; par Ir Stanislas Aristide NGASSAKI ONDZE 06 677 91 90

c’est le cas en langage C et en Visual Basic. Donc attention, Truc(6) est le

septième élément du tableau Truc !

• être un nombre entier Quel que soit le langage, l’élément Truc(3,1416) n’existe
jamais.
• être inférieure ou égale au nombre d’éléments du tableau (moins 1, si l’on
commence la numérotation à zéro). Si le tableau Bidule a été déclaré comme
ayant 25 éléments, la présence dans une ligne, sous une forme ou sous une
autre, de Bidule(32) déclenchera automatiquement une erreur.

Je le répète, si l’on est dans un langage où les indices commencent à zéro, il faut en
tenir compte à la déclaration :
Tableau Note(13) en Numérique

...créera un tableau de 14 éléments, le plus petit indice étant 0 et le plus grand 13.

VI.3 Tableaux dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre d’éléments

que devra comporter un tableau. Bien sûr, une solution consisterait à déclarer un
tableau gigantesque. Pour être sûr que « ça rentre ». Mais d’une part, on n’en sera
jamais parfaitement sûr, d’autre part, en raison de l’immensité de la place mémoire
réservée – et la plupart du temps non utilisée, c’est un gâchis préjudiciable à la
rapidité, voire à la viabilité, de notre algorithme.
Aussi, pour parer à ce genre de situation, a-t-on la possibilité de déclarer le tableau
sans préciser au départ son nombre d’éléments. Ce n’est que dans un second
temps, au cours du programme, que l’on va fixer ce nombre via une instruction de
redimensionnement : Redim.
N.B : Tant qu’on n’a pas précisé le nombre d’éléments d’un tableau, d’une
manière ou d’une autre, ce tableau est inutilisable.
Exemple : on veut faire saisir des notes pour un calcul de moyenne, mais on ne sait
pas combien il y aura de notes à saisir. Le début de l’algorithme sera quelque chose
du genre :
Tableau Notes() en Numérique
Variable nb en Numérique
Début
Ecrire "Combien y a-t-il de notes à saisir ?"
Lire nb
Redim Notes(nb-1)
…
Cette technique n’a rien de sorcier, mais elle fait partie de l’arsenal de base de la
programmation en gestion.

31