TABLE DES MATIERES

TABLE DES MATIERES........................................................................................................................1

Objectifs spécifiques.........................................................................................................................2
INTRODUCTION GENERALE.............................................................................................................3
1. Définition...................................................................................................................................3
2. Algorithmique et programmation.....................................................................................4
3. Conventions pour écrire un algorithme..........................................................................4
CHAP. I. LES VARIABLES....................................................................................................................6
1. Définition...................................................................................................................................6
2. Déclaration des variables....................................................................................................6
2.1. Types numériques classiques........................................................................................7
2.2. Autres types numériques................................................................................................8
2.3 Type alphanumérique........................................................................................................8
2.4. Type booléen (En Langage C bool)............................................................................9
3. L’instruction d’affectation....................................................................................................10
3.1. Syntaxe et signification.................................................................................................10
3.2. Ordre des instructions...................................................................................................11
4. Expressions et opérateurs...................................................................................................13
a) Opérateurs numériques :...............................................................................................14
b) Opérateur alphanumérique : &................................................................................14
c) Opérateurs logiques (ou booléens) :.........................................................................15
[Link]. LECTURE ET ECRITURE...................................................................................................16
1. Les instructions de lecture et d’écriture..........................................................................17
[Link]. LES TESTS..........................................................................................................................18
1. Structure d’un test...............................................................................................................18
2. Conditions composées........................................................................................................20
3. Tests imbriqués.....................................................................................................................21
[Link]. LES BOUCLES..................................................................................................................23
1. A quoi cela sert-il donc ? C’est pas sorcier !...............................................................23
2. Boucler en comptant, ou compter en bouclant.........................................................27
LES TABLEAUX...............................................................................................................................29

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 1
Objectifs spécifiques
☞ Permettre à l’étudiant d’obtenir de la machine un travail
effectué à notre place,
☞ Expliquer à la «machine» comment elle doit s'y prendre,
☞ Savoir expliciter son raisonnement,
☞ Savoir formaliser son raisonnement
☞ Concevoir (et écrire) des algorithmes: séquence d’instructions
qui décrit comment résoudre un problème particulier.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 2
INTRODUCTION GENERALE

1. Définition.
Un algorithme, est une séquence d’opérations visant à la résolution
d’un problème en un temps fini, qui une fois exécuté correctement.
 Si l’algorithme est correct, le résultat est le résultat voulu,
 Si l’algorithme est faux, le résultat est, disons, aléatoire.
L’Algorithme c’est un mot dérivé du nom du mathématicien
Al_Khwarizmi qui a vécu au XIII ème siècle, était membre d’une académie des
sciences à Bagdad. Un savant arabe natif de la ville persane appelée «
Khawarezm ». Ce savant développa par ailleurs l'Algèbre, terme provenant
de l'arabe « Al-Jabr », qui signifie compensation, sous-entendu « la
compensation par la recherche de la variable inconnue X afin d'équilibrer
les résultats des calculs ».
Un algorithme prend des données en entrée, exprime un traitement
particulier et fournit des données en sortie.

Pour fonctionner, un algorithme doit donc contenir uniquement des

instructions compréhensibles par celui qui devra l’exécuter.
Les ordinateurs, quels qu’ils soient, ne sont fondamentalement
capables de comprendre que quatre catégories d'ordres (en
programmation, on n'emploiera pas le terme d'ordre, mais plutôt celui
d'instructions).
Ces quatre familles d'instructions sont :
1°) l’affectation de variables

2°) la lecture / écriture

3°) les tests

4°) les boucles (les structures répétitives)
Un algorithme informatique se ramène donc toujours au bout du
compte à la combinaison de ces quatre petites briques de base. Il peut y en
avoir quelques-unes, quelques dizaines, et jusqu’à plusieurs centaines de
milliers dans certains programmes de gestion. Rassurez-vous, dans le cadre
de ce cours, nous n’irons pas jusque-là (cependant, la taille d’un algorithme

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 3
ne conditionne pas en soi sa complexité : de longs algorithmes peuvent être
finalement assez simples, et de petits très compliqués).

