Initiation à l’algorithmique

Dr Ir Géraud AZEHOUN PAZOU

Dernière mise à jour : 4 mars 2021

Version 1.2
Sommaire 1

Sommaire

Sommaire 1

Chapitre 1 : Introduction générale 3

1.1 Introduction à l’informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Concepts de base en algorithmique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Mise en œuvre et exécution d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Méthode de résolution d’un problème algorithmique . . . . . . . . . . . . . . . . . . . . . . . . 12

Chapitre 2 : Structure et syntaxe 14

2.1 Notion de variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Les instructions élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 Structure générale d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Opérateurs sur les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Chapitre 3 : Les structures de contrôle 21

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Les structures itératives ou répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Chapitre 4 : Les tableaux 31

4.1 Pourquoi les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2 Définitions et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3 Tableau à une dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Tableau à double dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.5 Tableau à n dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Chapitre 5 : Les algorigrammes 40

5.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Sommaire 2
5.2 Symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.3 Règles de construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 Structures algorithmiques élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Chapitre 6 : Les sous-programmes 48

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6.3 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.4 Les procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Chapitre 7 : Les chaînes de caractères 52

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.2 Opérations sur les caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.3 Les chaînes de caractères. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.4 Exercice d’application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 3

Chapitre 1

Introduction générale

1.1 Introduction à l’informatique

L’informatique est une science qui permet de traiter l’information de façon automatique.
- Science : donc des théories et des modèles,
- Information : texte, image ou son (et mêmes odeurs, saveurs et toucher), représentés
sous une forme manipulable par la machine en fonction de sa technologie.

1.1.1 Quelques disciplines de l’informatique

Quel sont les différentes branches de l’informatique ?
- Réseaux, logiciels de télécommunications, sécurité des échanges d’information.
- Systèmes embarqués, robotique.
- Images, son, multimédia, interfaces homme/machine, infographie . . .
- Calcul scientifique, optimisation, intelligence artificielle, bio-informatique, traitement
des langues . . .
On distingue quatre (04) concepts importants en informatique à savoir :
- algorithme ;
- machine ;
- langage ;
- information.
Les relations entre ces différents concepts donnent les différents domaines d’application
précédemment évoqués et permet de constituer la structure profonde de l’informatique.

1.1.2 L’ordinateur : la machine

L’ordinateur est un appareil très puissant permettant de traiter les informations (don-
nées) sous forme binaire avec une très grande vitesse, une précision élevée et a la faculté

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 4
de stocker toutes ces informations. Il est divisé en deux (02) parties : la partie matérielle
(hardware) et la partie logicielle (software).

La partie matérielle de l’ordinateur est composée de circuit électronique (processeur,

interface, support de stockage, périphérique, etc. . .) permettant de stocker des données
sous forme binaire ; c’est-à-dire sous forme de bits.

La partie logicielle est celle à laquelle les instructions sont données pour exécuter des
actions bien précises : on parle de programme informatique.

Les programmes interagissent avec l’environnement ou les utilisateurs grâce aux périphé-
riques d’entrée et de sortie. Leur mise en œuvre est assurée par la partie matérielle au
cœur de laquelle se trouve le processeur.

1.1.2.1 Les types d’ordinateur

Ordinateur de bureau

Un ordinateur de bureau est conçu pour être toujours au même endroit, généralement
sur un bureau. Il se compose :

1. d’une unité centrale : qui contient les principaux composants de l’ordinateur. C’est
également sur celle-ci que vous trouverez le bouton pour allumer l’ordinateur ;
2. d’un écran : qui permet d’afficher le contenu de l’ordinateur ;
3. d’un clavier : qui permet de communiquer avec l’ordinateur en tapant du texte ;
4. d’une souris : qui permet de déplacer le curseur à l’écran.

D’autres éléments peuvent être ajoutés, on les appelle des périphériques.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 5
Ordinateurs all in one

Il existe également des ordinateurs sur lesquels tous les composants sont regroupés derrière
l’écran, on les appelle ordinateurs all in one ou tout-en-un en français.

À ces ordinateurs, il faut ajouter un clavier et une souris pour pouvoir les utiliser.

Ordinateurs portables

Les ordinateurs portables sont conçus pour être compacts et mobiles. Ainsi, ils ne dis-
posent pas d’une unité centrale, tous les composants se situent sous le clavier.

Sur ce type d’ordinateur, brancher une souris n’est pas obligatoire, car il y a un touchpad :
une surface sensible au toucher qui permet de déplacer le pointeur à l’écran.

Comme pour les ordinateurs de bureau, d’autres périphériques peuvent être ajoutés.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 6
Tablettes

Il existe aussi des tablettes, ce sont des ordinateurs mobiles à la taille réduite. Les écrans
sont tactiles et affichent un clavier virtuel. Tous les composants sont situés derrière l’écran.
Ainsi, les tablettes n’ont pas besoin d’unité centrale, ni de clavier ou de souris. Sur certains
modèles, il est toutefois possible d’y connecter un clavier et/ou une souris.

1.1.2.2 Les composants d’un ordinateur

Découvrons à présent les principaux composants d’un ordinateur :

Le processeur

C’est le cerveau de l’ordinateur. Il réalise tous les calculs nécessaires au fonctionnement

de l’ordinateur. C’est notamment la fréquence du processeur, c’est-à-dire la vitesse à
laquelle il travaille, qui détermine la rapidité de l’ordinateur. Cette fréquence s’exprime en
Giga Hertz (GHz). Les ordinateurs sont devenus multicoeurs c’est-à-dire qu’ils possèdent
plusieurs processeurs pour effectuer plus rapidement les tâches demandées. Ainsi :
- Dual Core = 2 cœurs
- Quad Core = 4 cœurs
- Hexa Core = 6 cœurs
- Octa Core = 8 cœurs
Il existe différents modèles de processeurs et cette technologie évolue rapidement. Les
processeurs des marques AMD et Intel sont les plus fréquemment rencontrés.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 7

La marque Intel propose par exemple les modèles :

- Intel Core i3 qui correspond à l’entrée de gamme des processeurs Intel Core,
- Intel Core i5 qui constitue le milieu de gamme,
- Intel Core i7 et Intel Core i9 qui sont de la gamme supérieure.

La mémoire vive ou RAM (Random Access Memory)

C’est la mémoire temporaire de l’ordinateur, c’est là où sont stockés tous les fichiers
sur lesquels l’utilisateur est en train de travailler. Cette mémoire est temporaire, car les
informations sont supprimées lors de l’arrêt de l’ordinateur.

Plus cette mémoire est importante, plus l’ordinateur travaille facilement et rapidement
et plus il peut gérer des tâches différentes.

La capacité de cette mémoire s’exprime en Gigaoctets (Go). La mémoire vive se présente

sous forme de petites barrettes que l’on insère dans la carte mère. Un ordinateur peut
ainsi comporter plusieurs barrettes pour avoir au total (cela dépend des ordinateurs) 4 -
8 - 16 ou 32 Go de RAM.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 8
Le disque dur (mémoire morte)

C’est le support sur lequel on peut stocker des informations. Les capacités de stockage
ne cessent d’augmenter et permettent donc d’enregistrer un grand nombre de données :
documents, photos, films...

Il y a actuellement deux types de disques durs : SSD et HDD. Les SSD ont l’avantage
d’être extrêmement rapides, mais ils sont plus chers et de capacité limitée.

La carte graphique ou vidéo

Elle permet de produire une image affichable sur un écran d’ordinateur. La carte gra-
phique peut être intégrée à la carte mère ou dédiée, c’est-à-dire qu’elle est séparée et
qu’elle dispose de sa propre mémoire vive. Une carte graphique dédiée est plus puissante,
mais coûte plus cher. Elle permet de faire fonctionner correctement des jeux en 3D, des
logiciels de retouche vidéo/photo par exemple.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 9
AMD et NVIDIA sont les marques de cartes graphiques les plus courantes

Le ventilateur

Le ventilateur est utilisé pour réduire la température souvent élevée du processeur et

réduire les risques de surchauffe.

La carte mère (motherboard)

Elle se trouve au centre de l’ordinateur et connecte tous les composants de l’ordinateur. La