2. Algorithmique et programmation
a) Définition :
Le Programme est une série d’instructions pouvant s’exécuter en
séquence, ou en parallèle (parallélisme matériel) qui réalise (implémente)
un algorithme.
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 (arranger) les
difficultés pour mieux les vaincre.
b) Définition des concepts
☞ Programme : une suite d’instructions permettant de réaliser une
ou plusieurs tâche(s), de résoudre un problème, de manipuler des
données. Le programme est l’expression d’un algorithme dans n
langage donné pour une machine donnée.
☞ Logiciel : désigne l’ensemble de tous les programmes. Mais un
logiciel est aussi un programme.

3. Conventions pour écrire 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 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.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 4
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 é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.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 5
CHAP. I. LES VARIABLES
1. Définition
Une variable est un nom donné à une valeur. Le nom de variable
représente une et une seule valeur qui peut évoluer au cours du temps.
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). 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: elles peuvent être des
nombres, du texte, etc. Dès que l’on a besoin de stocker une
information au cours d’un programme, on utilise une variable.

2. Déclaration des variables

La première chose à faire avant de pouvoir utiliser une variable est
de donner le nom et de lui apprêter un type. 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 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 libre du nombre de signes pour
un nom de variable, pour des raisons purement pratiques, on évite
généralement les noms à rallonge.
Lorsqu’on déclare une variable, il s’agit de réserver un emplacement
mémoire et le type de codage utilisé.
Ex : * Déclaration algorithmique : tension, puissance : flottant

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 6
 * Déclaration en C : float tension, puissance ;

2.1. Types numériques classiques

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 en disant qu’on
ne pourra coder que 28 = 256 valeurs différentes. Cela peut signifier 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.
Bref, le type de codage (autrement dit, le type de variable) 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
Réel simple -3,40x1038 à -1,40x1045 pour les valeurs
négatives 1,40x10-45 à 3,40x1038pour les
valeurs positives
Réel double 1,79x10308 à -4,94x10-324pour les valeurs
négatives 4,94x10-324à 1,79x10308 pour les
valeurs positives
Un bon algorithme ne se contente pas de « marcher » ; il marche en
évitant de gaspiller les ressources de la machine. Sur certains programmes
de grande taille, l’abus de variables surdimensionnées peut entraîner des

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 7
ralentissements notables à l’exécution, voire un plantage pur et simple de
l’ordinateur. Alors, autant prendre dès le début de bonnes habitudes
d’hygiène.
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

2.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 dans ce cours ; mais je les signale, car
vous ne manquerez pas de les rencontrer en programmation proprement
dite.

2.3 Type alphanumérique

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.
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, qu’il soit ou non stocké dans une variable est
appelé chaîne de caractères.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 8
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.
 L'autre confusion, plus grave et plus fréquente ; consiste à se
mélanger le nom d'une variable et son contenu.

2.4. Type booléen (En Langage C bool)

Le dernier type de variables est le type booléen : on y stocke

uniquement les valeurs logiques VRAI et FAUX.
Ensemble de définition : B={Vrai , Faux}
 Déclaration algorithmique : a, b : booléen
 Déclaration en C : bool a, b ;
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). 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.
Le type booléen est très souvent négligé par les programmeurs, à
tort. Il est vrai qu'il n'est pas à proprement parler indispensable, et qu'on
pourrait écrire à peu près n’importe quel programme en l'ignorant
complètement. Pourtant, si le type booléen est mis à disposition des
programmeurs dans tous les langages, ce n'est pas pour rien. Le recours
aux variables booléennes s'avère très souvent un puissant instrument de
lisibilité des algorithmes : il peut faciliter la vie de celui qui écrit
l'algorithme, comme de celui qui le relie pour le corriger.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 9
 Alors, maintenant, c'est certain, en algorithmique, il y a une question
de style : c'est exactement comme dans le langage courant, il y a plusieurs
manières de s'exprimer pour dire sur le fond la même chose.

3. L’instruction d’affectation

3.1. Syntaxe et signification

En fait, la variable n'est pas un outil bien sorcier à manipuler. On ne peut

pas faire plusieurs choses avec une variable, 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 à une variable. L'instruction
d'affectation se note avec le signe ←
Ainsi :
 Notation algorithmique : Sifa ←24 ou i← i+1 Attribue la valeur 24 à
la variable Sifa.
 Notation en langage C : Sifa =3 ; ou i=i+1
Ceci, soit dit en passant, que Sifa soit une variable de type
numérique. Si Sifa a été défini dans un autre type, il faut bien comprendre
que cette instruction provoquera une erreur.
On peut en revanche sans aucun problème attribuer à une variable la
valeur d’une autre variable, telle quelle ou modifiée. Par exemple :
Frem ← Sifa Signifie que la valeur de Frem est maintenant celle de Sifa.
Notez bien que cette instruction n’a en rien modifié la valeur de Sifa :
une instruction d’affectation ne modifie que ce qui est situé à gauche de la
flèche.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 10
Frem ← Sifa+ 4 Si Sifa contenait 12, Frem vaut maintenant 16. De même
que précédemment, Sifa vaut toujours 12.
Frem ← Frem + 1 Si Frem valait 6, il vaut maintenant 7. La valeur de Frem
est modifiée, puisque Frem 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 :
Exemple n°1
Exemple n°2
Début Début
Riri ← "Loulou"
Riri ← "Loulou" Fifi ← Riri
Fifi ← "Riri" Fin

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 différent.
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 oublie la règle des guillemets aux chaînes de
caractères.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 11
3.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 2
Exemple 1 Variable A Numérique
Variable A Numérique Début
Début A ← 12
A ← 34 A ← 34
A ← 12 Fin
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 Exemple 2
Variable A Numérique Variable A Numérique
Début Début
A ← 12 A ← 34
Fin Fin

Exercices 1. Quelles seront les valeurs des variables A et B après

exécution des instructions suivantes ?
Variables A, B Entier

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 12
Début
A←1
B←A+3
A←3
Fin
Exercice 2. Quelles seront les valeurs des variables A, B et C après
exécution des instructions suivantes ?
Variables A, B, C Entier
Début
A←5
B←3
C←A+B
A←2
C←B–A
Fin
Exercice 3. Quelles seront les valeurs des variables A et B après exécution
des instructions suivantes ?
Variables A, B Entier
Début
A←5
B←A+4
A←A+1
B←A–4
Fin
Exercice 4. Quelles seront les valeurs des variables A, B et C après
exécution des instructions suivantes ?
Variables A, B, C Entier
Début
A←3
B ← 10
C←A+B
B←A+B

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 13
 A←C
Fin

4. Expressions et opérateurs.

Dans une instruction d’affectation, on trouve :

☞ A 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.
☞ A 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.
Par exemple, voyons quelques expressions de type numérique. Ainsi :
5+4
123-45+844
Toto-12+5-Riri
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
Les opérateurs possibles dépendent du type des valeurs qui sont en jeu.

a) Opérateurs numériques :
Les quatre opérations arithmétiques sont.
+ : addition
- : soustraction
* : multiplication
/ : division
Mentionnons également le ^ qui signifie « puissance ». 45 au carré
s’écrira donc 45 ^ 2.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 14
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.
b) Opérateur alphanumérique : &
Cet opérateur permet de concaténer, deux chaînes de caractères. Par
exemple :
Variables A, B, C Caractère
Début
A ← "Gloubi"
B ← "Boulga"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "GloubiBoulga"

c) Opérateurs logiques (ou booléens) :

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

Exercice 5. Que produit l’algorithme suivant ?
Variables A, B, C en Caractères
Début
A ← "423"
B ← "12"
C←A+B
Fin

Exercice 6 : Que produit l’algorithme suivant ?

Variables A, B, C Caractères
Début
A ← "423"
Cours
B← d’Algorithmqiue
"12" dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link]
C←A&B 15

Fin
[Link]. LECTURE ET ECRITURE

Imaginons que nous ayons fait un programme pour calculer le carré

d’un nombre, mettons 12. Si on a fait au plus simple, on a écrit un truc du
genre :