carte mère contient les connexions pour le processeur, la mémoire, les unités de stockage. . .
Elle intègre une carte son et une carte graphique.

Voici un exemple de carte mère et ses principaux composants :

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 10

Remarque 1
Pour un ordinateur de bureau, ces différents composants se retrouvent dans l’unité centrale.
Pour les ordinateurs all in one, ils se retrouvent derrière l’écran et pour les ordinateurs por-
tables, ils se retrouvent sous le clavier.

1.1.3 Le langage
Le langage informatique est un langage dans lequel il est aisé de communiquer avec
l’ordinateur. Il est composé de mots clés, de fonctions prédéfinies qui sont utilisés dans le
but de donner des instructions à une machine. On distingue deux (02) types de langages
en informatique : le langage machine et le langage évolué.

Le langage machine est un langage plus proche de celui de la machine.

Ex : Langage assembleur.

Le langage évolué ou langage haut niveau est un langage qui utilise les mots-clés du lan-
gage naturel. Leur utilisation est plus facile pour les programmeurs. Parmi ces langages,
on distingue les langages compilés et les langages interprétés.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 11

1.2 Concepts de base en algorithmique

Si l’on tient compte des multiples applications qui nécessitent l’utilisation des ordinateurs,
on s’aperçoit qu’il peut traiter autant de problèmes différents grâce à des actions de
base qu’il sait réaliser. Pour ce faire, il suffit de lui indiquer l’ordre dans lequel il faut
qu’il effectue ces actions et les données à utiliser. Ces ordres élémentaires sont appelés
instructions et sont rassemblés au sein d’un ensemble appelé programme.

1.2.1 Le programme
Un programme représente un assemblage et un enchaînement d’instructions élémentaires
écrites dans un langage de programmation et exécutées par un ordinateur afin de traiter
les données d’un problème et retourner les résultats. Le langage de programmation est
donc un langage de communication par le biais duquel on est en mesure de communiquer
avec l’ordinateur.

1.2.2 Le problème
Un problème est un ensemble de données et de traitements décrivant une situation que
l’on cherche à résoudre. Le but visé à travers la résolution du problème peut être :
- automatiser une tâche ;
- satisfaire un besoin ;
- informatiser un système.
Exemple 1.2.1
Supposons qu’un enseignant dispose d’un ordinateur et veut un programme de calcul des
moyennes. Le problème ici est : Mettre en place des moyens et des procédures afin que si l’on
fournit des notes, on obtienne en retour les moyennes.

Dans ce problème, les données sont les différentes notes. Les traitements consisteront à faire
la somme de toutes les notes que l’on divise par la somme des coefficients. Le résultat à la
fin de ce problème est la moyenne.

Si dans le programme, il est prévu de fournir d’autres résultats, ils pourront être fournis.
Un moyen de décrire la procédure de résolution d’un problème est d’écrire un algorithme.

1.2.3 L’algorithme
Un algorithme est l’enchaînement des actions ou instructions élémentaires nécessaires
pour faire exécuter une tâche à un ordinateur ; c’est-à-dire pour résoudre un problème.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 12
L’algorithme est écrit dans un pseudo-langage de programmation appelé langage algorith-
mique. Il a l’avantage d’être facilement traductible dans tous les langages de program-
mation.

L’algorithmique est donc l’art d’écrire des algorithmes. Il permet de se focaliser sur la
procédure de résolution du problème sans avoir à se soucier des spécificités d’un langage
particulier.

1.3 Mise en œuvre et exécution d’un programme

1.3.1 Mise en œuvre
Réflexion Codes
Problème Algorithme Programme
Lang. de Prog.

La mise en œuvre d’un programme commence par la réflexion sur le problème posé.
Ensuite la procédure identifiée pour la résolution est décrite dans un algorithme. Ce
dernier peut alors être traduit en programme dans un langage de programmation.

1.3.2 Exécution
Après que le programme est édité, il est enregistré sous la bonne extension dans un
emplacement précis sur l’ordinateur. Ensuite, il est traduit en code binaire (0 et 1) grâce
à un compilateur. La compilation produit donc un exécutable (.exe) que le processeur
exécute en respectant l’ordre des instructions.

1.4 Méthode de résolution d’un problème algorithmique

1.4.1 Introduction
Compte tenu de la multiplicité des applications et des situations qui incluent l’utilisation
d’un ordinateur ou d’un automate, on est en droit de se poser la question sur la meilleure
manière d’aborder leur résolution. A ce propos, une démarche générale de résolution des
problèmes algorithmiques peut être suivie. Elle inclut un certain nombre d’étapes qui, si
elles sont suivies, aboutissent irrémédiablement à un résultat, fut-il différent de la solution
voulue.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 1 : Introduction générale 13

1.4.2 Etapes de résolution d’un problème algorithmique

1.4.2.1 Redéfinition du problème

A cette étape, on pense à reformuler le problème en utilisant des termes et des concepts
complètement différents de ceux utilisés dans le domaine d’application. Il s’agit ici de
penser aux données du problème qui peuvent être utilisées par l’ordinateur ou l’automate
pour résoudre ledit problème.

1.4.2.2 Analyse du problème

Cette étape fait suite à l’étape précédente. Ainsi, après avoir essayé de se focaliser sur
les données probables du problème, on cherche à identifier les variables d’entrée, les
variables intermédiaires et les variables de sortie.

Le second volet de cette étape inclut les différentes opérations ou les différents traitements
que l’on doit opérer sur ou avec les variables.

1.4.2.3 Conception de la solution

A cette étape, il est question de concevoir un enchaînement séquentiel censé aboutir au

résultat souhaité. Cette étape n’inclut pas encore l’écriture de l’algorithme lui-même. On
pourra toutefois écrire au brouillon, les étapes suivant lesquelles le programme pourra se
dérouler.

1.4.2.4 Ecriture de l’algorithme

Il s’agit ici d’écrire la solution en respectant la syntaxe et en faisant usage des structures
et outils prévus par la science algorithmique.

1.4.2.5 Tests de vérification

On simule le déroulement du programme en choisissant des cas pratiques ou des exemples

avec des données réelles. Ce faisant, on vérifie l’exactitude de la solution proposée.
Remarque 2
La dernière étape peut amener à se rendre compte que l’on a mal traité le problème ou que
l’on n’a pas tenu compte de tous les cas de figure possibles. Cela peut donc amener à redéfinir
le problème.
Remarque 3
L’étape écriture de l’algorithme peut être remplacée selon le cas par dessin d’un algori-
gramme ou ordinogramme ou diagramme algorithmique.

La réalisation de ce genre de solution graphique sera abordée dans le chapitre 5.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 14

Chapitre 2

Structure et syntaxe

2.1 Notion de variable

2.1.1 Définition
Une variable est un symbole qui associe un nom (l’identificateur) à une valeur. Elle est
représentée par (ou correspond à) une case-mémoire qui contient la valeur de la variable
et à laquelle on fait appel lorsqu’on veut manipuler la valeur.

On attribue un nom unique appelé identificateur à la variable. C’est à travers cet iden-
tificateur qu’on peut recueillir ou modifier la valeur de la variable. Les valeurs que peut
prendre une variable sont également précisées à travers les types.

Pour qu’un programme puisse utiliser une variable, il faut au préalable réserver la case-
mémoire à laquelle elle doit correspondre. Pour ce faire, il faut procéder à la déclaration
des variables qui est une instruction spécifique.

2.1.2 Règles de déclaration d’une variable

La déclaration d’une variable consiste à indiquer deux choses : son identificateur et son
type.

2.1.2.1 Identificateur

L’identificateur peut être composé de lettres et de chiffres. Il ne peut pas commencer par
un chiffre et ne peut comporter d’espace. Il doit être suffisamment signifiant pour qu’on
y reconnaisse la chose représentée.

2.1.2.2 Type

En algorithmique, on distingue cinq (05) types principaux :

Les caractères : Lettres, chiffres, ponctuations, code des opérateurs, espace ; plus géné-
ralement toutes les touches du clavier.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 15
Les chaînes de caractères : C’est une suite de caractères.
Les entiers : Ce sont les nombres sans virgule signés ou non (tout nombre appartenant
à Z).
Les réels : Les nombres à virgule.
Les booléens : Type logique avec deux (02) valeurs possibles : Vrai ou Faux.