Variable A Numérique
Début
A ← 12^2
Fin
D’une part, ce programme nous donne le carré de 12. Mais si l’on
veut le carré d’un autre nombre que 12, il faut réécrire le programme.
D’autre part, le résultat est nécessairement calculé par la machine.
Mais elle le garde soigneusement pour elle, et l’utilisateur qui fait exécuter
ce programme, lui, ne saura jamais quel est le carré de 12.
C’est pourquoi, il existe des instructions pour permettre à la machine de
dialoguer avec l’utilisateur.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 16
 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.
N.B : 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.
Comme un algorithme, 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.
Ainsi 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.

1. Les instructions de lecture et d’écriture

Pour que l’utilisateur entre la (nouvelle) valeur de Titi, on mettra : Lire

Titi
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 Toto
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,
l’utilisateur passe son temps à se demander ce que l’ordinateur attend de
lui…) :
Exemple :

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 17
Ecrire "Entrez votre nom : "
Lire NomFamille
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).

Exercice1. Quel résultat produit le programme suivant ?

Variables val, double numériques
Début
Val ← 231
Double ← Val * 2
Ecrire Val
Ecrire Double
Fin
Exercice 2.
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui
calcule et affiche le carré de ce nombre.
Exercice 3.
Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le
taux de TVA, et qui fournit le prix total TTC correspondant. Faire en sorte
que des libellés apparaissent clairement.

[Link]. LES TESTS

1. Structure d’un test.
Il n’y a que deux formes possibles pour un test ; la première est la plus
simple, la seconde la plus complexe.
Si booléen Alors
Instructions
Finsi
Si booléen Alors
Instructions 1
Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 18
Sinon
Instructions 2
Finsi
Ceci appelle quelques explications.
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
Nous reviendrons dans quelques instants sur ce qu’est une condition
en informatique.
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 complète, 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 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.

1. Définition.
Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 19
Une condition est une comparaison
Elle est composée de trois éléments :
☞ une valeur
☞ un opérateur de comparaison
☞ une autre valeur
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 !

Les opérateurs de comparaison sont :

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

Remarque très importante : En formulant une condition dans un

algorithme, il faut se méfier de certains raccourcis du langage courant, ou
de certaines notations valides en mathématiques, mais qui mènent à des
non-sens informatiques. Prenons par exemple la phrase « Toto est compris
entre 5 et 8 ». On peut être tenté de la traduire par : 5 < Toto < 8 Or, une
telle expression, qui a du sens en français, comme en mathématiques, ne
veut rien dire en programmation. En effet, elle comprend deux
opérateurs de comparaison, soit un de trop, et trois valeurs, soit là aussi
une de trop.

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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 20
 En fait cette phrase cache 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 ET.

Comme on l’a évoqué plus haut, l’informatique met à notre disposition

quatre opérateurs logiques : ET, OU, NON, et 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 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 toute fois 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.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 21
 3. Tests imbriqués.
Graphiquement, on peut très facilement représenter un SI comme une
bifurcation de chemin de fer (ou une bifurcation de train électrique). 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 fatigant. 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
Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 22
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
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.
EXERCICES
1. Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe
en suite si ce nombre est positif ou négatif (On laisse de côté le cas où le
nombre est zéro).
2. Ecrire un algorithme qui demande deux nombre à l’utilisateur, et
l’informe en suite si leur produit est positif ou négatif (On laisse de côté
le cas où le produit est nul).Attention on ne peut pas calculer le produit
des deux nombres.
3. Ecrire un programme qui demande trois noms à l’utilisateur et l’informe
en suite s’ils sont rangés dans l’ordre alphabétique ou non.

[Link]. LES BOUCLES

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 23
 On peut dire que les boucles constituent la seule vraie structure
logique caractéristique de la programmation. Si vous avez utilisé un tableur
comme Excel, 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 n'a aucun équivalent. Cela n'existe que dans les langages de
programmation proprement dits.

1. A quoi cela sert-il ? C’est pas sorcier !

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 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.
Essayons 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 erroné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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 24
faudrait rajouter un SI. Et ainsi de suite, on peut rajouter des centaines de
SI, et écrire un algorithme aussi lourd.
La solution consistant à aligner des SI… en désordre est donc un danger. La
seule sortie est donc de lancer 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 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é
Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 25
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
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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 26
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 finir 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"
Lire Rep
FinTantQue
Ecrire "Saisie acceptée"
Fin
Quant à la deuxième solution, elle pourra devenir :
Variable Rep en Caractère
Début

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 27
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

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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 28
boucle uniquement avec un « TantQue ». Le seul intérêt du « Pour » est
d’épargner un peu de fatigue au 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.

Exercices
1. Ecrire un algorithme qui demande à l’utilisateur un nombre compris
entre 1 et 3 jusqu’à ce que la réponse convienne.
2. Ecrire un algorithme qui demande un nombre compris entre 10 et 20,
jusqu’à ce que la réponse convienne. En cas de réponse supérieure à
20, on fera apparaître un message : « Plus petit ! », et inversement, «
Plus grand ! » si le nombre est inférieur à 10.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 29
 3. Ecrire un algorithme qui demande un nombre de départ, et qui
ensuite affiche les dix nombres suivants. Par exemple, si l'utilisateur
entre le nombre 17, le programme affichera les nombres de 18 à 27.
4. Ecrire un algorithme qui demande un nombre de départ, et qui
ensuite écrit la table de multiplication de ce nombre, présentée comme
suit (cas où l'utilisateur entre le nombre 7) :
Table de 7 : 7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70
Je vous avais annoncé qu’il y a avait quatre structures logiques dans
la programmation et on les a toutes passées en revue.
Mais il vous reste tout de même quelques petites choses à apprendre…

LES TABLEAUX
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é (férocité) du genre :
Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12
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.
Si en plus on est dans une situation où 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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 30
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.
N.B. : 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 sert à repérer chaque valeur dans un tableau, 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.

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. 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).
En nous procréant 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,

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 31
 ç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

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 32
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 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 Truc a été
déclaré comme ayant 25 éléments, la présence dans une ligne, sous
une forme ou sous une autre, de Truc(32) déclenchera
automatiquement une erreur.
A retenir : 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.
LE GAG DE LA JOURNEE Il consiste à confondre, dans sa tête et / ou dans
un algorithme, l’indice d’un élément d’un tableau avec le contenu de cet
élément.
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 (10 000 éléments) pour être
sûr que « ça rentre ». Mais d’une part, on n’en sera jamais parfaitement

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 33
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 chaos préjudiciable à la
rapidité, voire à la viabilité, de notre algorithme.
Aussi, pour relever à 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.
Notez que 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.

Exercices
1. Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs
numériques en les mettant toutes à zéro.

2. Ecrire un algorithme qui déclare et remplisse un tableau contenant les

six voyelles de l’alphabet latin.

3. Ecrire un algorithme qui déclare un tableau de 9 notes, dont on fait

ensuite saisir les valeurs par l’utilisateur.

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 34
 4. Que produit l’algorithme suivant ?
Tableau Nb(5) en Entier
Variable i en Entier
Début
Pour i ← 0 à 5
Nb(i) ← i * i
i suivant
Pour i ← 0 à 5
Ecrire Nb(i)
i suivant
Fin
Peut-on simplifier cet algorithme avec le même résultat ?

4. Tableaux à deux dimensions.

Prenons le cas de la modélisation d’un jeu de dames, et du
déplacement des pions sur le damier. Je rappelle qu’un pion qui est sur une
case blanche peut se déplacer (pour simplifier) sur les quatre cases
blanches adjacentes.
Avec les outils que nous avons abordés jusque-là, le plus simple serait
évidemment de modéliser le damier sous la forme d’un tableau. Chaque
case est un emplacement du tableau, qui contient par exemple 0 si elle est
vide, et 1 s’il y a un pion.

Reprenons. Un pion placé dans la case numéro i, autrement dit la