2.1.3 Exemple de déclaration de variables

2.1.3.1 Syntaxe

VARIABLE : <identificateur> : <type>

OU

VARIABLE : <identificateur1>, ... , <identificateurm> : <type1>

<identificateur1>, ... , <identificateurn> : <type2>
.
.
.
<identificateur1>, ... , <identificateurp> : <typeN>

2.1.3.2 Exemple

VARIABLE : a, b : REEL
Ent1, Ent2, Ent3 : ENTIER
Justin : ENTIER

NB : Les mots clés s’écrivent toujours en majuscule.

2.2 Les instructions élémentaires

2.2.1 L’affectation
L’affectation consiste à donner à une variable déclarée, une valeur appartenant à son
type. Elle permet de donner une première valeur à la variable ou de changer sa valeur
courante.

2.2.1.1 Syntaxe

<identificateur> ←− <expression> ;

2.2.1.2 Exemple

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 16

Justin ←− 12 ;
a ←− 4 * 2.5 ;
a ←− 0.0 ;
b ←− 5 * Justin + a + 2.5 ;
a ←− Justin ;

2.2.2 L’écriture
C’est une instruction qui permet au programme de fournir des informations ou de retour-
ner des résultats sous forme compréhensible pour l’utilisateur à travers l’écran.

2.2.2.1 Syntaxe

ECRIRE (<expression1>, <expression2>, ...) ;

OU
AFFICHER (<expression1>, <expression2>, ...) ;

2.2.2.2 Exemple

ECRIRE ("Bonjour Mr Justin") ;

Justin ←− 18 ;
ECRIRE ("Mr Justin, vous avez : ", Justin, "ans") ;

2.2.3 La lecture
C’est une instruction qui permet de récupérer des données à partir du périphérique d’en-
trée (généralement le clavier). La valeur récupérée est rangée dans une variable.

2.2.3.1 Syntaxe

LIRE (<variable1>, <variable2>, ...) ;

OU
SAISIR (<variable1>, <variable2>, ...) ;

2.2.3.2 Exemple

Chaine1 ←− "Bonjour Mr Justin." ;

Caract1 ←− "t" ; //espace
ECRIRE (Chaine1, "Quel est votre âge ?") ;
LIRE (Justin) ;
ECRIRE ("Mr Justin, vous avez", Caract1, Justin, Caract1, "ans") ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 17

2.3 Structure générale d’un programme

De façon générale, la structure d’un programme est la suivante :

PROGRAMME <NomProgramme>
VARIABLE : <var11>, <var12>, ... , <var1n> : <type1>
<var21>, <var22>, ... , <var2m> : <type2>
.
.
.
<varN1>, <varN2>, ... , <varNp> : <typeN>
DEBUT
<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;
FIN

2.3.1 Exercice d’application 1

Ecrire un algorithme qui calcule et affiche la somme et le produit de deux nombres entiers
entrés par l’utilisateur.
Résultat

PROGRAMME SommeEtProduit
VARIABLE : Ent1, Ent2, produit : ENTIER
DEBUT
ECRIRE ("Entrez les deux nombres entiers") ;
LIRE (Ent1, Ent2) ;
ECRIRE ("La somme donne : ", Ent1 + Ent2) ;
produit ←− Ent1 ∗ Ent2 ;
ECRIRE ("Le produit donne : ", produit) ;
FIN

2.3.2 Exercice d’application 2

Dresser la table de multiplication partielle d’un nombre entier entré au clavier (s’arrêter
à 5).
Résultat

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 18

PROGRAMME TableDeMultiplicationPartielle
VARIABLE : n : ENTIER
DEBUT
ECRIRE ("Entrez un entier") ;
LIRE (n) ;
ECRIRE (n, " × 1 = ", n) ;
ECRIRE (n, " × 2 = ", 2 ∗ n) ;
ECRIRE (n, " × 3 = ", 3 ∗ n) ;
ECRIRE (n, " × 4 = ", 4 ∗ n) ;
ECRIRE (n, " × 5 = ", 5 ∗ n) ;
FIN

2.4 Opérateurs sur les variables

Les opérateurs permettent de faire un certain nombre de manipulations sur les variables.

2.4.1 Opérateurs arithmétiques

2.4.1.1 Addition

Elle permet d’additionner deux variables de type entier ou réel. Son symbole est ( + ).

2.4.1.2 Soustraction

Elle permet de calculer la différence entre deux variables de type entier ou réel. Son
symbole est ( − ).

2.4.1.3 Multiplication

Elle permet de faire le produit de deux variables de type entier ou réel. Son symbole est
( ∗ ).

2.4.1.4 Division

Elle permet de faire le quotient de deux variables de type entier ou réel. Son symbole est
( / ). Il n’est pas rare de rencontrer le symbole (÷).

2.4.1.5 Division entière

Cet opérateur permet d’obtenir la partie entière du quotient de deux variables de type
entier ou réel. Son symbole est div.

2.4.1.6 Partie entière

Cet opérateur retourne la partie entière d’une variable réelle. Son symbole est ent.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 19
2.4.1.7 Exposant

Cet opérateur permet d’élever un nombre à une puissance donnée. Son symbole est (^).

2.4.1.8 Reste de la division entière

Il retourne le reste de la division de deux variables de type entier. Son symbole est mod.
Il ne s’applique pas aux nombres réels.

Exemple

PROGRAMME Calculs
VARIABLE : Ent1, Ent2, ENt3 : ENTIER
Rel1, Rel2 : REEL
DEBUT
1 Ent1 ←− 12 ; //Ent1 est initialisé à 12
2 Ent2 ←− 5 ; //Ent2 est initialisé à 5
3 Ent3 ←− (Ent1 ∗ Ent2) + Ent1 − (Ent2 / Ent1) ;
4 Rel1 ←− 14.75 ; //Rel1 est initialisé à 14.75
5 Rel2 ←− Rel1 + 3.15 ; //Rel2 = 17.90
6 Rel1 ←− Rel1 − (Ent2 / Ent1) ; //Rel1 = 14.33333
7 Ent1 ←− Ent1 + Ent1 DIV Ent2 ; //Ent1 = 14
8 Ent2 ←− Ent2 + ENT(Ent1 / Ent2) ; //Ent2 = 7
9 Ent3 ←− Ent1 MOD Ent2 ; //Ent3 = 0
FIN

Commentaire
Le programme Calculs ci-dessus manipule cinq (05) variables dont trois (03) de type
entier et deux (02) de type réel. Aux lignes d’instructions 1, 2 et 4, des initialisations
sont faites. A la ligne d’instruction 3, on tente d’affecter une valeur calculée à la variable
Ent3. Si l’on regarde de près le calcul effectué, on se rend compte qu’il y a un risque
d’obtenir un nombre à virgule à cause de la division. L’objectif dans ce cas pourrait donc
ne pas être atteint car Ent3 est de type entier. Au niveau des lignes d’instruction 7 et
8, ce problème est bien géré avec les opérateurs div et ent. Par contre, au niveau de la
ligne d’instruction 6, le problème ne se pose pas.

2.4.2 Opérateurs logiques

2.4.2.1 Comparaison

Les opérateurs de cette catégorie permettent de comparer les contenus de deux variables
ou de deux expressions. Les symboles ci-après sont utilisés :
< : infériorité ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 2 : Structure et syntaxe 20
> : supériorité ;
≤ : infériorité ou égalité ;
≥ : supériorité ou égalité ;
= : égalité ;
6= : différence ;
Tous ces opérateurs retournent des résultats de type booléen.

2.4.2.2 La négation

Elle permet de faire un NON logique sur une expression. Son symbole est non.

2.4.2.3 La conjonction

Elle permet de faire un ET logique sur deux expressions. Son symbole est et.

2.4.2.4 La disjonction

Elle permet de faire un OU logique sur deux expressions. Son symbole est ou.

Exemple

// Ce sont les variables du programme précédent qui sont utilisées

Ent1 < Ent2 //retourne F A U X
Ent1 = Ent2 //retourne F A U X
((Ent1 > Ent2) ET (Ent3 > Ent2)) OU (Ent3 > Ent1)
(Ent1 − Ent2) < (Ent3 + Ent1) //retourne V R A I
Ent1 < Ent1 //retourne F A U X
Ent3 ≤ Ent3 //retourne V R A I
NON(Ent1)

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 21