valeur 1 de Cases(i), peut bouger vers les cases en diagonale. Cela va nous
obliger à de petites acrobaties intellectuelles : la case située juste au-
dessus de la case numéro i ayant comme indice i-8, les cases valables sont
celles d’indice i-7 et i-9. De même, la case située juste en dessous ayant
comme indice i+8, les cases valables sont celles d’indice i+7 et i+9.
Bien sûr, on peut fabriquer tout un programme comme cela, mais le
moins qu’on puisse dire est que cela ne facilite pas la clarté de l’algorithme.
L’informatique nous offre la possibilité de déclarer des tableaux dans
lesquels les valeurs ne sont pas repérées par une seule, mais par deux
coordonnées.
Un tel tableau se déclare ainsi :
Tableau Cases (7, 7) en Numérique

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 35
 Cela veut dire : réserve-moi un espace de mémoire pour 7 x 7 entiers,
et quand j’aurai besoin de l’une de ces valeurs, je les repèrerai par deux
indices (comme à la bataille navale, ou Excel, la seule différence étant que
pour les coordonnées, on n’utilise pas de lettres, juste des chiffres).
Pour notre problème de dames, les choses vont sérieusement
s’éclaircir. La case qui contient le pion est dorénavant Cases (i, j). Et les
quatre cases disponibles sont Cases (i-1, j-1), Cases (i-1, j+1), Cases (i+1, j-
1) et Cases(i+1, j+1).

Remarque essentielle : Il n’y a aucune différence qualitative entre un

tableau à deux dimensions ( i, j ) et un tableau à une dimension ( i * j ). De
même que le jeu de dames qu’on vient d’évoquer, tout problème qui peut
être modélisé d’une manière peut aussi être modélisé de l’autre.
Simplement, l’une ou l’autre de ces techniques correspond plus
spontanément à tel ou tel problème, et facilite donc (ou complique, si on a
choisi la mauvaise option) l’écriture et la lisibilité de l’algorithme.
Une autre remarque : une question classique à propos des tableaux à
deux dimensions est de savoir si le premier indice représente les lignes ou
le deuxième les colonnes, ou l’inverse. Les indices des tableaux ne sont que
des coordonnées logiques, pointant sur des adresses de mémoire vive.

5. Tableaux à n dimensions
Si vous avez compris le principe des tableaux à deux dimensions, sur
le fond, il n’y a aucun problème à passer au maniement de tableaux à trois,
quatre, pourquoi pas neuf dimensions. C’est exactement la même chose. Si
je déclare un tableau Titi (2, 4, 3, 3), il s’agit d’un espace mémoire
contenant 3 x 5 x 4 x 4 = 240 valeurs. Chaque valeur y est repérée par
quatre coordonnées.
Exercices
1. Écrivez un algorithme remplissant un tableau de 6 sur 13, avec des zéros.
2. Quel résultat produira cet algorithme ?
Tableau X(1, 2) en Entier
Variables i, j, val en Entier
Début
Val ← 1
Pour i ← 0 à 1
Pour j ← 0 à 2
X(i, j) ← Val
Val ← Val + 1
j Suivant
i Suivant
Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 36
Pour i ← 0 à 1
Pour j ← 0 à 2
Ecrire X(i, j)
j Suivant
i Suivant
Fin

3. Quel résultat produira cet algorithme ?

Tableau X(1, 2) en Entier
Variables i, j, val en Entier
Début
Val ← 1
Pour i ← 0 à 1
Pour j ← 0 à 2
X(i, j) ← Val Val ← Val + 1
j Suivant
i Suivant
Pour j ← 0 à 2
Pour i ← 0 à 1
Ecrire X(i, j)
i Suivant
j Suivant
Fin
4. Quel résultat produira cet algorithme ?
Tableau T(3, 1) en Entier
Variables k, m, en Entier
Début
Pour k ← 0 à 3
Pour m ← 0 à 1
T(k, m) ← k + m
m Suivant
k Suivant
Pour k ← 0 à 3
Pour m ← 0 à 1
Ecrire T(k, m)
m Suivant
k Suivant
Fin

Cours d’Algorithmqiue dispensé en BAC1 IG/ I.S.P-Kalemie par Léon BYAMUNGU TCH. Assistant2
Année Académique 2023-2024.
Tél. +243 816 908 922 ; +243 979 467 252 .E-mail : leonbyams@[Link] 37