Chapitre 3

Les structures de contrôle

3.1 Introduction
La résolution d’un problème par un algorithme peut faire ressortir un certain nombre de
cas ou de situations qui nécessitent que l’on dise à l’ordinateur comment réagir. Il peut
s’agir de choix à opérer ou de comportement récurrent à gérer. En algorithmique, les
structures de contrôle sont prévues pour faire face à ce genre de situation.

On distingue deux grandes familles de structures de contrôle :

- Les structures conditionnelles,
- Les structures répétitives ou itératives

3.2 Les structures conditionnelles

3.2.1 La structure "SI"
3.2.1.1 Syntaxe

SI (<condition>) ALORS


<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

FINSI

NB : S’il y a une seule instruction, alors on peut se passer des accolades (ouvrante et
fermante). Les accolades jouent le rôle de délimitateur.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 22
3.2.1.2 Exemple

PROGRAMME Controle1
VARIABLE : val1 : ENTIER
DEBUT
ECRIRE ("Entrez un entier positif") ;
LIRE (val1) ;

SI (val1 < 0) ALORS

ECRIRE ("Vous avez perdu") ;
FINSI
FIN

Commentaire
Le programme exécute l’instruction qu’il y a entre si et finsi si et eulement si la condition
val1 < 0 est vérifiée.

3.2.2 La structure "SI imbriquée"

Dans le programme Controle1, le cas où un entier positif est effectivement entré n’est
pas pris en compte. Pour pallier cela, il est prévu en algorithmique une alternative à la
condition que gère si. On utilise dans ce cas le mot clé sinon.

3.2.2.1 Syntaxe

SI (<condition>) ALORS


<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

SINON


<instruction1> ;
<instruction2> ;
.
.
.
<instructionm> ;

FINSI

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 23
3.2.2.2 Exemple

PROGRAMME Controle2
VARIABLE : val1 : ENTIER
DEBUT
ECRIRE ("Entrez un entier positif") ;
LIRE (val1) ;

SI (val1 < 0) ALORS

ECRIRE ("Vous avez perdu.") ;
SINON
ECRIRE ("Vous avez gagné.") ;
FINSI
FIN

Commentaire
Dans le programme Controle2, si tant est que l’utilisateur entre une valeur qui n’est
pas inférieure à 0, il verra s’afficher Vous avez gagné. Mais dans ce cas, les autres
entrées au clavier qui ne seront pas des chiffres seront prises également en compte. Donc
le programme Controle2 nécessiterait qu’on gère ces cas aussi ; d’où le recours à des
structures imbriquées plus complexes du genre :

SI (<condition1>) ALORS


<instruction1> ;
.
.
.

SINON


<instruction1> ;
.
.
.

SI (<condition2>) ALORS


<instruction1> ;
.
.
.

SINON


<instruction1> ;
.
.
.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 24

FINSI

SI (<condition3>) ALORS


<instruction1> ;
.
.
.

SI (<condition4>) ALORS


<instruction1> ;
.
.
.

FINSI

FINSI

FINSI

3.3 Les structures itératives ou répétitives

3.3.1 La structure "TANT_QUE . . . FAIRE"
3.3.1.1 Syntaxe

TANT_QUE (<condition>) FAIRE



<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

FTQ

Commentaire
Le programme n’exécutera les instructions qu’il y a dans la structure TANT_QUE que si la
condition est vérifiée et ne sortira de cette structure que si la condition n’est plus vérifiée.
Le bloc d’instructions sera répété encore et encore jusqu’à ce que la condition ne soit plus
vérifiée. Cette manière de répéter le bloc d’instruction s’appelle BOUCLER ou FAIRE
UNE BOUCLE.

3.3.1.2 Exemple

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 25

PROGRAMME Controle3
VARIABLE : val : ENTIER
DEBUT
ECRIRE ("Entrez un entier strictement positif") ;
LIRE (val) ;

TANT_QUE (val ≤ 0) FAIRE



ECRIRE ("Valeur incorrecte !") ;

ECRIRE ("Entrez à nouveau") ;
LIRE (val) ;

FTQ

SI ((val ≥ 3) ET (val < 10)) ALORS

ECRIRE ("Vous avez gagné !") ;
SINON
ECRIRE ("Vous avez perdu !") ;
FINSI
FIN

Commentaire
Si aucune instruction n’est prévue dans la structure (boucle) TANT_QUE pour permettre de
sortir de la structure, alors on est dans le cas d’une boucle infinie. De la même manière,
si une condition est posée de manière à ce qu’elle soit toujours vérifiée, alors on est
également dans le cas d’une boucle infinie.
Exemples de boucle infinie

PROGRAMME BoucleInfinie
VARIABLE : val : ENTIER
DEBUT

TANT_QUE (VRAI) FAIRE



ECRIRE ("Entrez un nombre") ;

LIRE (val) ;

FTQ

TANT_QUE (0 < 1) FAIRE

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 26


ECRIRE ("Coucou ! ! !") ;

FTQ
FIN

3.3.1.3 Exercice d’application

Ecrire un programme permettant de dresser la table de multiplication de n (entier naturel

entré au clavier). On affichera les résultats de 0 à 100.
Résultat

PROGRAMME Table_de_Multiplication
VARIABLE : i, n : ENTIER //i sert de compteur et permettra la
//répétition de la boucle et n la table voulue
DEBUT
i ←− 0 ;
ECRIRE ("Entrez un nombre entier") ;
LIRE (n) ;

TANT_QUE (i ≤ 100) FAIRE



ECRIRE (n, " × ", i, " = ", n ∗ i) ;

i ←− i + 1 ;

FTQ
FIN

3.3.2 La structure "FAIRE . . . TANT_QUE"

3.3.2.1 Syntaxe

FAIRE


<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

TANT_QUE (<condition>) ;

Commentaire

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 27
Cette structure permet également de répéter un bloc d’instructions un certain nombre
de fois suivant que la condition qui se trouve devant TANT_QUE est vérifiée ou pas. Sa
particularité est qu’elle exécute au moins une fois le bloc d’instructions avant d’aller
vérifier la condition.

3.3.2.2 Exemple

PROGRAMME Table_de_Multiplication
VARIABLE : i, n, rep : ENTIER
DEBUT

FAIRE


i ←− 0 ;
ECRIRE ("Entrez un nombre entier") ;
LIRE (n) ;

TANT_QUE (i ≤ 100) FAIRE



ECRIRE (n, " × ", i, " = ", n ∗ i) ;

i ←− i + 1 ; //incrémentation

FTQ
ECRIRE ("Voulez-vous recommencer ? Si oui, tapez 1, sinon,
tapez autre") ;
LIRE (rep) ;

TANT_QUE (rep = 1) ;
FIN

Note : Gestion des itérations

Je veux itérer n fois :
Lorsqu’on veut itérer n fois avec la structure itérative TANT_QUE ... FAIRE, il faut pro-
céder comme suit :
- Choisir a et b, respectivement valeur initiale et valeur finale du compteur, tel
que (b-a)+1=n ;
- Mettre la condition sous la forme de compteur ≤ b ;
- Faire l’incrémentation ou la décrémentation après avoir exécuté les instructions rela-
tives à la structure.
Lorsqu’on choisit la condition compteur < b, un problème se pose à nous : n-1 itérations
seront exécutées. Pour palier cela, il faut :

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 28
• Mettre b+1 à la place de b dans la condition,
• Ou bien changer la manière d’incrémenter.
Il peut arriver que le compteur joue en plus de son rôle, un autre rôle. Dans ce cas,
on doit faire attention aux différentes instructions qui l’utilisent.

3.3.2.3 Exemple
Dans cet exemple, on va écrire un programme qui fait la somme cubique d’un certain
nombre entré par l’utilisateur.

PROGRAMME Somme_Cubique
VARIABLE : somme, N, i : ENTIER
DEBUT
ECRIRE ("Entrez une entier supérieur ou égal à 5") ;
LIRE (N) ;
i ←− 5 ;
somme ←− i^3 ;

TANT_QUE (i < N) FAIRE



i ←− i+1 ;
somme ←− somme + i^3 ;

FTQ
ECRIRE ("Le résultat est ", somme) ;
FIN

3.3.3 La structure "REPETER . . . JUSQU’A"

La structure REPETER ... JUSQU’A est semblable à la structure FAIRE ... TANT_QUE.
Tout comme cette dernière, elle inclut l’exécution d’une séquence d’instructions avant
la vérification de la condition. Cependant, la différence entre ces deux structures réside
dans le fait que FAIRE ... TANT_QUE exécute les instructions aussi longtemps que la
condition est satisfaite alors que REPETER ... JUSQU’A le fait aussi longtemps que la
condition n’est pas satisfaite ; c’est-à-dire jusqu’à ce qu’elle devienne vraie.

3.3.3.1 Syntaxe

REPETER


<instruction1> ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 29
<instruction2> ;
.
.
.
<instructionn> ;

JUSQU’A (<condition>) ;

3.3.3.2 Exemple

Nb ←− 1 ; Nb ←− 1 ; Nb ←− 1 ;
i ←− 10 ; i ←− 10 ; i ←− 10 ;

TANT_QUE (i ≤ 20) FAIRE FAIRE REPETER

  

ECRIRE (Nb) ; ECRIRE (Nb) ; ECRIRE (Nb) ;

Nb ←− Nb + 1 ; Nb ←− Nb + 1 ; Nb ←− Nb + 1 ;
i ←− i + 2 ; i ←− i + 2 ; i ←− i + 2 ;

FTQ TANT_QUE (i ≤ 20) ; JUSQU’A (i ≥ 20) ;

Ces trois blocs de codes sont identiques.

Remarque 4
On pourra constater que les conditions sur les structures TANT_QUE sont des conditions de
continuation, tandis que celle devant REPETER ... JUSQU’A est une condition d’arrêt.

3.3.4 La structure "POUR"

Il est fréquent que l’on connaisse à l’avance le nombre de fois qu’on veut répéter un bloc
d’instructions. Dans ce cas, il apparaît plus simple d’utiliser une structure itérative qui
permet de répéter exactement le nombre fois que l’on désire. Le mécanisme permettant
cela est la boucle POUR. Cette boucle permet de parcourir un intervalle en répétant un trai-
tement ou un bloc d’instructions pour chacune des valeurs de cet intervalle en respectant
un pas donné.

3.3.4.1 Syntaxe

POUR <var> ALLANT DE <début> A <Fin> PAS DE <incrément>



<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 3 : Les structures de contrôle 30

FPOUR
OU

POUR
<var> ALLANT DE <début> A <Fin>
PAS DE <incrément>


<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;

FPOUR

3.3.4.2 Exemple
Dans l’exemple ci-après, on veut afficher tous les nombres compris entre 8 et 23.

PROGRAMME Affichage
VARIABLE : i : ENTIER
DEBUT

POUR i ALLANT DE 10 A 25 PAS DE 1



ECRIRE (i − 2) ;

FPOUR
FIN

Commentaire
A travers cet exemple, on peut voir que le fonctionnement de la structure itérative POUR
est tel que la variable compteur prend toutes les valeurs de l’intervalle de parcours y
compris les valeurs des bornes. Ces valeurs successives sont définitives et des manipu-
lations qui pourraient être faites sur elles dans le bloc d’instructions n’auront aucun
impact sur la manière dont elles sont incrémentées ou décrémentées selon l’instruction
ALLANT DE ... A ... PAS DE ....

NB : ... <début>...<Fin>...<incrément> sont des entiers ou des variables de type

entier.
Selon le pas d’incrémentation ou de décrémentation, la valeur qui est dans <Fin> pourrait
ne pas être prise par la variable compteur.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 31

Chapitre 4

Les tableaux

4.1 Pourquoi les tableaux

Imaginons que l’on veuille calculer la moyenne des notes d’une promotion, mais en gardant
en mémoire toutes les notes des étudiants pour par exemple faire d’autres calculs tels que
l’écart-type, la note maximale, la note minimale, etc... Il faudrait alors déclarer autant
de variables que d’étudiants. Si l’on a une dizaine d’étudiants, le problème ne se pose
pas a priori. Mais si l’on a n étudiants, ce ne serait pas réaliste de procéder ainsi. L’idéal
serait donc de pouvoir passer par l’intermédiaire d’une seule variable : c’est le rôle des
tableaux.

Un tableau est un type complexe de variable. Il est caractérisé par le nombre maximale
de valeurs qu’il peut contenir et le type de ces valeurs.

4.2 Définitions et syntaxe

4.2.1 Définitions
Un tableau est une structure particulière regroupant plusieurs valeurs du même type
appelées composantes du tableau. Il permet donc de stocker dans une même variable
de type tableau, plusieurs valeurs ayant une référence sémantique commune ; c’est-à-dire
désignant la même chose. Ce qui permet de différencier une valeur d’une autre dans un
tableau est son index (ou indice).

4.2.2 Syntaxe
<nomVariable>[<Nmax>] : <type>

Exemple

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 32

Note[100] : ENTIER

Remarque 5
Il n’est pas rare de faire la déclaration des tableaux comme suit :

TAB <nomVariable>[<Nmax> : <type>]

Le mot clé TAB indiquant qu’il s’agit d’une variable de type tableau.

4.3 Tableau à une dimension

4.3.1 Cas pratique
Considérons le problème du calcul de la moyenne, de l’écart-type, du minimum et du
maximum des notes d’une classe d’étudiant. L’algorithme de résolution de ce problème
est le suivant :

PROGRAMME Notes_Etudiants
VARIABLE : Moy, Ecart : REEL
N, i, Min, Max : ENTIER
Notes[1000] : ENTIER
DEBUT
ECRIRE ("Combien de notes ?") ;
LIRE (N) ;
Moy ←− 0 ;
Min ←− 20 ;
Max ←− 0 ;

POUR i ALLANT DE 0 A N − 1 PAS DE 1



ECRIRE ("Entrez la note ", i + 1) ;

LIRE (Notes[i]) ;
Moy ←− Moy + Notes[i] ;

SI (Min ≥ Notes[i]) ALORS

Min ←− Notes[i] ;
FINSI

SI (Max ≤ Notes[i]) ALORS

Max ←− Notes[i] ;
FINSI

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 33

FPOUR
Moy ←− Moy / N ;
Ecart ←− (Notes[0] − Moy)^2 ;

POUR i ALLANT DE 1 A N − 1 PAS DE 1

Ecart ←− Ecart + (Notes[i] − Moy)^2 ;
FPOUR
Ecart ←− SQRT(Ecart / N) ;
ECRIRE ("La note minimale est : ", Min) ;
ECRIRE ("La note maximale est : ", Max) ;
ECRIRE ("La moyenne des notes est : ", Moy) ;
ECRIRE ("L’écart-type des notes est : ", Ecart) ;
ECRIRE ("AU REVOIR ! ! !") ;
FIN

Commentaire
On peut constater que les index de la variable Notes varient de 0 à N-1. N étant le nombre
de valeurs que l’on veut stocker. En règle générale, c’est ce qui se fait. Mais on peut faire
varier les index d’une variable d’une valeur a donnée à une valeur b donnée (avec a<b)
selon l’utilisation que l’on veut faire des données stockées.

Pour parcourir les valeurs du tableau, on doit faire usage d’une boucle. La structure POUR
est recommandée à cet effet. Lorsque l’on veut afficher une valeur précise, on utilise son
index.

4.3.2 Problème du tri

Le problème du tri est un problème classique dans lequel on cherche à ranger des nombres
dans un certain ordre. On parlera donc du tri croissant et du tri décroissant.

Lorsqu’il s’agit de trois nombres, les structures conditionnelles imbriquées peuvent être
utilisées pour régler le problème de tri. Dans ce cas, on aura à gérer 3! possibilités. Mais
quand il va s’agir de n nombres, le travail sera fastidieux non seulement du point de vue
du nombre de valeurs à stocker, mais aussi du point de vue du nombre de possibilités à
gérer.

Pour gérer donc le tri de n nombres, il est préférable de faire usage des tableaux et de
minimum local ou maximum local. Pour ce faire, on peut imaginer plusieurs procédures,
mais elles peuvent toutes se ramener en deux cas :
- On fait usage d’un premier tableau pour stocker les nombres à ranger et on fait le
classement dans un second tableau.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 34
- On utilise le même tableau à la fois pour stocker et ranger. Dans ce cas, on fait usage
de la technique d’échange ou swapping ou interversion.

4.3.2.1 Utilisation de deux tableaux

PROGRAMME Tri_croissant
VARIABLE : T1[100], T2[100] : ENTIER
pos, i, j, N : ENTIER
min, max : ENTIER
DEBUT
ECRIRE ("Combien de nombre voulez-vous trier ?") ;
LIRE (N) ;

POUR i ALLANT DE 0 A N − 1 PAS DE 1



ECRIRE ("Entrez le nombre ", i + 1) ;

LIRE (T1[i]) ; //Remplissage du tableau

FPOUR
max ←− T1[0] ;

POUR i ALLANT DE 1 A N − 1 PAS DE 1



//Recherche du maximum global

SI (max < T1[i]) ALORS

max ←− T[i] ;
FINSI

FPOUR
T2[N − 1] ←− max ; //maximum global

POUR i ALLANT DE 0 A N − 2 PAS DE 1



min ←− T1[0] ;
pos ←− 0 ;

POUR j ALLANT DE 1 A N − 1 PAS DE 1



SI (min > T1[j]) ALORS



Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 35
min ←− T1[j] ; //minimum local
pos ←− j ;

FINSI

FPOUR
T2[i] ←− min ;
T1[pos] ←− max ; //ancienne valeur écrasée et remplacée
//par max pour que lors de prochaines
//itérations, elle ne soit pas prise
//en compte

FPOUR
FIN

4.3.2.2 Utilisation de la technique du swapping

PROGRAMME Tri_croissant
VARIABLE : T[100] : ENTIER
min, pos, temp, i, j, N : ENTIER
DEBUT
ECRIRE ("Combien de nombre voulez-vous trier ?") ;
LIRE (N) ;

POUR i ALLANT DE 0 A N − 1 PAS DE 1



ECRIRE ("Entrez le nombre ", i + 1) ;

LIRE (T[i]) ; //Remplissage du tableau

FPOUR
min ←− T[0] ;
pos ←− 0 ;

POUR i ALLANT DE 1 A N − 1 PAS DE 1



SI (min > T[i]) ALORS



min ←− T[i] ; //minimum local

pos ←− i ;

FINSI

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 36

FPOUR
temp ←− T[0] ;
T[0] ←− T[pos] ;
T[pos] ←− temp ;
j ←− 1 ;

TANT_QUE (j < N − 1) FAIRE



min ←− T[j] ;
pos ←− j ;

POUR i ALLANT DE j + 1 A N − 1 PAS DE 1



SI (min > T[i]) ALORS



min ←− T[i] ; //minimum local

pos ←− i ;

FINSI

FPOUR
temp ←− T[j] ;
T[j] ←− T[pos] ;
T[pos] ←− temp ;
j ←− j + 1 ;

FTQ
FIN

4.4 Tableau à double dimension

Les tableaux vus jusqu’ici sont à une dimension. Conceptuellement, tous les éléments se
trouvent dans une seule ligne ou colonne.
Dans la pratique, on est souvent confronté à des cas où l’on veut stocker dans la même
variable, plus d’une donnée. Pour ce faire, on peut avoir recours à des tableaux à plusieurs
dimensions. Le plus souvent, ce sont les tableaux à deux dimensions qui sont les plus
utilisés en informatique.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 37

4.4.1 Définition et syntaxe

4.4.1.1 Définition

Un tableau à deux dimensions ou matrice est un rectangle composé de lignes et de co-

lonnes. Chaque élément stocké dans le tableau est identifiable par sa position donnée par
sa ligne et sa colonne.

4.4.1.2 Syntaxe

<NomTableau>[N1][N2] : <type>

4.4.1.3 Exemple

Tab[50][20] : ENTIER

Commentaire
Avec cet exemple, on a déclaré un tableau de 50 lignes et 20 colonnes devant conte-
nir des valeurs de type ENTIER. D’une manière générale, la convention veut que l’on
énumère la ligne avant la colonne. Quant au type, tous les types de base sont permis
(REEL, ENTIER, CHAR, VARCHAR, BOOLEEN).

Dans l’exemple, l’indice de la ligne va varier de 0 à 49 et celui de la colonne de 0 à 19.

4.4.2 Remplissage et parcours d’un tableau à deux dimensions

Pour remplir et parcourir un tableau à deux dimensions, on utilise un double POUR. La
mise en œuvre est présentée dans l’exercice d’application suivant :

Exercice d’application

On veut collecter des données météo sur une période de 30 jours. Les données d’une jour-
née sont composées de la température relevée et de la vitesse du vent. Dans le programme
ci-après, on utilise les lignes pour faire varier les jours et les colonnes pour différencier la
donnée sur le vent de celle sur la température.

PROGRAMME Donnees_Meteo
VARIABLE : Tab[30][2] : REEL
i, j : ENTIER
DEBUT
ECRIRE ("Nous allons collecter vos données météo") ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 38
POUR i ALLANT DE 0 A 29 PAS DE 1


ECRIRE ("Jour ", i + 1) ;

POUR j ALLANT DE 0 A 1 PAS DE 1



SI (j = 0) ALORS


ECRIRE ("Vent : ") ;

LIRE (Tab[i][j]) ;

SINON


ECRIRE ("Température : ") ;

LIRE (Tab[i][j]) ;

FINSI

FPOUR

FPOUR
FIN

Exemple de parcours
Pour afficher la donnée du 25e jour relative au vent, on va faire :

ECRIRE (Tab[24][0]) ;

Pour calculer la température moyenne des 30 jours, on va faire :

moy ←− 0 ;

POUR i ALLANT DE 0 A 29 PAS DE 1

moy ←− moy + Tab[i][1] ;
FPOUR
moy ←− moy / 30 ;
ECRIRE ("La température moyenne est", moy) ;

Remarque 6
Le sens qui est donné à chaque dimension du tableau est important comme on a pu le voir
dans les exemples du tableau précédent. Il faudra donc faire attention à ne pas changer ce
sens lors de l’utilisation du tableau.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 4 : Les tableaux 39

4.5 Tableau à n dimensions

Par extension des tableaux à deux dimensions, on peut aussi utiliser des tableaux à plus
grande dimension. Leur déclaration est à l’image de celle des tableaux à deux dimensions ;
c’est-à-dire :

<NomTableau>[<Dim1>][<Dim2>] ... [<DimN>] : <type>

Exemple 4.5.1
Si l’on prend l’exemple précédent relatif de la météo, on peut vouloir collecter les données
journalières en question toutes les heures et également disposer de ces données pour tous
les mois. L’analyse de ces contraintes nous fait constater que chaque donnée stockée est
caractérisée par :
– Le mois (1 à 12),
– Le jour (1 à un maximum de 31),
– L’heure (1 à 24),
sans oublier le vent et la température qui se rapportent à la donnée elle-même. On se retrouve
donc à 4 dimensions que l’on doit toutes prendre en compte pour pouvoir distinguer les
données.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 40

Chapitre 5

Les algorigrammes

5.1 Définitions
L’algorigramme est la représentation graphique de l’algorithme. Il permet de représenter
chaque opération élémentaire au moyen d’un symbole graphique normalisé.

En réalité c’est un diagramme qui permet de représenter et d’étudier le fonctionnement

des automatismes de types séquentiels comme les chronogrammes ou le GRAFCET mais
davantage réservé à la programmation des systèmes microinformatiques ainsi qu’à la
maintenance.

Le diagramme est une suite de directives composées d’actions et de décisions qui doivent
être exécutés selon un enchaînement strict pour réaliser une tâche (ou séquence).

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 41

5.2 Symboles
5.2.1 Symboles de traitement

Opération de mise Opération ou Opération de Groupe

à disposition groupe préparation ou d’opérations
d’une information d’opérations sur d’organisation. considéré comme
à traiter ou des données, une seule
enregistrement instructions ou opération sous
d’une donnée à opération pour programme.
traiter. laquelle il n’existe
aucun symbole
normalisé.

5.2.2 Symboles de test logique

L’opération de test logique se fait sur une condition. Le résultat de cette opération im-
plique le choix d’une voix parmi plusieurs.

Le symbole de test logique est couramment employé pour représenter une décision ou un
aiguillage.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 42

5.2.3 Symboles auxiliaires

Symbole de renvoi Symbole de Opération Commentaires :

utilisé 2 fois pour début, de fin ou manuelle symbole utilisé
assurer la d’interruption pour donner des
continuité d’un algorithme. indications
lorsqu’une partie marginales.
de la ligne de
liaison n’est pas
représentée.

5.3 Règles de construction

• centrer l’algorigramme sur une feuille ;
• construire l’algorigramme afin que sa lecture s’effectue verticalement ;
• les lignes de liaison entre symboles ne doivent pas en principe se couper (utiliser un
symbole de renvoi) ;
• une ligne de liaison doit toujours arriver sur le haut et au centre d’un symbole ;
• les commentaires sont à placer de préférence à droite, et les renvois de branchement
à gauche.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 43

5.4 Structures algorithmiques élémentaires

5.4.1 La structure séquentielle ou linéaire
Algorithme Algorigramme

<opération 1> ;

<opération 2> ;

<opération 3> ;

5.4.2 La structure conditionnelle ou alternative SI

Algorithme Algorigramme

SI (<condition>) ALORS


<operation 1> ;

FINSI

SI (<condition>) ALORS


<operation 1> ;

SINON


<operation 2> ;

FINSI

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 44
Remarque 7
– la condition doit forcément s’énoncer au moyen d’une préposition logique.
– l’une des deux opérations peut ne pas exister, ce qui fait disparaître le sinon.

5.4.3 Les structures itératives ou répétitives

5.4.3.1 La structure TANT_QUE ... FAIRE

Algorithme Algorigramme

TANT_QUE (<condition>) FAIRE



<operation 1> ;
<operation 2> ;

FTQ

5.4.3.2 La structure FAIRE ... TANT_QUE

Algorithme Algorigramme

FAIRE


<operation 1> ;
<operation 2> ;

TANT_QUE (<condition>) ;

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 45
5.4.3.3 La structure POUR

Algorithme Algorigramme

POUR i ALLANT DE i1 A i2 PAS DE d



<operation> ;

FPOUR

5.5 Exemples
5.5.1 Exemple 1
Nous allons illustrer l’algorithme de l’exemple de la page 24 sous la forme d’un algo-
rigramme.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 46

5.5.2 Exemple 2
Pour cet exemple, nous utiliserons l’algorithme du tri croissant avec la technique du
swapping de la page 35.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 5 : Les algorigrammes 47

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 6 : Les sous-programmes 48

Chapitre 6

Les sous-programmes

6.1 Introduction
Il arrive que dans les programmes algorithmiques, on ait des blocs d’instructions qui se
répètent. Pour éviter ces répétitions et parfois pour rendre la structure générale d’un
algorithme plus lisible, on peut décider d’extraire lesdits blocs d’instructions et de les
ranger dans une structure spéciale. On pourra donc les appeler à travers une seule ligne
d’instructions dans l’algorithme principal. Pour ce faire, les blocs d’instructions extraits
devront être identifiés (pour être appelés) et constituent des sortes d’algorithmes indé-
pendants. On distinguera donc l’algorithme dit algorithme principal de ces algorithmes
indépendants qu’on appelle sous-programmes.

6.2 Définitions
6.2.1 Sous-programmes
Un sous-programme est un moyen de nommer une action complexe généralement compo-
sée de plusieurs actions ou calculs élémentaires dans le but de :
- l’utiliser plusieurs fois parce que la résolution du problème nous y contraint ;
- rendre la structure d’un algorithme plus claire et plus lisible.
On parle de modularité pour désigner la qualité d’un algorithme à être divisé.
Il existe deux types (ou formes) de sous-programmes : les Fonctions et les Procédures.

6.2.2 Paramètres et arguments

Les sous-programmes sont relativement indépendants de l’algorithme principal. Cepen-
dant, ils nécessitent souvent des données pour effectuer leur traitement. Les données
utilisées dans l’algorithme principal sont propres à ce dernier. Elles ne sont pas connues
hors de celui-ci. Il faut donc un mécanisme pour assurer le passage de ces données entre
l’algorithme principal et le sous-programme. Les notions de paramètre et d’argument

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 6 : Les sous-programmes 49
correspondent à ce mécanisme.

6.2.2.1 Paramètres

Les paramètres d’une procédure ou d’une fonction constituent les données nécessaires à
son fonctionnement.

6.2.2.2 Arguments

Les arguments correspondent aux valeurs qui sont effectivement passées à la procédure
ou à la fonction au moment de son appel.

6.3 Les fonctions

Une fonction est un sous-programme qui fournit un résultat utilisable comme une expres-
sion : affectation, affichage, etc. . .

6.3.1 Syntaxe de définition d’une fonction : entête et corps

FONCTION <nomFonction> (par1 :type,..., parn :type) : <typeDeRetour>
VARIABLE : <déclaration des variables de la fonction>
DEBUT
<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;
RETOURNER (<variable calculée>) ;
FIN
FINFONCTION

6.3.2 Exemple d’application

6.3.2.1 Enoncé

Soit f une fonction mathématique définie par f (x) = x3 − 2x2 + 5. On désire écrire un
algorithme dans lequel les images de plusieurs valeurs par la fonction seront calculées.
On décide donc d’utiliser une fonction.

6.3.2.2 Solution

FONCTION ImagParf (x : REEL) : REEL

VARIABLE : y, z : REEL

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 6 : Les sous-programmes 50
a, b : ENTIER
DEBUT
a ←− − 2 ;
b ←− 5 ;
y ←− x ∗ x ∗ x + b ;
z ←− y + a ∗ x ∗ x ;
RETOURNER (z) ;
FIN
FINFONCTION

6.3.2.3 Exemple d’appel

PROGRAMME Ex_Appel
VARIABLE : a, b : REEL
DEBUT
ECRIRE ("Entrez une valeur") ;
LIRE (a) ;
b ←− ImagParf(a) ;
ECRIRE ("L’image par f de ", a, " est ", b) ;
FIN

6.4 Les procédures

Une procédure est un sous-programme qui exécute un certain nombre d’actions sans four-
nir de valeurs de retour après son exécution.

6.4.1 Syntaxe
PROCEDURE <nomProcedure> (par1 : type, ..., parn : type)
VARIABLE : <déclaration des variables>
DEBUT
<instruction1> ;
<instruction2> ;
.
.
.
<instructionn> ;
FIN
FINPROCEDURE

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 6 : Les sous-programmes 51

6.4.2 Exemples d’application

6.4.2.1 Exemple 1

PROCEDURE AfficherMenu ()
VARIABLE :
DEBUT
ECRIRE ("Menu") ;
ECRIRE ("Choix 1 : Addition, tapez A") ;
ECRIRE ("Choix 2 : Soustraction, tapez S") ;
ECRIRE ("Choix 3 : Multiplication, tapez M") ;
FIN
FINPROCEDURE

6.4.2.2 Exemple 2

PROCEDURE AfficherSomme (a : ENTIER, b : ENTIER)

VARIABLE : s : ENTIER
DEBUT
s ←− a + b ;
ECRIRE ("La somme de ", a, " et ", b, " donne ", s) ;
FIN
FINPROCEDURE

6.4.2.3 Exemple d’appel de procédure

PROGRAMME Sympa
VARIABLE : ent1, ent2 : ENTIER
choix : CHAR
DEBUT
AfficherMenu() ;
LIRE (choix) ;
ECRIRE ("Entrez deux entiers") ;
LIRE (ent1, ent2) ;

SI ((choix = ’A’) OU (choix = ’a’)) ALORS

AfficherSomme(ent1, ent2)
FINSI
FIN

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 52

Chapitre 7

Les chaînes de caractères

7.1 Introduction
Les chaînes de caractères et les caractères constituent des types de variables très utiles en
programmation. Mais leur utilisation est soumise à un certain nombre de contraintes dont
il faut cerner les subtilités. C’est pour cette raison qu’ils seront étudiés dans ce chapitre
afin de donner à l’apprenant tous les outils nécessaires pour pouvoir les manipuler.

7.2 Opérations sur les caractères

7.2.1 Rappel sur la déclaration des caractères
<nomVariable> : CHAR OU <nomVariable> : CARACTERE

Remarque 8
Un caractère est une lettre ou un chiffre ou un symbole. A tout cela, s’ajoute l’espace (␣) et le
vide (||). Le vide (||) ici est différent de l’espace (␣). Un espace peut séparer deux caractères,
mais un vide entre deux caractère signifie qu’ils sont juxtaposés. On pourra en déduire que
la fonction de suppression que peut offrir un clavier sera remplie en utilisant le caractère vide
(||). Ce caractère se met dans deux simples côtes (’ ’).

7.2.2 Opérateur CODE

Cet opérateur retourne un entier qui est le code ASCII de la variable avec laquelle il est
utilisé. Cette variable doit être de type caractère.

En informatique, le code ASCII est une valeur numérique qui est associée à chaque ca-
ractère. L’ensemble des codes est recensé dans une table nommée Table des codes ASCII.
Donc quand on stocke un caractère en mémoire, on mémorise en réalité son code ASCII
(American Standard Code forInformation Interchange).

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 53
7.2.2.1 Syntaxe

CODE(<nomVariable>) ;

7.2.2.2 Exemple

ent1 ←− CODE(’A’) ;

7.2.3 Opérateur CAR

L’opérateur CAR retourne un caractère à partir de son code ASCII.
Syntaxe

ENTIER
z }| {
CAR(<code ASCII>), sinon CAR(<nomVariable>)

7.2.4 Opérations de comparaison

Les opérateurs < , > , ≤ , ≥ , = et 6= permettent de comparer les caractères entre eux
en se basant sur leur code ASCII.
Remarque 9
L’opérateur CAR retourne du vide quand le code ASCII est incorrect et CODE retourne 0 quant
le caractère n’appartient pas à la table des codes ASCII.

7.3 Les chaînes de caractères

7.3.1 Définition et syntaxe
7.3.1.1 Définition

Une chaîne de caractères est une suite finie de caractères.

7.3.1.2 Syntaxe

<nonVariable> : VARCHAR
CHAINE

7.3.1.3 Exemple

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 54

VARIABLE :prenom : CHAINE

prenom ←− "Baobab" ;
prenom ←− "123" ;
prenom ←− "killer_18" ;
prenom ←− "Bill Gate" ;

7.3.2 Relation d’ordre

Pour comparer deux chaînes de caractères, l’ordinateur compare les caractères de même
rang dans les deux chaînes en commençant par le premier caractère de chaque chaîne.

7.3.3 Concaténation
Le but de la concaténation est de créer des chaînes de caractères en juxtaposant deux
ou plusieurs caractères et/ou chaînes de caractères. L’opérateur de concaténation est
remplacé par "//" ou " + ".
Exemple

phrase ←− "Je sui"//"s content" ; OU

phrase ←− "Je sui" + "s content" ;

Cette instruction va retourner la phrase : Je suis content.

7.3.4 Opérateur SSCHAINE

7.3.4.1 Syntaxe

SSCHAINE(<chaine>, <position>, <nombre>) ;

Cet opérateur extrait de la variable <chaine> (ou de la chaîne de caractères passée

directement en paramètre) un nombre <nombre> de caractères à partir de la position
<position>.

7.3.4.2 Exemple

s ←− SSCHAINE("Baobab", 3, 3) ; // s = "oba"
prenom ←− Bill Gates, ce milliardaire ! ;
s2 ←− SSCHAINE(prenom, 7, 12) ; //s2 = "ates, ce mil"

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 55

7.3.5 Opérateur de comparaison sur les chaînes de caractères

Les opérateurs < , > , ≤ , ≥ , = et 6= sont utilisés pour comparer les chaînes de caractères
entre elles. Pour y arriver, ces opérateurs se basent sur le code ASCII de leurs caractères
respectifs.

7.3.6 Opérateur RANG

7.3.6.1 Syntaxe

RANG(<chaine>, <sous-chaine>, <position>) ;

Cet opérateur recherche dans la chaine <chaine>, la sous-chaine <sous-chaine> à partir

de la position <position>. et retourne le rang de son premier caractère. Si sous-chaine
n’existe pas dans <chaine> à partir de <position>, l’opérateur retourne la valeur 0.

7.3.6.2 Exemple

ch1 ←− "Baobab" ;
ch2 ←− "Bobaraba" ;
p ←− RANG(ch1, "oba", 1) ; //p = 3
p ←− RANG(ch1, "oba", 4) ; //p = 0
p ←− RANG(ch2, "a", 1) ; //p = 4

7.3.7 Opérateur LONGUEUR

7.3.7.1 Syntaxe

LONGUEUR(<chaine>) ;

Cet opérateur donne le nombre de caractères contenu dans la chaine de caractère <chaine>.

7.3.7.2 Exemple

a ←− LONGUEUR("Baobab") ; //a = 6

7.3.8 Opérateur CVCHAINE

7.3.8.1 Syntaxe

CVCHAINE(<Ent>) ;

Cet opérateur convertit la variable <Ent> de type entier en chaine de caractères.

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 56
7.3.8.2 Exemple

ent ←− 25 ;
c ←− CVCHAINE(ent) ; //c = "25"

7.3.9 Opérateur CVNOMBRE

7.3.9.1 Syntaxe

CVNOMBRE(<chaineEnt>) ;

Cet opérateur convertit une variable de type chaine de caractère ne contenant que des
chiffres en entier.

7.3.9.2 Exemple

chEnt ←− "25" ;
c ←− CVNOMBRE(chEnt) ; //c = 25

7.3.10 Opérateur CHERCHER

C’est un opérateur qui recherche toute ou partie d’une sous-chaîne dans une chaîne et
retourne les rangs du premier et du dernier caractère retrouvés. Il retourne un tableau
d’une dimension et de taille 2. S’il ne retrouve rien, il retourne 0 et 0 dans le tableau.

7.3.10.1 Syntaxe

CHERCHER(<chaine>, <sous-chaine>, <position>) ;

7.3.10.2 Exemple

ch1 ←− "Ananas" ;
ch2 ←− "Topographe" ;
T1[] ←− CHERCHER(ch1, "na", 3) ; //T1[0] = 4, T1[1] = 5
T2[] ←− CHERCHER(ch2, "graphe", 7) ; //T2[0] = 7, T1[1] = 10

7.4 Exercice d’application

PROGRAMME Pseudo_mot_de_passe
VARIABLE : nom, prenom, pseudo, ch : CHAINE
pos1, pos2, nbcar, i : ENTIER

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique

Chapitre 7 : Les chaînes de caractères 57
DEBUT
ECRIRE ("Entrez votre Nom, Prénom et Age dans cet ordre
séparés par un espace ( )) ;
LIRE (ch) ;
pos1 ←− RANG(ch, " ", 1) ;
nbcar ←− pos1 − 1 ;
nom ←− SSCHAINE(ch, 1, nbcar) ;
pos2 ←− RANG(ch, " ", pos1 + 1) ;
nbcar ←− pos2 − (pos1 + 1) ;
prenom ←− SSCHAINE(ch, pos2 + 1, nbcar) ;
nbcar ←− LONGUEUR(ch) − pos2 ;
age ←− SSCHAINE(ch, pos2+1, nbcar) ;
pseudo ←− SSCHAINE(prenom, 1, 1) ;

SI (CODE(pseudo) ≤ 90) ALORS

pseudo ←− CAR(CODE(pseudo) + 32) ;
FINSI
pseudo ←− pseudo + ’.’ ;

POUR i ALLANT DE 1 A (LONGUEUR(nom)) PAS DE 1



SI (CODE(SSCHAINE(nom, i, 1)) ≤ 90) ALORS

pseudo ←− pseudo + CAR(CODE(SSCHAINE(nom, i, 1)) + 32) ;
SINON
pseudo ←− pseudo + SSCHAINE(nom, i, 1) ;
FINSI

FPOUR
FIN

Dr Ir Géraud AZEHOUN PAZOU Initiation à l’algorithmique