Fascicule ALGORITHME

FASCICULE D'ALGORITHME © 1
SOMMAIRE
Avertissement.………………………………………………………………………………………………………………………………………………………………….Page 5
Préface…………………………………………………………………………………………………………………………………………………………………………….…Page 6
Avant propos…………………………………………………………………………………………………………………………………………………………..…….....Page 6
SECTION1 : CONNAISSANCES GENERALES INFORMATIQUES………………………………………………………...Page 7
CHAPITRE 1 : NOTIONS GENERALES D’INFORMATIQUE…………………………………………………………..........…...Page 8

1_L'informatique…………………………………………………………………………………………………………………….............................……Page 8
2_Origine de l'informatique………………………………………………………………………………………………………..........................….Page 8
3_L'ordinateur……………………………………………………………………………………………………………………….............................…….Page 9
a_Définition…………………………………………………………………………………………………………………...................................…….Page 9
b_Historique…………………………………………………………………………………………………………………..................................….…Page 9
c_Les caractéristiques de l'ordinateur………………………………………………………………………………................................Page 11
d_Les applications de l'ordinateur………………………………………………………………………………………..............................Page 12
e_La configuration d'un ordinateur…………………………………………………………………………………........................…….....Page 12
Les unités de mésure de la capacité d'information en informatique……………………………………...................…Page 14
f_Les différents types d'ordinateur…………………………………………………………………………………................................…Page 14
g_Les familles d'ordinateur………………………………………………………………………………………………..............................…..Page 16
4_Le système informatique…………………………………………………………………………………………………………...........................Page 16
Quiz n° 1………………………………………………………………………………………………………………………………………………………………….Page 17
CHAPITRE2 : LES LOGICIELS……………………………………………………………………………………………………………………..........Page 18

1_L'enjeu……………………………………………………………………………………………………………………………..............................………..Page 18
2_Définition…………………………………………………………………………………………………………………………...............................….….Page 18
3_L'interêt des logiciels………………………………………………………………………………………………………………......…....................Page 18
4_Les différents types de logiciels……………………………………………………………………………………………….......................….Page 19
5_Les différentes classes de logiciels………………………………………………………………………………………………......................Page 20
6_Mise en place d'un programme informatique……………………………………………………………………………...............……...Page 20
Quiz n° 2………………………………………………………………………………………………………………………………………………………………..…Page 21
SECTION2 : L’ALGORITHME………………………………………………………………………………………………………………................….Page 22
CHAPITRE 3 : INTRODUCTION A L’ALGORITHMIQUE……………………………………………………………………...........Page 23

1_Définition de l'algorithmique…………………………………………………………………………………………………...........................…Page 23
2_Le problème de l'algorithmique……………………………………………………………………………………………….......................…..Page 23
3_Notion d'algorithme…………………………………………………………………………………………………………….........................….…..Page 23
a_Définition………………………………………………………………………………………………………………………....................................Page 23
b_Rôle et interêt de l'algorithme…………………………………………………………………………………………..........................….Page 23
c_L'analyse d'un problème…………………………………………………………………………………………………................................Page 23
d_Les éléments d'un algorithme…………………………………………………………………………………………..............................Page 24
e_Les caractéristiques d'un algorithme………………………………………………………………………………........................…...Page 24
Quiz n° 3……………………………………………………………………………………………………………………………………………………...............Page 24
CHAPITRE 4 : INTRODUCTION AUX ELEMENTS DE L’ALGORITHME………………………………………….....…..Page 25

I_La structure d'un algorithme…………………………………………………………………………………………………..............................Page 25
II_Les objets…………………………………………………………………………………………………………………………………............................Page 25
1_Déclaration des objets…………………………………………………………………………………………………...........................…......Page 25
Exercice d'application n° 1………………………………………………………………………………………….................................Page 26
2_Déclaration d'une constante……………………………………………………………………………………...........…....Page 26
3_Déclaration d'une variable……………………………………………………………………………………………..................................Page 26
4_Les types de base…………………………………………………………………………………………………………….................................Page 27
a_ Entier…………………………………………………………………………………………………………………......................................….Page 27
Exercice d'application n° 2………………………………………………………………………………….............................….....Page 27
b_Réel……………………………………………………………………………………………………………………...........................................Page 27
c_Caractère……………………………………………………………………………………………………………...........................................Page 27
d_Chaîne de caractère………………………………………………………………………………………………......................................Page 27
NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

e_Booléen……………………………………………………………………………………………………………….......................................Page 28
Exercices d'application n° 3, 4, 5…………………………………………………………………………..............................Page 28
5_Les opérateurs………………………………………………………………………………………………………………..................................Page 28
Exercices d'application n° 6..........…………………………………………………………………………..............................Page 28
Quiz n° 4……………………………………………………………………………………………………………………......................................….Page 29
CHAPITRE5 : LES INTRUCTIONS DE CONTROLE………………………………………………………………………................Page 30
1_L'instruction d'affectation………………………………………………………………………………………………................................….Page 30
2_Les instructions d'incrémentation et de décrémentation………………………………………………………........................Page 30
Exercice d'application n° 1………………………………………………………………………………………………..........................…..Page 31
3_Les instructions d'entrée et de sortie…………………………………………………………………………………..............................Page 31
4_Les blocs d'instructions………………………………………………………………………………………………….....................................Page 32
5_Les instructions alternatives ou de décision……………………………………………………………………………....................Page 32
6_Imbrication de SI…ALORS et SI…ALORS…SINON…………………………………………………………………….......................Page 34
Exercice d'application n° 2………………………………………………………………………………………………................................Page 36
Exercice d'application n° 3………………………………………………………………………………………………................................Page 38
7_La structure SUIVANT…FAIRE…………………………………………………………………………………………….........................…....Page 38
8_Les opérations sur les propositions………………………………………………………………………………………............................Page 40
Exercice d'application n° 4.....................………………………………………………………………………….................................Page 41
9_Les commentaires…………………………………………………………………………………………………………………..............................Page 41
10_Les boucles………………………………………………………………………………………………………………………..................................Page 41
a_La structure TANT QUE…FAIRE……………………………………………………………………………………................................Page 42
b_La structure REPETER…JUSQU'A…………………………………………………………………………………...........................…...Page 42
c_La sructure POUR…FAIRE……………………………………………………………………………………………..................................Page 43
L'art de la programmation…………………………………………………………………………………………………………..........................Page 44
Test n° 1…………………………………………………………………………………………………………………………………..................................Page 45
CHAPITRE 6 : LES SOUS PROGRAMMES…………………………………………………………………………………..................…...Page 48

1_Définition…………………………………………………………………………………………………………………………….............................…...Page 48
2_Différence entre une fonction et une procédure…………………………………………………………………….........................Page 48
3_Interêt des fonctions et procédures………………………………………………………………………………………….........................Page 48
4_Structure générale des fonctions et procédures………………………………………………………………………...............….....Page 49
Exercice d'application n°1……………………………………………………………………………………………………...................…......Page 50
Exercices d'application n°2, 3, 4……………………………………………………………………………………………………….............Page 51
Exercices d'application n° 5…………………………………………………………………………...................................................Page 53
5_L'appel d'une fonction ou d'une procédure………………………………………………………………………………...................…..Page 53
6_La recursivité…………………………………………………………………………………………………………………………...............................Page 54
Exercices d'application n° 6…………………………………………………………………………......................................................Page 53
Conseils pratiques………………………………………………………………………………………………………………………............................Page 55
Test n°2…………………………………………………………………………………………………………………………………….................................Page 56
CHAPITRE 7 : LES STRUCTURES DE DONNEES STATIQUES…………………………………………………….….Page 58
Exercice d'application n° 1………………………………………………………………………………………………………........................Page 58
1_Les Chaînes de caractères……………………………………………………………………………………………………….............................Page 58
a_Définition………………………………………………………………………………………………………………………......................................Page 58
b_Affectation……………………………………………………………………………………………………………………......................................Page 58
Exercices d'application n° 2, 3, 4, 5…………………………………………………………………………………….........................Page 59
c_Les différentes fonctions applicables sur les chaînes de caractères……………………………………….....................Page 60
d_Les opérateurs applicables sur les chaînes de caractères……………………………………………………........................Page 60
2_Les Tableaux………………………………………………………………………………………………………………………..............................Page 60
a_Définition…………………………………………………………………………………………………………………….....................................…Page 60
b_Les diffétents types de tableau et leurs déclarations……………………………………………………….........................…Page 60
c_Affectation…………………………………………………………………………………………………………...........................................…….Page 61
Exercice d'application n° 6……………………………………………………………………………………….......................................Page 62
d_Parcours des tableaux………………………………………………………………………………………………........................................Page 63
Exercice d'application n° 7…………………………………………………………………………………….......................................…Page 63

Exercices d'application n° 8, 9, ………………………………………………………………………………………..............................Page 64
e_Imbrication des tableaux………………………………………………………………………………………………................................….Page 65
Exercice d'application n° 10……………………………………………………………………………………………...........................….Page 65
f_Définition de constantes de type tableau……………………………………………………………………………............................Page 65
Exercice d'application n° 11……………………………………………………………………………………………...............................Page 65
g_Tri de tableau……………………………………………………………………………………………………………….................................…...Page 66
Exercices d'application n° 12, 13……………………………………………………………………………………..........................….Page 66
h_Le passage de tableau en paramètre à une fonction ou à une procédure……………………………..............…...Page 67
3_Le type Enuméré………………………………………………………………………………………………………………………..............................Page 68
Exercice d'application n° 14……………………………………………………………………………………………………..........................Page 68
Exercice d'application n° 15……………………………………………………………………………………………………......................….Page 69
Exercice d'application n° 16……………………………………………………………………………………………………..........................Page 69
4_Les Intervalles…………………………………………………………………………………………………………………………................................Page 69
Exercice d'application n° 17……………………………………………………………………………………………………….......................Page 70
5_Le type Ensemble……………………………………………………………………………………………………………………….............................Page 70
a_Définition…………………………………………………………………………………………………………………………....................................Page 70
b_Déclaration du type ensemble……………………………………………………………………………………………..............................Page 70
Exercice d'aplication n° 18………………………………………………………………………………………………....................….......Page 71
c_Construction d'ensemble……………………………………………………………………………………………………................................Page 71
Exercice d'application n° 19, 20…………………………………………………………………………………………..................….....Page 71
Exercice d'application n° 21, 22…………………………………………………………………………………….........................…....Page 72
d_Les opérations portant sur les ensembles…………………………………………………………………………................................Page 72
Exercice d'application n° 24………………………………………………………………………………………………............................Page 73
6_Le type Enregistrement………………………………………………………………………………………………………….......................….........Page 75
a_Définition…………………………………………………………………………………………………………………………......................................Page 75
b_Déclaration……………………………………………………………………………………………………………………............................…..........Page 75
c_Interêt……………………………….…………………………………………………………………………………………..........................................Page 75
d_Les opérations portant sur un type Enregistrement……………………………………………………………….........................Page 75
Exercice d'application n° 25……………………………………………………………………………………………................................Page 75
e_L'instruction AVEC…FAIRE………………………………………………………………………………………………....................................Page 76
Exercice d'application n° 26……………………………………………………………………………………………….............................Page 76
f_Imbrication d'enregistrements…………………………………………………………………………………………….................................Page 77
g_Passage d'enregistrement en paramètre à une fonction ou à une procédure………………………............…........Page 78
Exercice d'aplication n° 28………………………………………………………………………………………………...............................Page 78
Optimisation d'un programme………………………………………………………………………………………………....................…....Page 79
Test n° 3………………………………………………………………………………………………………………………………………..................................Page 80
CHAPITRE 8 : LES FICHIERS…………………………………………………………………………………………………………............................Page 83

1_Définition…………………………………………………………………………………………………………………………………....................................Page 83
2_Déclaration………………………………………………………………………………………………………………………………....................................Page 83
3_L'accès au fichier………………………………………………………………………………………………………………………..................................Page 84
a_La création du fichier ou assignation………………………………………………………………………………………………………………...Page 84
b_L'ouverture du fichier…………………………………………………………………………………………………………………………………..........Page 84
4_Les différentes opérations sur un fichier……………………………………………………………………………………............................Page 84
a_Ecriture dans un fichier…………………………………………………………………………………………………….....................................Page 85
b_Lecture d'un fichier…………………………………………………………………………………………………………...............................Page 85
c_Recherche de données dans un fichier………………………………………………………………………………................................Page 86
- Accès direct…………………………………………………………………………………………………………………........................................Page 86
- Accès séquentiel……………………………………………………………………………………………………………......................................Page 86
d_Modification des données d'un fichier………………………………………………………………………………................................Page 89

e_Suppression d'un fichier……………………………………………………………………………………………………..................................Page 90

5_Le parcours des données d'un fichier…………………………………………………………………………………………............................Page 90
6_Les fonctions supplémentaires utilisables sur un fichier………………………………………………………………........................Page 90
Exercice d'application n° 4……………………………………………………………………………………………………................…....Page 91
Test n°4…………………………………………………………………………………………………………………………………....................................…..Page 93
CHAPITRE 9 : LES STRUCTURES DE DONNEES DYNAMIQUES…………………………………………………………….........Page 95
I_Concepts fondamentaux……………………………………………………………………………………………………………………………….............Page 95
1_Définition…………………………………………………………………………………………………………………………….....……........................Page 95
2_Déclaration……………………………………………………………………………………………………………………………….............................Page 95
3_Les différents types de pointeur……………………………………………………………………………………….................................Page 95
Exercice d'application n° 1………………………………………………………………………………………........................................Page 95
4_Affectation………………………………………………………………………………………......................................................................Page 96
5_Les opérations sur un pointeur………………………………………………………………………………………...................................Page 96
Exercice d'application n° 2……………………………………………………………………………………….......................................Page 97
II_Construction de structures de données dynamiques……………………………………………………………………………………......Page 97
1_Définition……………………………………………………………………………………………………………………….........................................Page 97
2_Déclaration d'une cellule………………………………………………………………………………………………………………………...............Page 97
3_L'accès aux différents champs d'une cellule…………………………………………………………………………………....................Page 98
4_L'affectation…………………………………………………………………………………………………………………………..................................Page 98
5_Les différentes opérations portant sur une cellule…………………………………………………………………….......................Page 98
a_Création d'une nouvelle cellule…………………………………………………………………………………………………...............…....Page 98
Exercice d'application n° 3………………………………………………………………………………………...................................Page 99
b_Suppression d'une cellule……………………………………………………………………………………………………….........................Page 99
Exercice d'application n° 4………………………………………………………………………………………………..........................Page 99
6_Les listes……………………………………………………………………………………………………………………………....................................Page 100
a_Définition………………………………………………………………………………………………………………………..................................Page 100
Exercice d'application n° 5…………………………………………………………………………………………………...................…..Page 100
b_Les opérations portant sur une liste……………………………………………………………………………………………….............Page 101
Exercice d'application n° 6………………………………………………………………………………………...................................Page 101
Exercice d'application n° 7…………………………………………………………………………………………………….....................Page 102
7_Les piles…………………………………………………………………………………………………………………………….........................................Page 104
b_Applications des piles………………………………………………………………………………………………………………………...........Page 104
c_Les opérations portant sur une pile…………………………………………………………………………………………………………...Page 104
Exercice d'application n° 8…………………………………………………………………………………………………........................Page 104
8_Les arbres……………………………………………………………………………………………………………………………......................................Page 106
b_Applications des arbres……………………………………………………………………………………………………………………….......Page 106
Test n°5………………………………………………………………………………………………………………………………….......................................Page 106
SECTION 3 : ANNEXES……………………………………………………………………………………………………………………………………….........Page 107

Correction du test n° 1…………………………………………………………………………………………………………………..............................Page 108
Correction du test n° 2……………………………………………………………………………………………………………………............................Page 128
Correction du test n° 3……………………………………………………………………………………………………………………….........................Page 137
Table des codes ASCII…………………………………………………………………………………………………………………………….........................Page 190

AVERTISSEMENT
Cet ouvrage s’adresse:
Aux étudiants BTS dans les filières technologiques:
▪ Informatique de gestion (1 ère et 2e année)
▪ NTIC (1 ère et 2e année)
▪ TELECOM (1 ère et 2e année)
▪ Electronique (1 ère et 2e année)
▪ 2IM (1 ère et 2e année),
 Aux étudiants Ingénieurs dans les filières technologiques,
 A tous ceux qui sont passionnés de la programmation informatique et qui souhaiteraient en repous-
ser leurs limites.
PREFACE
Nous sommes de plus en plus fascinés et émerveillés par les prouesses technologiques dans presque tous les domaines
d’activités de la vie humaine. Cette fascination est rendue possible grâce à l’introduction d’un outil de travail qui
s’adapte à nos besoins : l’ordinateur.
Nous devons cette facile adaptation de l’ordinateur à nos besoins, par sa facilité de communication, avec nous les êtres
humains. Ainsi donc nous lui soumettons nos désirs et celui-ci les exécute pour nous donner satisfaction.
Cet ouvrage a pour but de présenter de façon pédagogique un état de l’art de la communication avec l’ordinateur (pro-
grammation). Ce domaine est si étendu qu’il est impossible d’être exhaustif et cet ouvrage n’a pas la prétention de l’être.
Cependant, il essaie de dresser un panorama aussi complet que possible du domaine de la programmation.
Ce document est composé de trois (3) sections renfermant au total neuf (09) chapitres et nous allons essayer de résu-
mer dans les lignes qui suivent, la composition des différents chapitres:
La première section intitulée CONNAISSANCES GENERALES est composée de deux (2) chapitres :
Le premier chapitre présente les termes et connaissances informatiques utiles pour la suite.
Le second chapitre expose les différentes catégories de langages de programmation et leurs caractéristiques.
La deuxième section intitulée L’ALGORITHME est constituée de sept (7) chapitres:

Il sera question dans le troisième chapitre de l’enjeu de l’algorithmique,
Le chapitre 4 présente les éléments constitutifs de l'algorithme,
Le chapitre 5 spécule sur les instructions de contrôle,
Dans le chapitre 6, il est question de la mise en place des sous programmes et de leur importance,
Le chapitre 7 traite des structures de données statiques et de leur utilité,
Dans le chapitre 8, il est question des fichiers et de leur importance dans la programmation,
Et le chapitre 9 présente les structures de données dynamiques et leur utilisation.
La troisième section intitulée ANNEXES (corrections et explications des exercices des différents tests) est entièrement
consacrée à la correction et aux explications détaillées des exercices des différents tests.

AVANT PROPOS
Le but visé par cet ouvrage est de vous amener, vous lecteurs ou exploitants de ce document, d’être chevronnés en
programmation; domaine qui nous permet d’atteindre la pointe de la technologie. Vous êtes sans ignorer que les pays
qui détiennent présentement les secrets de la technologie de pointe (aéronautique, télécommunication & téléinforma-
tique, industries nucléaires, aérospatial…) sont ceux qui ont des connaissances très poussées principalement en informa-
tique et donc en programmation. Je pourrais citer les Etats-Unis, le Japon, la Russie et ses anciens Etats fédérés,
l’Allemagne, le Canada…et de nos jours certains pays de l’Asie du sud-Est notamment la Corée du Sud, l’Inde, la Chine,
la Thaïlande…Et pourquoi pas nous demain ?
Les connaissances véhiculées par cet ouvrage, une fois assimilées, vous permettront d’avoir un esprit logique très pous-
sé, bénéfique dans votre vie en plus des opportunités d’emploi et d’obtention de bourses d’études. Donc vous ne passe-
rez pas inaperçu quant à la nouvelle donne de mondialisation prônée car vous serez imbus de connaissances à faire va-
loir.
Cet ouvrage, pour une meilleure assimilation de son contenu, renferme des parties nommées:
▪ DES EXERCICES D'APPLICATION qui sont de petites évaluations directes pour renforcer la partie du cours, en
cours; et donc pour une meilleure assimilation. Les exercices d'application seront corrigés ensemble avec les étu-
diants.
▪ QUIZ qui sont en fait un ensemble de questions de connaissances générales sur le chapitre terminé, pour tester
vos connaissances sur ledit chapitre. C’est en fait des selfs test (auto test en français). Ceci concerne les quatre
premiers chapitres. Ces QUIZ ne sont pas corrigés car c'est une invitation pour les étudiants à la recherche .
▪ TESTS qui sont en fait des cas pratiques dont la résolution va aboutir à la mise en place d’algorithmes. C'est donc
le cœur même du ducument. En fait, il s’agit de tester vos connaissances algorithmiques par l’écriture d’algorithmes
pour résoudre des cas pratiques. Ceci concerne les chapitres 5 à 9. Ces TEST sont corrigés entièrement dans le do-
cument au niveau de la section 3 (annexes), avec tous les détails et explications possibles.
STATISTIQUES CONCERNANT LE CONTENU DE CE DOCUMENT

 Nombre de quiz: 4.
 Nombre de tests: 5 mais qui regroupent au total 52 exercices.

 Nombre d'exercices d'application : 57.
 Nombre de pages occupées par les 52 exercices des 5 tests: 83 pages car les exercices ont été tous
corrigés et expliqués dans les moindres détails, de manière approfondies et souvent, avec plusieurs méthodes
possibles de résolution des exercices.
Cet ouvrage renferme donc une immensité de savoir qui en réalité, vous sera bénéfique à condition que
vous l’exploitiez à fond c'est-à-dire que vous vous exerciez assez surtout au niveau des algorithmes car ils
sont le socle de la programmation. Ne vous contentez pas de lire ce document comme un roman ou un
journal, mais plutôt d’appliquer les connaissances qu’il diffuse. C’est à ce prix que vous serez chevronnés.
۩ Je vous prie donc de suivre ces derniers conseils !
BON APPRENTISSAGE DONC !


CHAPITRE 1 : NOTIONS GENERALES D’INFORMATIQUE

OBJET: Ce chapitre présente l’environnement de l’ordinateur
OBJECTIF : À la fin de chapitre, vous devez être en mesure de savoir :
▪ Ce que c’est que l’informatique, son origine et sa vocation,
▪ Ce que c’est que l’ordinateur, son origine, ses caractéristiques, ses applications, ses éléments constitutifs,
les différents types et familles d’ordinateur.
1) L’informatique
L’informatique, terme issu de la contraction de INFORmation et de autoMATIQUE, est la science de traitement auto-
matique de l’information à l’aide de l’ordinateur.
De cette définition, trois (3) termes submergent :
− Science : savoir, ensemble de connaissances théoriques que l’on acquiert par l’étude, l’expérience et par
l’observation.
− Traitement de l’information : ensemble de techniques (Electronique, électrotechnique, mécanique, logique mathé-
matique, arithmétique, automatisme,…) permettant de stocker des informations, d’y accéder, de les combiner en
vue de leur exploitation. C’est en fait agir sur l’information pour produire des résultats escomptés.
Données Résultats
Traitement de l’information
Exemples de traitement de l’information : Vous appuyez sur une touche du clavier et le caractère gravé sur cette touche
apparaît à l’écran ou vous cliquez sur le bouton Enregistrer et l’information que vous avez saisie est enregistrée.
Données Résultats
Appui sur la touche du clavier Affichage du caractère à l’écran
Clic sur le bouton Enregistrer Mémorisation de l’information
− Automatique : Qualifie un dispositif qui exécute de lui-même (sans intervention humaine) certaines opérations dé-
finies à l’avance.
 De la définition des trois (3) termes précédents, nous pouvons retenir également ceci : l’informatique est
l’ensemble des connaissances théoriques acquises par l’étude, l’expérience, l’observation sur les tech-
niques permettent d’agir sur les données en vue de résultats, et cela sans l’intervention humaine parce
que ces opérations étant connues d’avance par l’ordinateur. En fait la mise en application des connaissances
théoriques de la science informatique est le fait de l’ordinateur.
L’informatique renferme deux (2) aspects : Le matériel (HARDWARE en anglais) est tout ce qui est physique et se charge
du traitement de l’information. C’est en fait la partie exécutante ; et le logiciel (SOFTWARE en anglais) est la partie intel-
ligente c’est à dire la partie qu contient ce qu’il faut faire pour aboutir aux résultas. C’est en fait la partie qui contient les
directives à exécuter.
۩ Le matériel et le logiciel sont dépendants l’un de l’autre, c’est à dire sans le matériel, le logiciel ne peut fonctionner et vice ver-
sa.
2) Origine de l’informatique
۩ On dit une informatique.
Le mot « Informatique » date de 1962 c'est-à-dire que c’est en 1962 que ce mot est apparu pour la première fois dans le
dictionnaire français. Ici, il s’agit du mot informatique et non de la science informatique.
Le mot informatique est apparu avec le développement des ordinateurs. La science informatique est apparue avec
l’ordinateur donc une science récente, et d’ailleurs c’est la dernière née des sciences (la plupart des sciences sont nées
bien avant la naissance de Jésus Christ) qui au fil du temps a vu son domaine d’intervention s’étendre du fait des be-
soins sans cesse croissant des utilisateurs et aussi de l’avancée significative de la technologique.
La science informatique, au départ était présente seulement dans les grands centres de recherche et grands laboratoires
aux Etats-Unis d’Amérique. Les initiés à cette époque étaient en nombre infime et l’informatique se limitait seulement au
stockage des informations, à leur restitution et surtout aux calculs complexes très compliqués balistiques (science du
mouvement des projectiles lancés dans l’espace).

En effet, la science informatique est née dans le souci de faire face aux difficultés croissantes dans la gestion des calculs
très complexes et fastidieux dans les domaines tels que les mathématiques, l’automatisme, l’astronomie, la chimie, la
physique… et la balistique surtout.
En fait l’informatique est née dans le but de faire gagner du temps aux chercheurs dans leurs quotidiennes et fasti-
dieuses tâches.
De nos jours, l’informatique est présente partout dans le monde entier, dans tous les secteurs d’activité et même dans
les foyers.
3) L’ordinateur
a) Définition
L’ordinateur [Computer en anglais] est la machine de traitement de l’information. Il est capable d’effectuer automati-
quement des opérations arithmétiques, logiques, de comparaison... (à des fins scientifiques, administratives, comptables,
scientifiques...) à partir de programmes définissant la séquence de ces opérations et cela à une très grande rapidité et
sans erreur.
L’ordinateur est capable d’acquérir, de conserver des informations, d’effectuer des traitements (par application des pro-
grammes) et des restituer les informations traitées ou stockées.
L’ordinateur ne « réfléchit » pas. Toutes les prouesses qu’il effectue sont le fait de l’être humain qui les lui communique
d’avance et ceci à travers les programmes. C'est donc une machine programmable (c’est-à-dire une machine dont les
possibilités changent quand on modifie son "programme").
b) Historique
Le tout premier ordinateur est apparu en 1946 aux Etats-Unis. Il porte le nom ENIAC (Electronic Numerical Integrator
And Calculator). Il pesait trente (30) tonnes et pouvait multiplier deux (2) nombres de dix (10) chiffres en 3ms (millise-
conde). Il remplaçait deux cents (200) personnes chargées auparavant de calculer les tables de tir. Il occupait 23 m3,
coûtait à l’époque demi million de dollar américain (cela fait 250 millions FCFA. A l’époque c’était énorme !) et consom-
mait presque 192 KW. Il était constitué de 70 000 résistances, 10 000 condensateurs, 1 500 relais, 6 000 commutateurs
manuels et 19 000 tubes à vide.
Il est l’œuvre de John Presper ECKERT et de John William MAUCHLY (Etats-Unis) et commandé par l’armée améri-
caine en 1943. L’ENIAC a fonctionné jusqu’en 1955 et durant ses neuf (9) années de fonctionnement, il a subi 19 000
interventions (réparations) !
Les ordinateurs de cette époque, appelés gros systèmes, étaient très volumineux, très chers et donc rares. Ils étaient
donc très peu connus du monde entier et de la population.
Vue d’ensemble de l’ENIAC, installé dans une salle machine

Non, ce n'est pas un sommelier qui choisit une bouteille de vin mais un technicien qui change l'un des 19000
tubes de l'ENIAC !

Deux opératrices en train de câbler un "programme" sur l'ENIAC
Ça y est, le "programme" est câblé sur l’ENIAC
c) Les caractéristiques de l’ordinateur

L’ordinateur est doté de caractéristiques remarquables qui sont :
▪ Grande capacité de mémorisation : en effet l’ordinateur est capable de mémoriser une très grande
quantité d’informations diverses (images, son, texte, graphiques) et cela sur une très longue période.
▪ Très rapide dans l’exécution des tâches.
▪ Fiable car exécute les tâches sans erreurs.

▪ Programmable : l’on peut facilement lui communiquer notre volonté et il l’exécute. C’est pour cette
raison qu’il effectue des tâches nombreuses et variées.
d) Les applications de l’ordinateur

A l’origine, l’ordinateur était utilisé pour effectuer surtout des calculs complexes et fastidieux dans les grands centres de
recherches et grands laboratoires aux Etats-Unis. De nos jours, l’ordinateur est utilisé dans tous les domaines d’activité
(commerce, industrie, administration, laboratoire, établissements scolaires, agriculture, architecture…).
Ainsi est-il utilisé pour le traitement de texte et d’image, la reconnaissance de la parole, de la vision, de la forme et des
empruntes, la compréhension des langages naturels, les diagnostics médicaux, la correction des fautes d’orthographes et
de grammaire, la robotisation, le contrôle de la trajectoire d’un satellite et son pilotage, la conception des maquettes des
engins avant leur construction, les analyses chimiques et biologiques, optimiser la conception d’un circuit électronique,
les échanges commerciaux, la simulation du vol d’un avion ou d’une fusée, la météorologie, la communication, le tracé
de courbes, la facturation, la gestion des stocks, du personnel, de la population…Vous le constater, ce à quoi peut servir
l’ordinateur est immense et très variés. Raison pour laquelle, il est souvent appelé « machine universelle », c'est-à-
dire une machine qui peut pratiquement tout faire. C’est un outil incontournable de nos jours.
e) La configuration d’un ordinateur

Un ordinateur est constitué du boîtier de l’unité centrale sur lequel viennent se connecter les périphériques externes
(clavier, souris, moniteur, l’imprimante, la table traçante, le crayon optique, le scanner, modem…). Le boîtier de l’unité
centrale contient en plus du microprocesseur et de la mémoire centrale, des périphériques internes (Lecteur de CD ROM
de disquette, le disque dur) et d’autres éléments (boîtier d’alimentation, les connecteurs, la carte mère sur laquelle tous
les éléments se trouvant à l’intérieur du boîtier de l’unité centrale s’enfichent : d’où le terme « mère »…).
Boîtier de l’unité centrale

Une carte mère
Un microprocesseur (l’élément se trouvant dans la main du monsieur)
Note: Il y a des microprocesseurs de forme carrée (comme celui-ci dessus) et d’autres de forme rectangulaire.

Une barrette de mémoire centrale Un disque dur
Rôle de certains éléments de l’ordinateur :

Le microprocesseur : il a pour rôle d’exécuter les instructions des programme pour ainsi faire fonctionner
l’ordinateur. C’est le cœur de l’ordinateur. Sa rapidité est mesurée en Hertz (Hz). Exemple un microprocesseur de 2
GHz.
La mémoire centrale : C’est le lieu de rangement de tous les programmes à être exécuter. Ainsi si un pro-
gramme est sur le disque dur ou le CD ROM par exemples, pour qu’il soit exécuté, il faudrait le placer d’abord en mé-
moire centrale et c’est de là que le microprocesseur pourra l’exécuter. Après l’exécution de celui-ci, il est effacé de la
mémoire centrale pour faire la place aux autres programmes. La mémoire centrale est volatile c'est-à-dire qu’elle ne
conserve les informations que lorsqu’il y a du courant électrique. En cas de coupure de courant ou de l’extinction de
l’ordinateur, son contenu est perdu.
Le disque dur : C’est la mémoire principale de l’ordinateur. Toutes nos données, nos logiciels sont mémorisés sur
le disque dur.
Unités de mesure de la capacité d’information en informatiques
L’unité élémentaire de mesure de l’information est le BIT (BInary digiT=chiffre binaire). Le bit ne peut ne peut prendre
que les valeurs 0 ou 1. Le zéro (0) correspond à l’absence de courant et le un (1) à la présence de courant. C’est en
effet ce langage que l’ordinateur comprend : courant ou pas courant.
En informatique, les unités de mesure de capacité sont (les multiples du bit) :
۰ 1 octet (O)= 8 bits ۰ Giga (G) = 230 ۰ Exa (E) = 260
۰ Kilo (K) = 2 10
۰ Tera (T) = 2 40
۰ Zetta (Z) = 270
۰ Méga (M) = 2 20
۰ Péta (P) = 2 50
۰ Yotta (Y) = 280
Ainsi :
▪ 1Kbit = 210 bits soit 1024 bits ; 1Mbit = 220bits soit 1048576 bits, 1Gbit = 230 bits soit 1 073 741 824 bits….
▪ 1 KO= 210 octets soit 1024 octets soit 1024*8=8 192 bits
▪ 1 MO = 220 octets soit 1048576 octets soit 8 388 608 bits
▪ 1 GO = 230 octets soit 1 073 741 824 octets
▪ 1 TO = 240 octets
▪ ….
۩ Dans tout autre domaine en dehors de l’informatique (mathématiques, en physique ,…),: 1 Kilo = 103 ; 1 Méga = 106 ; 1 Giga =
109 ; 1 Téra = 1012 ; 1 Péta = 1015, 1 Exa = 1018, 1 Zetta = 1021 et
1 Yotta = 1024.
f) Les différents types d’ordinateur

L’on distingue classiquement quatre (4) types d’ordinateur suivant leurs puissances et leurs modalités d’utilisation :
▪ Les main frames ou superordinateurs
Ils ont une grande taille et ont des puissances et des capacités de stockage très importantes. Ce sont les ordinateurs les
plus modernes, les plus sophistiqués, les plus puissants et les plus chers, de nos jours. Ils sont essentiellement utilisés
dans les entreprises de très grandes tailles nécessitant le stockage d’une très grande quantité d’informations pour des-
servir un très grand nombre d’utilisateurs à la fois. Le premier main frame a été fabriqué en 1976 et porte le nom
CRAY1.
۩ Les main frames n’ont rien à voir avec les gros systèmes des années 40-50.
Un seul main frame peut coûter plus de 5 milliards FCFA !

Exemple de noms de main frame et de leurs fabricants : Cray (CRAY), VAX9440 (DEC), DPS7 (BULL)
Photos de superordinateurs
Quelques caractéristiques du tout dernier main frame d’IBM : il intègre en son sein:
✓ 1920 microprocesseurs !
✓ 644 GO comme capacité de la mémoire centrale !
✓ 100 TO comme capacité d’un seul de ses disques durs !
▪ Les minis ordinateurs
Ils ont une taille moyenne. Ces ordinateurs ont des puissances de calcul et capacités de stockage relativement
importantes. Ils sont employés dans les entreprises de grande taille.
Au niveau de la puissance de calcul et de stockage, ils sont justes en dessous des main frames.
Exemple de noms des minis ordinateurs et de leurs fabricants : AS400 (IBM), DPX (BULL°)
Photos de mini ordinateur

▪ Les micro-ordinateurs ou ordinateurs de bureau ou ordinateur personnels
Ils sont nommés Personal computer (PC) en anglais. Ils ont une petite taille. Ce sont eux que nous utilisons dans nos
tâches quotidiennes au bureau, à l’école, à la maison. La société pionnière des micro-ordinateurs est IBM. En effet il a
commercialisé son premier micro-ordinateur nommé IBM PC (ordinateur personnel d’IBM) le 12 août 1981 et c’est à
partir de cette date que les micro ordinateurs ont été divulgués. Mais avant IBM, une autre société du nom d’APLLE avait
mis en place aussi des ordinateurs de petite taille mais un peu dans l’anonymat.
Les ordinateurs portables font partie des micro-ordinateurs.
Exemple de marque de micro-ordinateurs : Compaq, HP, Fujitsu, Packard Bell, DEC, DELL, IBM, LG…
Il existe des ordinateurs sans marque appelés des clones.

▪ Les ordinateurs de poche appelés PDA (Personal Digital Assistant = assistant personnel ou ordinateur
de poche)
Photo de PDA
Avant tout un agenda et carnet d'adresse, Les PDA intègrent des fonctions de plus en plus élaborées et n'ont presque
plus rien à envier aux ordinateurs de bureau. Lecture de MP3, de vidéos, auxquels s'ajoutent des programmes qui les
transforment en outils de navigation associés à un GPS, par exemple.
g) Les familles d’ordinateur

Les ordinateurs se repartissent en deux (2) grandes familles qui sont:
▪ Les IBM PC & compatibles : Ce sont les ordinateurs conçus à l’image du premier micro-ordinateur d’IBM de
1981. D’où le terme « IBM PC & compatible » c'est-à-dire des ordinateurs qui en sont des copies. Ils sont équipés
généralement de microprocesseurs d’Intel ou de microprocesseurs voisins de ceux d’Intel.
Ce sont les ordinateurs que nous utilisons partout ici.
▪ Les macintosh : Ce sont des ordinateurs fabriqués par la société APPLE et qui sont équipés par les microproces-
seurs de Motorola.
Photos d’ordinateurs MACINTOSH
4) Le système informatique
On appelle système informatique, l’ensemble formé par le matériel (ordinateur) et les logiciels nécessaires au fonction-
nement du matériel et vice versa. Donc si vous voyez un ordinateur en fonctionnement (donc il a en son sein des logi-
ciels), son vrai nom n’est pas ordinateur mais système informatique car l’ordinateur est tout l’ensemble formé par
tout ce qui est matériel.

QUIZ N°1
Exercice 1
1) Que signifie « Traitement de l’information » ?

2) Qu’est ce qui rend possible le traitement de l’information ?
3) Qu’est ce que le microprocesseur ? Quel est son rôle ?
4) Citez trois domaines où l’on utilise l’ordinateur.
5) L’informatique peut-elle se passer du microprocesseur ?
6) Quelle était à l’origine, la vocation de l’informatique ?
7) Quels sont les impacts du développement de l’informatique sur la vie des êtres humains?
8) Qu’est ce qui est à l’origine du développement de l’informatique ?
9) Quelles sont les particularités d’un ordinateur ?
10) Le premier ordinateur, l’ENIAC, a été conçu en 1946. Mais il a fallu attendre 1962 pour que le mot
« Informatique » voie le jour. Quelle explication pouvez-vous donner à cela ?
Exercice 2
1) Répondre par vrai (V) ou faux (F) aux affirmations suivantes

2) L’informatique est la science des ordinateurs.
3) L’informatique est l’étude des ordinateurs
4) Sans l’ordinateur, l’on peut parler d’informatique
5) L’ordinateur est le logiciel associé au matériel
6) Un système informatique est constitué de l’ordinateur uniquement
7) Les données sont exécutables
8) Sans les données, le système informatique est capable de fournir des résultats
9) Le système informatique fait partie de l’ordinateur
10) Les minis ordinateurs sont les ordinateurs les plus utilisés
11) Le matériel et le logiciel sont dissociables
12) Un programme informatique est constitué de données, d’instructions, des mémoires et du micropro-
cesseur
13) Le microprocesseur est un programme qui exécute les autres programmes
14) Le microprocesseur est localisé dans le moniteur
15) Un périphérique est tout matériel permettant des échanges avec l’unité centrale
16) Une instruction est un ordre que l’on donne au microprocesseur afin de réaliser une tâche élémentaire
17) Il existe quatre (4) types d’ordinateur selon les modalités d’utilisation
18) Sans la mémoire centrale, l’ordinateur est capable de fonctionner
19) Le système informatique est l’ensemble formé par le matériel et les logiciels nécessaires au fonction-
nement du matériel (ordinateur) et vice versa
20) L’ordinateur est tout ce qui est physique dans un système informatique
21) Le premier ordinateur, l’ENIAC, est apparu en 1941 aux Etats-Unis.

CHAPITRE 2 : LES LOGICIELS

OBJET: Ce chapitre présente l’environnement des programmes informatiques.
OBJECTIF : À la fin de ce chapitre, vous devez être à mesure de savoir :

▪ Ce qu’est un logiciel
▪ Son intérêt dans un système informatique
▪ Les différents types de logiciels
▪ Le passage du problème au programme informatique
1) L’enjeu
Depuis 1946, date de la création du tout premier ordinateur l’ENIAC, dont le but était de faire face aux calculs complexes
et fastidieux dans les grands centres de recherches et grands laboratoires de l’époque aux Etats-Unis, le rôle joué par
l’ordinateur s’est accrû nettement. En effet de nos jours, l’ordinateur est présent dans tous les secteurs d’activité, partout
dans le monde entier et permet de faire des tâches très diversifiées et nombreuses.
A l’achat d’un appareil ou machine électronique (poste radio, photocopieuse, TV, fer à repasser, téléfax…), l’on a une
idée claire et précise de ce que celui-ci fait : poste radio  écouter la musique et suivre l’actualité, photocopieusefaire
des photocopies, TVsuivre les programmes des différentes chaînes de TV, visionner les films et clips, téléfaxenvoyer
des copies à distance…
Par contre l’ordinateur qui est aussi une machine électronique a un champ d’utilisation presqu’illimité. En clair,
l’ordinateur peut pratiquement tout faire. Ainsi est-il capable de faire du traitement de texte et d’image, la reconnais-
sance de la parole, de la vision, de la forme et des empruntes, la compréhension des langages naturels, les diagnostics
médicaux, la correction des fautes d’orthographes et de grammaire, la robotisation, le contrôle de la trajectoire d’un
satellite et son pilotage, la conception des maquettes des engins avant leur construction, les analyses chimiques et bio-
logiques, l’optimisation de la conception d’un circuit électronique, les échanges commerciaux, la simulation du vol d’un
avion ou d’une fusée, la météorologie, la communication, le tracé de courbes, la facturation, la gestion des stocks, du
personnel, de la population…
Qu’est ce qui distingue donc l’ordinateur des autres machines électroniques ?
L’ordinateur est capable de tant de prouesses, c’est parce qu’il est programmable. En effet lorsque l’on désire que
l’ordinateur fasse telle ou telle tâche pour nous, il suffit de le lui « dire » à travers un langage qui lui est intelligible (qu’il
comprend), de manière détaillée et il le fait très bien (sans erreur) et avec une très grande rapidité. Programmer un
ordinateur, c’est prévoir absolument tout ce qu’il doit faire et le lui expliquer très précisément.
En clair, l’ordinateur ne peut absolument rien faire sans qu’on ne le lui « dise ». L’ensemble de ce qu’on lui « dit »,
l’ensemble de ces directives, l’ensemble de ces instructions, de ces ordres en vue de la réalisation d’une tâche précise,
est connu sous le vocable programme informatique.
Un programme est donc un ensemble d’instructions, un ensemble d’ordres que l’on soumet à l’ordinateur afin qu’il
l’exécute pour produire un résultat escompté, pour répondre à un besoin spécifique de l’utilisateur.
2) Définition
Un logiciel (software en anglais) est un ensemble de programmes informatiques coopérants dont l’exécution par
l’ordinateur, vise à répondre à un certain besoin. L’ensemble de ces programmes constituant ainsi le logiciel, forme un
tout logique, une même entité. Par simplification programme informatique = logiciel.
3) L’intérêt des logiciels

Les logiciels représentent la partie intelligente dans un système informatique. En effet dans le système informatique, il y
a deux (2) parties fonctionnelles : la partie exécutrice qui s’occupe de l’exécution des tâches élémentaires pour faire
fonctionner le système informatique (ordinateur) ; et la partie commande qui dicte à la partie exécutrice ce qu’il faut
faire (logiciel). En effet le logiciel indique au matériel comment traiter les données.
La partie commande fournit des ordres à la partie exécutrice qui les exécute. Sans la partie commande, la partie exécu-
trice ne peut absolument rien faire car toute initiative vient de la partie commande.
Exemple : Soit la recette de cuisine ci-après :

− Découper l’oignon,
− Ajouter de l’huile dans la casserole et la mettre sur le feu,
− Découper la viande de poulet, la rincer et mettre le tout dans la casserole,
Instructions − Ajouter du cube Maggi,
− Y ajouter un peu de piment et du sel,
− Laisser mijoter durant 15mn et remuer le contenu de la casserole,
− Ajouter un peu à nouveau dans la casserole
Programme ou logiciel
Qui va faire la préparation ? C’est la cuisinière. Donc l’agent exécuteur est la cuisinière (la cuisinière joue le rôle de
l’ordinateur ici).
Qui apporte les directives de la préparation ? C’est la recette de cuisine. Donc l’agent commande est la recette (la recette
de cuisine joue le rôle des logiciels ici).
Pour effectuer la préparation, la cuisinière (ordinateur) va suivre des directives (instructions) contenues dans la recette
de cuisine (logiciel).
۩ Vous pouvez installer autant de logiciels que vous désirez sur votre ordinateur pourvu qu’il y ait de mémoire disponible.
4) Les différents types de logiciels

Nous distinguons trois (3) types de logiciels :
a) Les systèmes d’exploitation ou logiciels de base ou systèmes opératoires
Ils permettent d’exploiter, d’utiliser l’ordinateur. Sans eux, l’ordinateur ne peut fonctionner ni les autres logiciels
ni le matériel informatique. Toute opération sur l’ordinateur n’est possible que par le biais des systèmes
d’exploitation. Ils constituent les intermédiaires entre l’utilisateur et l’ordinateur. Par analogie, c’est la fondation de la
maison. Avant toute utilisation de l’ordinateur, il faut d‘abord installer le système d’exploitation ; et c’est à partir de cet
instant l’on pourra installer les autres éléments matériels et logiciels pour les faire fonctionner.
۩ L’on peut installer plusieurs systèmes d’exploitation sur un même ordinateur mais l’on ne pourra utiliser qu’un seul système
d’exploitation à la fois.
Exemples de noms de systèmes d’exploitation
MS DOS (MicroSoft Disk Operating System)
OS/2
Windows 95, 98, 2000, NT (New Technology), XP (eXPerience), Millenium, 2003
Linux
MVS, BSD, HP_UX, AIX, Xetrix
Netware
b) Les logiciels d’application ou progiciels

Ils ont pour rôle de fournir un traitement répondant à un besoin spécifique de l’utilisateur. Ce besoin de l’utilisateur peut
être généraliste c'est-à-dire commun à tout le monde (comptabilité, tracé de courbes, traitement de texte,…) ou sur
mesure c'est-à-dire spécifique (paie, gestion d’une entreprise, d’un super marché,…).
Les logiciels d’application peuvent conçus par des entreprise spécialisées et être vendus sur le marché ou être conçus
par les utilisateurs eux-mêmes en fonction de leurs besoins ou ceux des autres (logiciels personnalisés).
Exemples de logiciels d’application
− Les traitements de texte (Microsoft Word, WinWord, Wordperfect, Amipro…) : Ils permettent de saisir du texte,
de le mettre en couleur, de le souligner, de bien le présenter…C’est ce que les secrétaires utilisent en entreprise.
− Les tableurs (Excel, lotus…) : Ils permettent de tracer des courbes, des histogrammes…
− La comptabilité (SAARI…) : Ils permettent de faire la comptabilité des les entreprises.
− Architecture (Autocad…) : Ils permettent de tracer les plans des immeubles, des ponts, des engins mécaniques…
− PAO (Publicité Assistée par Ordinateur) (Publisher…) : Ils permettent de bien présenter les revues avec des couleurs
attirantes, des images (les journaux, les magasines…).
− DAO (Dessin Assisté par Ordinateur) (Corel Draw…) : Ils permettent de faire des posters publicitaires en trois di-
mensions, de retoucher les images…et aussi de faire les maquettes (plan de bâtiments, de ponts, d'engins méca-
niques…).

− Les SGBD (Système de Gestion des Bases de Données) (Oracle, Mysql, Access…): Ils permettent de créer une
banque de données, c'est-à-dire de pouvoir enregistrer les données, d’y effectuer des traitements tels que par
exemples la liste de tous les étudiants dont l’age est compris entre 20 et 25 ans, la liste des Ivoiriens nés à Abid-
jan…
− Les utilitaires (Antivirus, les compresseurs/décompresseurs de données…) : Ce sont des logiciels permettant
d’effectuer des travaux dans le système informatique. Ils aident en quelque sorte le système d’exploitation. Ce
qu’ils font est vaste et varié.
c) Les langages de programmation et logiciels outils

Ils permettent d’automatiser des tâches sur l’ordinateur. En effet c’est avec eux que l’on crée les logiciels d’application et
les systèmes d’exploitation. Bref c’est avec eux que l’on programme l’ordinateur donc ils permettent de créer des pro-
grammes informatiques.
Exemples de langages de programmation et logiciels outils
 Langages de programmation
▪ Pascal
▪ C et C++
▪ Lisp
▪ Prolog
▪ Smaltalk
▪ Python
▪ PHP
▪ Java
▪ …
 Les logiciels outils : Ils intègrent du graphique et donc permettent de programmer plus vite. Ils s’utilisent
conjointement avec les SGBD.
▪ Visual basic, Delphi
▪ Magic
▪ Windev
▪ Developper 2000
▪ Frontpage
▪ Dreamweaver
5) Les différentes classes de logiciels

Logiciel propriétaire : logiciel que l’acheteur ne peut en suivant des règles parfois extrêmement limitatives (on n’a pas
accès au code source dons impossible de les modifier le logiciel car l’on dispose seulement du code exécutable, interdit
de les distribuer, de les prêter, de les graver…)
Shareware ou logiciel contributif ou partagiciel : Logiciel diffusé massivement et de façon gratuite pour un temps
d’utilisation donné (temps d’essai). Après ce temps d‘utilisation, si l’on désire continuer l’utilisation du logiciel, il va donc
falloir maintenant payer un droit.
Freeware ou logiciel public: Logiciel entièrement gratuit qu’on peut copier comme on veut mais son code ne peut
être modifié car l’on ne peut y accéder. En général si un programme est en freeware, c’est qu’il n’est pas fantastique
(faibles performances, peu de fonctions,…)
Groupware ou Synergiciel ou Logiciel de groupe de travail: Logiciel permettant à un groupe d'utilisateurs de tra-
vailler en collaboration sur un même projet sans être nécessairement réunis.
Logiciel libre : Logiciel payant ou gratuit (freeware) dont on a accès à son code source et que l’on peut modifier à vo-
lonté pour l’adapter à ses besoins (pour ainsi donner naissance à un autre logiciel proche de l’original).
Spyware ou espiogiciel (contraction de « espion » et de « logiciel »): Logiciel espion qui vous surveille sans vous le
dire et recueille vos informations importantes de manière sournoise (coordonnées bancaires par exemples…) lorsque
vous travaillez sur l’ordinateur ou internet.
Middleware ou logiciel médiateur: Assure l’intermédiaire entre les logiciels d’application et le transport des données
par le réseau.Shareware n. m.
6) Mise en place d’un programme informatique

Un programme informatique, est conçu pour résoudre un problème auquel l’utilisateur est confronté et donc de satisfaire
un besoin. Ainsi partant du problème, les différentes étapes pour aboutir à sa résolution par l’ordinateur sont :
PROBLEME  ALGORITHME  PROGRAMME  ORDINATEUR  SOLUTION AU PROBLEME

 Etant confronté à un problème et désirant le résoudre en utilisant l’ordinateur, l’on traduit le problème en algorithme.
 L’algorithme sera ensuite traduit en programme informatique en utilisant un langage de programmation.
 Le programme informatique sera ensuite exécuté par l’ordinateur.
 L’exécution du programme informatique donnera la solution au problème.
QUIZ N°2
1) Qu’est ce qu’un logiciel ?

2) Comment appelle t-on la partie "intelligente" d'un système informatique?
3) Quel est l’intérêt des logiciels dans un système informatique ?
4) Quels sont les types de logiciels que nous avons ? Donner un exemple pour chaque type.
5) Quelles sont les étapes de la mise en place d’un programme informatique ?
6) Peut-on utiliser l’ordinateur sans logiciel ?
7) Qu'est ce qui peut limiter le nombre de logiciels installés au sein d'un système informatique?
8) Qu'est ce qui permet à l'ordinateur de s'adapter aux différents problèmes de l'Homme?


CHAPITRE 3 : INTRODUCTION A L’ALGORITHME

OBJET : Ce chapitre explique ce que c’est que l’algorithmique et l’algorithme.
OBJECTIFS : À la fin de ce chapitre, vous devez être à mesure de connaître :
▪ Ce qu’est l’algorithmique,
▪ Ce que c’est l’algorithme ; son rôle, son intérêt et ses caractéristiques.
1) Définition de l’algorithmique
L’algorithmique est la discipline qui traite des méthodes permettant d’écrire des algorithmes c'est-à-dire les règles, les
méthodes à observer pour concevoir l’algorithme. L’algorithmique se penche sur la clarté, la lisibilité, le caractère non
ambigu de l’algorithme.
Certes, nous devons écrire des algorithmes pour résoudre des problèmes en utilisant l’ordinateur, mais cette écriture de
l’algorithme ne doit pas se faire à n’importe pièce mais en suivant des directives.
2) Le problème de l’algorithmique
Nous disposons d’un agent (humain, machine, ordinateur…) capable de réaliser un ensemble d’opérations (actions, ins-
tructions…) qu’il est capable d’interpréter c'est-à-dire qu’il peut comprendre et exécuter directement.
Lorsque l’ordinateur est capable d’exécuter directement des actions, l’on parle d’actions élémentaires (ou actions de
base ou actions non décomposables).
Le problème est donc de faire réaliser par l’ordinateur une tâche complexe (problème) alors qu’il n’est
capable que d’actions élémentaires. Il convient donc pour cela de décomposer cette tâche complexe en une suite
organisée d’actions élémentaires (qu’on appelle algorithme) que l’ordinateur sera capable d’interpréter et d’exécuter
directement, par sa traduction dans un langage que celui-ci comprend.
Cette méthode de décomposition de problèmes permet de passer avec un maximum de chances de réussite de la des-
cription du problème initial (action complexe) à sa résolution.
3) Notion d‘algorithme
a) Définition
Un algorithme est la description précise et rigoureuse d’une suite d’opérations permettant d’obtenir la solution d’un pro-
blème en un nombre fini d’étapes.
L’algorithme est écrit dans un langage naturel (français, anglais, allemand, arabe…) et est inintelligible à l’ordinateur
(l’ordinateur ne comprend pas l’algorithme).
Le terme ALGORITHME vient du mathématicien arabe MUHAMMAD IBN MUSA AL KHAREZMI (fin VIII e siècle, début IXe
siècle) qui rédigea un traité exhaustif sur le système de chiffres et de numérotation hindou d’où est tiré le nôtre. A partir
de ce moment, l’utilisation des chiffres et des modes de calcul hindou fut connue sous le nom d’ALGORISMI.
b) Rôle et intérêt de l’algorithme

 Le rôle de l’algorithme est fondamental. En effet sans lui, il n’y aurait pas de programme (qui n’est que sa
traduction dans un langage compréhensible par l’ordinateur : langage de programmation). De plus, l’algorithme est fon-
damental en un autre sens : il est indépendant à la fois de l’ordinateur qui l’exécute (à travers les programmes)
et des langages de programmation dans lesquels il est énoncé et traduit. Cela signifie que lorsque vous écrivez
votre algorithme, vous ne devrez pas vous soucier du langage dans lequel votre algorithme sera traduit et l’ordinateur
sur lequel l’algorithme sera traduit et exécuté. Il n’y a pas d’algorithme spécialement pour tel ou tel langage ou pour tel
ou tel ordinateur. Pas parce que l’algorithme que je vais écrire sera après, traduit dans le langage Pascal que je vais
l’écrire de telle façon ou dans le langage C que je vais l’écrire de telle autre façon. Non ! Ne vous souciez pas du langage
dans lequel votre algorithme sera traduit. Ecrivez seulement votre algorithme indépendamment des langages de pro-
grammation ; et après vous choisirez le langage dans lequel vous devez traduire votre algorithme.
 Savoir programmer, c’est plus savoir trouver l’algorithme à un problème que de connaître toutes les
instructions d’un langage de programmation. Cela veut simplement dire qu’un bon programmeur est celui qui est
fort en algorithme. La base de la programmation est l’algorithme. Donc maîtriser l’algorithme, c’est maîtriser la pro-
grammation.
c) L’analyse d’un problème
En amont de toute programmation se trouve nécessairement un problème. En fait c’est la résolution du problème en
utilisant l’ordinateur qui amène la programmation. Donc pour mieux cerner le problème à résoudre, il y a des étapes à
suivre. Ainsi l’analyse d’un problème consiste à :

▪ Enoncer le problème
▪ Poser le problème
▪ Décrire le cheminement pour la résolution du problème.
Enoncer le problème : Il consiste à répertorier toutes les données, les situations initiales et aussi les résultats. En plus de
cela ici il s’agit majoritairement de comprendre à fond la nature et le contenu du problème. Bref, c’est comprendre
clairement le problème à résoudre car si vous n’avez pas bien compris le problème, je me demande comment vous
allez le résoudre ?
Vous devrez vous poser ces quelques questions :
De quoi est-il question dans le problème ? Qu’est ce qu’on me demande ?
Quels sont les éléments contenus dans le problème et que je dois utiliser pour sa résolution ?
Quelle est la finalité du problème ?
Poser le problème : C’est décrire les grandes lignes de la résolution du problème posé, c'est-à-dire pour passer des don-
nées aux résultats tout en respectant les hypothèses de travail. Ici il s’agit simplement de dégager les grandes
lignes de la résolution du problème. Ceci est l’étape qui précède la résolution proprement dite du problème.
Le cheminement : Il s’agit de décrire de façon non ambiguë et détaillée les différentes étapes pour passer des
données aux résultats tout en respectant les hypothèses de travail. En fait, c’est ici que l’on résout le problème posé. Ce
cheminement devra être formulé dans un langage naturel mais non intelligible à l’ordinateur appelé ALGORITHME. Bref,
c’est ici que l’on écrit l’algorithme.
d) Les éléments de l’algorithme

Un algorithme se caractérise par deux (2) sous ensembles qui sont :
▪ L’ensemble des objets (données et résultats)
▪ L’ensemble des opérations ou actions
L’objet désigne une entité du problème. Il est caractérisé par son identificateur (son nom) et par son titre (l’ensemble
des opérations applicables à cet objet).
Les actions sont appliquées sur les données pour produire les résultats.
e) Les caractéristiques de l’algorithme
✓ Formel : Langage qui utilise un ensemble de termes et de règles syntaxiques pour permettre de communiquer
sans aucune ambiguïté (par opposition au langage naturel).
✓ Inintelligible à l’ordinateur : L’ordinateur ne comprend pas l’algorithme donc il va falloir le traduire dans un lan-
gage que l’ordinateur comprend (langage de programmation) pour que l’ordinateur puisse l’exécuter.
✓ Indépendant à la fois de l’ordinateur qui l’exécute (à travers les programmes) et des langages de programma-
tion.
✓ L’algorithme est écrit dans un langage naturel (français, anglais, allemand, espagnol, baoulé, dioula, bété, sé-
noufo,…).
QUIZ N°3
1) Quelles sont les qualités attendues d’un programmeur ?
2) « Savoir programmer, c’est plus savoir trouver l’algorithme à un problème que de connaître toutes les
instructions d’un langage de programmation ». Commentez ce passage.
3) De quoi est constitué un programme informatique?
4) Quelles sont les grandes lignes de la résolution d'un problème?
5) Pourquoi pour la résolution d'un problème par l'ordinateur, nous devons le décomposer en éléments
très simples et détaillés?

CHAPITRE 4 : INTRODUCTION AUX ELEMENTS DE L’ALGORITHME

OBJET : Ce chapitre présente la structure de l’algorithme et les objets servant à l’élaboration de celui-ci, c'est-à-dire les
différents éléments sur lesquels les actions vont porter.
OBJECTIFS : A la fin de ce chapitre, vous serez à mesure de savoir :
✓ La structure d’un algorithme,
✓ Les différents éléments de l’algorithme sujets aux traitements,
✓ Les différents opérateurs
I/ La structure d’un algorithme

La mise en place d’un algorithme respecte un certains nombres de règles. Ainsi la structure d’un algorithme se subdivise-
t-elle en trois (3) parties dont l’ordre à respecter est le suivant :
 Le nom de l’algorithme ou l’en-tête : C’est le nom que l’on donne à l’algorithme. Il est obligatoire, c'est-à-
dire que tout algorithme doit nécessairement avoir un nom. Le nom que l’on donne à l’algorithme est au choix
mais doit respecter un certain nombre de règles (voir le II 1) a) ).
 La partie déclarative : c’est ici que l’on déclare les constantes, les variables, les structures de données, les fonc-
tions et les procédures. Les différents éléments dont il s’agit ici seront vus dans la suite de ce document.
Cette partie est facultative car dépendant de la nature du problème et des besoins de l’utilisateur, c'est-à-dire
par exemple si le problème auquel je suis confronté nécessite l’utilisation d’une variable alors je vais en déclarer,
dans le cas contraire je ne vais pas déclarer de variable. Pareil pour les autres…
 Le corps de l’algorithme : Il est obligatoire et débute par le mot clé DEBUT et se termine par le mot clé FIN.
C’est en effet dans cette partie que l’on effectue les différentes actions nécessaires pour la résolution du pro-
blème ; en utilisant les éléments déclarés éventuellement dans la partie déclarative.
La structure d’un algorithme se présente comme suit :
Syntaxe :
ALGORITHME nom_algorithme ; En-tête
-------------------
-------------------
-------------------- Partie déclarative de l’algorithme
---------------------
DEBUT
Instruction1 ;
.
. Corps de l’algorithme
.
.
Instruction n ;
FIN.
Une instruction est une action élémentaire que l’on effectue en vue de la résolution du problème, dans la mise e place e
l’algorithme. Elle se termine par un point-virgule (;).
Le langage d’expression algorithmique utilise des mots clés et des structures, permettant d’organiser l’exécution des
traitements de manière systématique, qu’il faudra mettre en relief en les soulignant et en les mettant en majuscules
dans l’algorithme.
II/ Les objets

Ce sont les objets sur lesquels l’on porte une action, un traitement. Ils servent à sauvegarder en effet les données et
résultats (intermédiaires et finaux).
Nous avons les constantes, les variables et les structures de données. Ils sont déclarés dans la partie déclarative de
l’algorithme.
Nous allons nous intéresser pour le moment aux constantes et variables ; les autres seront vus dans les chapitres à ve-
nir.
1) Déclaration des objets
Déclarer un objet, c’est exprimer la volonté de l’utiliser dans le programme. En fait, c’est dans les objets que nous allons
mettre les données afin de réaliser des traitements sur eux, pour résoudre notre problème. Ainsi donc tous les objets
dont nous aurons besoin pour la résolution de nos problèmes seront obligatoirement déclarés, c’est présentés à
l’ordinateur.
La déclaration des objets se fait à l’aide des éléments suivants :

▪ L’identificateur ou nom,
▪ Le type,
▪ Et éventuellement sa valeur.
a) L’identificateur ou nom
C’est le nom que l’on donne à l’objet. Le programmeur est libre de décider des noms à donner à ses objets. Cependant
la nomination des objets doit respecter un certain nombre de règles, à savoir :
▪ Les caractères utilisés peuvent être des lettres (les lettres de l’alphabet)
▪ Les chiffres de 0 à 9 et le caractère « souligné » ( _ )
▪ Les symboles ne sont pas acceptés (exemples : #, $, %, &, (, §, β, , Ω, λ, ε, φ, μ, ®,© ;ç, -…) pas plus que les
opérateurs (*, /, +,<, >,=)
▪ Les caractères accentués ne sont pas acceptés (à, é, è, ë, ï, î, ù),
▪ Le premier caractère doit obligatoirement être différent d’un chiffre,
▪ Aucun espace ne doit figurer dans le nom des objets,
▪ Ne pas utiliser les mots clés du langage utilisés ou de l’algorithme.
 Exercice 1 d'application : Dire lesquelles des déclarations suivantes sont correctes :
Ca_3, nom_enf, nom-enf, élève, note1, man, 1bic, maç, notes, som me, bD, âge, nom_etudiant, debut, fin, si
Noms correctes :……………………………………………………………………………………………………………………………………………
Noms incorrects :…………………………………………………………………………………………………………………………………………
b) Le type
C’est l’intervalle des différentes valeurs que peuvent prendre l’objet. Ainsi suivant le type qu’on va attribuer à l’objet (qui
est d’ailleurs fonction du problème qu’on aura à résoudre), celui-ci pourra prendre telles valeurs ou ne pourra pas pren-
dre telles autres.
c) La valeur
C’est ce que vaut l’objet à un instant donné. C’est son contenu.
2) Déclaration d’une constante

a) Définition
Une constante est un élément dont la valeur (le contenu) ne change pas au cours du traitement, et donc son contenu
reste identique durant tout le programme ; d’où le terme « constante ». Elle conserve la valeur qu’on lui a attribuée au
départ, sans aucune possibilité de modification.
b) Déclaration
La déclaration d’une constante est précédée du mot clé CONST.
Syntaxe : CONST
Nom_de_la_constante = valeur ;
Exemple : CONST
Val = 3.5 ;
Age_max = 150 ;
Cat = 'c';
3) Déclaration d’une variable

a) Définition
Une variable est un élément dont la valeur est susceptible de varier tout au long du déroulement du programme ; d’où le
terme « variable ». En fait, l’on peut lui attribuer une valeur x et après lui attribuer une autre valeur Y, et ainsi de suite.
b) Déclaration
La déclaration d’une variable est précédée du mot clé VAR.
Syntaxe : VAR
Nom_de_la_variable : type_de_la_variable ;
Exemple : VAR
val : ENTIER;
a: REEL;

4) Les types de base

Les types représentent les différents ensembles de valeurs que peuvent prendre les objets de l’algorithme. Ici type de
« base » car c’est à partir de ceux-ci que l’on va obtenir d’autres types.
En plus de cette caractéristique, ces types sont dits types scalaires car ils ne peuvent contenir une et une seule valeur
à la fois.
Nous avons :
a) Le type entier : ENTIER
Un entier est codé sur deux (2) octets, soit sur 16 bits. L’ensemble des valeurs prises par un entier est :
D = [ (-216)/2 ; +(216/2) - 1], soit D = [-32 768 ; +32 767]
JUSTIFICATION :
216 car avec 16 bits, le nombre de combinaisons que l’on peut obtenir sachant qu’un bit ne peut prendre que 2
valeurs (0 ou 1) est 216
216/2 car l’on voudrait dans cet ensemble de valeurs ainsi obtenu une partie, une moitié négative (-) et l’autre moi-
tié positive (+).
Les entiers servent à faire des calculs.
Pour déclarer un type entier, l’on utilise le mot clé ENTIER.
Soit la déclaration suivante :
VAR
i : ENTIER ;
 Exercice 2 d'application : Peut-on attribuer à i n’importe quelle valeur ?
Réponse:………………………………………………………………………………………………………………………………………………………………
b) Le type réel : REEL
Un réel est codé sur six (6) octets, soit sur 48 bits. L’ensemble des valeurs prises par un réel est : D = [ (-248)/2 ;
+(248/2) - 1], soit D = [-1,4*1014 ; +1,4*1014]. En plus, les réels peuvent comporter des virgules comme en ma-
thématique. Les réels servent à faire des calculs sur les nombres à virgules et aussi sur les grands nombres.
Pour déclarer un type réel, l’on utilise le mot clé REEL (les entiers sont inclus dans l'ensemble des réels).
Exemple :
VAR
J : REEL ;
A l’instar de l’exemple précédent, les valeurs que l’on pourra attribuer à J, doivent être forcement dans l’intervalle:
D = [-1,4*1014 ; +1,4*1014].
c) Le type caractère : CARACTERE
Un caractère est une lettre, un chiffre, un symbole, un espace. Il est codé sur un octet (8 bits). Ce qui permet d’avoir:
28 soit 256 caractères différents.
La valeur d’un caractère est toujours placé entre quote (' ') et le mot clé utilisé pour déclarer un caractère est
CARACTERE. Les caractères vont servir à gérer par exemple des réponses (O pour oui et N pour non)…
Exemple:
VAR
cat : CARACTERE ;
Ainsi, les valeurs que l’on pourra attribuer à cat sont : un seul caractère ou un seul chiffre ou un seul symbole ou un seul
espace, et cette valeur est placée entre ‘ ’ comme par exemples ‘a’, ‘1’, ‘&’.
d) Le type chaîne de caractères : CHAINE
Une chaîne de caractères est une suite de caractères juxtaposées c'est-à-dire collés les uns à côté des autres. La valeur
d’une chaîne de caractères est toujours placé entre double quote (" ") et le mot clé utilisé pour déclarer une chaîne de
caractères est CHAINE. Les chaînes de caractères vont servir à gérer par exemples, les noms, des n° matricule, des
phrases…
Exemple :
VAR
Nom : CHAINE ;
Ainsi, l’on peut attribuer par exemples les valeurs suivantes à la variable nom : "Soro", "yao", "nguessan2"…

e) Le type booléen : BOOLEEN

Un booléen est une variable particulière ne pouvant prendre seulement que les valeurs VRAI ou FAUX.
Le mot clé utilisé pour déclarer un booléen est BOOLEEN.
Exemple :
VAR
trouver : BOOLEEN ;
Ainsi, l’on pourra attribuer seulement que les valeurs VRAI ou FAUX à la variable trouver.
 Exercice 3 d'application : Peut-on attribuer à une variable de type CARACTERE, n'importe quelle valeur ?
…………………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………….
 Exercice 4 d'application : Peut-on attribuer à une variable de type CHAINE, n'importe quelle valeur ?
…………………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………….
 Exercice 5 d'application : En programmation, à quoi servent les booléens ?

…………………………………………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………………………………………..
5) Les opérateurs
a) Les opérateurs arithmétiques
L’on s’en sert pour faire les calculs. Nous avons :
+ (addition), - (soustraction), / (division décimale), * (Multiplication), DIV (Division entière), MOD (Modulo =
reste de la division entière), ^ (exposant).
Exemples : 5/3=1,6666… ; 5 DIV 3 = 1 ; 5 MOD 3 = 2 ; 5^3 = 125
b) Les opérateurs logiques de base

Ce sont les conjonctions de coordination utilisées en programmation. Ils permettent de relier des conditions pour en faire
une seule.
Nous avons ET, OU (OU inclusif), NON (négation : c’est l’équivalent de « ne pas » en littérature), XOU (OU exclusif),
dont seuls les trois (3) premiers sont les plus utilisés.
Exemples d'application:
▪ Si (e>1) ET (j=3) ALORS instruction 1 ;
 L’instruction 1 sera exécutée si et seulement si …………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………………
▪ SI (a=b) OU (x>y) ALORS instruction 2 ;
 L’instruction 2 sera exécutée si et seulement si ………………………………………………………………………………………….
……………………………………………………………………………………………………………………………………………………………………………
▪ SI NON (p=t) ALORS instruction 3 ;
 L’instruction 3 sera exécutée si et seulement si ………………………………………………………………………………………….
▪ SI (t  0) XOU (b>a) ALORS instruction 4 ;
 L’instruction 4 sera exécutée si et seulement une et une seule des conditions est vraie.
 Exercice 6 d'application: Exercice lié au dernier cas( XOU ):
t=0 ; b =5 et a=2 ; dans ce cas ……………………………………………………………………………………………………………….
t=3 ; b=8 et a=3 ; dans ce cas………………………………………………………………………………………………………………..
t=0 ; b =5 et a=12 ; dans ce cas…………………………………………………………………………………………………………......
c) Les opérateurs relationnels

Ils permettent de faire des comparaisons. Ce sont : , , , ,  et =.

QUIZ N°4
1) Que signifie « Traitement de l’information » ?

2) Qu’est ce qui rend possible le traitement de l’information ?
3) Quelle était à l’origine, la vocation de l’informatique ?
4) Qu’est ce qui est à l’origine du développement de l’informatique ?
5) D’où provient la très grande souplesse de l’ordinateur ?
6) Pourquoi l’ordinateur est utilisé dans la résolution de nos problèmes ?
7) Est-ce vrai que l’ordinateur est capable d’intuition ? Justifier
8) Quel est l’intérêt d’un algorithme ?
9) Quelles sont les particularités d’un algorithme ?
10) Quelles sont les particularités d’un ordinateur ?
11) Quelles sont les étapes lors de l’analyse d’un problème ? Les expliquer brièvement suivant votre
compréhension. A quel niveau se situe l’algorithme ?
12) Qu’est ce qui différencie l’algorithme d’un langage de programmation ?
13) Quel est l’intérêt des objets au niveau de l’algorithme ?
14) Qu’est ce qui caractérise un objet au niveau de l’algorithme ?
15) Dans quel but est née la programmation ?

CHAPITRE 5 : LES INSTRUCTIONS DE CONTRÔLE

OBJET : Ce chapitre présente les différents traitements, les différentes actions qu’on va s’en servir pour agir sur les don-
nées, pour les manipuler.
OBJECTIFS : A la fin de ce chapitre, vous serez à mesure de connaître :
✓ Les différentes actions de l’algorithme
✓ Les actions de l’algorithme à utiliser dans telle ou telle situation,
 La difficulté dans la réussite d’un algorithme e situe à deux (2) niveaux :
▪ Les différentes instructions de l’algorithme qu’il faut face à une situation,
▪ L’agencement de ces différentes instructions pour résoudre tel ou tel problème.
L’agencement de celles-ci suit une certaine logique visant à épouser les différentes étapes de la résolution du problème.
1) L’instruction d’affectation : 
C’est l’opération qui consiste à attribuer une valeur à un objet donné. L’élément utilisé pour matérialiser cela est : 
Syntaxe : nom_objet valeur ou nom_objet expression ou nom_objet1 nom_objet2
Ainsi nom_objet valeur se lit « nom_objet reçoit valeur »
Exemples :VAR
Age, note1, note2 : ENTIER ;
Moyenne1, moyenne2 : REEL ;
Age  25 ; (cas nom_objet valeur)
Note1  14 ;
Note2  17 ;
Moyenne1  (note1 +note2) / 2 ; (cas nom_objet expression)
moyenne2  moyenne1 ; (cas nom_objet1 nom_objet2)
Explications : Ainsi par exemple Age  25 ; est schématisé par :
25
age
moyenne2  moyenne1; Cette instruction ordonne à l’ordinateur d’attribuer à la variable moyenne2, le
contenu de la variable moyenne1. Ainsi après l’exécution de cette instruction, les variables moyenne1 et moyenne2 au-
ront la même valeur, auront le même contenu.
2) Les instructions d’incrémentation et de décrémentation

L’incrémentation est l’opération qui consiste à accroître par addition, la valeur d’une variable à partir de son ancienne
valeur.
Syntaxe : nom_variable1  nom_variable1 +  ( réel ou entier positif)
Exemples : b  b + 1 ; qte  qte +5 ;
Explications : b  b + 1 ; signifie « prendre la valeur de la variable b à laquelle il faudra ajouter 1, et le résultat ainsi
obtenu sera la nouvelle valeur de b »
Soit la situation suivante :
Avant exécution Après exécution
10 11
b b
La décrémentation est l’opération qui consiste à décroître par soustraction, la valeur d’une variable à partir de son an-
cienne valeur.
Syntaxe : nom_variable1  nom_variable1 −  ( réel ou entier positif)
Exemples : P  P − 3 ; tt−2;
Explications : P  P − 3 ; signifie « prendre la valeur de la variable P à laquelle il faudra retrancher 3, et le résultat ainsi
obtenu sera la nouvelle valeur de P »
Soit la situation suivante :
Avant exécution Après exécution
25 22
P P
 Exercice 1 d'application : Dire lesquelles des instructions suivantes sont des incrémentations ou des décrémenta-
tions.

YY+a; ……………………………………………………………………………………………………………………………………..
V V–Y;  ………………………………………………………………………………………………………………………
Note  Note + 5 ;  ………………………………………………………………………………………………………………………
Moyenne  moyenne − 0,5 ;  ……………………………………………………………………………………………………
Ga+b;  …………………………………………………………………………………………………………………………………
3) Les instructions d’entrée et de sortie

a) L’instruction de sortie
L’instruction de sortie permet d’afficher des informations à l’écran de l’ordinateur afin que l’utilisateur puisse en prendre
connaissance. Le vocable utilisé est AFFICHER.
Syntaxe : AFFICHER (‘ information à afficher ’) ; pour afficher une simple information à l’écran
Exemple 1 : AFFICHER (‘Entrer votre nom ‘) ;
 On verra afficher à l’écran Entrer votre nom
Syntaxe AFFICHER(nom_variable) ; pour afficher la valeur d’une variable
Exemple 2 :VAR
a, b : ENTIER ;
a  8 ; b  25 ;
AFFICHER (a) ;
 On verra afficher à l’écran 8
AFFICHER (a,b) ;
 On verra afficher à l’écran 8 25
Syntaxe AFFICHER ('information à afficher' , nom_variable) ; pour afficher une information et la valeur d’une va-
riable.
Exemple 3 :VAR
a : ENTIER ;
a  18 ;
AFFICHER (‘ Le résultat est :’ , a) ;
 On verra afficher à l’écran Le résultat est 18
Exemple2
a  25 ;
b  12 ;
AFFICHER(‘ Le produit de’ , a, ‘et de’ , b, ‘ vaut :’ , a*b) ;
 On verra afficher à l’écran Le produit de 25 et de 12 vaut : 300
Note : En fait ici tout message est entre ‘ ’ et les variables qu’on désire afficher leur valeur ne sont pas entre ‘ ’. Enfin, tout ce qui
est entre ‘ ’ et ce qui ne l’est pas, on les sépare par une virgule (,).
b) L’instruction d’entrée
Elle permet de ranger, de mémoriser la valeur que l’on vient de saisir, afin d’un usage ultérieur. Le vocable utilisé est
SAISIR.
Syntaxe : SAISIR(nom_variable) ;
Exemple :VAR
c : ENTIER ;
AFFICHER (‘ Entrer une valeur’) ;
SAISIR(c) ;
 Permet de ranger la valeur que l’utilisateur va rentrer, dans la variable c
Exemple de simulation
A l’écran, on a : Entrer une valeur
L’utilisateur saisit : 50
Alors 50 sera rangé dans la variable c, pour être utilisé par la suite dans le programme.
50

4) Les séquences ou blocs d’instructions

Une séquence ou bloc d’instructions est une suite d’instructions juxtaposées et délimitées par les mots clés DEBUT et
FIN. Elle est localisée à l’intérieur du corps de l’algorithme ou au sein d’une fonction ou d’une procédure.
Lorsque des instructions concourent à la réalisation d’une tâche donnée, alors celles-ci sont mises en bloc.
Syntaxe :
DEBUT
Instruction 1 ;
.
. Bloc d'instructions
Instruction n ;
FIN ;
5) Les instructions alternatives ou de décision

a) L’instruction alternative réduite : SI…ALORS
Non
Syntaxe :
Condition ?
SI condition ALORS
DEBUTSI
Instruction 1 ;
.
Oui
. Bloc d’instructions
Instruction n ; Instructions
FINSI ;
Suite
Si la condition est vérifiée alors le bloc d’instructions est exécuté ; dans le cas contraire, il est ignoré.
Exemple 1 Exemple 2 Exemple 3
a  10 ; a5; a  10 ; b1 ;
Si a>8 ALORS Si a>9 ALORS Si (a>8) ET (b<0) ALORS
DEBUTSI DEBUTSI DEBUTSI
F c * a ; F c * a ; F c * a ;
Kk–2; Kk–2; Kk–2;
FINSI ; FINSI ; FINSI ;
d  a*2 ; d  a*2 ; d  a*2 ;
COMMENTAIRES COMMENTAIRES COMMENTAIRES

Les instructions comprises entre Les instructions comprises entre Les instructions comprises entre
DEBUTSI et FINSI seront exécu- DEBUTSI et FINSI ne seront pas DEBUTSI et FINSI ne seront pas
tées car a >8. Et après cette exé- exécutées car a <9. Par contre, exécutées car certes a >8 mais b
cution, l’on va exécuter après avoir sauté tout ce qui est n’est pas < 0 ; Par contre, l’on va
l’instruction d  a*2 ; (car elle entre DEBUTSI et FINSI, l’on va exécuter l’instruction d  a*2 (car
n’est pas liée à la condition de SI) exécuter l’instruction d  a*2 (car elle n’est pas liée à la condition de
elle n’est pas liée à la condition de SI)
SI)

b) L’instruction alternative complète : SI…ALORS…SINON

SI condition ALORS
DEBUTSI
Instruction 1;
.
. Bloc 1 d’instructions
Instruction n;
FINSI ;
SINON
DEBUTSINON
Instruction p;
.
Bloc 2 d’instructions
.
Instruction v;
FINSINON ;
Oui Non
Condition ?
Bloc d’instructions 1 Bloc d’instructions 2
Suite
Si la condition est vérifiée alors le bloc 1 d’instructions est exécuté et le bloc 2 ignoré (pas exécuté). Dans le cas con-
traire, le bloc 1 est ignoré au profit du bloc 2.
Note : Dans tous les cas, c’est un (1) et un (1) seul bloc qui est exécuté à la fois et on ne n’ignore pas no plus les deux (2) blocs à la
fois.
Exemple 3
Exemple 1 Exemple 2
pt5 ; a  3 ;
pt5 ; pt5 ; a 2 ;
Si ( pt=0) OU (a  5) ALORS
Si pt=0 ALORS Si (pt 0) ET (a=2) ALORS
DEBUTSI
DEBUTSI DEBUTSI
II+1;
II+1; II+1;
kk*i;
kk*i; kk*i;
FINSI ;
FINSI ; FINSI ;
SINON
SINON SINON
DEBUTSINON
DEBUTSINON DEBUTSINON
ei–3;
ei–3; ei–3;
ff*3;
ff*3; ff*3;
k0;
k0; k0;
FINSINON ;
FINSINON ; FINSINON ;
Xi*f;
Xi*f; Xi*f;
COMMENTAIRES COMMENTAIRES COMMENTAIRES
Ici pt n’est pas égal à 0 donc le Ici bloc d’instructions compris Ici le bloc d’instructions compris
bloc d’instructions compris entre entre DEBUTSI et FINSI sera exé- entre DEBUTSI et FINSI ne sera
DEBUTSI et FINSI ne sera pas cuté car les deux (2) conditions pas exécuté car même pas une
exécuté et celui compris entre sont vérifiées à la fois ; et celui seule des deux (2) conditions
DEBUTSINON et FINSINON, sera compris entre DEBUTSINON et n’est vérifiée. Par contre celui
exécuté. Après cela, l’on passera à FINSINON, ne sera pas exécuté. compris entre DEBUTSINON et
l’exécution de l’instruction X  i * Après cela, l’on passera à FINSINON, sera exécuté. Après
f ; (car elle n’est pas liée à la con- l’exécution de l’instruction X  i * cela, l’on passera à l’exécution de
dition de SI…ALORS…SINON). f ; (car elle n’est pas liée à la con- l’instruction X  i * f ; (car elle
dition de SI…ALORS…SINON). n’est pas liée à la condition de
SI…ALORS…SINON).

6) Les imbrications de SI…ALORS et SI…ALORS…SINON
Lorsque l’on veut envisager un (1) choix parmi n possibles (n<2), il est alors possible d’utiliser plusieurs primitives
SI…ALORS ou SI…ALORS…SINON, mais en les imbriquant c'est-à-dire en faisant apparaître des SI…ALORS ou
SI…ALORS…SINON à l’intérieur d’autres.
Syntaxe :
SI condition1 ALORS
DEBUTSI
SI condition2 ALORS
DEBUTSI
SI condition3 ALORS
DEBUTSI
Insturction1 ;
.
.
Instruction n ;
FINSI ;
SINON
DEBUTSINON
Instruction o ;
.
.
Instruction v ;
FINSINON ;
FINSI ;
FINSI ;
Suite
………
Cette structure peut être représentée par l’arbre ci-après :
Non
Oui
Condition 1
Oui
Condition 2 Non
Oui
Non
Condition 3
Instruction 1 Instruction o ;
. .
. .
Instruction n ; Instruction v ;
Suite
Exemple 1
NGUESSAN KOFFI MATHIEU ij

INGENIEUR INFORMATICIEN INPHB
Oui
Non
SI i  j ALORS
DEBUTSI
SI c< i ALORS
DEBUTSI
k0;
d i ;
FINSI ;
FINSI ;
SINON
DEBUTSINON
p0;
md;
xk*2;
FINSINON ;
d 0 ;
i e ;
…
Commentaires :

Exemple 2
SI a > b ALORS
DEBUTSI
SI b< 0 ALORS
DEBUTSI
SI c = 5 ALORS
DEBUTSI
i3;
d 0 ;
FINSI ;
SINON
DEBUTSINON
SI c > 5 ALORS
DEBUTSI
k b ;
c1;
FINSI ;
SINON
DEBUTSINON
a  -2 ;
FINSINON ;
FINSINON ;
FINSI ;
k p * j ;
FINSI ;
pm–d;
…..
 Exercice 2 d'application : Dresser l’arbre correspondant à ces imbrications. :


 Exercice 3 d'application (lié à l'exercice 2)

 A quelle(s) condition(s) les instructions suivantes sont-elles exécutées ?
 I  3 ; et d  0 ; Réponse :
 K  b ; et c  1 ; Réponse :
 A  -2 ; Réponse :
 K  p * j ; Réponse :
 P  m – d ; Réponse :

 Est-il possible d’exécuter dans l’algorithme, les blocs d’instructions (i 3 ; d  0 ;) et (k  b ; c  1 ;) ?
Réponse : ……………………………………………………………………………………………………………………………………………
 Est-il possible d’exécuter dans l’algorithme, les blocs d’instructions (i 3 ; d  0 ;) et (k  p * j) ?
Réponse : ……………………………………………………………………………………………………………………………………………
 Est-il possible d’exécuter dans l’algorithme, les blocs d’instructions (a  -2 ;) et (p  m - d;) ?
Réponse : ……………………………………………………………………………………………………………………………………………
 Est-il possible d’exécuter dans l’algorithme, les blocs d’instructions (k p * j) et (p m - d;) ?
Réponse : ……………………………………………………………………………………………………………………………………………
 Etablir les ordres d’exécution des différents blocs d’instructions.
Réponses :
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
7) La structure SUIVANT…FAIRE ou structure de conditions multiples

Lorsque l’on veut envisager un (1) choix parmi n possibles (n>2), il est également possible (à l’instar des imbrications de
SI…ALORS/SINON), d’utiliser la structure SUIVANT…FAIRE, en adoptant deux (2) syntaxes un peu distinctes :
Syntaxe 1 : SUIVANT nom_variable FAIRE
Etiquette 1 : instruction 1 ou bloc 1 d’instructions ;
.
.
Etiquette n : instruction n ou bloc n d’instructions ;
FINSUIVANT ;
OU BIEN
Syntaxe 2 :
SUIVANT nom_variable FAIRE
.
.
Etiquette n : instruction n ou bloc n d’instructions ;
SINON
Etiquette p : instruction p ou bloc p d’instructions ;
.
.
Etiquette V : instruction V ou bloc 2 d’instructions ;
FINSUIVANT ;

Remarque :
▪ « étiquette » doit être un entier, un caractère, une chaîne de caractère ou un booléen. (Il ne
peut être un réel car les réels sont écrits avec une valeur approchée…)
▪ « étiquette » peut être une constante, une liste de constante ou un intervalle, de même type que
nom_variable, c'est-à-dire si nom_variable est un entier alors « étiquette » doit forcement être aussi
un entier…, pour respecter la compatibilité de type.
▪ Dans la structure de SUIVANT…FAIRE, lorsqu’il s’agit d’un bloc d’instructions en face de « étiquette »
alors le bloc d’instructions doit forcement être encadré par DEBUT et FIN.
Explications
Syntaxe 1 : Lorsque nom_variable a son contenu qui correspond à une étiquette alors l’instruction ou le bloc d’instruction
en face de cette étiquette est exécuté(e). Après cela, l’on sort de la structure SUIVANT…FAIRE. Mais si nom_variable a
son contenu qui ne correspond à aucune étiquette alors dans ce cas aucune instruction ou le bloc d’instruction ne sera
exécuté(e).
Syntaxe 2 : Idem à la syntaxe 1, mais ici si nom_variable a son contenu qui ne correspond à aucune étiquette alors
toutes les instructions qui sont situées entre SINON et FINSUIVANT, seront exécutées.
Exemple 1 :
. .
C : ENTIER ;
AFFICHER (‘Entrez un nombre’) ;
SAISIR (C) ;
SUIVANT C FAIRE
1 : AFFICHER (‘Le nombre saisi est petit’) ;
2, 3, 4 : AFFICHER (‘Le nombre saisi est juste moyen’) ;
5..10 : AFFICHER (‘Le nombre saisi est moyen’) ;
FINSUIVANT ;
……………
Explications :
Si la variable C vaut 1 alors afficher « le nombre est petit ». (Ici il s’agit d’une constante).
Dans le cas contraire si elle vaut 2 ou 3 ou 4 alors afficher « le nombre est juste moyen ». (Il s’agit ici d’une liste de
constantes).
Dans le cas contraire si elle est comprise entre 5 et 10 alors afficher « le nombre est moyen ». (Il s’agit ici d’un inter-
valle de constantes).
Exemple 2 :
……...
A, B, C : ENTIER ;
SAISIR (C) ;
SUIVANT C FAIRE
1 : DEBUT
AFFICHER (‘Le nombre saisi est petit’) ;
B B*2;
FIN ;
2, 3, 4 : AFFICHER (‘Le nombre saisi est juste moyen’) ;
5..10 : DEBUT
AFFICHER (‘Le nombre saisi est moyen’) ;
AC*B;
FIN ;
SINON
AFFICHER (‘le nombre saisi n’est pas autorisé’) ;
A B+C;
FINSUIVANT ;
……………
Explications:
Si la variable C vaut 1 alors exécuter le bloc d’instructions : afficher « Le nombre est petit » et
BB*2;.
Dans le cas contraire si elle vaut 2 ou 3 ou 4 alors afficher « le nombre est juste moyen ».
Dans le cas contraire si elle est comprise entre 5 et 10 alors exécuter le bloc d’instructions : afficher « le nombre est
moyen » et A  C * B ;
Maintenant si C ne correspond à aucune des valeurs alors afficher « le nombre saisi n’est pas autorisé» et exécuter

A B+C;
Limites de la structure SUIVANT…FAIRE : Au niveau des étiquettes, l’on ne peut utiliser les signes <, , >, , . Si
d’aventure le problème l’exige dans l’option du choix, dans ce cas, l’on n’a pas le choix que d’utiliser plusieurs
SI…ALORS/SINON pour assouvir ce besoin du problème, à la place de SUIVANT…FAIRE.
Exemple :
C : ENTIER ;
SAISIR (C) ;
SUIVANT C FAIRE
<1 : AFFICHER (‘Le nombre saisi est petit’) ;
>2 et < 4 : AFFICHER (‘Le nombre saisi est juste moyen’) ;
5..10 : AFFICHER (‘Le nombre saisi est moyen’) ;
 10 : AFFICHER (‘Le nombre saisi est Bon’) ;
FINSUIVANT ;
8) Les opérations sur les propositions

a) Définition
Une proposition est une condition. Partant, elle peut être vraie ou fausse. Le but de cette partie du document est de
mettre ensemble des conditions ou propositions (par les opérateurs logiques de base : ET, OU, NON) et de voir à
quel moment cet ensemble de conditions est VRAI ou FAUX.
Les propositions portent des noms généralement en majuscules (Exemple : P, Q, R, S,…).
Exemple : c 5 ; b 8 ;
La proposition c > b est fausse (car la variable c n’est pas > à b).
b) Les opérations
Pour les propositions, nous retiendrons les opérations logiques les plus utilisées, à savoir : ET, OU et NON. Dans
cette partie, nous allons utiliser la représentation mathématique de ces opérateurs logiques de base : ET est repré-
senté par  ; OU est représenté par  et NON est représenté par  .
Jetons un coup d’œil sur le tableau ci-après :
P Q P Q P Q P
F F F F V
F V F V V
V F F V F
V V V V F
Explications
Ligne1 : Si la proposition P est fausse (F) et Q est fausse (F) alors (P  Q) est fausse (F), (P  Q) est fausse
(F). Si P est fausse (F) alors  P est vraie (V).
Pareil pour les autres lignes…
Les propriétés suivantes sont à retenir :
▪ (P  Q) = ( P  Q)  ( P  Q )  ( P  Q)
Explication : Si l’ensemble (PQ) est faux, c’est que ( P est fausse et Q est vraie) ou c’est que ( P est vraie et Q
est faux) ou c’est que ( P est fausse et Q est fausse).
▪ (P  Q) = P  Q
Explication : Si l’ensemble (P  Q) est faux, c’est que P est fausse et Q aussi est fausse (les 2 sont faux à la fois).
▪ (X > Y)  X = Y ou bien X < Y

Explication : Si X n’est pas > à Y, c’est que soit X = Y ou bien X < Y.
▪ (X < Y)  X = Y ou bien X > Y

Explication : Si X n’est pas < à Y, c’est que soit X = Y ou bien X > Y.

 Exercice 4 d'application : Applications de toutes ces propriétés.
Exemple 1
SI A > B ALORS
A quelle condition l’instruction K  A / J ; sera-t-elle exécutée ?
DSI
Réponse :
Jj+1;
FSI ;
SINON
DSINON
K A/J;
FSINON ;
Exemple 2
A quelle condition l’instruction K  A / J ; sera-t-elle exécutée ?
SI (A > B) OU (C = 5) ALORS Réponse :
DSI
Jj+1;
FSI ;
SINON
DSINON
K A/J;
FSINON ;
Exemple 3
SI (A > B) ET (C = 5) ALORS
DSI A quelle condition l’instruction K  A / J ; sera-t-elle exécutée ?
Jj+1; Réponse :
FSI ;
SINON
DSINON
K A/J;
FSINON ;
9) Les commentaires
Les commentaires sont des phrases généralement courtes, que l’on insère dans l’algorithme dans le but de faciliter la
compréhension de notre algorithme. Ils ne sont donc pas des instructions.
Les commentaires sont souvent très importants car par exemple si vous concevez un vaste algorithme et que des mois
plus tard, vous revenez sur ce même algorithme, sans les commentaires, vous serez « perdu » dans votre propre algo-
rithme à tous les coups.
Les commentaires sont ignorés par l’ordinateur lors de l’exécution du programme car ils sont là seulement pour la com-
préhension du programme et donc n’influence nullement sur l’exécution du programme.
En algorithme, les commentaires sont placés entre (* et *).
Exemple
Pt : ENTIER ; (* Déclaration d’un entier du nom de pt *)
Som : REEL ; (* Déclaration d’un réel du nom de Som *)
10) Les boucles ou structures répétitives

Elles permettent de répéter un certain nombre de fois une instruction ou un bloc d’instructions tant qu’une condition est
vérifiée.
En effet, lors de la résolution de problèmes, nous sommes souvent amenés à répéter des actions un certain nombre de
fois. Par exemple dans la vie courante, pour construire une maison, le maçon pose les briques une à une ; et il répète
cette même action jusqu’à ce que le mur atteigne une certaine hauteur voulue. Et après cela, l’on pourra poser la char-
pente de la maison. C’est pareil en algorithme. Par exemple, lors de l’acquisition des données, l’on voudrait éviter la sai-
sie de valeurs négatives. Dans ce cas, tant que l’utilisateur n’entre pas de valeurs positives, l’on va continuer à l’inviter
de saisir ces valeurs. Voici là un cas d’utilisation des boucles.
Les boucles sont au nombre de trois (3) :

TANT QUE…FAIRE
REPETER…JUSQU'A
POUR…FAIRE
a) La structure TANT QUE …FAIRE

Syntaxe : TANT QUE condition FAIRE
DTQ TANTQUE
Instruction 1
.
Instruction n ;
FIN TANT QUE ;
Suite…
Bloc d’instructions

Fausse Vraie
Condition ?

Suite 
Explication : Tant que la condition est vérifiée (vraie), le bloc d’instructions est exécuté. Ici, l’on vérifie d’abord la condi-
tion (d’où le ) .Si la condition est vérifiée alors l’on exécute le bloc d’instructions, (d’où le ) . Et si la condition n’est
pas vérifiée, l’on saute le bloc d’instructions et l’on poursuit l’exécution du programme juste après le bloc d’instructions ;
(d’où le  également).
Au cas où la condition est vérifiée et après l’exécution du bloc d’instructions, l’on revient à nouveau vérifier la condition,
et si elle est vérifiée l’on exécute le bloc d’instructions. Dans le cas contraire, l’on saute le bloc d’instructions et l’on pour-
suit l’exécution du programme juste après le bloc d’instructions ; et ainsi de suite…
Exemple : TANT QUE (a b) ET (c<0) FAIRE
DTQ (* DEBUT TANT a été abrégé DQ *)
Ca+b;
AFFICHER (‘La valeur de C est :’ , C) ;
FTQ ; (* FIN TANT QUE a été abrégé FTQ *)
b) La structure REPETER…JUSQU’A
Syntaxe :
REPETER
Instruction 1
. Bloc d'instructions
.
Instruction n ;
JUSQU’A condition;
Suite…


Vraie Fausse
Condition ?

Suite…
Explications : Le bloc d’instructions est exécuté jusqu'à ce que la condition soit vérifiée (vraie). En fait ici, l’on exécute
d’abord le bloc d’instructions (d’où le  ) et après l’on vérifie la condition (d’où le ). Si la condition est fausse alors
l’on exécute à nouveau le bloc d’instructions. Dans le cas contraire, l’on saute le bloc d’instructions et l’on poursuit
l’exécution du programme juste après le bloc d’instructions ; et ainsi de suite…
Exemple :
P1; (* initialisation de la variable P *)
REPETER
Ab+4;
C  d MOD b ;
PP+1;
JUSQU'A P = 10 ; (* On va exécuter le bloc d’instructions jusqu'à ce que P vale 10 *)
c) La structure POUR…FAIRE
Cette structure s’utilise de préférence lorsque l’on connaît exactement le nombre d’itérations c'est-à-dire le nombre de
fois que l’on répéter le bloc d’instructions.
Syntaxe :
POUR nom_variable  valeur initiale A valeur finale FAIRE
DPOUR
Instructions 1 ;
.
Instruction n ;
FPOUR ;
Note : nom_variable est aussi appelé compteur car c’est lui qui compte à chaque fois qu’on parcourt le
bloc d’instructions. Il est généralement de type numérique et notamment un entier ( jamais un réel car avec les
réels, la boucle ne va jamais s'arrêter parce que par exemple dans l'intervalle [1; 2], il existe une infinité de réels).

Oui Non
Compteur > valeur finale ?

Suite 
Explications : Le compteur est initialisé à « valeur initiale ». Et à chaque parcours du bloc d’instructions, il est incré-
menté de 1 automatiquement jusqu’à atteindre « valeur finale ». Après quoi, l’on sort du bloc d’instructions pour la
poursuite du déroulement de l’algorithme. Mais avant tout l’on vérifie d’abord si le compteur est > valeur finale (d’où le
 ). Si tel n’est pas le cas, l’on exécute le bloc d’instructions (d’où le  ), puis l’on revient à nouveau vérifier la condi-

tion. Par contre si tel est le cas, l’on saute le bloc d’instruction et l’on poursuit l’exécution du programme juste après le
bloc d’instructions.
Exemple 1 : Exemple 2
POUR i  1 à 5 FAIRE POUR j n à p FAIRE
DPOUR DPOUR
Ja + b; aa*2;
AFFICHER(‘BIENVENUE’) ; b0;
C  b * d /2 ; FPOUR ;
FPOUR ;
Remarques :
✓ Dans une situation nécessitant l’utilisation de boucle, l’on peut généralement utiliser n’importe
laquelle des boucles.
✓ Une boucle POUR…FAIRE est toujours transformable en une boucle TANT QUE… FAIRE comme
suit :
POUR j valeur initiale à valeur finale j  valeur initiale ;
DPOUR TANT QUE j  valeur finale FAIRE
Instruction 1 ; DTQ
. Instruction 1 ;
. .
Instruction n ; .
FPOUR ; Instruction n ;
Jj+1;
FTQ ;
Note : Vous avez remarqué l’instruction J  J + 1; dans la structure TANT QUE …FAIRE. Cela est dû au fait que contrairement à la
structure POUR…FAIRE où le compteur j est incrémenté automatiquement de 1 à chaque parcours de la boucle, dans la structure
TANT QUE…FAIRE, ce n’est pas le cas. Nous devons nous même l’incrémenter de manière explicite.
Exemple
POUR e  1 à 10 FAIRE e 1 ;
DPOUR TQ e  10 FAIRE
PP –2;  DTQ
C  P MOD 2 ; PP – 2;
FPOUR ; C  P MOD 2 ;
e e+1;
FTQ ;
L’ART DE LA PROGRAMMATION
Cette partie est importante dans la réussite de l’élaboration de vos algorithmes. Certes, nous devons concevoir des algo-
rithmes mais pas n’importe comment. En effet l’élaboration de l’algorithme suit des directives qui certes ne sont pas
obligatoires mais vous aidera énormément dans la compréhension et la lisibilité de vos algorithmes. De surcroît, ces di-
rectives vous aideront énormément dans la recherche d’erreurs dans votre algorithme.
En voici :
 Le DEBUT et la FIN d’une structure doivent être sur la même colonne. Cela permet de mieux structurer l’algorithme
et de savoir que tel traitement débute ici et se termine là.
 Faire toujours des décalages vers la droite lorsqu’on débute un traitement lié à une structure ; et aligner les ins-
tructions liées à un même traitement, sur la même colonne. Cela permet de mieux structurer l’algorithme et aussi de
l’aérer (voir l’exemple juste au dessus).
 Au niveau de la mise en place de l'algorithme, il faudra toujours voir s'il n' y a pas de cas particulier(s). S'il en
existe, il faudra gérer ces cas particuliers et par la suite gérer le cas général. (Exemple: Pour la division de a/b, le cas particulier est
lorsque b=0).
 La lisibilité : Débarrassez-vous des instructions non nécessaires à la résolution d'un problème, au niveau du pro-
gramme; et aussi à commenter souvent vos lignes d'instructions.
 L’exactitude : aptitude d’un programme à fournir le résultat voulu et à répondre ainsi aux spécifications du pro-
blème donné.

 La robustesse : aptitude à bien réagir lorsque l’on s’écarte des conditions normales d’utilisation, c'est-à-dire lors
de l'acquisition des données, veuillez à ce que les données saises soient conformes aux spécifications du problème.
(Exemple: Lors de la saisie de l'âge des personnes, il faut s'assurer que la valeur saisie par l'utilisateur ne soit pas négative par exemple).
.
 L’efficience : Minimiser le temps d’exécution du programme et aussi l'espace occupé en mémoire centrale.
 Faire des simulations à la fin de l’algorithme pour voir si ça marche.
TEST N°1
BUT : Maîtriser les structures de contrôle.
Note : Les exercices 1 à 13 concernent les étudiants débutants, c'est-à-dire ceux de la 1 ère année.
Les exercices 14 à 24 concernent les étudiants un peu initiés (2e année).
EXERCICE 1
1) Ecrire un algorithme qui calcule la somme de trois (3) nombres entiers et en affiche le résultat.
2) Modifier l’algorithme précédent afin que vous puissiez calculer la somme de trois (3) nombres entiers, en afficher
le résultat et cela autant de fois que vous voudrez.
EXERCICE 2
Ecrire un algorithme qui permet d'échanger les valeurs de deux (2) entiers saisis au clavier puis d'afficher les nouvelles
valeurs.
EXERCICE 3
Concevoir un algorithme permettant d'afficher les diviseurs d'un nombre entier.
EXERCICE 4
Ecrire un algorithme qui permet de déterminer la parité (pair ou impair) d’un nombre entier saisi au clavier.
EXERCICE 5
Concevoir un algorithme qui permet d’afficher le maximum de trois (3) nombres entiers.
EXERCICE 6
Proposer un algorithme qui calcule le factoriel d’un nombre entier.
EXERCICE 7
Concevoir un algorithme qui calcule et affiche la somme des entiers positifs ≤ N (N entier positif saisi au clavier) en
utilisant séparément:
1) la structure POUR…FAIRE
2) la structure TANT QUE…FAIRE
3) la structure REPETER…JUSQU'A.
EXERCICE 8
1) Ecrire un algorithme qui calcule et affiche la somme des entiers impairs positifs compris entre 1 et le nombre en-
tier I saisi au clavier.
2) Ecrire un algorithme qui calcule et affiche la somme des entiers pairs positifs compris entre 1 et le nombre entier I
saisi au clavier.
EXERCICE 9
Ecrire un algorithme qui effectue la multiplication de deux (2) nombres entiers positifs saisis au clavier par l'utilisateur;
en utilisant uniquement l'addition. Afficher le résultat du calcul.
EXERCICE 10
Proposer un algorithme qui à partir d'un réel noté x et d'une valeur entière appelée n, retourne x à la puissance n.
EXERCICE 11
Mettre en place un algorithme qui convertit un temps saisi en secondes par l'utilisateur, en heures, en minutes et en
secondes. Exemple: 4000 s = 1 h 06 mn 40 s.
EXERCICE 12
J’achète une certaine quantité d’un produit donné ; la remise est de 8% pour tout achat inférieur ou égal à 10 000 F et
de 10% pour tout achat supérieur à 10 000F
Ecrire un algorithme permettant de déterminer le prix à payer.

EXERCICE 13
Dans le cadre de la répartition du budget de l'année alloué à son ministère, M. le Ministre de l'enseignement supérieur
fait le partage comme suit:
▪ Service de l'orientation: 10% du budget global,
▪ Service des examens et concours: le 1/3 du budget restant,
▪ Service d'évaluation des établissements scolaires: les ¾ du budget alloué au service des examens et concours,
▪ Service du mobilier et de l'immobilier: le reste du budget.
Etant donné le budget alloué audit ministère, concevoir un algorithme permettant à M. le Ministre de faire sa répartition.
EXERCICE 14
Déterminer un algorithme qui permet de ressortir le PGCD (Plus Grand Commun Diviseur) de deux (2) entiers.
EXERCICE 15
Une compagnie de chemin de fer pratique ses tarifs en fonction de la catégorie du voyageur:
▪ Voyageur normal (N): plein tarif
▪ Abonné de la compagnie (A): 40% de réduction
▪ Enfant de moins de 10 ans (E): gratuit
▪ Employé de la compagnie (T): gratuit
▪ Parent d'un employé (P): 50% de réduction
▪ Personne âgée de 70 ans et plus (V): 30% de réduction.
Ecrire un algorithme qui permet, connaissant le tarif normal du voyage, de calculer le prix à payer par un voyageur don-
né.
EXERCICE 16
A partir du "Menu principal" affiché à l'écran:
▪ Effectuer la somme de trois nombres réels,
▪ Effectuer le produit de trois nombres réels,
▪ Effectuer la moyenne de trois nombres réels,
l'utilisateur fera le choix de son opération par la saisie d'une valeur entière.
Proposer un algorithme qui permet à partir du menu principal, d'effectuer les opérations ci-dessus.
EXERCICE 17
Une société de transport compte vingt (20) chauffeurs qui font chacun un versement pendant 26 jours par mois. A l'is-
sue des 26 jours de versement, le salaire de chaque chauffeur est égal à 20% de sa recette mensuelle.
Concevoir un algorithme qui pourra afficher le salaire de chaque chauffeur et la part globale de la société de transport à
la fin du mois.
EXERCICE 18
Un centre de formation de football compte 100 pensionnaires.
Proposer un algorithme qui, connaissant l'âge de l'enfant, informe l'utilisateur de la catégorie de celui-ci:
✓ Poussin: de 6 à 7 ans,
✓ Pupille: de 8 à 10 ans
✓ Minime: de 11 à 13 ans,
✓ Cadet: à partir de 14 ans
Donnez le nombre d'enfants par catégorie.
Note: L'âge des pensionnaires est compris entre 6 et 20 ans inclus.
EXERCICE 19
La direction des bourses voudrait octroyer des bourses d'études aux étudiants. Si la moyenne annuelle est supérieure à
15 alors l'étudiant obtient une bourse de pays européens. Par contre si la moyenne annuelle est supérieure à 12 alors
l'étudiant obtient une bourse d'un pays africain.
Proposer un algorithme qui permet de déterminer le nombre de bourses octroyées en Afrique et en Europe.
Le nombre de postulants étant saisi au clavier.
EXERCICE 20
Un démarcheur à domicile est rémunéré avec un salaire fixe de 600 000F CFA. Il perçoit aussi une commission qui repré-
sente 5% du montant des ventes qu’il a réalisées. Le salaire ainsi obtenu est augmenté de 10% pour prendre en compte
ses frais de déplacement.
1) Ecrire un algorithme qui calcule son salaire étant donné le montant des ventes réalisées.
2) Appliquer l'algorithme précédent à un certain nombre de vendeur.
EXERCICE 21
Réalisez un programme "Distributeur Automatique de billets de banque". L'automate (la machine) contient des billets de
1000F, 2000F, 5000F et de 10 000F. Etant donnée une demande de retrait de l'utilisateur, le programme calcule et af-
fiche le nombre de billets de chaque valeur. Le programme devra minimiser le nombre de billets distribués.
Réalisez l'algorithme de ce distributeur automatique de billets de banque.

EXERCICE 22
Concevoir un algorithme permettant de calculer et d'afficher année par année, le montant du capital et des intérêts ac-
quis pour une somme initiale de S francs, placée à T% pendant N années.
Note: Il s'agit ici d'un intérêt composé.
EXERCICE 23
Le responsable d'un supermarché de la place vous sollicite pour l'aider à mettre en place un programme informatique qui
devra fonctionner comme suit: Lorsqu'un client se présente à la caisse, l'on saisit d'abord le nombre d'exemplaires et le
prix unitaire de chaque catégorie d'article et ce, pour toutes les catégories d'articles présents dans son panier. Ensuite la
somme versée. Après quoi, le programme devra afficher le montant total de toutes les catégories d'articles et le montant
de la monnaie.
Le programme devra gérer tous les clients de la journée et à la fermeture du magasin, afficher le montant de tous les
achats effectués pendant la journée.
Exemple de simulation
Nombre d’article 1: 5
Prix unitaire article 1 : 500
Prix unitaire article 2 1000
Prix unitaire article 3 850
TOTAL : 6350
Versé : 10 000
Rendu : 3650
Un autre client (O/N) ?
TOTAL journée :
1) Proposer un algorithme permettant d'assouvir ce besoin.

2) Le responsable voudrait désormais connaître en plus du montant des achats de la journée, le montant des achats à
la fin du mois (un mois = 30 jours). Modifiez donc l'algorithme précédent afin de prendre en compte cette nouvelle
donne.
EXERCICE 24
Le professeur principal d'une classe de 25 étudiants vous sollicite pour mettre en place un programme informatique lui
permettant de calculer les moyennes de ses étudiants. Les matières à considérer et leurs différents coefficients sont:
Informatique: coefficient 4, mathématiques: coefficient 3 et l'anglais: coefficient 2.
Pour chaque matière, l'on dispose de deux (2) notes avec des coefficients différents: note de test lourd: coefficient 5 et
note de devoir: coefficient 3.
Le professeur principal voudrait savoir:
▪ La moyenne de classe de chaque étudiant,
▪ Le premier dans chaque matière,
▪ Le premier de la classe,
▪ La moyenne générale de la classe.
Proposer un algorithme lui permettant d'assouvir son besoin.
Note: Les étudiants seront identifiés par des numéros (par exemple n°1, n°2,…).

CHAPITRE 6 : LES FONCTIONS ET PROCEDURES

Objet : Ce chapitre s’appesantit sur la décomposition des programmes informatiques en sous partis, appelés sous pro-
grammes.
Objectif : A la fin de ce chapitre, vous serez à mesure de maîtriser la programmation modulaire et l’intérêt de cette mo-
dulation.
1) Définition
Les fonctions et procédures sont des sous programmes à l’intérieur d’un programme.
Exemple : pour le calcul des moyennes des étudiants de la classe IG2, nous pouvons procéder à différentes étapes :
▪ La saisie des notes des étudiants, dans un premier temps,
▪ Le calcul de leurs moyennes, ans un second temps,
▪ Et l’affichage des celles-ci.
Ces différentes étapes sont assimilables à des fonctions et procédures.
2) Différence entre fonction et procédure

La fonction diffère de la procédure, au niveau des résultats. La fonction ne fournit q’un seul résultat. Ce résultat peut
être un entier, un réel, un booléen, un caractère, une chaîne de caractère…..
La procédure peut fournir zéro ou plusieurs résultats.
En effet lorsqu’un sous programme doit renvoyer nécessairement un seul résultat et que ce résultat doit être
utilisé par la suite dans le programme, ce sous programme est nécessairement une fonction (c'est-à-dire on effec-
tue une ou plusieurs opérations (généralement un calcul mais pas dans tous les cas) et le résultat de ces opérations est
forcement utilisé par la suite dans le programme (on dit qu’on renvoie le résultat de l’opération). Ici on n’affiche pas le
résultat de l’opération mais on le fournit pour être utilisé ailleurs dans le programme.). Dans le cas contraire (c’est-à-dire
on peut effectuer ces opérations et en même temps afficher le résultat de ces opérations dans le même sous pro-
gramme ; ou une simple saisie ou d’un simple affichage) c’est forcement une procédure.
Exemple : Dans l’exemple précédent,
▪ Nous allons utiliser une procédure pour« La saisie des notes des étudiants » car ici on ne se contente que
d’une simple saisie donc on ne renvoie rien ; d’où zéro (0) résultat renvoyé.
▪ Nous allons utiliser une fonction pour « Le calcul de leurs moyennes » car ici on doit calculer la moyenne des
notes saisies et par la suite, transmettre (on dit qu’on renvoie) cette moyenne ainsi obtenue à un autre élé-
ment, pour être affichée. Dans notre exemple, c’est la procédure suivante qui va l’afficher.
Remarque : Si ici on devrait calculer la moyenne et afficher cette moyenne dans le même sous programme, on aurait utilisé une
procédure à la place de la fonction.
▪ Nous allons utiliser une procédure pour « l’affichage des moyennes » car ici il s’agit d’un simple affichage.
Note : Le nombre de fonctions et procédures utilisées dans un programme, dépend de la nature du problème à résoudre et de la
volonté du programmeur. Egalement la nature du sous programme (fonction ou procédure) à utiliser dépend majoritairement de la
volonté du programmeur, bien qu’une infime partie est lié à l’état logique du problème à résoudre.
3) Intérêts des fonctions et procédures

Les fonctions et procédures répondent à quels besoins ? Qu’est ce qu’elles nous apportent ?
 Dés qu’un programme devient un peu volumineux, sa clarté et sa compréhension deviennent souvent une
difficulté. Partant pour faciliter sa compréhension, il est nécessaire de le décomposer en sous parties (les fonction et
procédures) dans lesquelles des actions spécifiques sont menées.
 Nombreux sont les programmes dans lesquels certaines séquences d’instructions y interviennent fréquem-
ment. Il est préférable dans ce cas de regrouper ces séquences d’instructions en fonctions ou procédures. Du coup, on
écrit une seule fois la séquence d’instructions et on l’appelle autant de fois qu’on voudra. Ce qui a pour conséquence
d’alléger le programme.
 Facilite la maintenabilité des programmes. La maintenabilité d’un programme, c’est le fait de modifier le pro-
gramme afin de répondre à de nouveaux besoins, à de nouvelles spécifications. Ainsi si le programme n’est pas modulé
(c’est pas constitué de fonction et procédure) dans ce cas pour répondre à de nouveaux besoins, l’on sera obligé de
modifier tout le programme entier. Ce qui va engendrer une perte de temps énorme. Dans le cas contraire (c'est-à-dire
cas où le programme est modulé), il s’agira pour répondre à de nouveaux besoins, de modifier quelques fonctions ou
procédures ; ou d’en ajouter simplement. Ce qui permet un gain énorme en temps.

4) Structure générale d’une fonction et procédure

Une fonction ou une procédure est caractérisée par les éléments suivants :
▪ Son nom (donné au choix par le programmeur mais de manière unique dans le programme)
▪ Ses arguments (0, 1 ou plusieurs arguments), le type de ses arguments et leur mode de transmission
(par valeur ou par adresse).
▪ Sa partie déclarative : Elle est facultative car dépend de la nature du problème à résoudre et surtout de la
volonté du programmeur). Les variables déclarées dans la partie déclarative d’une fonction ou d’une procé-
dure, sont appelées variables locales.
▪ Son corps : Il débute par le mot clé DEBUT et se termine par le mot clé FIN; . C’est en effet dans cette par-
tie que l’on effectue les différentes actions.
Note : Une fonction ou une procédure est mise en œuvre dans la partie déclarative du programme mère, c'est-à-dire que c’est dans
la partie déclarative du programme principal que l’on définit les fonctions et les procédures.
Syntaxes de déclaration d’une fonction ou d’une procédure
FONCTION nom_fonction (arg1 : type, arg2 : type,…, arg n : type) : type renvoyé par la fonction ;
Partie déclarative
DEBUT
.
Corps de la fonction
.
FIN ;
Note : Arg = argument ; et le corps de la fonction ou de la procédure se termine par un point-virgule (FIN;).
PROCEDURE nom_procedure (arg1 : type, arg2 : type,…, arg n : type);

Partie déclarative
DEBUT
. Corps de la procédure
.
FIN ;
Note : Ici on ne précise pas le type renvoyé par la procédure.

Exemples :
FONCTION cube (VAR a : ENTIER, b : REEL) : REEL ;
VAR
I, j : REEL ;
DEBUT
Instruction 1;
.
.
Instruction n ;
FIN ;
PROCEDURE afficher (VAR e, f : REEl) ;
DEBUT
Instruction 1;
.
.
Instruction n;
FIN;
a) Les arguments (ou paramètres) d’une fonction ou d’une procédure

On appelle argument ou paramètre d’une fonction ou d’une procédure, les variables qui lui sont fournies de l’extérieur et
sur lesquelles la fonction ou la procédure va agir afin d’obtenir un résultat escompté. Ces variables sont placées entre
parenthèses juste après le nom de la fonction ou de la procédure.
Exemple : FONCTION cube (VAR a : ENTIER, b : REEL) : REEL ;
a et b sont les arguments.

 Exercice 1 d'application Quel est l’intérêt des arguments ?

Réponse : ………………………………………………………………………………………………………………………………………………………….
…………………………………………………………………………………………………………………………………………………………………………
Combien de catégories d’arguments distinguons nous ?
Nous en distinguons deux : les paramètres formels et les paramètres effectifs.
 On appelle paramètres formels, les paramètres qui figurent dans une fonction ou une procédure au moment de sa
définition (au moment où on écrit la fonction ou la procédure). Ils sont fictifs et donc pas besoin de les déclarer dans
une quelconque partie déclarative. Ils sont utilisés pour nous aider à construire notre fonction ou procédure.
 On appelle paramètres effectifs, les paramètres qui figurent dans une fonction ou une procédure au moment de son
appel (voir la partie réservée à l’appel de fonction ou procédure). Ce sont des variables qui ont été préalablement décla-
rées (généralement dans la partie déclarative du programme principal bien qu’ils puissent aussi être déclarées dans la
partie déclarative d’une autre fonction ou une autre procédure).
Exemple : Concevoir un algorithme qui permet de calculer la moyenne de trois (3) notes et d’en afficher la moyenne et
ceci par l’utilisation d’une fonction nommée moyenne.
ALGORITHME calcul_moyenne ;
VAR
A, b,c : REEL ;
Moy : REEL ;
FONCTION moyenne (Var e, f, g : REEL) : REEL ;  (* e, f et g sont des paramètres formels *)
VAR
Som : REEL ;
DEBUT
Som  e+ f + g ;
Moyenne  som / 3 ; (* On utilise toujours le nom de la fonction pour recueillir la valeur renvoyée : ici moyenne *)
FIN ; (* Fin de la fonction’’ moyenne *)
DEBUT (* Début du programme principal *)
AFFICHER (‘Entrez les trois notes’) ; 
SAISIR (a, b, c) ; 
Moy  moyenne (a, b, c) ;  (* a, b et c sont des paramètres effectifs car c’est ici que l’on appelle la fonction ‘moyenne’. Et la
variable moy est mise là pour recueillir la valeur renvoyée par la fonction moyenne *)
AFFICHER (‘La moyenne des 3 notes est :’, moy) ; 
FIN.  (* Fin du programme principal *)
Explication : L’exécution de l’algorithme ci-dessus débute obligatoirement par le corps de l’algorithme princi-
pal en  . Puis en  , ensuite en  où l’on effectue l’appel de la fonction moyenne. De là nous sortons du
corps de l’algorithme principal pour se brancher sur la fonction appelée, ici la fonction moyenne, d’où le.
En , les paramètres formels seront remplacés par les paramètres effectifs qui en effet contiennent les don-
nées proprement dites, ici les données saisies par l’utilisateur aux étapes  et . Ainsi les variables e, f et g
seront remplacées respectivement par les variables a, b, et c. L’étape  va se poursuivre jusqu’à la fin de la
fonction moyenne. De là, nous retournons au programme appelant c'est-à-dire d’où on était quitté, ici le
corps de l’algorithme principal. D’où l’étape . Mais en retournant, le résultat renvoyé par la fonction
moyenne sera sauvegardé dans la variable moy (de l’étape  ). Enfin, l’on atteint l’étape  qui matérialise
la fin de l’exécution de notre programme.
b) Le passage de paramètres
C’est la façon avec laquelle un programme échange des données avec ses fonctions et procédures. Nous distinguons
deux (2) passages de paramètres :
b1) Le passage de paramètre par valeur
Lorsque des variables sont passées en paramètres par valeur, celles-ci peuvent, certes être modifiées au sein de la fonc-
tion ou de la procédure, mais lorsque l’on retourne au programme appelant (c'est-à-dire le programme d’où on a appelé
la fonction ou la procédure en question ; bien que généralement le programme principal mais pas dans tous les cas), ces
variables retrouvent leurs valeurs initiales comme si rien ne s’est passé.
Comment passer des paramètres par valeur ? En ne précédant de rien, l'argument.
Exemple : FONCTION moyenne (e, f, g : ENTIER) : REEL ;
Vous voyez bien qu’il n’y a rien entre la 1 ère parenthèse et la variable e.

 Exercice 2 d'application : Quel est l’intérêt du passage de paramètre par valeur ?

Réponse: ……………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………..
b2 Le passage de paramètre par adresse ou par référence

Lorsque des variables sont passées en paramètres par adresse, lorsque celles-ci sont modifiées au sein de la fonction ou
de la procédure, elles le sont même lorsque l’on retourne au programme appelant.
Comment passer des paramètres par adresse ?
On le fait simplement en précédant les paramètres de VAR.
Exemple : FONCTION moyenne (VAR e, f, g : ENTIER) : REEL ;
Vous voyez bien qu’il y a bien VAR entre la 1 ère parenthèse et la variable e.
 Exercice 3 d'application : Quel est l’intérêt du passage de paramètre par adresse ?
Réponse:
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
 Exercice 4 d'application : Définir en paramètres à la procédure affichage, deux (2) variables X et Y, tous deux de
type REEL. X étant passé en paramètre par valeur et Y par adresse.
…………………………………………………………………………………………………………………………………………………………………………..
Application : Soit cet algorithme qui permet de permuter les valeurs de deux (2) nombres entiers.
 ALGORITHME permutation ;
VAR DEBUT (* début du programme principal *)
t1, t2 : ENTIER ; AFFICHER (‘Entrez les 2 valeurs *)
PROCEDURE permute (a, b : ENTIER) ; SAISIR (t1, t2) ;
VAR permute (t1, t2) ; (*Appel de la procédure *)
temp :ENTIER ; AFFICHER(‘La valeur de t1 est’, t1) ;
DEBUT AFFICHER (‘La valeur de t2 est’, t2) ;
temp  a ; FIN. (* Fin du programme principal *)
ab;
b  temp ;
FIN ; (suite)      
A l’exécution, on aura :
Entrez les 2 valeurs
5 8 (* t1  5 et t2  8 *) (* 5 et 8 ont été saisis à titre d’exemples *)
La valeur de t1 est : 5
Vous voyez bien qu’avant l’appel de la procédure permute, t1 valait 5 et t2 valait 8. Après l’appel de la procédure per-
mute, censée permuter les deux valeurs, nous nous rendons compte que t1 a toujours gardée sa valeur de départ qui
est 5 et pareil pour t2.
Exercice de préparation: Soit cet autre algorithme qui permet de permuter également les valeurs de deux (2)
nombres entiers.
 ALGORITHME permutation ;
VAR t1, t2 : ENTIER ;
PROCEDURE permute (VAR a, b : ENTIER) ;
VAR
temp :ENTIER ;
DEBUT (* début de la procédure permute *)
temp  a ;
ab;
b  temp ;
FIN ; (* Fin de la procédure permute *)


AFFICHER (‘Entrez les 2 valeurs *)
SAISIR (t1, t2) ;
permute (t1, t2) ; (*Appel de la procédure *)
AFFICHER (‘La valeur de t1 est’, t1) ;
AFFICHER (‘La valeur de t2 est’, t2) ;
FIN. (* Fin du programme principal *)
A l’exécution, on aura :
Entrez les 2 valeurs
5 8 (* t1  5 et t2  8 *) (* 5 et 8 ont été saisis à titre d’exemples *)
Vous voyez bien qu’avant l’appel de la procédure permute, t1 valait 5 et t2 valait 8. Après l’appel de la procédure per-
mute, les deux (2) valeurs ont été effectivement permutées.
C) Les variables locales et globales

C1 Définition
On appelle variables globales, celles qui sont déclarées dans la partie déclarative du programme principal ; et va-
riables locales, celles qui sont déclarées à l’intérieur d’une fonction ou d’une procédure.
ALGORITHME essai ;
CONST
b=5;
VAR Variables globales
I, j : ENTIER ;
K: CARACTERE;
FONCTION valeur_absolue (a : ENTIER) : ENTIER ; 
VAR
P : ENTIER ; Variable locale
DEBUT
SI a < 0 ALORS
DSI
P-a;
FSI ;
SINON
DSINON
Pa;
FSINON ;
Valeur_absolue  p ;
FIN ; (*Fin de la fonction ‘ valeur_absolue’ *)
PROCEDURE saisie ;  (* Ici on n’a pas besoin d’argument pour la procédure saisie *)
DEBUT (* Début de la procédure saisie *)
AFFICHER (‘Entrez un entier:’) ;
SAISIR (I) ;
FIN ; (* Fin de la procédure saisie *)
PROCEDURE afficher ; 
DEBUT (* Début de la procédure afficher *)
AFFICHER (‘La valeur absolue de’, I,’ est :’, j) ;
FIN ; (* Fin de la procédure afficher *)
Saisie () ;  (* Appel de la procédure Saisie *)
J  valeur_absolue(I) ;  (* Appel de la fonction valeur_absolue *)
Afficher () ;  (* Appel de la procédure Afficher *)
FIN.  (* Fin du programme principal *).
Explication : L’exécution de l’algorithme ci-dessus débute obligatoirement par le corps de l’algorithme princi-
pal en  qui coïncide avec l’appel de la procédure ‘saisie’. De là nous sortons du corps de l’algorithme prin-
cipal et nous nous branchons à la procédure appelée, c'est-à-dire la procédure ‘saisie’ ; d’où le . Puis nous
continuons l’exécution jusqu’à la fin de la procédure ‘saisie’. De là, nous revenons dans le programme appe-
lant, ici le corps du programme principal, d’où le . L’étape  est l’appel de la fonction

‘ valeur_absolue’ avec pour argument la variable I (qui est ici un paramètre effectif); ce qui va provoquer la
sortie à nouveau du corps du programme principal pour se brancher sur la fonction ‘valeur_absloue’,d’où le
, où le paramètre formel ‘a’ sera remplacé par le paramètre effectif ‘I’. L’exécution va se poursuivre jusqu’à
la fin de la fonction
‘valeur_absolue’. De là nous revenons au programme appelant, ici l’algorithme principal ; d’où le . Mais en
retournant, le résultat renvoyé par la fonction ‘ valeur_absolue’ sera sauvegardé dans la variable j (de l’étape
 ). L’étape  est un appel de la procédure ‘Afficher’. De là, nous sortons du programme appelant pour se
brancher sur la procédure ‘Afficher’ ; d’où le . L’exécution se poursuit jusqu’à la fin de la procédure ‘Affi-
cher’. De là, nous retournons au programme appelant c'est-à-dire le corps du programme appelant ; d’où le
 . De là l’exécution du programme prend fin.
C2 La portée des variables locales et globales

Les variables globales sont utilisables partout dans le programme principal y compris à l’intérieur des fonctions et procé-
dures : on dit que leur portée s’étend à tout le programme entier.
Par contre les variables locales ne sont utilisables seulement qu’à l’intérieur des fonctions et procédures où elles ont été
déclarées : on dit que leur portée se limite aux fonctions et procédures.
 Exercice 5 d'application : A quel moment utilise-t-on les variables locales ? Et les variables globales ?
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
5) L’appel d’une fonction ou d’une procédure

Appeler une fonction ou une procédure, c’est matérialiser son intention d’exécuter les instructions qu’elle renferme.
 L’appel d’une fonction se fait par : nom_variable  nom_fonction( argument(s) ) ;
Avec nom_variable de même type que le type renvoyé par la fonction en question.
Exemple : d  moyenne (a, b, c) ;
 L’appel d’une procédure se fait par : nom_procédure( argument(s) ) ;
Exemple : permute (t1, 2) ;
Note : L’appel d’une fonction ou d’une procédure se fait dans le corps du programme principal mais aussi au
sein d’une autre fonction ou une autre procédure.
6) La récursivité
Un sous programme est récursif s’il peut s’appeler soi-même c'est-à-dire qu’il apparaît dans sa propre définition.
Dans la définition d’un sous programme récursif, il faut toujours préciser la condition d’arrêt sinon l’exécution du
programme ne s’arrêtera jamais.
Note : Il ne faut pas abuser de la récursivité car elle est gourmande en mémoire.
 Exercice 6 d'application : Concevez un algorithme permettant de calculer le factoriel d’un nombre entier de 2 ma-
nières différentes: 1 ère
méthode: sans fonction récursive et 2e méthode: avec une fonction récursive.


Conseils pratiques concernant les fonctions et procédures

▪ Le choix d'utilisation d'une procédure ou d'une fonction dépend certes souvent de l'énoncé de l'exercice
mais en grande partie de vous, programmeur.
▪ Le nombre de fonctions et/ou de procédures utilisées dans un algorithme, dépend grandement de vous,
programmeur.
▪ La manière de décomposer votre algorithme en fonctions et procédure, dépend grandement de vous, pro-
grammeur.
▪ La présence, l'absence et le nombre d'arguments utilisés au niveau des fonctions et procédure, dépend
grandement de vous, programmeur.
▪ Si votre fonction ou procédure n'a pas d'argument, c'est que là, vous allez travailler sur les variables glo-
bales. Mais si elles en possèdent, c'est que vous travaillerez sur des variables formelles (arguments formels).

TEST N°2
BUT : Maîtriser la programmation modulaire.
NOTE : Le test 2 est la reprise d'une partie du test 1 afin de vous permettre de comprendre davantage la base
de la programmation; mais cette fois-ci en utilisant des fonctions et procédures.
EXERCICE 1
Dans le cadre de la répartition du budget de l'année alloué à son ministère, M. le Ministre de l'enseignement supérieur
fait le partage comme suit:
▪ Service de l'orientation: 10% du budget global,
▪ Service des examens et concours: le 1/3 du budget restant,
▪ Service d'évaluation des établissements scolaires: les ¾ du budget alloué au service des examens et con-
cours,
▪ Service du mobilier et de l'immobilier: le reste du budget.
Etant donné le budget alloué audit ministère, concevoir un algorithme permettant à M. le Ministre de faire sa répartition.
EXERCICE 2
Déterminer un algorithme qui permet de ressortir le PGCD (Plus Grand Commun Diviseur) de deux (2) entiers.
EXERCICE 3
Une compagnie de chemin de fer pratique ses tarifs en fonction de la catégorie du voyageur:
▪ Voyageur normal (N): plein tarif
▪ Abonné de la compagnie (A): 40% de réduction
▪ Enfant de moins de 10 ans (E): gratuit
▪ Employé de la compagnie (T): gratuit
▪ Parent d'un employé (P): 50% de réduction
▪ Personne âgée de 70 ans et plus (V): 30% de réduction.
Ecrire un algorithme qui permet, connaissant le tarif normal du voyage, de calculer le prix à payer par un voyageur don-
né.
EXERCICE 4
A partir du "Menu principal" affiché à l'écran:
▪ Effectuer la somme de trois nombres réels,
▪ Effectuer le produit de trois nombres réels,
▪ Effectuer la moyenne de trois nombres réels,
l'utilisateur fera le choix de son opération par la saisie d'une valeur entière.
Proposer un algorithme qui permet à partir du menu principal, d'effectuer les opérations ci-dessus.
EXERCICE 5
Une société de transport compte vingt (20) chauffeurs qui font chacun un versement pendant 26 jours par mois. A l'is-
sue des 26 jours de versement, le salaire de chaque chauffeur est égal à 20% de sa recette mensuelle.
Concevoir un algorithme qui pourra afficher le salaire de chaque chauffeur et la part globale de la société de transport à
la fin du mois.
EXERCICE 6
Un centre de formation de football compte 100 pensionnaires.
Proposer un algorithme qui, connaissant l'âge de l'enfant, informe l'utilisateur de la catégorie de celui-ci:
✓ Poussin: de 6 à 7 ans,
✓ Pupille: de 8 à 10 ans
✓ Minime: de 11 à 13 ans,
✓ Cadet: à partir de 14 ans
Donnez le nombre d'enfants par catégorie.
Note: L'âge des pensionnaires est compris entre 6 et 20 ans.
EXERCICE 7
La direction des bourses voudrait octroyer des bourses d'études aux étudiants. Si la moyenne annuelle est supérieure à
15 alors l'étudiant obtient une bourse de pays européens. Par contre si la moyenne annuelle est supérieure à 12 alors
l'étudiant obtient une bourse d'un pays africain.
Proposer un algorithme qui permet de déterminer le nombre de bourses octroyées en Afrique et en Europe.
Le nombre de postulants étant saisi au clavier.

EXERCICE 8
Un démarcheur à domicile est rémunéré avec un salaire fixe de 600 000F CFA. Il perçoit aussi une commission qui repré-
sente 5% du montant des ventes qu’il a réalisées. Le salaire ainsi obtenu est augmenté de 10% pour prendre en compte
ses frais de déplacement.
Ecrire un algorithme qui calcule son salaire étant donné le montant des ventes réalisées.
EXERCICE 9
Réalisez un programme "Distributeur Automatique de billets de banque". L'automate (la machine) contient des billets de
1000F, 2000F, 5000F et de 10 000F. Etant donnée une demande de retrait de l'utilisateur, le programme calcule et af-
fiche le nombre de billets de chaque valeur. Le programme devra minimiser le nombre de billets distribués.
Réalisez l'algorithme de ce distributeur automatique de billets de banque.
EXERCICE 10
Concevoir un algorithme permettant de calculer et d'afficher année par année, le montant du capital et des intérêts ac-
quis pour une somme S francs, placée à T% pendant N années.
EXERCICE 11
Le professeur principal d'une classe de 25 étudiants vous sollicite pour mettre en place un programme informatique lui
permettant de calculer les moyennes de ses étudiants. Les matières à considérer et leurs différents coefficients sont:
Informatique: coefficient 4, mathématiques: coefficient 3 et l'anglais: coefficient 2.
Pour chaque matière, l'on dispose de deux (2) notes avec des coefficients différents: note de test lourd: coefficient 5 et
note de devoir: coefficient 3.
Le professeur principal voudrait savoir:
▪ La moyenne de classe de chaque étudiant,
▪ Le premier dans chaque matière,
▪ Le premier de la classe,
▪ La moyenne générale de la classe.
Proposer un algorithme lui permettant d'assouvir son besoin.
Note: Les étudiants seront identifiés par des numéros (par exemple n°1, n°2,…).

CHAPITRE 7 : LES STRUCTURES DE DONNEES STATIQUES

Objet : Ce chapitre traite des variables plus évoluées que celles déjà vues (entier, réel, caractère, booléen) et néces-
saires pour résoudre certains problèmes.
Objectif : A la fin de ce chapitre, vous devrez être à mesure de savoir utiliser les chaînes de caractères, les tableaux, les
intervalles, les ensembles, les énumérés, les enregistrements.
Introduction
Dans les chapitres précédents, nous avons vu et présenté quatre (4) types simples (ou scalaires : c'est-à-dire que ces
variables ne peuvent contenir une (1) et une (1) seule valeur à la fois) : REEL, ENTIER, CARACTERE et BOOLEEN.
Ces types simples permettent de manipuler aisément des nombres ou des caractères.
En effet, il arrive fréquemment que l’on ait besoin de manipuler non plus une variable isolée de ces différents types mais
une suite de variables de ceux-ci. Ainsi pouvons nous être amenés à traiter d’autres sortes d’informations, par
exemples : des mois de l’année (janvier, février mars,…), les jours de la semaine (lundi, mardi, mercredi,…), des notes
de musique, des noms de cartes à jouer (as, roi, dame, pique,…), des marques de voiture, des couleurs…savoir par
exemple pour une personne donnée, son lieu d’habitation, son âge, son sexe, sa profession, son contact…
Pour répondre à de tels besoins, l’on a mis sur pied des structures pour pouvoir accueillir de telles données : les struc-
tures de données, permettant de donner un nom, non plus à une seule valeur, mais à un ensemble de valeurs.
En clair, les structures de données statiques sont des variables évoluées car elles peuvent contenir plusieurs valeurs à
la fois ; et une fois leur taille fixée, il est impossible de la modifier durant le programme, d’où le thème ‘sta-
tique’.
Pour le cours, nous en étudierons six (6) :
▪ Les chaînes de caractères,
▪ Les tableaux,
▪ Les intervalles,
▪ Les ensembles,
▪ Les énumérés,
▪ Les enregistrements.
 Exercice 1 d'application : A quoi servent les structures de données ?

…………………………………………………………………………………………………………………………………………………………………………
1) Les chaînes de caractères

a) Définition
Une chaîne de caractères est une suite de caractères juxtaposés, c'est-à-dire les différents caractères sont collés les
uns aux autres. Exemple "Pendant" : Le 'e' est collé au 'p', qui a son tour, le 'n' lui est collé et ainsi de suite.
Une chaîne de caractères est définie par :
▪ Son nom et
▪ Sa longueur maximale, c'est-à-dire le nombre maximal de caractères que cette chaîne de caractères peut
contenir.
Note : Le nom et la longueur maximale de la chaîne de caractères sont au choix du programmeur.
La syntaxe de déclaration d'une chaîne de caractères se fait par :
VAR
Nom_chaîne: CHAINE [longueur maximale]; avec longueur maximale  [1; 255].
Exemple : VAR
Nom CHAINE [30];  Nous venons de déclarer une chaîne de caractères nommée Nom et pouvant con-
tenir au maximum trente (30) caractères.
b) L'affectation
C'est le fait d'attribuer une valeur à une chaîne de caractères. Nous pouvons le faire de trois (3) manières :
Syntaxe1: nom_chaîne  "valeur de type chaîne de caractères "; ou
Syntaxe2: nom_chaîne1  nom_chaîne2; ou
Syntaxe3: SAISIR (nom_variable);
Exemples: VAR
Nom : CHAINE [30]; Classe : CHAINE [25];
……
 (Syntaxe 1) Nom  " SORO Digbeu";

SORO Digbeu
Nom
 La chaîne de caractères Nom reçoit la valeur "SORO Dgbeu"
 (Syntaxe 2) : Classe  Nom;  La chaîne de caractères Classe reçoit le contenu de la chaîne de
caractères Nom, c'est-à-dire "SORO Digbeu".
Note : Une valeur de type chaîne de caractère est toujours placée entre double quote ( " ").
 (Syntaxe 3)
AFFICHER ('Entrez notre nom et prénom');
SAISIR (Nom); (* permet de ranger ce que l'utilisateur va taper au clavier, dans la chaîne de caractères Nom *)
 Exercice 2 d'application : Que va-t-il se passer si l'on veut mettre une certaine quantité de caractères dans une
chaîne de caractères, plus qu'elle n'en peut contenir ?
Par exemple Nom : CHAINE [10]; Et plus loin Nom " NGUESSAN Konaté Mel Tapé Aka" ?
Réponse :
…………………………………………………………………………………………………………………………………………………………………………
 Exercice 3 d'application Soit Nom : CHAINE [30]; Faut-il nécessairement mettre 30 caractères dans la chaîne de
caractères nom ?
Réponse :
…………………………………………………………………………………………………………………………………………………………………………
 Exercice 4 d'application Soit Nom : CHAINE [30];

….
Nom "SORO Adama Séri"; et plus loin dans le programme, la chaîne de caractères Nom reçoit:
Nom "Yao";
Quel sera désormais le contenu de la chaîne de caractères Nom ?
Réponse :
…………………………………………………………………………………………………………………………………………………………………………
L'on peut parcourir ou atteindre les différents éléments d'une chaîne de caractères (les différents caractères qui la com-
posent) grâce à un indice (entier >0) débutant par 1, comme suit : nom_chaîne [indice]. En fait l'indice ici est la posi-
tion de cet élément (le caractère) dans la chaîne de caractères.
Exemple : VAR
Nom : CHAINE [30];
….
Nom "SORO Adama Mel Digbeu Yapo";
Ainsi nom [1] désignera 's' (le 'S' de SORO).
Ainsi nom [4] désignera 'o' (Le 2e 'O' de SORO).
Ainsi nom [5] désignera '' (L'espace entre SORO et Adama).
Ainsi nom [8] désignera 'a' (Le 2e 'a' d'Adama).
Ainsi nom [18] désignera 'g' (Le 'g' de Digbeu).
 Exercice 5 d'application : Quel sera le contenu de la chaîne de caractères Nom après l'exécution de ces instruc-
tions ?
Nom [3]'P'? 
……………………………………………………………………………………………………………………………………………………………………… .
Nom [9]'X'? 
………………………………………………………………………………………………………………………………………………………………………..
Nom [12]'K'? 
………………………………………………………………………………………………………………………………………………………………………..
Note : Vous remarquerez dans les instructions ci-dessus, par exemple Nom [3]'P', le P est placé entre
simple quote (' '). Cela parce que les différents éléments d'une chaîne de caractères sont des caractères
donc placé ente simple quote.

c) Les différentes fonctions applicables sur une chaîne de caractères

L'on peut effectuer les différentes opérations usuelles suivantes sur une chaîne de caractères :
▪ LONGUEUR (M) : Détermine la longueur de la chaîne de caractères M c'est-à-dire le nombre de caractères
qu'elle contient réellement.
Exemple : VAR Nom : CHAINE [30];
Nom "KOFFI Koné Séri";
Ainsi LONGUEUR (Nom) affichera 15 (on compte tous les caractères qui se trouvent dans la chaîne de caractères Nom y
compris les espaces car ils sont aussi des caractères).
Application : POUR i 1 à LONGUEUR (Nom) FAIRE….
▪ COPIER (M, i, j) : Permet de copier j caractères de la chaîne de caractères M à partir de son caractère n° i in-
clus, dans une autre chaîne de caractères.
Exemple : VAR Phrase : CHAINE [20]; P : CHAINE [10];

….
Phrase " Heureux sont ceux qui sont pieux";
P  COPIER (Phrase, 3, 8); (* En fait cette instruction stipule de copier 8 carac-
tères de la chaîne de caractères Phrase mais à partir de son caractère n°3 inclus *).
Ainsi la chaîne de caractères P contiendra "ureux so"
▪ CONCATENER(L, M): Permet de concaténer(souder) les chaînes de caractères L et M, c'est-à-dire prendre la 2e
chaîne de caractères (ici M) et la coller à la 1 ère chaîne de caractères (ici L). Puis mettre le résultat de cette opération
dans une autre chaîne de caractères. Donc CONCATENER (L, M)  CONCATENER (M, L) :
Exemple : VAR Nom : CHAINE [20]; Prenom: CHAINE [25]; Nom_P: CHAINE [50];
….
Nom " Côte";
Prenom  "d'Ivoire"
Nom_P  CONCATENER (Nom, Prenom);
Ainsi Nom_P contiendra "Côted'Ivoire". Vous constatez que les deux (2) mots sont collés (Côted'Ivoire). Si d'aventure,
l'on désire les séparer, il va falloir soit mettre un espace (je le matérialise ici par  ) comme suit:
Nom_P  CONCATENER (Nom, " ", Prenom); Désormais Nom_P contiendra "Côte d'Ivoire".
▪ INSERER (L, M, K): Permet d'insérer la chaîne de caractères L dans la chaîne de caractères M mais à partir du
caractère n° k (c'est-à-dire juste après le caractère n° k-1) de la chaîne de caractères M.
Exemple : VAR Nom : CHAINE [20]; Prenom: CHAINE [25];
….
Nom " NGUESSAN";
Prenom  "Mathieu"
INSERER (Nom, Prenom, 4); (* Cette instruction ordonne de prendre le contenu de
la chaîne de caractères Nom et de l'insérer dans le contenu de la chaîne de caractères Prenom mais à
partir du caractère n°4 (c'est-à-dire juste après le caractère n°3) de la chaîne de caractères Prenom *).
Ainsi la chaîne de caractères Prenom contiendra finalement "MatNGUESSANhieu".
▪ EFFACER (M, i, j) : Permet d'effacer j caractères de la chaîne de caractères M mais à partir de son caractère n° i
inclus.
Exemple : VAR Nom : CHAINE [20];
….
Nom " NGUESSAN";
EFFACER (Nom, 2, 4); (* Cette instruction ordonne de se positionner sur le 2 e caractère de la
chaîne de caractères Nom et à partir de ce 2e caractère inclus, d'effacer 4 caractères, vers la droite *)
Ainsi la chaîne de caractères Nom contiendra finalement "NSAN".
d) Les opérateurs applicables sur une chaîne de caractères
Ce sont : +, =, , <, >, , .
Exemples :
+: joue exactement le même rôle que la concaténation. Exemple : Nom_P  Nom + prenom;
=: Permet de comparer deux(2) chaînes. Exemple SI Nom = prenom ALORS…
: Permet de différencier 2 chaînes. Exemple SI nom  prenom ALORS….
<, >, ,  : Permettent de savoir si une chaîne précède ou succède une autre, alphabétiquement.
Exemple : SI Nom < prenom ALORS…
Ainsi "Adama" < "Yao" par exemple.

2) Les tableaux
a) Définition
Un tableau est une structure de données contenant des éléments de même type. Ces éléments peuvent être des
entiers, des réels, des booléens, des chaînes de caractères, des caractères, des tableaux, des enregistrements…
Un tableau est caractérisé par :
▪ Son nom
▪ Sa taille, c'est-à-dire le nombre maximal d'éléments qu'il va contenir.
▪ Et le type de ses éléments.
b) Les différents types de tableaux et leur déclarations

L'on distingue des tableaux à une (1) dimension, à deux (2) dimensions, à trois (3),…à n dimensions. Pour le cours nous
nous limiterons aux tableaux à une (1) et deux (2) dimensions.
b1 Tableau à une dimension
Un tableau à une (1) dimension est constitué d'une (1) seule ligne et n colonnes (1 seule ligne et plusieurs colonnes).
Exemple de tableau à une (1) dimension
Un tableau à une (1) dimension peut être déclaré soit dans la partie VAR soit dans la partie TYPE; mais majoritairement
dans la partie VAR. Si d'aventure, un tableau à une (1) dimension est déclaré dans la partie TYPE, il faudra nécessaire-
ment par la suite, déclarer une variable ayant pour type, le type déclaré dans la partie TYPE.
La syntaxe de déclaration d'un tableau à une dimension se fait par
VAR
Nom_tableau: TABLEAU [taille] de type_éléments; avec taille, un entier >0.
OU
TYPE
Nom_tableau = TABLEAU [taille] de type_éléments;
Exemple 1: VAR
T: TABLEAU [15] de REEL; (* Nous venons de définir un tableau à une dimension du nom de T qui est cons-
titué de 15 cases et dans chaque case, l'on mettra un réel *)
T:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Exemple 2: TYPE
P : TABLEAU [10] de CARACTERE;
VAR
T : P; (* Ainsi c'est la variable T qui sera utilisé par la suite dans le programme *)
Pour atteindre chaque élément d'un tableau à une dimension, l'on procède comme suit : nom_tableau [indice] avec in-
dice  [1; taille].
Exemple : T [5]; permet d'atteindre le 5e élément du tableau T et d'y faire ce que l'on désire (soit envoyer une valeur là
(écriture) ou prendre possession de la valeur déjà là (lecture)).
b2 Tableau à plusieurs dimensions
L'on peut avoir un tableau à 2, 3, …n dimensions. Mais dans la pratique c'est le tableau à deux (2) dimensions qui est
fréquement utilisé.
Ainsi un tableau à 2 dimensions est constitué de k lignes et p colonnes (plusieurs lignes et plusieurs colonnes).
Un tableau à deux (2) dimensions peut être déclaré soit dans la partie VAR soit dans la partie TYPE; mais majoritaire-
ment dans la partie VAR. Si d'aventure, un tableau à deux (2) dimensions est déclaré dans la partie TYPE, il faudra né-
cessairement par la suite, déclarer une variable ayant pour type, le type déclaré dans la partie TYPE.
La déclaration d'un tableau P à deux (2) dimensions se fait par :
VAR
P: TABLEAU [Nombre de lignes] [Nombre de colonnes] de type_éléments; Avec Nombre de lignes et
Nombre de colonnes des entiers >0.
OU
TYPE
P = TABLEAU [Nombre de lignes] [Nombre de colonnes] de type_éléments;
Ainsi P : TABLEAU [7] [5] de CARACTERE; définit un tableau de 7 lignes et 5 colonnes, soit 35 cases et chaque case
va recevoir un seul caractère..

1 2 3 4 5
1
2
3
4
5
6
7
Pour atteindre un élément d'un tableau à deux (2) dimensions, l'on procède comme suit :
nom_tableau [n° ligne] [n° colonne].
Exemple : P [2][5]; permet d'atteindre l'élément du tableau P se trouvant à l'intersection de la 2 e ligne et la 5e colonne.
C) Affectation
C'est le fait d'attribuer une valeur à un élément du tableau et cette affectation se fait élément par élément. Nous
pouvons le faire de trois (3) manières différentes.
C1) Tableau à une dimension
Syntaxe 1 : nom_tableau[n° case]  valeur; ou
Syntaxe 2 : nom_tableau[n° case I]  nom_tableau[n° case K]; ou
Syntaxe 3 : SAISIR (nom_tableau[n° case]);
 Ainsi T [10]  5; (Syntaxe 1) (T un tableau contenant des éléments de type ENTIER)
5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
T [3]  250;
250 5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
T [8]  100;
250 100 5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 P  T [3]; (P une variable de type entier) permet de prendre le contenu de la 3e case du tableau T et de la mettre
dans la variable P. Ainsi au regard de notre exemple, P contiendra 250.
Aussi T [12] T [8]; (Syntaxe 2) permet de prendre le contenu de la 8 e case du tableau T et de la mettre dans la
12e case du tableau T. Ainsi au regard de notre exemple, T [12] contiendra 100.
 AFFICHER ('Entrez une valeur');

SAISIR (T [5]); (Syntaxe 3) Permet de ranger ce que l'utilisateur va taper au clavier, dans la 5e case du tableau à
une dimension T.
C2) Tableau à deux (2) dimensions

Syntaxes d'affectation :
Syntaxe 1 : nom_tableau[n°ligne] [n° colonne] valeur; ou
Syntaxe 2 : nom_tableau[n°ligne I] [n° colonne K]  nom_tableau[n°ligne P] [n° colonne G] ; ou
Syntaxe 3 : SAISIR (nom_tableau[n°ligne] [n° colonne] );
 Exercice 6 d'application : Représenter les différents cas suivants : (Syntaxe 1)

Soit P: TABLEAU[7][5] de CARACTERE;
P [1] [3]  'A';
P [2] [5] 'X'; (Voir page suivante)
P [6] [4]  'C';
P [3] [3]  'D';

Réponse :
1 2 3 4 5
1
2
3
4
5
6
7
 (Syntaxe 2)
Soit P [7] [2]  P [6] [4]; Cette instruction ordonne d'attribuer le contenu de la case se trouvant à l'intersection de la
ligne 6 et de la colonne 4, à la case se trouvant à l'intersection de la ligne 7 et de la colonne 2. Ainsi au regard de notre
exemple P [7] [2] contiendra 'C'.
 . (Syntaxe 3)
AFFICHER ('Entrez une valeur');
SAISIR (P [2] [5]); Permet de ranger ce que l'utilisateur va taper au clavier, dans la case se trouvant à l'intersec-
tion de la ligne 2 et de la colonne 5, du tableau à deux (2) dimensions P.
d) Parcours des tableaux

Pour parcourir les différents éléments (1 à 1) d'un tableau à une (1) dimension, l'on utilise la boucle POUR…FAIRE et
pour un tableau à deux (2) dimensions, l'on utilise deux (2) boucles POUR…FAIRE mais imbriquées c'est-à-dire un
POUR…FAIRE à l'intérieur d'un autre POUR…FAIRE.
Remarque : Le remplissage d'un tableau à deux (2) dimensions se fait ligne par ligne (de la 1 ère ligne à la dernière ligne).
 Exercice 7 d'application : Ecrire un algorithme pour remplir un tableau à une dimension et un autre algorithme
pour remplir un tableau à deux dimensions. Les deux (2) tableaux vont contenir des réels et auront une taille de 20 élé-
ments.
Solutions :

 Exercice 8 d'application : Pourquoi l'utilisation d'un tableau à deux (2) dimensions ?

Réponse :…………………………………………………………………………………………………………………………………………………………….
Remarque : Un tableau à une (1) dimension est transformable en un tableau à deux (2) dimensions et
vice versa.
Soit P [30] de REEL;  P [10] [3] de REEL; ou P [3] [10] de REEL;
Soit T [20] [5] de REEL  T [100] de REEL;
 Exercice 9 d'application Ecrire un algorithme permettant de saisir 10 valeurs entières puis de calculer le factoriel
de chaque valeur; et enfin d'afficher chaque valeur avec son factoriel(Le faire d'abord avec un tableau à une dimension
puis à 2 dimensions).
Solution :

e) Imbrication des tableaux

Un tableau peut en imbriquer un autre c'est-à-dire qu'un tableau peut se retrouver à l'intérieur d'un autre tableau. Dans
ce cas les tableaux à imbriquer doivent nécessairement être déclarés dans la partie TYPE.
TYPE
P:TABLEAU [5] de CHAINE;
T: TABLEAU [10] de P;
VAR
M: T;
 Exercice 10 d'application
 Compléter la phrase ci-après: Au regard de la déclaration ci-dessus, nous venons de déclarer une variable du nom de
M, de type tableau, contenant………..cases et chaque case contient……….autres cases pouvant contenir des éléments de
type…………………; soit M contient au total……………. cases.
 Représenter la structure M (qui est un tableau) sous forme de schéma.
 Affecter une valeur quelconque à la 5e case du tableau M: ………………………………………………………………………………….
f) Définition de constante de type Tableau

Il est souvent nécessaire, dans la résolution de certains problèmes, de définir des constantes de type tableau. Ici en
effet, l'on déclare le tableau et l'on l'initialise en même temps c'est-à-dire qu'on l'on lui attribue déjà ses valeurs. Mais
une fois les valeurs du tableau attribuées, l'on ne pourra plus les modifier car l'on a défini le tableau dans la partie
CONST (donc ses éléments sont des constantes).
En fait une telle déclaration permet de pallier les insuffisances des structures de données notamment de
la structure de données Ensemble, qui ne permet pas de définir des ensembles de chaînes de caractères.
Syntaxe:
CONST
Nom_cste: TABLEAU [taille_tableau] de Type_éléments = (éléments1, élément2,…éléments n);
Exemple 1: CONST Tab : TABLEAU [5] de ENTIER = (1, 45, 78, -156, 0);
Ainsi le tableau d'une dimension Tab se présente comme suit:
Tab
1 45 78 -156 0
Exemple 2: CONST T: TABLEAU [3][5] de CARACTERE = ( ('b','5', 'p', '-','B'), ('1','r','T','y','m'), ('>', '&','@','W','Q') );
Ou simplement : CONST T: TABLEAU [3][5] de CARACTERE = ('b','5', 'p', '-','B', '1','r','T','y','m', '>', '&','@','W','Q');
 Définir une constante de type tableau d'une dimension, de 6 cases et contenant des chaînes de caractères au choix,
d'au plus 10 caractères. Puis la représenter.
Réponse :
 Définir une constante de type tableau de deux (2) dimensions, de 5 lignes et 7 colonnes et contenant des réels au
choix. Puis la représenter.
Réponse :

g) Tri de tableau
Pour trier un tableau à une (1) dimension de taille N éléments, il faudra utiliser deux (2) structures POUR…FAIRE mais
imbriquées; et donc 2 compteurs. Soit I et J ces 2 compteurs. Le 1er compteur I ira de 1 à N-1 et le second compteur J
ira de I+1 à N.
Concevoir un algorithme permettant d'afficher par ordre décroissant, cinq (5) nombres entiers que l'utilisateur aura saisis
au clavier.
Réponse :
Remarque : On peut introduire les valeurs d'un autre tableau dans un autre tableau. Mais pour cela, il
faut que les deux tableaux en question soient du même type (ou de types compatibles), qu'ils aient le
même nombre de dimension(s) et le même nombre d'éléments.
Syntaxe : nom_du_premier_tableau  nom_du_deuxième_tableau ;
Soit la déclaration suivante :
TYPE
Tab=TABLEAU [10] de REEL;
Bp=TABLEAU [8] de REEL;
Mg=TABLEAU [5] de CARACTERE;
Jk=TABLEAU [8] de BOOLEEN;
VAR
t1, t2: Tab; b1, b2: Bp; m1, m2: Mg; j1, j2: Jk;
Dire si ces affectations suivantes sont possibles :
▪ t1 b1; Réponse : ………………………………………………………………………………………………………………………………………
▪ t1 m1; Réponse : ……………………………………………………………………………………………………………………………………..
▪ t1 t2; Réponse : ………………………………………………………………………………………………………………………………………
▪ j1 m2; Réponse : ………………………………………………………………………………………………………………………………………

h) Le passage de tableau en paramètre, à une fonction ou à une procédure

ère
1 méthode:
Pour passer un tableau en paramètre formel à une fonction ou une procédure(lors de la définition de la fonction ou de la
procédure), l'on le fait par: VAR nom_tableau[taille] de type_élément. Mais ici le tableau doit avoir la même taille et le
même type d'éléments que le tableau utilisé lors de l'appel de la fonction ou de la procédure.
Pour passer un tableau en paramètre réel à une fonction ou une procédure(lors de l'appel de la fonction ou de la procé-
dure), l'on le fait en mentionnant simplement le nom du tableau.
2e méthode:
Déclarer dans la partie TYPE, un type tableau. Au niveau du paramètre formel, déclarer une variable de type, le tableau
déclaré dans la partie TYPE. Au niveau du paramètre réel, utiliser une variable déclarée dans la partie VAR, de type, le
tableau déclaré dans TYPE et utiliser cette dernière.
Exemple pour la 1ère méthode

ALGORITHME exemple;
VAR Tab: TABLEAU[15] de REEL;
I: ENTIER; Som: REEL;
FONCTION calculer_somme(VAR pt: TABLEAU[15] de REEL): REEL; (* Même taille et même type que le tableau Tab *)
VAR e: ENTIER; St: REEL;
DEBUT (* Début du corps de la fonction calculer_somme *)
St  0;
POUR e  1 à 15 FAIRE
DPOUR
St  St + pt[e];
FPOUR;
Calculer_somme  St;
FIN; (* Fin du corps de la fonction calculer_somme *)
DEBUT (* Début du corps du programme principal *)
POUR I  1 à 15 FAIRE (* Remplissage du tableau H *)
DPOUR
AFFICHER('Entrez la valeur n° ', I
SAISIR(Tab[I]);
FPOUR;
Som  calculer_somme(Tab); (* Appel de la fonction calculer_somme, en mentionnnant simplement le nom du tableau *)
AFFICHER('La somme vaut:', Som);
FIN. (* Fin du corps du programme principal *)
Exemple pour la 2e méthode

ALGORITHME essai;
TYPE
Tab: TABLEAU[15] de REEL;
VAR
H: Tab;
I: ENTIER; Som: REEL;
FONCTION calculer_somme(VAR pt: Tab): REEL; (* pt de type Tab déclaré dans la prtie TYPE *)
VAR e: ENTIER; St: REEL;
DEBUT (* Début du corps de la fonction calculer_somme *)
St  0;
DPOUR
St  St + pt[e];
FPOUR;
Calculer_somme  St;
FIN; (* Fin du corps de la fonction calculer_somme *)
POUR I  1 à 15 FAIRE (* Remplissage du tableau H *)
DPOUR
AFFICHER('Entrez la valeur n° ', I
SAISIR(H[I]);
FPOUR;

Som  calculer_somme(H); (* Appel de la fonction calculer_somme, en mentionnnant simplement le nom du tableau *)
AFFICHER('La somme vaut:', Som);
3) Le type énuméré
a) Définition
C'est un ensemble ordonné d'éléments. C'est en fait un ensemble dans lequel l'on énumère tous ses éléments et l'ordre
d'énumération des éléments a une importance. Ce n'est véritablement pas une structure de données.
b) Déclaration
Un type énuméré est défini dans la partie TYPE de l'algorithme. La syntaxe de déclaration est la suivante : TYPE
Nom_type_énuméré = ( Identificateur1, Identificateur2, …, Identificateur n);
Avec les identificateurs qui sont semblables aux noms des variables.
Note : Tout type déclaré dans la partie TYPE, ne peut être utilisé comme tel. Il faudra nécessairement
déclarer dans la partie VAR, une variable de type, le type déclaré dans la partie TYPE; et c'est cette va-
riable qui sera utilisé par la suite dans le programme (voir l'exemple qui suit).
Exemple :
TYPE
Jours = (Dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi);
Etat_civil = (celibataire, marie, veuf, separe);
Corps = (C, O, H, CO2, H2O);
VAR
P: Jours; (* Déclaration de la variable P de type Jours. Et à cet effet, P ne pourra recevoir que les valeurs
citées entre parenthèses dans Jours (Dimanche, lundi,…) mais une seule à la fois *)
F: Etat_civil; (* Déclaration de la variable F de type Etat_civil. Et à cet effet, F ne pourra recevoir que les
valeurs citées entre parenthèses dans Etat_civil (celibataire, marie,…) mais une seule à la fois *)
Mt: Corps; (* Déclaration de la variable Mt de type Corps. Et à cet effet, Mt ne pourra recevoir que les
valeurs citées entre parenthèses dans Corps (C, O, H,…) mais une seule à la fois *)
C'est donc les variables P, F et Mt qui seront utilisés par la suite dans le programme (et non Jours, Etat_civil et Corps).
 Exercice 14 d'application : Quel est l'intérêt du type énuméré ?
Réponse:……………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………..
c) Règles concernant les identificateurs du type énuméré

 Les identificateurs ne doivent pas être des mots réservés de langage (que ce soit l'algorithme ou les langages
de programmation). Ceci pour éviter toute confusion
Exemple: TYPE note = (si, mi, fa, sol, debut); ceci serait rejeté car 'si' et 'debut' sont des mots réservés de l'algorithme.
 Un même identificateur ne peut désigner plusieurs choses différentes.
Exemple : TYPE Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
Jours_travail = (lundi, mardi, mercredi, jeudi, vendredi);
Ces deux (2) déclarations seront rejetés car un identificateur tel que 'mardi' représenterait deux entités de types diffé-
rents, c'est-à-dire lorsqu'on dit 'mardi', est ce le 'mardi' de Jours ou le 'mardi' de Jours_travail? Il y a donc confusion ! Or
la programmation est formelle c'est-à-dire il ne doit pas y avoir de confusion.
 Les identificateurs ne peuvent être des constantes.

Exemple :
TYPE impair = (1, 3, 5, 7, 9); Ceci serait rejeté car 1, 2, 3, 5, … sont des constantes de type entier.
Voyelle = ('a', 'e', 'i', 'o', 'u', 'y'); Ceci serait rejeté car 'a', 'e', 'i', 'o',… sont des constantes de type caractère.
d) Propriétés du type énuméré

• Affectation :
Exemple : TYPE Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
VAR dt, pt, ft: Jours;
…..
dt  mardi;
pt jeudi;
ft  pt;
 Exercice 15 d'application : Cette affectation dt  petit est-elle correcte?
Réponse:……………………………………………………………………………………………………………………………………………………………

• Les opérateurs relationnels (=, <, >=, >, >=, ) sont utilisables avec des éléments de même type.
Exemple : SI dt = dimanche ALORS…
SI pt > mercredi ALORS…
• Les fonctions ORD, PRED et SUCC sont utilisables.
Exemple : Au regard de la déclaration plus haut :
SUCC (mardi) vaut mercredi
PRED (samedi) vaut vendredi
Mais PRED (lundi) et SUCC (dimanche) ne sont pas définis (n'existent pas).
La 1ère valeur d'un type énuméré possède le rang zéro (0). Ainsi ORD (lundi) vaut 0, ORD (jeudi) vaut 3…
Exemple d'application
ALGORITHME essai;
TYPE marque = (ford, renault, mercedes, bmw, nissan, peugeot, jaguar, hummer);
VAR pt: marque;
DEBUT
POUR pt  ford à hummer FAIRE
DPOUR
SI (pt = ford) OU (pt = hummer) ALORS
DSI
AFFICHER ('C'est une marque américaine');
FSI;
SI (pt = mercedes) OU (pt = bmw) ALORS
DSI
AFFICHER ('C'est une marque allemande');
FSI;
SI pt = jaguar ALORS
DSI
AFFICHER ('C'est une marque britannique');
FSI;
SI (pt = renault) OU (pt = peugeot) ALORS
DSI
AFFICHER ('C'est une fausse marque');
FSI;
FPOUR;
FIN.
Note : Il est impossible d'utiliser les instructions AFFICHER et SAISIR avec les variables de type énuméré.
Il est également impossible de les utiliser comme indice à un tableau.
Exemple: T: TABLEAU[8] de REEL et pt la variable de l'algorithme ci-dessus.
POUR pt  ford à hummer FAIRE
DPOUR
T[pt]  25; Impossible.
AFFICHER('La voiture en cours est:' , pt); Impossible.
 Exercice 16 d'application : Pourquoi dit-on que le type énuméré n'est pas une véritable structure de données ?
Réponse:
………………………………………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………………………………………
4) Les intervalles
a) Définition
Contrairement au type énuméré où nous sommes obligés de définir tous ses éléments, le type intervalle permet de défi-
nir un ensemble de valeurs par la simple connaissance de la valeur initiale et de la valeur finale.

b) Déclaration
Un type intervalle est défini dans la partie TYPE de l'algorithme. La syntaxe de déclaration est la suivante: TYPE
nom_intervalle = valeur_initiale . . valeur_finale; Avec valeur_initiale et valeur_finale, des constantes (entier, caractère,
énuméré) telles que valeur_initiale < valeur_finale.
Exemple1: Exemple2
TYPE CONST
Age = 1..150; age_max = 160;
VAR TYPE
age_pere: age; age = 1..age_max;
VAR
Age_mere: age;
Note 1: Ainsi age_pere ne pourra recevoir seulement que les valeurs comprises entre 1 et 150 y compris.
Quant à age_mere, elle recevra seulement les valeurs comprises entre 1 et 160 y compris. Mais une
seule valeur à la fois.
Note 2: Un intervalle est forcément ordonné et continu.
Remarque: Il est possible d'utiliser des constantes d'un type énuméré pour constituer un type intervalle.
Exemple:
TYPE Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
Jours_travail = lundi.. vendredi;
Week_end = samed . . dimanche;
Mais les deux (2) dernières déclarations ont été possibles parce que l'on a auparavant déclaré un type énuméré ayant
ces constantes (lundi…).
 Exercice 17 d'application : Cette spécification d'intervalle 5..2 est-elle correcte?
Réponse :…………………………………………………………………………………………………………………………………………………………..
c) Propriété du type intervalle

Les variables d'un type intervalle jouissent exactement des mêmes propriétés que le type hôte. Elles peuvent intervenir
dans les mêmes expressions:
Type ENTIER: , +, *, /, =, -, <; <=, >, >=, .
Type CARACTERE: , =, <; <=, >, >=, , ORD, SUCC, PRED.
Type ENUMERE: , ORD, SUCC, PRED, incrémentation, décrémentation
Exemple:
TYPE Jours = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
Jours_travail = lundi .. vendredi;
VAR
Courant, aujourd_hui: Jours_travail;
Ct: Jours;
……
Aujourd_hui  mardi;
Courant  SUCC (aujourd_hui); (* Courant contiendra mercredi *)
Aujourd_hui  aujourd'hui +2; (* aujourd_hui contiendra jeudi *)
Remarque: Il est possible d'utiliser des valeurs de type énuméré comme compteur dans la boucle
POUR…FAIRE. En s'appuyant sur l'exemple ci-dessus, nous pouvons avoir :
POUR Ct  lundi à dimanche FAIRE (* Ici il faut que Ct soit une variable de type énuméré *)
DPOUR
Instructions;
FPOUR;
5) Le type ensemble
a) Définition
Il faudra entendre par 'ensemble', une collection non ordonnée d'éléments de même type, c'est-à-dire le rang des
éléments n'a aucune importance.
b) Déclaration du type ensemble
La déclaration d'un type ensemble se fait majoritairement dans la partie TYPE (bien qu'on puisse le faire aussi dans la
partie VAR). La syntaxe de déclaration est la suivante :
TYPE
Nom_type_ensemble = ENSEMBLE de type_de_base; ou

VAR
Nom_type_ensemble : ENSEMBLE de type_de_base;
Avec type_de_base, un type ordinal (ENTIER, REEL, CARACTERE, ENUMERE) ou intervalle d'un type ordinal dont les
valeurs ordinales sont comprises entre zéro (0) et 255 et contenant au plus 256 éléments.
Exemple 1: TYPE
Lettres = ENSEMBLE de CARATERE;
Premier = ENSEMBLE de 1..250;
VAR
Ft: Lettres; P:Premier;
Ainsi Ft pourra contenir zéro (0), un (1) ou plusieurs caractères à la fois; et P pourra contenir zéro (0), un (1)
ou plusieurs valeurs entières à la fois comprises entre 1 et 250 y compris.
Exemple 2: TYPE TYPE
Note= (ut, re, mi, fa, sol, la); Note= (ut, re, mi, fa, sol, la);
Accord = ENSEMBLE de Note; ou VAR
VAR Accord : ENSEMBLE de Note;
It: Accord;
 Exercice 18 d'application : Dire si ces déclarations sont correctes ou pas.
TYPE Réponses :
At = ENSEMLE de ENTIER;
……………………………………………………………………………………………………………………………………………………………………….
Plus = ENSEMLE de 1 . . 500;
……………..………………………………………………………………………………………………………………………………………………………..
V = ENSEMLE de 300 . . 500;
……………………………………………………………………………………………………………………………………………………………….
T = ENSEMLE de REEL;
……………………………………………………………………………………………………………………………………………………………….
G = ENSEMLE de 'a' .. 'v';
………………………………………………………………………………………………………………………………………………………………..
X = ENSEMLE de CHAINE;
………………………………………………………………………………………………………………………………………………………………
c) Construction d'ensemble
Construire un ensemble, c'est constituer ses éléments. Un ensemble se construit grâce à la paire de crochets [ ]. La
syntaxe de construction d'un ensemble est la suivante : [Objets] où Objets peut être une liste d'éléments séparés par
des virgules ou bien 1 ou plusieurs intervalles séparés par des virgules ou bien la combinaison des deux (liste d'éléments
et intervalle). Mais tous les éléments constituant un même ensemble doivent nécessairement être du même
type.
Exemple:
Ainsi ['a', 'j', 'm'] est l'ensemble constitué des 3 caractères a, j et m.
[9, 7, 6, 25] est l'ensemble constitué des nombres 9; 7; 6 et 25.
[1..5, 8, 15..20] est l'ensemble constitué des nombres 1; 2; 3; 4; 5; 8; 15; 16; 17; 18; 19 et 20.
 Exercice 19 d'application : Ces constructions d'ensemble sont-elles correctes ?
['1', 1, 'z', 'P']; [a, b, c]; [-1..10, 25..50]; [1; 3..10]; [1.5, 45].
Réponses:
…………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………………
 Exercice 20 d'application: Dire si cette affirmation est correcte ou pas: "Une variable de type énuméré ne peut
recevoir qu'une seule valeur à la fois alors qu'une variable de type ensemble peut en recevoir plusieurs à la fois"
Réponse:………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………..
Remarque:
• L'ordre dans lequel sont mentionnées les expressions n'a aucune importance. Ainsi [5,7] et [7,5] définissent le même
ensemble ([5,7] = [7,5]).
• Il est possible de déclarer des constantes de type ensemble.
Exemple:

CONST
Voyelle = ['a', 'e', 'i', 'u', 'o', 'y'];
P = 10;
Valeurs = [P, 2*P, 3*P];
C ='e';
Lettres = [C, PRED (C), SUCC (C)];
 Exercice 21 d'application : Préciser le contenu des ensembles de l'exemple ci-dessus.
Réponses :
Valeurs = …………………………………………………
Lettres = ………………………………………………….
 Exercice 22 d'application : Les fonctions PRED, SUCC et ORD s'appliquent-elles au type ensemble ? Pourquoi ?
Réponse: ……………………………………………………………………………………………………………………………………………………..
……………………………………………………………………………………………………………………………………………………………………..
d) Les opérations portant sur les ensembles
• Affectation
TYPE
Voy = ENSEMBLE de CARACTERE;
VAR
T: Voy;
……….
T ['a', 'f'];
L'on peut faire l'affectation entre deux (2) ensembles mais il faudrait que ceux-ci soient constitués d'éléments de même
types.
 Exercice 23 d'application : Soit les déclarations suivantes :
TYPE
Voy = ENSEMBLE de CARACTERE;
Gt = ENSEMBLE de 15..50;
Vp = ENSEMLE de 'a' .. 'v';
VAR
T1, T2: Voy;
Y: Gt;
P: Vp;
Dire si les affectations ci-après sont correctes:
T1  Y; …………………………………………………………………………………………………………………………………………………….
P  Y; ……………………………………………………………………………………………………………………………………………………
T1  T2; ……………………………………………………………………………………………………………………………………………………..
• Réunion : +. Elle permet de fusionner les éléments de plusieurs ensemble, sans redondance.
Exemple: Ici A et B sont des ensembles.
A B A+B
[1, 3]……………………………………….. [2, 6]…………………………………………….. [1, 2, 3, 6]
[1, 3]……………………………………….. [4, 3]………………………………………………. [1, 3, 4]
[1, 5]……………………………………….[1, 5, 6]…………………………………………….. [1, 5, 6]
• Intersection : *. :L'intersection de deux(2) ensembles ou plus, l'ensemble formé des éléments appartenant à la fois
aux deux(2) ensembles ou plus.
Exemple :
A B A*B
[1, 3, 8]……………………………………. [1, 5, 8, 11]……………………………. [1, 8]
[1, 5]…………………………………………[1, 3, 5, 8]……………………………… [1, 5]
[3, 7]………………………………………… [2, 9, 11]………………………………… [ ]
• Différence : -. Soit A et A deux ensembles. A – B est l'ensemble formé des éléments appartenant à A et n'apparte-
nant pas à B (on retire de A, tout ce qui appartient à B). A – B  B – A

Exemple :
A B A– B
['a', 'c', 'f', 'k']………………………………. ['c', 'f']……………………………. ['a', 'k']
['a', 'b', 'c']………………………………… ['d', 'e']………………………… ['a', 'b', 'c']
['f', 'g']………………………………..['a', 'f', 'g', 'k']…………………………. [ ]
• L'instruction d'appartenance: DANS : Elle permet de savoir si un élément appartient à un ensemble ou pas.
Syntaxe: nom_variable DANS nom_variable_ensemble.
Exemple: TYPE
Lettres = ENSEMBLE de CARACTERE;
VAR
Voy: Lettres; C: CARACTERE;
………….
Voy ['a', 'A', 'e', 'E', 'y', 'Y', 'i', 'I', 'u','U', 'o', 'O'];
AFFICHER ('Entrez une lettre SVP!');
SAISIR (C);
SI C DANS Voy ALORS
DSI
AFFICHER ('Vous avez saisi une voyelle');
FSI;
…………………
• Les opérations de comparaison
▪ Egalité: =: A =B si A et B sont formés des mêmes éléments
▪  (inclusion): A  B si A est inclus dans B.
Exemple :
SI Lettres = ['a'..'z'] ALORS AFFICHER ('Ce texte contient toutes les lettres');
Si Lettres  ['a', 'e', ''i', 'o', 'u', 'y'] ALORS AFFICHER ('Ce texte ne contient que des voyelle');
Note 1 : Une affection à un ensemble en supprime les éléments qu'il contenait avant l'affectation. Si en
cours d'un programme, on souhaite ajouter ou supprimer un ou des élément(s) à l'ensemble, on doit uti-
liser les opérateurs additif + et soustractif - .
Note 2 : Il est impossible d'utiliser les procédures AFFICHER et SAISIR avec les variables de type en-
semble.
 Concevoir un algorithme permettant de déterminer le nombre de voyelles contenu dans un mot fourni en donnée.
 Ecrire un algorithme permettant de savoir si l'on a saisi une consonne ou pas.


6) Le type Enregistrement
a) Définition
La structure de type enregistrement est un mélange de valeurs de types différents (ENTIER, REEL, CARACTERE, CHAINE
DE CARACTERES, BOOLEEN, ENSEMBLE, INTERVALLE, TABLEAUX, ENREGISTREMENT…). En fait une variable de type
Enregistrement peut contenir plusieurs données à la fois de types différents.
La structure de type enregistrement est caractérisée par son nom, le nombre et le type de ses éléments appelés
champs.
b) Déclaration
La déclaration d'un type Enregistrement se fait dans la partie TYPE.
Syntaxe: TYPE
Nom_type_enregistrement = ENREGISTREMENT
Nom_élément1: type_élément1;
Nom_élément2: type_élément2; Les champs de l'enregistrement
……..
Nom_élément n: type_élément n;
FIN;
Après la déclaration d'un type Enregistrement dans la partie TYPE, il faudra par la suite, déclarer une variable de type
Enregistrement dans la partie Var et c'est celle-ci qui sera utilisée par la suite dans le programme.
Note : les champs d'une variable de type structuré peuvent être de tout type (même tableau) sauf de type fichier.
C) Intérêt
Le type Enregistrement sert à identifier dans les détails, un objet donné.
Exemple : pour identifier l'objet Produit, l'on a besoin :
▪ Du nom du produit ou libellé (CHAINE DE CARACTERES),
▪ De sa référence (CHAINE DE CARACTERES),
▪ Et de son prix de vente (REEL).
Ainsi pour définir le type enregistrement produit, l'on procédera comme suit :
TYPE
Produit = ENREGISTREMENT
Nom: CHAINE DE CARACTERE;
Reference: CHAINE DE CARACTERE;
Prix_vente : REEL;
FIN;
VAR Article: Produit;
d) Les opérations portant sur le type Enregistrement

L'on manipule les différents champs d'un enregistrement séparément, l'un après l'autre.
• L'on accède aux différents champs d'une variable de type enregistrement en précisant le nom de la variable, suivi
d'un point (.) et du nom du champ en question.
Ainsi pour accéder au champ reference de la variable Article, l'on procédera comme suit :
Article. reference.
• L'écriture consiste à affecter une valeur à un champ donnée et la lecture consiste à afficher ou à prendre posses-
sion du contenu du champ concerné.
Ecriture : Article.reference "A002" ; Article.nom  "Coca Cola";
Lecture : AFFICHER('Le nom recherché est:', article.nom);
P  Article.reference;
Définir un type Enregistrement Etudiant et permettant d'avoir les informations suivantes sur celui-ci: son nom et prénom,
sa classe, sa moyenne et son contact. Enfin affecter une valeur à chaque champ.

e) L'instruction AVEC…FAIRE
Elle est utilisée pour éviter de traîner à chaque fois le nom d'une variable de type Enregistrement.
Syntaxe: AVEC nom_variable_type_enregistrement FAIRE
………………………….
FIN;
Réécrire l'algorithme précédent en utilisant l'instruction AVEC…FAIRE.

f) Imbrication d'enregistrements
Une structure de données Enregistrement peut en imbriquer d'autres c'est-à-dire des enregistrement peuvent figurer à
l'intérieur d'un autre enregistrement.
Exemple : TYPE
Contact = ENREGISTREMENT
Telephone: CHAINE [10];
Boite_postale: CHAINE [15];
Lieu_habitation: CHAINE [25];
FIN;
Personne = ENREGISTREMENT
Nom: CHAINE [15];
Prenom: CHAINE [25];
Taille: REEL;
Ct: Contact; (* Imbrication *)
FIN;
VAR
P: Personne;
Ainsi, l'on aura par exemple :
P.Nom  "YAPI";
P.Prenom  "Yapo Claude";
P.Taille  1,80;
P.Ct.telephone  "09 10 25 78";
P.Ct.Boite_postale  "15 BP 145 Abidjan 15";
P.Ct.Lieu_habitation  "Abidjan, Cocody, 2 Plateaux";
Proposer un algorithme permettant de saisir les informations (nom et prénom, date et lieu de naissance, taille, groupe
sanguin) concernant les étudiants d'une classe dont l'effectif s'élève à 50.

g) Passage d'enregistrement en paramètre à une fonction ou à une procédure

Au niveau du paramètre formel, déclarer une variable de type, le type Enregistrement déclaré dans la partie TYPE. Au
niveau du paramètre réel, utiliser une variable déclarée dans la partie VAR, de type l'enregistrement déclaré dans TYPE
et utiliser cette dernière.
Exemple
ALGORITHME essai;
TYPE
T= ENREGISTREMENT
nom_P: CHAINE[40];
classe: CHAINE[10];
moyenne: REEL.
FINENRG;
VAR
eleve: T;
I: ENTIER;
PROCEDURE calculer_moyenne(VAR pt: T); (* pt de type T déclaré dans la prtie TYPE *)
VAR e: ENTIER; St, note: REEL;
DEBUT (* Début du corps de la fonction calculer_moyenne *)
St  0;
DPOUR
AFFICHER('Entrez la note n°', e);
SAISIR(note);
St  St + note;
FPOUR;
Pt.moyenne  St / 3;
AFFICHER('La moyenne de l'étudiant ' , Pt.nom_P ,'vaut' , Pt.moyenne);
FIN; (* Fin du corps de la fonction calculer_moyenne *)
POUR I  1 à 50 FAIRE (* Parcours des 50 étudiants *)
DPOUR
AFFICHER('Entrez le nom et prénom de l'étudiant n° ', I
SAISIR(eleve.nom_P);
AFFICHER('Entrez la classe de l'étudiant n° ', I);
SAISIR(eleve.classe);
calculer_moyenne(eleve);  (* Appel de la fonction calculer_moyenne, en mentionnnant simplement le nom de la var eleve *)
FPOUR;
 Note: Ici, l'on a transmis toutes les informations contenues dans la variable eleve ,à savoir le contenu du champ nom_P et celui du champ classe
qu'on a saisis, à la procédure calculer_moyenne. Pendant cette transmission, le champ moyenne n'etait pas encore renseigné, c'est-à-dire n'avait
pas encore de valeur. Il aura sa valeur dans la procédure calculer_moyenne.
Puisque c'est pour modifier le champ moyenne de la variable eleve qu'on a appelé la procédure calculer_moyenne, l'on pouvait au niveau du 
dans l'algorithme, faire ceci: calculer_moyenne(eleve.moyenne); Dans ce cas, au niveau de la définition de la procédure calculer_moyenne, le
paramètre serait de même type que eleve.moyenne, c'est-à-dire un réel: VAR pt: REEL.
 Exercice 28 d'application: Préciser la quantité de mémoire centrale occupée par les déclarations suivantes :
Déclarations Quantité mémoire occupée par la/les déclaration(s)

VAR som : ENTIER ;
VAR moy : REEL
VAR Tab : TABLEAU[100] de ENTIER;
VAR nom : CHAINE[20] ;
VAR prenom: CHAINE;

VAR x, y, z : ENTIER ;
VAR tab1, tab2 : TABLEAU[10][15] de ENTIER;
VAR Tab: TABLEAU[15] de CHAINE[10];

Type persone = ENREGISTREMENT
nom, prenom : CHAINE[20] ;
age : ENTIER ;
tel : CHAINE ;
FIN;
VAR client, fournisseur : personne ;
Type Contact = ENREGISTREMENT
Num_tel: CHAINE[8];
Lieu_hab: CHAINE[25];
FIN;
Type persone = ENREGISTREMENT
nom, prenom : CHAINE[20] ;
age : ENTIER ;
Ct: Contact ;
FIN;
VAR clt : personne ;
OPTIMISATION D'UN PROGRAMME

Définition : Optimiser un programme informatique, c'est le rendre de telle sorte qu'il :
▪ Occupe moins de place dans la mémoire centrale lors de son chargement en vue de son exécution,
▪ Que le microprocesseur mette moins de temps pour l'exécuter.
Comment optimiser un programme ?
▪ Utiliser le moins de variable possible,
▪ Eviter d'allonger inutilement le programme par l'utilisation d'instructions non nécessaires,
▪ Utiliser les solutions les plus simples et les plus courtes.
 Exercice 29 d'application : Soit cet algorithme ci-après. L'on vous demande de l'optimiser.
ALGORITHME essai; Solution
VAR
I, J: ENTIER;
a, b, c, S1, S2, Som, Moy: REEL;
DEBUT
I 0;
AFFICHER('Entrez le 1 ère note');
SAISIR(a);
I  I + 1;
AFFICHER('Entrez la 2e note');
SAISIR(b);
I  I + 1;
S1  a+ b;
AFFICHER('Entrez la 3e note');
SAISIR(c);
S2  S1 + c;
I  I + 1;
J  I;
Som  S2;
Moy  Som/J;
AFFICHER('LA moyenne des 3 notes est:' , Moy);
FIN;

TEST N°3
But : Maîtriser la manipulation des structures de données statiques.
EXERCICE1
Concevoir un algorithme qui prend en entrée dix (10) réels et qui les retourne triés par ordre croissant.
EXERCICE2
L’on entre vingt (20) nombres réels au clavier. Concevez une application qui permet de déterminer le plus petit de ces 20
nombres et la position qu’il occupe dans l’ordre de saisie.
EXERCICE3
Concevoir un algorithme permettant à un utilisateur de saisir une phrase terminée par un point et de:
▪ Remplacer une lettre par une autre,
▪ Compter et éditer le nombre de mots que compte cette phrase.
Remarque:
✓ Cette phrase ne comportera que des virgules et un point comme ponctuation.
✓ L'utilisateur saisira la lettre à remplacer et la lettre remplaçante.
EXERCICE4
Proposer un algorithme permettant de classer par ordre alphabétique, une liste de cinq noms.
Note: Ne pas utiliser l'opérateur < ou > pour la comparaison des noms.
EXERCICE5
La société NEKOMAT a douze (12) employés. Le directeur voudrait pour chaque mois, savoir le salaire le plus élevé et le
moins élevé. De plus, il aimerait avoir le salaire le plus fréquemment payé, c'est-à-dire le salaire reçu par un plus grand
nombre d’employés.
Concevez un algorithme permettant d’assouvir le besoin du directeur.
EXERCICE6
Mettre en place un algorithme permettant de ranger dans une même chaîne de caractères, les éléments dans l'ordre
inverse. Exemple: "BONJOUR" au départ, et "RUOJNOB" à l'arrivée.
EXERCICE7
Une grande école, dans le cadre du paiement des droits d'examen de ses étudiants en 2 e année, a ouvert un guichet
spécialement pour recueillir ces droits d'examen. Les filières au sein de l'établissement sont: IG, NTIC, ELN et TLCOM.
Les effectifs sont:
✓ IG: 25
✓ NTIC: 50
✓ ELN: 30
✓ TLCOM: 45.
La paie des droits d'examen est fixée à une date précise et pendant toute cette journée, le guichet est mis à la disposi-
tion des étudiants.
Chaque étudiant qui paie ses droits, est enregistré par la saisie de son nom, son prénom, sa filière et son matricule.
A la fin de la journée, l'administration voudrait savoir:
▪ Le nombre total des étudiants qui ont payé leur droit,
▪ Le nombre d'étudiant s'ayant acquitté de leur droit d'examen et ceux ne l'ayant pas fait; ceci par filière.
NB: Pour ceux qui ont payé, afficher leur nom, leur prénom, leur matricule et leur filière.
▪ Le nombre total des étudiants qui n'ont pas payé leur droit.
Concevoir un algorithme répondant aux besoins de l'administration.
EXERCICE8
L’école primaire Notre Dame de Treichville voudrait encourager l’excellence en octroyant des prix aux meilleurs élèves.
Notre Dame de Treichville a six (6) classes et chaque classe comporte trente (30) élèves.
La composition de passage est basée sur cinq (5) matières de coefficient chacune. Le classement est effectué par classe
et l’on affiche le nom, la moyenne et le rang de l’élève par ordre de mérite.
1) Concevoir un algorithme permettant d’effectuer le classement de cette école.
2) Modifier l'algorithme précédent afin de prendre en compte désormais la mention de l'élève.
Note: Pour la mention, nous retiendrons ceci:
✓ <10: Médiocre,
✓ [10; 12[: Passable,
✓ [12; 14[: Assez Bien,
✓ [14; 16[: Bien,
✓ [16; 18]: Très bien,
✓ ]18; 20]: Excellent.

EXERCICE9
Monsieur NEKOMAT, désirant connaître ses dépenses mensuelles et annuelles, vous sollicite pour l'aider à mettre en
place un algorithme pour assouvir son besoin.
L'on considéra que les 12 mois de l'année compte chacun 30 jours et que la saisie des dépenses est journalière.
Les dépenses se présentent comme suit:
▪ Dépenses journalières:
✓ Frais de transport
✓ Frais alimentaires
✓ Frais de communication
✓ Divers.
▪ Dépenses supplémentaires effectuées à chaque fin de mois
✓ Loyer,
✓ Argent de poche de la famille.
▪ Dépenses supplémentaires effectuées à chaque bimensuel
✓ Montant facture CIE,
✓ Montant destiné à la grande famille.
▪ Dépenses supplémentaires effectuées à chaque trimestre
✓ Montant facture SODECI.
1) Proposer un algorithme lui permettant de savoir:
▪ Ses dépenses mensuelles, et
▪ Ses dépenses annuelles.
2) Modifier l'algorithme précédent afin que désormais, l'on puisse savoir le mois où il a le plus dépensé en plus de savoir
ses dépenses mensuelles et annuelles.
NB: Tout calcul débutera le 1er jour du mois n°1.
EXERCICE 10
Vers les pays
Commutateur 2
INTERNATIONAL Commutateur 3 KORHOGO
Commutateur 1
ABIDJAN
Commutateur 4 DALOA
Usager
Commutateur 5 BOUAKE
Commutateur 6
Yamoussoukro

Le responsable d'une entreprise de téléphonie fixe, basée à Abidjan, vous sollicite pour mettre en place un programme
informatique pour gérer son commutateur installé à Abidjan.
En effet, le programme informatique devrait permettre de déterminer la destination des appels effectués par les clients
lorsque ceux-ci composent leurs numéros téléphoniques: Appels internationaux ou nationaux.
Pour composer un numéro à l'international, les usagers composent d'abord 00, suivi du code du pays et enfin le numéro
téléphonique de leur correspondant, comme suit: 00<Code du pays><n° correspondant>. Le code du pays étant sur 1,
2 ou 3 chiffres.
Pays Code indicatifs
Burkina Faso 226
Mali 223
Sénégal 221
Ghana 233
Ainsi, pour joindre un correspondant au Burkina Faso, dont le numéro est le 76 43 10, je fais: 00 226 73 43 10.
Ainsi une fois un numéro est composé depuis Abidjan, l'appel de l'usager parvient au niveau du commutateur 1, qui va
analyser si l'appel est destiné à l'international ou au national (en Côte d'Ivoire).
• S'il est international, le commutateur 1 oriente l'appel vers le commutateur 2 qui à son tour l'envoie vers le pays con-
cerné.
• S'il est national, on a les cas suivants:
✓ Si le numéro composé débute par 3685 ou 3686, c'est que l'appel est en direction de Korhogo. Dans ce
cas, le commutateur 1 oriente l'appel vers le commutateur 3.
✓ Si le numéro composé débute par 3278, c'est que l'appel est en direction de Daloa. Dans ce cas, le
commutateur 1 oriente l'appel vers le commutateur 4.
✓ Si le numéro composé débute par 3163 ou 3164, c'est que l'appel est en direction de Bouaké. Dans ce
✓ Si le numéro composé débute par 3064, c'est que l'appel est en direction de Yamoussoukro. Dans ce
✓ Si le numéro composé débute par 20, 21, 22, 23 ou 24, c'est que l'appel est local, c'est-à-dire au ni-
veau d'Abidjan. Dans ce cas, le commutateur 1 oriente l'appel directement vers le destinataire.
Concevoir un algorithme permettant de déterminer:
▪ Le commutateur vers lequel l'appel sera orienté ou si l'appel est local,
▪ Pour l'international, afficher le pays destinataire,
▪ Pour le national, afficher la ville destinataire.
Note: Pour l'algorithme, l'on se bornera aux 4 pays et aux 5 villes mentionnés ci-dessus.

CHAPITRE 8 : LES FICHIERS

OBJET : Ce chapitre traite d'une structure de donnée plus évoluée permettent de sauvegarder des données sur un sup-
port de sauvegarde (Disque dur, disquette, clé USB…), lors de l'exécution d'un programme informatique.
OBJECTIF : A la fin de ce chapitre, vous devrez être à mesure de percevoir l'intérêt de la structure de donnée FICHIER
et de pouvoir l'utiliser, pour résoudre tel ou tel problème informatique.
Introduction
Les structures de données étudiées jusqu'ici, servaient à décrire, à manipuler des informations situées en mémoire cen-
trale. Ainsi après avoir quitté la fenêtre d'exécution de notre programme, les données que nous avons saisies et qui ont
servies à l'exécution de notre programme, sont perdues et donc aucune possibilité de les conserver.
Pour palier cet état de fait, car nous avons besoins très souvent de conserver des données (par exemples concernant
une entreprise, les comptes bancaires, des données personnelles…), l'on a introduit une structure de données qui va
permettre de manipuler (créer ou utiliser) des informations sur un support externe tel que le disque dur, la disquette, la
clé USB…supports capables de conserver les données et de les restituer à temps voulu : la structure de donnée FI-
CHIER.
1) Définition
Un fichier est un ensemble ordonné de données présentant une même structure et pouvant être consultées individuelle-
ment. Cet ensemble de données (fichier) est sauvegardé généralement sur le disque dur (support de sauvegarde par
excellence), bien que cet ensemble de données puisse être également sauvegardé sur une disquette ou une clé USB. La
sauvegarde est effectuée sur un support de masse afin de permettre un usage ultérieur des données même après
un long temps.
Il existe deux (2) catégories de fichiers: Les fichiers-système (qui appartiennent au système d'exploitation) et les fichiers
de flux de données. Les fichiers de flux de données se subdivisent en deux (2) parties:
▪ Les flux de texte: Fichiers constitués de suite de caractères, interprétés comme données intrinsèques ou comme
composants de chaîne de caractères.
▪ Les flux binaires: Fichiers dont les données sont en blocs donc structurés et où tous les blocs du même fichier ont
une taille identique et fixe.
C'est ce dernier type de fichier qui est le plus utilisé et donc va faire l'objet de notre étude.
La structure de base des informations stockées dans un fichier est l'enregistrement.
Enregistrement n° 0 Enregistrement n° 1 Enregistrement n° 2 …………………. Enregistrement n° n
FICHIER
Note : Les numéros des enregistrements débutent toujours par zéro (0).
C'est en fait une base de données que nous allons créer par programmation. En effet, on saisit d'abord les données
dans la structure de données Enregistrement, puis l'on se sert de la structure de données Fichier pour pouvoir sauvegar-
der ces données saisies, sur le support de masse. Ainsi une fois les données sont mémorisées sur le support de masse,
pour les manipuler (consultation, destruction, modification, insertion…), l'on va également se servir de la structure de
données Fichier. C'est dons une structure de données un peu particulière.
Note : Le terme Fichier ici, st pratiquement semblable à la notion de Fichier en système d'exploitation.
2) Déclaration
La structure de données Fichier est généralement déclarée dans la partie VAR mais il faut auparavant déclarer l'enregis-
trement qui sera la structure de base du fichier (dans la partie TYPE).
Syntaxe: VAR nom_var_fichier: FICHIER de enregistrement_de_base;
Exemple:
TYPE
Nom: CHAINE;
Contact: CHAINE;
FIN;
VAR
Rept: FICHIER de Personne;
Id: Personne;

…………………………………………………
3) L'accès au fichier
L'utilisation d'un Fichier est précédée des deux (2) étapes suivantes:
▪ d'abord la création du fichier et
▪ enfin l'ouverture du fichier pour une lecture ou une écriture.
a) La création du Fichier ou l'assignation

La création d'un Fichier consiste à aménager un espace sur un support de sauvegarde (disque dur, la disquette, la clé
USB…) afin d'y enregistrer le contenu de ce fichier, dans le cas où il s'agit d'un nouveau Fichier que l'on crée. Si le Fi-
chier existe déjà, l'assignation dans ce cas, consiste à créer un lien pour atteindre ledit Fichier.
En programmation, la création d'un Fichier nécessite deux (2) noms:
 Le nom physique qui est le nom réel du Fichier sur le support de sauvegarde. A ce niveau, il s'agit de spé-
cifier le chemin d'accès complet de ce fichier c'est-à-dire de préciser le support de sauvegarde sur lequel nous allons
enregistrer ledit Fichier, ensuite l'éventuel Répertoire (En fait nous ne sommes pas obliger de préciser un quelconque
répertoire. Tout est au choix du programmeur) dans lequel nous allons y mettre le Fichier, et enfin le nom même du
fichier.
Exemple: C: \devoirs \ essai.txt Ici le support de sauvegarde est le disque dur (C:), le répertoire dans lequel nous
allons mettre notre Fichier est 'devoirs' et enfin le nom même du Fichier est 'essai.txt'.
 Le nom logique du Fichier ou nom de travail, qui est le nom utilisé dans le programme. Il s'agit d'un nom
simple (comme un nom de variable).
L'intérêt d'utiliser le nom logique dans le programme, est que celui-ci a généralement une écriture simple et donc évite
de traîner le nom physique généralement long, tout au long du programme.
La création d'un fichier se fait en utilisant le mot clé ASSIGNER comme suit:
Syntaxe: ASSIGNER(nom_logique_du_fichier, ' nom_physique_du_fichier');
Exemple: ASSINGER( ft, 'C:\devoirs\essai.txt'); Ainsi c'est ft qui sera utilisé pour désigner le fichier 'C:\devoirs\essai.txt'
dans tout le programme.
 Cette instruction crée donc le fichier essai.txt qui se trouve dans le répertoire devoirs et qui à son tour est sur le
disque dur C:. Le fichier ainsi créé portera le nom ft dans tout le programme.
b) L'ouverture du Fichier
Après la création du fichier, il faut à présent l'ouvrir afin d'y insérer des données (écriture) ou de rentrer en possession
de ses données (lecture). Cette opération consiste à créer une zone tampon (au niveau de la mémoire centrale) pour la
lecture ou l'écriture. Bref, pour la manipulation des données à insérer dans le fichier ou à prendre dans le fichier.
L'ouverture d'un Fichier utilise différemment deux (2) mots clés:
REECRIRE qui permet d'ouvrir le fichier avec écrasement : On l'utilise lorsqu'on vient de créer nouvellement un fichier
ou si l'on désire effacer tout le contenu d'un fichier existant.
RELIRE qui permet d'ouvrir le fichier sans écrasement : On utilise lorsqu'on veut ouvrir un fichier déjà existant, sans
effacer ses données.
Syntaxe: REECRIRE( nom_logique_du_Fichier);
RELIRE( nom_logique_du_Fichier);
Exemple:
REECRIRE(ft); Ainsi le fichier dont ft représente (c'est-à-dire C:\devoirs\essai.txt ), s'il n'existe pas, il sera créé.
Mais s'il existe, tout son contenu sera écrasé (effacé).
RELIRE(ft); Ainsi le fichier dont ft représente (c'est-à-dire C:\devoirs\essai.txt ) sera ouvert simplement, sans af-
fectation de son contenu. Mais bien sûr ici, il faut nécessairement que le fichier dont ft représente, existe.
4) Les différentes opérations sur un fichier

Il faudrait entendre par opérations sur un fichier, les actions que nous pouvons effectuer sur ce fichier.
Pour le cours, nous nous limiterons aux opérations suivantes :
 L'écriture dans un fichier,
 La lecture du contenu d'un fichier,
 La modification des données d'un fichier existant,
 La recherche de données dans un fichier,
 La destruction d'un fichier.

a) L'écriture dans un Fichier

C'est l'opération qui consiste à enregistrer des données dans le Fichier. Cet enregistrement de données peut être à la fin
du fichier ou à tout autre endroit du Fichier.
Le mot clé utilisé pour l'écriture est ECRIRE.
Syntaxe: ECRIRE(nom_logique_du_Fichier, nom_variable_type_enregistrement);
Exemple: TYPE
Nom: CHAINE;
Contact: CHAINE;
FIN;
VAR
Rept: FICHIER de Personne;
Id: Personne;
…………………………………………………
ECRIRE(Rept, Id);
…………………………………………………
 Pour utiliser un Fichier en écriture pour la 1 ère fois (il s'agit d'un nouveau Fichier vierge), il faudra suivre les
étapes suivantes, dans l'ordre :
▪ L'assignation du fichier (dans ce cas, il s'agit de la création proprement dite du Fichier sur le support de sau-
vegarde car c'est un nouveau Fichier) : ASSIGNER.
▪ L'ouverture du Fichier avec écrasement : REECRIRE (car c'est un nouveau Fichier).
▪ L'écriture proprement dite : ECRIRE. Elle consiste à inscrire des données dans le fichier.
▪ La fermeture du Fichier : Le mot clé utilisé est FERMER. En effet après l'utilisation d'un Fichier, il faut néces-
sairement le fermer avant de quitter le programme. En fait la fermeture du Fichier consiste à supprimer la
mémoire tampon créée par l'ouverture du Fichier.
Syntaxe : FERMER (nom_logique_du_fichier); Exemple : FERMER(Rept);
 Pour un Fichier contenant déjà des données, les étapes sont identiques aux précédentes mais à une petite différence
près :
▪ L'assignation du Fichier,
▪ L'ouverture du Fichier sans écrasement : RELIRE, (car on aimerait pas écraser les données du Fichier).
▪ L'écriture proprement dite,
▪ La fermeture du Fichier.
Fichier
Données
……………
………….. Disque dur
Mémoire tampon
Mémoire centrale
b) La lecture du Fichier
C'est l'opération qui consiste à prendre possession des données se trouvant dans le Fichier (une partie des données du
fichier ou toutes ses données.). En fait, c'est une simple copie de ses données.
Pour utiliser un fichier en lecture, il faudra suivre dans l'ordre, les étapes ci-après:
▪ L'assignation du fichier (dans ce cas, il s'agit de créer un lien pour atteindre le Fichier déjà existant): ASSI-
GNER.
▪ L'ouverture du Fichier sans écrasement: RELIRE.
▪ La lecture proprement dite: Le mot clé utilisé est LIRE qui permet de lire le fichier enregistrement après
enregistrement.
Syntaxe: LIRE(nom_logique_du_Fichier, nom_variable_type_Enregistrement);
Exemple: LIRE(Rept, Id);
▪ Affichage si nécessaire des données lues du Fichier: AFFICHER
Syntaxe: AFFICHER(champ_de_l'_enregistrement_constituant_le_Fichier);

Exemple: AFFICHER(Id.contact);
Note: Ici l'affichage se fait ici champ par champ.
▪ La fermeture du Fichier: FERMER.
Fichier
Données 1
2
……………
Ecran
OU Mémoire tampon
Mémoire centrale
OU bien
Fichier
Données
……………
Mémoire tampon
Mémoire centrale
C) Recherche de données dans le Fichier

Il s'agit de rentrer en possession des données de tel ou tel enregistrement en utilisant le numéro de l'enregistrement.
La recherche peut s'effectuer de deux (2) manières :
▪ L'Accès direct, c'est à dire que l'on va se positionner directement sur l'enregistrement dont le numéro a été
fourni. Ici, on saisit le n° de l'enregistrement désiré et l'on se positionne là-dessus pour lire les données s'y trouvant.
Donc sel un seul enregistrement est concerné, celui dont le n° a été saisi. Pour l'accès direct, le mot clé utilisé est:
RECHERCHER.
Syntaxe: RECHERCHER(nom_logique_du_Fichier, n°_Enregistrement);
Exemple: RECHERCHER(Rept, 3); Ainsi l'on va se positionner sur l'enregistrement n°3 (c'est-à-dire le 4e Enregistre-
ment car les ° débutent par 0) du Fichier dont l'alias (nom logique) est Rept.
▪ L'Accès séquentiel, c'est à dire que l'on va parcourir tout le fichier à la recherche des données répondant à
tel ou tel critère. Ici la recherche par contre, porte sur le critère qu'on aura à saisir. Ici plusieurs enregistrements peu-
vent être concernés. Ici, il n'y a pas de mot clé. On se contente de parcourir seulement le Fichier.
Ainsi les étapes pour
la recherche de données dans un fichier, dans l'ordre, sont :
• L'assignation,
• L'ouverture du Fichier sans écrasement,
• La recherche des données : par accès direct ou séquentiellement (out dépend du problème à ré-
soudre),
• La lecture des données
• L'affichage de ces données,
• La fermeture du Fichier.

 Concevoir un algorithme permettant de rechercher les données d'un enregistrement quelconque, par la saisie du n°
de cet enregistrement, du Fichier déjà existant, portant le nom physique C:\eleve.doc.
 Ecrire un algorithme permettant d'afficher les informations concernant les personnes ayant le nom ' Koffi '. Toutes
les données se trouvent dans le Fichier de nom physique C:\bases\essai.text.
Remarques : L'on considérera que les différents Fichiers contiennent déjà des données.
Utilisez comme enregistrement de base aux deux fichiers, celui là :
Nom: CHAINE [40];
Contact: CHAINE [20];
FIN;


d) Modification des données d'un Fichier.

Il faudrait entendre ici par 'Modification des données d'un Fichier', la modification de certaines données déjà
existantes dans le Fichier ou l'ajout de nouvelles données (donc de nouveaux enregistrements), soit à la fin du Fichier ou
à tout autre endroit dudit Fichier (extension donc du Fichier).
Dans le 1er cas, les étapes sont les suivantes :
▪ L'assignation du fichier
▪ L'ouverture sans écrasement, du fichier
▪ La recherche de l'enregistrement à modifier
▪ La lecture des données
▪ L'affichage des données
▪ La modification des données (la saisie de nouvelles valeurs)
▪ L'écriture des nouvelles valeurs saisies, dans le Fichier
Dans le 2e cas (extension du Fichier), les étapes sont les suivantes :
▪ L'assignation du fichier
▪ L'ouverture sans écrasement, du fichier
▪ Se mettre à l'endroit voulu du fichier
▪ Acquisition des nouvelles valeurs à insérer (Les nouveaux enregistrements)
▪ L'écriture des nouvelles valeurs saisies, dans le fichier
Concevoir un algorithme permettant de modifier le champ Contact de la personne ayant pour prénom 'Yao Séry', dans
le fichier possédant le nom physique C:\bases\eleve.doc et d'enregistrement de base:
TYPE
Nom: CHAINE [20];
Prenom: CHIANE [30];
FIN;
Réponse:

e) La suppression d'un Fichier

Supprimer ou détruire un fichier revient à l'effacer du support de sauvegarde. Le mot clé utilisé pour la suppression d'un
fichier est DETRUIRE.
Syntaxe: DETRUIRE(nom_logique_du_Fichier);
Exemple: DETRUIRE(Rept);
Les étapes de la suppression d'un fichier sont les suivantes:
▪ L'assignation du fichier,
▪ L'ouverture sans écrasement, di fichier,
▪ L'éventuelle utilisation du fichier (Lecture, écriture, modification, recherche…)
▪ La fermeture du Fichier,
▪ La destruction de Fichier.
5) Le parcours des données d'un Fichier
Le parcours des enregistrements d'un Fichier est effectué grâce à un Index qui permet de nous situer sur quel enregis-
trement nous sommes au niveau du fichier (le fichier est constitué d'un ensemble d'enregistrements).
 A l'ouverture d'un Fichier, l'index est positionné automatiquement sur le 1 er enregistrement c'est-à-dire l'enregistre-
ment n°0.
 Après la lecture ou l'écriture d'un enregistrement, l'index passe automatiquement à l'enregistrement suivant.
 L'enregistrement pointé par l'index est appelé Enregistrement courant. Ainsi le lecture ou l'écriture est toujours
porté sur l'enregistrement courant, c'est-à-dire l'enregistrement pointé par l'index.
 Exercice 3 d'application : Soit un Fichier constitué de sept (7) enregistrements.
 A l'ouverture du fichier, quelle est la situation (la position de l'index) ?
Enrg n°0 Enrg n°1 Enrg n°2 Enrg n°3 Enrg n°4 Enrg n°5 Enrg n°6
Réponse:……………………………………………………………………………………………………………………………………………………………
 Après la lecture de l'enregistrement n° 0, préciser la position de l'index.
Réponse:……………………………………………………………………………………………………………………………………………………………
 A ce moment précis, l'on veut écrire dans le Fichier. Préciser l'enregistrement dont les données seront affectées.
Pourquoi ?
Réponse:…………………………………………………………………………………………………………………………………………………………..
 L'on veut modifier les données de l'enregistrement n°6. Que doit-on faire ?
Réponse:………………………………………………………………………………………………………………………………………………………….
 A la fin de la modification (qui est matérialisée par une écriture dans l'enregistrement n°6), où l'index va-t-il se si-
tuer ?
Réponse:……………………………………………………………………………………………………………………………………………………………
 Nous voulons actuellement débuter la lecture entière de tout le Fichier. Où devons-nous positionner l'index? Ecrire
l'instruction qui permet de faire cela.
Réponse:…………………………………………………………………………………………………………………………………………………………..
6) Les fonctions supplémentaires utilisables sur un Fichier

Nous avons:
FIN_FICHIER (nom_logique_du_Fichier); Permet de savoir si nous sommes à la fin du fichier ou pas. En effet si
nous sommes à la fin du fichier, cette fonction renvoie VRAI; et FAUX dans le cas contraire.
Exemple: TANT QUE NON FIN_FICHIER(Rept) FAIRE………
TAILLE(nom_logique_du_Fichier); Permet de renvoyer le nombre d'enregistrements que le Fichier en question
contient.

Exemple: POUR I  0 à TAILLE(Rept) FAIRE……

Soit l'enregistrement suivant:
TYPE
Etudiant = ENREGISTREMENT
Nom: CHAINE [20];
Prenom: CHAINE [30];
Classe: CHAINE [15];
Taille: REEL;
FIN;
 L'on voudrait créer un Fichier ayant l'enregistrement ci-dessus comme base d'information. L'insertion d'informations
dans le Fichier se fera jusqu'à ce qu'on ne rentre plus de valeur pour le nom.
Concevez l'algorithme permettant d'assouvir ce besoin.
 Ecrire un algorithme permettant de visualiser tout le contenu du Fichier précédemment créé (au niveau du  ).
 A partir du Fichier créé au niveau du , concevoir un algorithme permettant de rechercher un nom donné, dans ce
Fichier.


TEST N°4
BUT : Maîtriser la manipulation des fichiers.
EXERCICE 1
L’on considère un fichier de chemin d’accès C:\TP\produits.txt contenant déjà des données sur des produits.
Chaque produit est identifié par son nom, sa référence et son prix de vente. Mettre en place un algorithme
permettant de mettre à jour le prix de vente de produits donnés.
Note: La recherche de produit se fera sur la base de son nom.
EXERCICE 2
1) Concevoir un algorithme qui permet de créer séquentiellement un fichier nommé répertoire compor-
tant pour chaque personne :
▪ Nom (20 caractères maximum),
▪ Prénom (25 caractères maximum),
▪ Age (entier),
▪ Numéro de téléphone (11 caractères maximum)
Les informations relatives aux différentes personnes seront lues au clavier et l’insertion d’informations se fera
jusqu’à ce qu’on ne rentre plus de valeur pour le nom.
2) Ecrire un algorithme permettant de lire le fichier précédemment créé.
EXERCICE 3
Créer sur un support de stockage, puis afficher à l’écran le fichier Famille.txt dont les informations sont structu-
rées de la manière suivante :
▪ Nom de famille
▪ Prénoms du père
▪ Prénoms de la mère
▪ Nombre d’enfants
▪ Prénoms des enfants.
Le nombre d’enregistrements à créer, est saisi au clavier par l’utilisateur.
NB : Le nombre de rubriques des enregistrements varie avec le nombre d’enfant.
EXERCICE 4
Le Sous Préfet de OUELLE vous sollicite pour mettre en place une application permettant l’établissement des
extraits d’acte de naissance de sa sous préfecture. L’on retiendra le numéro de l’extrait, le nom et prénom de
l’intéressé, la date et le lieu de naissance, le nom, le prénom de chaque parent.
Cet algorithme permettra à partir d’un menu :
▪ D’ajouter des données,
▪ De modifier des données,
▪ D’en faire des consultations
▪ De supprimer des données.
Proposer un algorithme pour assouvir le besoin du Sous Préfet.
NB : Pour une question de logique, veillez créer d'abord un fichier au choix, puis y ajouter des données avant d'effec-
tuer les autres opérations (modification, consultation et suppression).

EXERCICE 5
Cet exercice est une amélioration de l'exercice 4. L'on voudrait désormais qu'au lancement du programme,
l'utilisateur fasse le choix entre la création d'un nouveau fichier ou l'exploitation d'un fichier déjà existant. Pour
le choix de la création du nouveau fichier, la logique voudrait que l'utilisateur y insère des données avant de
passer aux autres opérations (modification, consultation et suppression des données). Si d'aventure, juste
après la création du nouveau fichier, l'utilisateur désire effectuer une de ces opérations: modification, consul-
tation et suppression de données, sans auparavant insérer des données dans le fichier, qu'une message
d'avertissement lui soit envoyer et que l'opération lui soit refusée.
Pour l'exploitation d'un fichier déjà existant, l'utilisateur devrait saisir le chemin d'accès complet du fichier (car il
peut exister plusieurs fichiers créés).
Proposer un algorithme pour assouvir ce besoin, tout en s'appuyant sur l'exercice 4.
EXERCICE 6
Cet exercice est une amélioration de l'exercice 5 mais cette fois-ci avec le menu ci-après:
▪ Création d'un fichier (une nouvelle base de données),
▪ Ajout de données,
▪ Modification de données,
▪ Consultations
▪ Suppression de données,
▪ Modification des mots de passe.
Pour sécuriser les données gérées par l'application, l'on a établi 2 catégories d'utilisateurs :
✓ Catégorie 1 : Administrateur; Mot de passe initail : admin1usagerroot
✓ Catégorie 2 : Utilisateur, Mot de passe initial : util2azert45d
La 1ère catégorie a accès à toutes les parties du logiciel, tandis que le 2 e catégorie n'a seulement accès qu'à
une partie du logiciel (Ajout de données, Consultations).
Au lancement de l'application, les usagers doivent obligatoirement s'authentifier par la saisie de la catégorie
et du mot de passe. Une fois les 2 informations ci-dessus validées, alors ils ont maintenant accès à leurs diffé-
rentes ressources respectives. A part la création de fichier et la modification des mots de passe, les autres opé-
rations nécessitent l'entrée du nom complet du fichier à exploiter (car il peut exister plusieurs fichiers créés).
Proposer un algorithme permettant de mettre en œuvre l'application et de la sécuriser par des comptes utili-
sateurs (catégorie + mot de passe) munis de droits d'accès.

CHAPITRE 9 : LES STRUCTURES DE DONNEES DYNAMIQUES

OBJET : Ce chapitre se penche sur des structures de données encore plus évoluées.
OBJECTIF : A la fin de ce chapitre, vous devrez être à mesure de pouvoir utiliser les pointeurs.
Introduction
Dans les cours précédents, nous avons vu et étudié des structures de données dites " statiques". Avec celles-ci, d'abord
la réservation de l'espace mémoire, une fois faite, demeurait jusqu'au terme de l'exécution du programme. Ensuite, par-
fois pour gérer une certaine quantité d'informations, nous sommes obligés de faire une importante réservation d'espace
mémoire, de peur de débordement qui en réalité, seule une partie est réellement utilisée : gaspillage d'espace mémoire.
Enfin, ces structures sont utilisées isolement.
Pour résoudre certains problèmes de manière optimale, nous avons besoin de juste utiliser l'espace mémoire qu'il faut,
de libérer un espace mémoire dont on n'a plus besoin après utilisation et enfin de chaîner des structures c'est-à-dire de
les lier entre elles pour ainsi construire des structures plus complexes et plus souple. D'où la notion de structure de
données dynamique dont le leitmotiv est le pointeur.
Le terme 'dynamique' signifie que la taille de ces structures de données n'est pas figée : elle peut s'agrandir ou rétrécir,
au besoin. Donc permet de gérer l'espace mémoire de manière optimale.
En effet, c'est avec les structures de données dynamiques que l'on conçoit les jeux informatiques (awalé, jeu de
dame…), les logiciels de compression et de décompression, les shareware, les Freeware, les synergiciel, les Logiciels
libre, les spyware…
I/ Concepts fondamentaux
1) Définition
 Notion de pointeur: Un pointeur est une variable qui contient l'adresse d'un objet, c'est-à-dire l'emplacement
de cet objet. Ainsi connaissant son pointeur (c'est-à-dire la variable qui contient son emplacement), peut-on facilement
atteindre l'objet en question. L'objet peut être un type simple(entier, caractère, réel, chaîne de caractère...) ou structuré
(enregistrement, tableaux...).
2) Déclaration du type pointeur

Elle se fait dans la partie TYPE comme suit:
TYPE
Nom_pointeur = ^ type_pointé; Avec type_pointé, un type simple, structuré, une cellule…
Exemple: TYPE
P = ^ ENTIER;
VAR
d: P; Cette déclaration signifie que la variable d de type P (c'est-à-dire un pointeur sur un entier),et va
contenir l'adresse d'un entier.
3) Les différents types de pointeurs

Nous avons des pointeurs sur des entiers, sur des caractères, sur des réels, sur des entregistrements, sur des chaînes de
caractères, sur des tableaux...
Définir un pointeur sur un réel, puis un autre sur un caractère, ensuite un autre sur une chaîne de caractère et enfin un
dernier sur un enregistrement dont les membres sont: nom, prénom et, classe.
Réponse:

4) Affectation
Il est pratiquement interdit d'attribuer directement une valeur à un pointeur(sauf pour des utilisation bien précise) car la
valeur attribuable à un pointeur est une adresse mémoire. Or c'est le système d'exploitation qui se charge de l'allocation
de la mémoirecentrale et donc de l'attribution des adresses mémoire. Si vous le faites, vous risquez de planter le sys-
tème car vous aurez détruit des données vitales au système. Pour le faire, il faudra avoir une parfaite connaissance de
l'occupation de la mémoire centrale.
Lors de la déclaration d'un pointeur, on lui reserve une zone mémoire qui va servir à contenir l' adresse d'un objet. Mais
l'espace mémoire pour l'objet n'est cependant pas encore reservé.
Ainsi, pour attribuer une valeur à un objet pointé, il faudrait:
▪ d'abord reserver l'espace mémoire de cet objet. Cette réservation d'espace mémoire se fait par le mot clé:
NOUVEAU dont la syntaxe est la suivante: NOUVEAU(nom_variable_pointeur);
▪ Ensuite, attribuer une valeur à l'objet pointé et qui se fait par: nom_variable_pointeur^  valeur;
Remarque: Nom_variable_pointeur^ désigne l'objet pointé par Nom_variable_pointeur.
Exemple:
TYPE
P = ÊNTIER;
VAR
d: P;
......................
NOUVEAU(d); (* Réservation de l'espace mémoire pour contenir l'entier pointé par d *)
d^  5; (* Affectation de la valeur 5 à l'entier pointé par d *)
Schema explicatif:
d: P;  d Réservation de l'espace mémoire pour le pointeur d. Pour l'heure, le contenu de d est non défini.
NOUVEAU(d);
d @ 
Espace réservé(créé) et pointé par d (d^)
 Désormais, d contient l'adresse de l'espace créé pour contenir l'entier
d^  5; d @ 
5 Espace réservé(créé) et pointé par d (d^).
5) Les différentes opérations sur un pointeur

Ce sont généralement les opérateurs + et -
Les opérateurs + et- s'appuie sur l'espace mémoire occupé par les différents types en question.
Rappel: 1 caractère occupe 1 octet, 1 entier occupe 2 octets, 1 réel occupe 4 octets.

Soit P un pointeur sur un objet de k octets. (P+1) fait pointer le pointeur P sur la case mémoire en sautant de k octets
depuis la case pointée initialement par P.
Exemple:
TYPE
P = ÊNTIER;
VAR
d: P;
Ici, on saute de 2 octets car c'est un entier.

d d+1 d+2
(Etat initial)
Soit:
TYPE
P = ÊNTIER; G=^CARACTERE; T=^REEL;
VAR
d: P; e: G, f: T;
A partir d'un état initial, représenter les cas suivants:
e, e-1, e+2, e+5;
f, f+1, f-2, f+3.
Réponse:
II/ Construction de structures de données dynamiques (à l'aide de pointeur)

1) Définition
 Notion de cellule: Une cellule est une variable contenant deux (2) champs:
• Un champ contenant de l'information qui peut être un type simple ou structuré. Ce champ peut être consti-
tué de un (1) ou plusieurs informations de type identique ou différent.
• Un champ contenant l'adresse. Cette adresse peut être nulle (c'est-à-dire ne contenant pas l'adresse d'une
autre cellule) ou non nulle (c'est-à-dire contenant l'adresse d'une autre cellule). Ce champ peut être consti-
tué d'une (1) ou plusieurs adresses également.
Une cellule est atteinte par son adresse donc grâce à son pointeur.
2) Déclaration d'une cellule (type structuré).

Elle se fait également dans la partie TYPE, comme suit:
TYPE
Nom_cellule = ENREGISTREMENT
Champ 1: type_champ 1;
……………. Champ information
Champ n: type_champ n;
Pointeur 1: type_pointeur 1;
…………… Champ adresse
Pointeur n: type_pointeur n;
FIN;

Pointeur
La flèche signifie " Pointe sur…", c'est-à-dire contient l'adresse de…
L'adresse Info 1 …….. Info n Adresse 1 ……… Adresse n

de la cellule
est à
l'intérieur Champ Information Champ Adresse
Cellule
Exemple:
TYPE
R = ^Cel;
Cel = ENREGISTREMENT
a: CARACTERE; Champ Information
b: CHAINE[15];
e: R; Champ adresse
FIN;
VAR
m: R;
3) L'accès aux différents champs d'une cellule

L'accès aux différents champs d'une cellule se fait comme suit: nom_variable_pointeur^.nom_champ;
Exemple: m^.b; Permet d'accéder au champ b de la variable m. Avec m = pointeur contenant l'adresse d'une cellule,
m^ = cellule pointée et m^.b = le champ b de la cellule pointée par m.
m @= Contient une adresse
@ Cellule pointée par m ( m^ )
a b e
4) Affectation
L'affectation se fait suivant deux syntaxes:
Nom_variable_pointeur^. Nom_champ valeur; OU
Nom_variable_pointeur 1  Nom_variable_pointeur 2;
Exemple: m^.b "IG2"; Pour dire d'affecter la valeur "IG2" au champ b de la cellule pointée par le pointeur m.
m^.e NULL; Pour dire que le champ e (qui est aussi un pointeur) de la cellule pointée par m , ne pointe
sur rien.
5) Les différentes opérations portant sur une cellule

a) Création d'une cellule:
L'on utilise le mot clé NOUVEAU comme suit:
NOUVEAU(nom_variable_pointeur); Cette instruction stipule la création d'une nouvelle cellule qui sera pointée par
nom_variable_pointeur;

 Exercice 3 d'application : Soit la déclaration suivante:

TYPE
R = ^Cel;
a: CARACTERE;
b: CHAINE[15];
e: R;
FIN;
VAR
m: R;
………………………………
NOUVEAU(m);
Décrire la situation de l'exemple ( NOUVEAU(m) ), à l'aide de schéma.

Réponse:
b) Destruction d'une cellule:

Elle consiste à libérer l'espace mémoire occupé par cette cellule (donc à effacer cette cellule de la mémoire centrale).
L'on utilise le mot clé DETRUIRE comme suit:
DETRUIRE(nom_variable_pointeur);
Exemple: DETRUIRE(m); permet d'effacer de la mémoire centrale, la cellule pointée par m.
 Exercice 4 d'application: Soit les déclarations suivantes:
TYPE
R = ^Cel;
e: CARACTERE;
f: CHAINE[15];
cpt: R;
FIN;
VAR
P1, P2 : R;
Représenter chaque cas suivant :
 P1 : R; P2 : R;
Réponse :
 NOUVEAU (P1); NOUVEAU (P2);

Réponse :
 P1^.e  'N'; P1^.f  "Attention"; P1^.cpt  NULL;

Réponse :
 P2^.e  'O'; P2^.f  "Essai";

Réponse :

 P1^.e  P2^.e
Réponse :
 P1^.cpt  P2;
 P1^.cpt^.f  "papa";
Réponse :
 P1  P2;
Réponse :
 DETRUIRE (P2);
Réponse :
 P1  NULL;
Réponse :
6) Les listes
a) Définition
Une liste ou liste linéaire chaînée, est constituée d'un ensemble de cellules chaînées entre elles.
C'est l'adresse de la 1ere cellule qui détermine la liste, c'est-à-dire que connaissant l'adresse de la 1ere cellule (son empla-
cement), l'on peut retrouver toutes les autres cellules de la liste (car toutes les cellules de la liste sont liées les unes aux
autres).
 Exercice 5 d'application: Soit les déclarations suivantes:
TYPE
R = ^Cel;
e: CARACTERE;
S: R;
FIN;
VAR
d: R;
Construire une liste constituée de quatre (4) cellules
Réponse:

b) Les différentes opérations sur une liste

 Création d'une liste : Elle consiste à mettre en place la liste et elle doit précéder toute opération sur une liste.
Les différentes étapes sont :
• Utiliser un pointeur qui va pointer sur la 1 ère cellule créée,
• Une fois le champ information de la 1 ère cellule rempli, pointer la zone adresse de cette 1 ère cellule sur une
nouvelle cellule créée (la 2e cellule) et ainsi de suite…
• A la fin de la liste, le champ adresse de la dernière cellule pointe sur NULL.
 Exercice 6 d'application : Proposer un algorithme permettant de créer une liste constituée d'un nombre quel-
conque de cellules. Chaque cellule étant constituée de deux (2) champs : Le champ information constituée par une
chaîne de caractères et appelé Info; le champ adresse appelé Suivant et pointant sur une cellule.
Note : Veuillez utiliser une procédure pour la création de la liste.

 Autres opérations sur une cellule : Destruction d'une cellule dans une liste, destruction d'une liste, insertion d'une
cellule dans une liste.
 Exercice 7 d'application: À partir de la liste créée dans l'algorithme précédent, proposer un algorithme pour mettre
en œuvre les différentes opérations ci-dessus.


7) Les piles
a) Définition
Une pile est une liste. Mais contrairement à une liste où l'insertion et la suppression de cellule se font à n'importe quel
endroit de la liste, l'insertion se fait toujours du même côté appelé sommet et l'on supprime toujours les cellules de ce
même côté également.
En fait une pile est une structure LIFO (Last In First Out), c'est-à-dire que la 1ere cellule qu'on insère dans une pile,
est la dernière à être retirée.
b) Applications des piles

Les piles nous servent à créer les menus et sous menus dans les téléphones portables et ordinateurs, à gérer les appels
de sous programmes…
c) Les différentes opérations sur une pile

Les deux (2) opérations sur une cellule sont:
• L'empilement ou l'insertion d'élément (on place l'élément au sommet de la pile),
• Le dépilement ou la suppression d'élément (on enlève l'élément qui se trouve au sommet de la pile).
EMPILEMENT
Pile
Cellule
Etape 0 Etape 1 Etape 2 Etape 3 Etape 4
DEPILEMENT
Pile
Cellule
Etape 0 Etape 1 Etape 2 Etape 3 Etape 4
 Exercice 8 d'application : Proposer un algorithme permettant :

 D'empiler un certain nombre de cellules au choix,
 De dépiler les cellules empilées.
Note : On utilisera la déclaration ci-après :
TYPE
Pile: = ^Cel;
Info: CHAINE [20];
Suivant: Pile;
FIN;


8) Les arbres
a) Définition
Un arbre est une structure de donnée non linéaire qui impose une hiérarchie entre les données qu'il contient.
b) Applications
Les arbres apparaissent dans de nombreux domaines de la vie.
Exemple: Arbre généalogique (pedigree),
Organisation d'un livre.
Livre C: Chapitre
SC: Sous chapitre
C1 C2 C3
c) Spécification
SC1 SC2 SC3_1 SC3_2 SC3_3
Gauche SC3_1_1 SC3_1_2

Information Droite
Gauche Info Droite Gauche Info Droite

TD5 SUR LES POINTEURS?
TEST N°5
EXERCICE
Proposer un algorithme permettant de:

▪ Créer une liste chaînée avec un nombre quelconque de cellules,
▪ De lire le contenu de la liste créée,
▪ D'ajouter des éléments à la fin de la liste,
▪ Supprimer un élément quelconque de la liste, par la connaissance du nom.
Note: La cellule de base sera constituée des champs suivants: nom, prénom et le pays.


Correction du TEST N°1

EXERCICE 1
1)
Posons le problème
− Saisir les trois (3) entiers (la saisie peut s'effectuer un à un ou les trois à la fois sur la même ligne, séparés par
des espaces. Exemple: 15 45 -856),
− Ensuite, effectuer leur somme,
− Enfin, afficher le résultat (la somme des 3 entiers).
1ere méthode: La saisie 1 à 1 des entiers.
ALGORITHME somme;
VAR
a, b, c: ENTIER; (* Les variables a, b et c vont contenir les 3 entiers que l'on va saisir *)
som: REEL; (* som va contenir le résultat. Elle est de type REEL pour contenir de grandes valeurs *)
DEBUT
AFFICHER ('Entrez le 1er entier');
SAISIR (a);
AFFICHER ('Entrez le 2eme entier');
SAISIR (b);
SAISIR (c);
som  a+b+c;
AFFICHER ('La somme des 3 entiers est:' , som);
FIN.
2eme méthode: La saisie des3 entiers sur la même ligne.

ALGORITHME somme;
VAR
DEBUT
AFFICHER ('Entrez les trois entiers');
SAISIR (a,b,c);
som  a+b+c;
FIN.
3eme méthode: Utilisation de boucle.

ALGORITHME somme;
VAR
a, i: ENTIER; (* La variables a, va contenir les 3 entiers que l'on va saisir mais entier après entier et i va parcourir les différents entiers*)
DEBUT
som  0; (* som est initialisée à 0 car sa 1ere utilisation est somsom+a; et elle intervient à droite du signe d'affectation. Donc prend
l'élément neutre de l'addition comme 1ere valeur. *)
POUR i  1 à 3 FAIRE
DPOUR
AFFICHER ('Entrez l'entier n°' , i);
SAISIR (a);
som  som + a; (* La nouvelle valeur de som = ancienne valeur de som + a *)
FPOUR;
FIN.
2)

Posons le problème
− Saisir les trois (3) entiers (la saisie peut s'effectuer un à un ou les trois à la fois sur la même ligne, séparés par
des espaces. Exemple: 15 45 -856),
− Ensuite, effectuer leur somme,
− Enfin, afficher le résultat (la somme des 3 entiers),
− L'utilisateur doit signifier s'il désire continuer l'exécution du programme ou pas. Et cela en répondant à une question: n
pour non et o pour oui.
ALGORITHME somme;
VAR
rep: CARACTERE; (* La variable rep va contenir la réponse de l'utilisateur *)
DEBUT
REPETER
AFFICHER ('Entrez les trois entiers');
SAISIR (a,b,c);
som  a+b+c;
AFFICHER ('Voulez-vous continuer? O pour OUI et N pour NON');
SAISIR (rep);
JUSQU'A (rep ='N') OU (rep='n'); (* Pour prendre en compte la majuscule et la minuscule *)
FIN.
EXERCICE 2
Posons le problème
− Saisir les 2 entiers à échanger,
− Faire la permutation des valeurs des 2 entiers saisis,
− Enfin, afficher les nouvelles valeurs.
Méthode
Mettre le contenu de la 1ere variable dans une tierce variable, puis mettre le contenu de la 2eme valeur dans la 1ere variable et enfin,
mettre le contenu de la tierce variable dans la 2eme variable.
ALGORITHME permutation;
VAR
val1, val2, temp: ENTIER; (* val1 et val2 vont contenir les 2 entiers et temp est l'intermédiaire *)
DEBUT
AFFICHER ('Entrez le 1er entier');
SAISIR (val1);
SAISIR (val2);
(* Nous allons à présent faire la permutation *)
temp  val1;
val1  val2;
val2  temp;
AFFICHER ('La nouvelle valeur de val1 est:' , val1);
AFFICHER ('La nouvelle valeur de val2 est:' , val2);
FIN.
EXERCICE 3
Posons le problème
− Saisir l'entier,
− Déterminer ses diviseurs et les afficher.
Méthode
Si le reste de la division entière de l'entier N par l'entier I, est zéro alors I est un diviseur de N.
Pour avoir tous les diviseurs, il faut parcourir les entiers compris entre 1 et N et voir à chaque fois si l'entier en question est un
diviseur de N ou pas. S'il est un diviseur de N alors on le prend en compte. Dans le cas contraire, on l'ignore.
Ici, il faut distinguer le cas où N est positif (dans ce cas l'on va parcourir les entiers compris entre 1 et N) et la cas où N est négatif
(dans ce cas l'on va parcourir les entiers compris entre 1 et la valeur absolue de N, c'est-à-dire –N).
Cas particulier: 0 possède une infinité de diviseurs, c'est-à-dire admet tous les nombres comme diviseurs.

ALGORITHME diviseurs;
VAR
r, N, i: ENTIER; (* N va contenir l'entier, r le reste de division entière et i va parcourir les entiers de 1 à N *)
DEBUT
AFFICHER ('Entrez l'entier');
SAISIR (N);
SI N = 0 ALORS (* Cas particulier *)
DSI
AFFICHER ('Il existe une infinité de diviseurs');
FSI;
SINON (* C'est à dire N  0. Là, nous sommes dans le cas général maintenant !*)
DSINON
SI N > 0 ALORS (* Cas où N est positif *)
DSI
POUR i  1 à N FAIRE
DPOUR
r  N MOD i;
SI r = 0 ALORS
DSI
AFFICHER (i, 'est un diviseur de' , N);
FSI;
FPOUR;
FSI;
SINON (* Cas où N est négatif *)
DSINON
POUR i  1 à -N FAIRE
DPOUR
r  N MOD i;
SI r = 0 ALORS
DSI
AFFICHER (-i, 'est un diviseur de' , N);
FSI;
FPOUR;
FSINON;
FSINON;
FIN.
EXERCICE 4
Posons le problème
− Saisir l'entier,
− Déterminer s'il est pair ou impair et l'afficher.
Méthode
Un nombre est pair si le reste de sa division entière par 2 donne 0. Dans le cas contraire, il est impair.
ALGORITHME parite;
VAR
r, N: ENTIER; (* N va contenir l'entier, r le reste de division entière par 2 *)
DEBUT
SAISIR (N);
r  N MOD 2;
SI r = 0 ALORS (* Cas particulier *)
DSI
AFFICHER (N, 'est un nombre pair');
FSI;
SINON (* c'est-à-dire r vaut 1 *)
DSINON
AFFICHER (N, 'est un nombre impair');
FSINON;
FIN.

EXERCICE 5
Posons le problème
− Saisir les 3 entiers,
− Déterminer le plus grand et l'afficher.
1ere méthode: L'on compare chaque entier aux 2 autres, à la fois.
ALGORITHME maximum;
VAR
a, b, c: ENTIER; (* a, b et c vont contenir les 3 entiers en raison d'un variable par entier *)
DEBUT
AFFICHER ('Entrez les 3 entiers');
SAISIR (a, b, c);
SI (a  b) ET (a  c) ALORS
DSI
AFFICHER ('Le maximum des 3 entiers est:' , a);
FSI;
SI (b  a) ET (b  c) ALORS
DSI
AFFICHER ('Le maximum des 3 entiers est:' , b);
FSI;
SI (c  a) ET (c  b) ALORS
DSI
AFFICHER ('Le maximum des 3 entiers est:' , c);
FSI;
FIN.
2e méthode: L'on compare les deux 1ers entiers et l'on tire le plus grand. Puis l'on compare ce plus grand au 3eme
entier, pour enfin déterminer le plus grand des trois entiers.
ALGORITHME maximum;
VAR
a, b, c, max: ENTIER; (* a, b et c vont contenir les 3 entiers et max le grand parmi les 3 *)
DEBUT
SAISIR (a, b, c);
SI a  b ALORS
DSI
max  a;
FSI;
SINON (* C'est-à-dire b  a *)
DSINON
max  b;
FSINON;
SI c > max ALORS
DSI
max  c;
FSI;
AFFICHER ('Le maximum des 3 entiers est:' , max);
FIN.

EXERCICE 6
Posons le problème
− Saisir le nombre entier. Mais veiller à ce qu'il soit positif (car le factoriel d'un nombre négatif n'existe pas).
− Calculer le factoriel de l'entier saisi en l'afficher.
Méthode:
▪ Cas particulier: Le factoriel de 0 et de 1 valent 1.
▪ Cas général (N0 et N1): Le factoriel de n vaut: 1*2*3*…*n. Il faut donc multiplier les nombres de 1 jusqu'à n, pour ainsi ob-
tenir le factoriel de n.
ALGORITHME factoriel;
VAR
n, j: ENTIER; (* n va contenir l'entier et j va parcourir les entiers de 1 à n *)
fact: REEL; (* fact va contenir le factoriel. Elle est de type REEL pour contenir les grandes valeurs *)
DEBUT
REPETER
SAISIR (n);
JUSQU'A n  0; (* Nous devons veiller à ce que l'utilisateur saisisse une valeur positive *)
SI (n = 0) OU (n = 1) ALORS (* Cas particuliers *)
DSI
fact  1;
FSI;
SINON (* Cas général*)
DSINON
fact  1; (* fact est initialisée à 1 car sa 1ere utilisation est factfact *j; et elle intervient à droite du signe d'affectation. Donc
prend l'élément neutre de la multiplication comme 1ere valeur. *)
POUR j  1 à n FAIRE
DPOUR
fact  fact * j; (* La nouvelle valeur de fact = ancienne valeur de fact * j *)
FPOUR;
FSINON;
AFFICHER ('Le factoriel de' , n , 'est:' , fact);
FIN.
EXERCICE 7
Posons le problème
− Saisir le nombre entier. Mais veiller à ce qu'il soit positif (C'est l'exercice qui le veut ainsi).
− FAIRE la somme des entiers positifs  N; puis l'afficher.
Méthode:
▪ Cas particulier: Si N = 0 alors cette somme vaut 0.
▪ Cas général (N>0): Parcourir les valeurs de 1 jusqu'à N et à chaque fois, faire l'addition des anciennes valeurs à la nouvelle va-
leur.
a) Avec la structure POUR…FAIRE
ALGORITHME somme;
VAR
N, j: ENTIER; (* N va contenir l'entier et j va parcourir les entiers de 1 à n *)
som: REEL; (* som va contenir la somme de ces entiers. De type REEL pour contenir les grandes valeurs *)
DEBUT
REPETER
SAISIR (N);
JUSQU'A N  0;
SI N = 0 ALORS
DSI
som  0;
FSI;
SINON (* c'est-à-dire N >0 *)
DSINON

som  0; (* som est initialisée à 0 car sa 1ere utilisation est somsom+j; et elle intervient à droite du signe d'affectation.
Donc prend l'élément neutre de l'addition comme 1ere valeur. *)
POUR j  1 à N FAIRE
DPOUR
som  som + j; (* La nouvelle valeur de som = ancienne valeur de som + j *)
FPOUR;
FSINON;
AFFICHER ('La somme vaut:' , som);
FIN.
b) Avec la structure TANT QUE …FAIRE

ALGORITHME somme;
VAR
DEBUT
REPETER
SAISIR (N);
JUSQU'A N  0;
SI N = 0 ALORS
DSI
som  0;
FSI;
DSINON
j  1; (* Car nous allons commencer à compter à partir de 1 *)
TQ j  N FAIRE
DTQ
j  j + 1; (* Permettant de passer de 1 à 2, puis à 3 et ainsi de suite jusqu'a N. Contrairement à POUR…FAIRE
où le compteur change de valeur automatiquement, ici ce n'est pas la cas. Nous devons donc le faire nous
même*)
FTQ;
FSINON;
AFFICHER ('La somme vaut;' , som);
FIN.
c) Avec la structure REPETER …JUSQU'A

ALGORITHME somme;
VAR
DEBUT
REPETER
SAISIR (N);
JUSQU'A N  0;
SI N = 0 ALORS
DSI
som  0;
FSI;
DSINON
j  1; (* Car nous allons commencer à compter à partir de 1 *)

REPETER
j  j + 1; (* Permettant de passer de 1 à 2, puis à 3 et ainsi de suite jusqu'a N. Contrairement à POUR…FAIRE où le
compteur change de valeur automatiquement, ici ce n'est pas la cas. Nous devons donc le faire nous même*)
JUSQU'A j> N; (* ou J = N + 1 *)
FSINON;
AFFICHER ('La somme vaut;' , som);
FIN.
EXERCICE 8
1)
Posons le problème
− Saisir le nombre entier I. Veiller à ce qu'il soit positif (C'est l'exercice qui le veut ainsi).
− Déterminer les entiers impairs compris entre 1 et I, puis faire leur somme (1et I ne sont pas pris en compte),
− Afficher la somme obtenue.
Méthode
Parcourir les entiers de 2 à I-1 et additionner seulement les entiers impairs.
ALGORITHME somme_des_impairs;
VAR
r, I, j: ENTIER; (* I va contenir l'entier, r le reste de division entière et j le parcours de 2 à I-1 *)
som: REEL; (* som va contenir la somme des impairs. De type REEL pour contenir les grandes valeurs *)
DEBUT
REPETER
SAISIR (I);
JUSQU'A I  2; (* Car I doit certes être positif mais >1 tel mentionné dans l'exercice *)
som  0; (* som est initialisée à 0 car sa 1ere utilisation est somsom+j; et elle intervient à droite du signe d'affectation. Donc prend
POUR j  2 à I-1 FAIRE
DPOUR
r  j MOD 2;
SI r = 1 ALORS (* C'est que j est impair *)
DSI
FSI;
FPOUR;
FIN.
2)
Posons le problème
− Saisir le nombre entier I. Veiller à ce qu'il soit positif (C'est l'exercice qui le veut ainsi).
− Déterminer les entiers pairs compris entre 1 et I, puis faire leur somme (1et I ne sont pas pris en compte),
− Afficher la somme obtenue.
Méthode
Parcourir les entiers de 2 à I-1 et additionner seulement les entiers pairs.
ALGORITHME somme_des_pairs;
VAR
r, I, j: ENTIER; (* I va contenir l'entier, r le reste de division entière et j le parcours de 2 à I-1 *)
som: REEL; (* som va contenir la somme des impairs. De type REEL pour contenir les grandes valeurs *)
DEBUT
REPETER
SAISIR (I);
JUSQU'A I  2; (* Car I doit certes être positif mais >1 tel mentionné dans l'exercice *).
som  0; (* som est initialisée à 0 car sa 1ere utilisation est somsom+j; et elle intervient à droite du signe d'affectation. Donc prend
POUR j  2 à I-1 FAIRE
DPOUR

r  j MOD 2;
SI r = 0 ALORS (* C'est que j est pair *)
DSI
FSI;
FPOUR;
FIN.
EXERCICE 9
1)
Posons le problème
− Saisir les 2 entiers. Veiller à ce qu'ils soient positifs (C'est l'exercice qui le veut ainsi),
− Faire une suite d'additions du 1er entier avec lui-même, et cela jusqu'à atteindre le 2e entier fois,
− Afficher le résultat obtenu.
Méthode
Soit I=1er entier et N= 2e entier.
Le travail demandé est: I+I+I+…+I ou N+N+N+…+N
N fois I fois
Cas particulier: Si l'une des valeurs vaut 0 alors le résultat est 0.
ALGORITHME multiplication_addition;
VAR
N, I, j: ENTIER; (* N et I vont contenir les 2 entiers et j va jouer le rôle du compteur *)
som: REEL; (* som va contenir la somme. De type REEL pour contenir les grandes valeurs *)
DEBUT
REPETER
SAISIR (N, I);
JUSQU'A (I  0) ET (N  0); (* N et I doivent être tous deux positifs à la fois. D'où le ET *)
SI (N = 0) OU (I = 0) ALORS
DSI
som  0;
FSI;
SINON (* c'est-à-dire N  0 et I  0 *)
DSINON
som  0; (* som est initialisée à 0 car sa 1ere utilisation est somsom+I; et elle intervient à droite du signe d'affecta-
tion. Donc prend l'élément neutre de l'addition comme 1ere valeur. *)
POUR j  1 à N FAIRE (* ou bien POUR j  1 à I FAIRE et plus loin som  som + N *)
DPOUR
som  som + I; (* La nouvelle valeur de som = ancienne valeur de som + I *)
FPOUR;
FSINON;
AFFICHER ('Le résultat de cette sorte de multiplication est:' , som);
FIN.
EXERCICE 10
Posons le problème
− Saisir les 2 entiers (X et n),
− Calculer X à la puissance n (xn),
− Afficher enfin le résultat obtenu.
Méthode:
▪ Cas particulier: 00=Impossible ; 0n=0 (n  0) et X0=1 (X  0).
▪ Cas général (X  0 et n  0): Là, nous avons 2 cas:
✓ 1er cas: L'exposant n est positif.
Effectuer la multiplication de X par lui-même et cela n fois.
Exemple: x=3 et n=5. Xn=3*3*3*3*3=243
✓ 2e cas: L'exposant n est négatif.
Faire pareil que le 1er cas mais en prenant la valeur absolue de n. et à la fin, prendre l'inverse du résultat obtenu.
Exemple: 3-5 = 1/35

ALGORITHME puissance;
VAR
X, n, j: ENTIER; (* X est l'entier, n est l'exposant et j pour compter le nbre de fois de multiplication *)
puiss: REEL; (* puiss va contenir Xn. De type REEL pour contenir les grandes valeurs *)
DEBUT
AFFICHER ('Entrez la valeur de X et de n');
SAISIR (X, n);
(* Gestion des cas particuliers *)
SI (X=0) ET (n=0) ALORS
DSI
AFFICHER ('OPERATION IMPOSSIBLE!');
FSI;
SINON (* Gestion des cas où le résultat du calul existe, c'est à dire X  0 et/ou n  0. *)
DSINON
SI (X=0) ET (n0) ALORS (* Cas particulier *)
DSI
puiss  0;
FSI;
SI (X0) ET (n=0) ALORS (* Cas particulier *)
DSI
puiss  1;
FSI;
(* Gestion à présent du cas général *)
SI (X0) ET (n0) ALORS
DSI
SI n > 0 ALORS (* Cas où l'exposant n est positif *)
DSI
puiss  1; (* puiss est initialisée à 1 car sa 1ère utilisation est puisspuiss *X; et elle intervient à droite du signe d'af-
fectation. Donc prend l'élément neutre de la multiplication comme 1ère valeur. *)
POUR j  1 à n FAIRE
DPOUR
puiss  puiss * X; (* La nouvelle valeur de puiss= ancienne valeur de puiss * X *)
FPOUR;
FSI;
SINON (* Cas où l'exposant n est négatif. On pouvait aussi écrire SI n <0 ALORS… *)
DSINON
puiss  1;
POUR j  1 à -n FAIRE (* -n pour la valeur absolue de n *)
DPOUR
puiss  puiss * X; (* La nouvelle valeur de puiss= ancienne valeur de puiss * X *)
FPOUR;
puiss 1/ puiss; (* Pour avoir l'inverse du résultat *)
FSINON;
FSI;
AFFICHER (X, ' à la puissance' ,n , 'est:' , puiss);
FSINON;
FIN.
EXERCICE 11
Posons le problème
− Saisir le temps en secondes. Veiller à ce que le temps saisi soit positif
− Déterminer le temps saisi, en heures, en minutes et en secondes,
− Enfin afficher ce résultat.

Méthode:
− Faire la division entière du temps saisi par 3600 (car 1h = 3600s). Soit q1 le quotient de r1 le reste de cette division entière.
− Faire la division entière de r1 par 60 (car 1mn = 60s). Soit q2 le quotient de r2 le reste de cette division entière.
− Finalement le temps initial saisi donne q1heure(s) q2minute(s) r2seconde(s).
ALGORITHME conversion;
VAR
q1, q2, r1, r2,N: ENTIER; (* N pour le temps initial saisi, q1, q2, r1 et r2 pr les quotient et restes de la division entière *)
DEBUT
REPETER
AFFICHER ('Entrez le temps en secondes');
SAISIR (N);
JUSQU'A N>0;
q1  N DIV 3600;
r1  N MOD 3600;
q2  r1 DIV 60;
r2  r1 MOD 60;
AFFICHER (N, 'secondes valent:' , q1, 'heure(s)', q2, 'minute(s) et' , r2, 'seconde(s)' );
FIN.
Note: Ici, on ne peut pas déclarer N de type réel car DIV et MOD ne s'apliquent pas aux réels.
EXERCICE 12
Posons le problème
-Saisir la quantité du produit,
-Saisir le prix unitaire,
-Déduire le prix d’achat,
-Calculer la remise,
-Déterminer le prix à payer et l’afficher.
1ère méthode
ALGORITHME remise ;
CONST
P1=0.08 ;
P2=0.1 ;
C=10000 ;
VAR
qte : ENTIER ;
R, pu, pa, pap :REEL ;
DEBUT
AFFICHER ('Entrez la quantité du produit') ;
SAISIR(qte) ;
AFFICHER ('Entrez le prix unitaire du produit') ;
SAISIR (pu) ;
pa  qte * pu ;
SI pa < C ALORS
DSI
R  pa * P1 ;
FSI ;
SINON
DSINON
R pa * P2 ;
FSINON ;
pap  pa - R ;
AFFICHER ('le prix à payer est :',pap) ;
FIN.

2e méthode
ALGORITHME remise ;
VAR
qte : ENTIER ;
pu, pa, R, pap :REEL ;
DEBUT
AFFICHER ('Entrez la quantité du produit')
SAISIR (qte) ;
AFFICHER ('Entrez le prix unitaire du produit') ;
SAISIR (pu) ;
pa  qte * pu ;
SI pa <10000 ALORS
DSI
R  pa * 8/100;
FSI ;
SINON
DSINON
R  pa * 10/100 ;
FSINON ;
pap  pa - R ;
AFFICHER ('Le prix à payer est :', pap) ;
FIN.
EXERCICE 13
Posons le problème
-Saisir le budget global du ministère,
-Calculer par la suite le budget alloué à chaque service dudit ministère,
-Enfin, afficher le budget alloué à chaque service.
ALGORITHME budget;
VAR
r, budgl, bud_sec, bud_se, bud_smi, bud_so: REEL; (*r va contenir le reste, budgl=budget global bud_sec=budget du service des exa-
mens et concours, bud_se= budget du service d'évaluation, bud_smi=budget du service du mobilier et l'immobilier, bud_so=busget
du service de l'orientation *)
DEBUT
AFFICHER ('Entrez le budget global alloué au ministère') ;
SAISIR (budgl);
bud_so  budgl*10/100;
r  budgl – bud_so;
bud_sec  r*1/3;
bud_se  bud_sec *3/4;
bud_smi  budgl – (bud_so + bud_sec + bud_se);
AFFICHER ('Le budget alloué au service de l'orientation est:' , bud_so);
AFFICHER ('Le budget alloué au service des examens et concours est:' , bud_sec);
AFFICHER ('Le budget alloué au service d'évaluation est:' , bud_se);
AFFICHER ('Le budget alloué au service du mobilier et de l'immobilier est:' , bud_smi);
FIN.
EXERCICE 14
Posons le problème
-Saisir les deux entiers,
-Déterminer leur PGCD.
Méthode
PGCD(a,b): Pour le trouver, il consiste à diviser (il s'agit ici d'une division entière) a et b par tous les nombres compris entre le plus
petit des 2 nombres(a et b), et 1; et s'arrêtant que lorsqu'on a trouvé un diviseur commun.

ALGORITHME pgcd;
VAR
a, b, min: ENTIER; (* a et b vont contenir les entiers à saisir et min le plus petit entre a et b *)
DEBUT
AFFICHER ('Entrez les 2 entiers') ;
SAISIR (a, b) ;
SI a < b ALORS
DSI
min  a;
FSI;
SINON (* b  a *)
DSINON
min  b;
FSINON;
TQ (min 1) ET ( (a MOD min  0) ou ( b MOD min  0) ) FAIRE
DTQ
min  min – 1;
FTQ;
AFFICHER ('Le PGCD de' , a, 'et de' , b , 'est:' , min);
FIN.
Explication de TQ (min 1) ET ( (a MOD min  0) ou ( b MOD min  0) ) FAIRE
On exécute la boucle tant que min  1 et le reste des 2 divisions entières est  0.
Exemple: PGCD(12, 8)=?
min(12, 8) =8
12 MOD 8= 4 (  0 ); 8 MOD 8=0 (=0 )
12 MOD 7= 5 (  0 ); 8 MOD 7=1 (0 )
12 MOD 6= 0 ( = 0 ); 8 MOD 6=2 (0 )
12 MOD 5= 2 (  0 ); 8 MOD 5=3 (0 )
12 MOD 4= 0 ( = 0 ); 8 MOD 4=0 (=0 ). D'où le PGCD (12, 8)=4
EXERCICE15
Posons le problème
- Saisir le tarif normal,
− Saisir la catégorie du voyageur. Veiller à ce que la catégorie saisie par l'utilisateur  {N, n, A, a, E, e, T, t, P, p, V, v} tel que
stipulé par l'exercice.
- Enfin déterminer le tarif à payer et l'afficher.
ALGORITHME tarif ;
VAR
tarif_N, tarif_Ap: REEL; (* tarif_N = tarif normal et tarif_Ap = tarif à payer *)
cat: CARACTERE; (* cat =catégorie *)
DEBUT
AFFICHER ('Entrer le tarif Normal');
SAISIR (tarif_N) ;
REPETER
AFFICHER ('Entrez la catégorie du voyageur') ;
SAISIR (cat) ;
JUSQU'A (cat = ‘N’) OU (cat = 'n') OU (cat = 'A') OU (cat = 'a') OU (cat = 'E') OU (cat = 'e') OU (cat = 'T') ou (cat = 't') ou (cat
= 'P') OU (cat = 'p') OU (cat = 'V') OU (cat = 'v');
SUIVANT cat FAIRE
'N', 'n' : tarif_Ap  tarif_N ;
'A', 'a' : tarif_Ap  tarif_N - (tarif_N * 40 /100) ;
'E', 'e', ’T’, ‘t’ : tarif_Ap  0;
'P', 'p' : tarif_Ap  tarif_N - (tarif_N * 50/100) ;
'V', 'v' :tarif_Ap  tarif_N - (tarif_N * 30 /100) ;
FSUIVANT;
AFFICHER ('Le tarif à payer est :',tarif_Ap) ;
FIN.
Remarque: A la place du SUIVANT…FAIRE précédent, l'on pouvait aussi utiliser plusieurs SI…ALORS comme par
exemple: SI (cat='N') OU (cat='n') ALORS….

SI (cat='A') OU (cat='a') ALORS….
EXERCICE 16
Posons le problème
- Saisir les 3 réels,
- Ensuite, faire le choix de l'opération (par la saisie),
- Enfin, effectuer l'opération choisie et en afficher le résultat.
ALGORITHME menu;
VAR
a, b, c, op :REEL ; (* a, b, c pour les 3 réels et op= résultat de l'opération *)
choix: ENTIER; (* choix pour le choix de l'opération *)
DEBUT
AFFICHER ('Entrez 1 pour effectuer la somme des trois nombres') ;
AFFICHER ('Entrez 2 pour effectuer le produit des trois nombres') ;
AFFICHER ('Entrez 3 pour effectuer la moyenne des trois nombres') ;
REPETER
AFFICHER ('Faites votre choix');
SAISIR (choix);
JUSQU'A (choix = 1) ou (choix = 2) ou (Choix = 3);
AFFICHER ('Entrez les trois nombres réels');
SAISIR (a, b, c);
SI choix = 1 ALORS
DSI
op  a+b+c;
FSI;
SI choix = 2 ALORS
DSI
op  a * b * c;
FSI;
SI choix = 3 ALORS
DSI
op  (a+b+c)/3;
FSI;
AFFICHER ('Le résultat de l'opération est :', op);
FIN.
EXERCICE 17
Posons le problème
- Pour chacun des 20 chauffeurs (chauffeur par chauffeur), saisir les ses 26 versements,
- Puis, calculer son salaire et l'afficher,
- Enfin, après avoir parcouru tous les 20 chauffeurs, calculer la part globale de la société (A l'issue des 26 versements, chaque
chauffeur perçoit 20% du cumul de ses 26 versements. La part globale de la société = le cumul des 80% des 26 versements
des 20 chauffeurs).
ALGORITHME salaire;
VAR
sal, vers, som_vers, part_ent, part_globale :REEL ; (* sal=salaire du chauffeur, vers =versement effectué, som_vers=somme des ver-
sements du chauffeur, part_ent=part entreprise, part_globale= part globale de la société *)
i, j: ENTIER; (* j pour parcourir les 20 chauffeurs et i pour effectuer les 26 versements *)
DEBUT
part_globale  0; (* part_globale est initialisée à 0 car sa 1ère utilisation est part_globale  part_globale + part_ent ; et elle inter-
vient à droite du signe d'affectation. Donc prend l'élément neutre de l'addition comme 1ère valeur. De surcroît
est placée ici parce qu'elle doit l'être avant d'entamer la gestion des chauffeurs*)
POUR j  1 à 20 FAIRE (* Parcours des 20 chauffeurs *)
DPOUR
som_vers  0; (* som_vers est initialisée à 0 car sa 1ère utilisation est som_vers  som_vers + vers;
et elle intervient à droite du signe d'affectation. Donc prend l'élément neutre de
l'addition comme 1ère valeur. De surcroît est placée ici parce qu'elle doit l'être avant
d'entamer la gestion des  versements*)
POUR i  1 à 26 FAIRE (* Gestion des 26 versements *)
DPOUR
AFFICHER ('Entrez le versement n°' , i, 'du chauffeur n°' , j);

SAISIR(vers);
som_vers  som_vers + vers; (* La nouvelle valeur de som_vers= ancienne valeur de som_vers + le nou-
veau versement *)
FPOUR; (* A la fin de cette boucle, on aura fini de gérer les 26 versements du chauffeur en cours *)
sal som_vers *20/100;
AFFICHER ('Le salaire du chauffeur n°' , j, 'est:' , sal);
part_ent  som_vers – sal; (* ou part_ent  som_vers *80/100; *)
part_globale  part_globale + part_ent; (* La nouvelle valeur de part_globale= ancienne valeur de part_globale
+ ce que la société vient de gagner sur le chauffeur en cours *)
FPOUR; (* A la fin de cette boucle, on aura fini de gérer tous les 20 chauffeurs *)
AFFICHER ('La part globale de la société est:' , part_globale); (* La part globale de la société ne sera connue qu'après avoir par-
couru tous les 20 chauffeurs donc après être sorti de la boucle POUR…FAIRE concernant les chauffeurs. Raison pour laquelle
cette instruction a été placée ici *)
FIN.
EXERCICE18
Posons le problème
-Saisir l’age de l’enfant et afficher sa catégorie,
− Ensuite, comptabiliser le nombre d'enfant,
-Enfin, afficher le nombre d’enfant par catégorie.
ALGORITHME pensionnaires ;
VAR
nbp, nbpu, nbc, nbm, age, I :ENTIER ; (* nbp=nombre de poussins, nbpu=nombre de pupille, nbc=nombre de cadet, nbm=nombre de
minime, age= âge des enfants, i=compteur pour parcourir les 100 enfants *)
DEBUT
Nbp  0 ; nbpu  0 ; nbm  0 ; nbc  0 ; (* Il faut initialiser ces variables à 0 ici, avant la gestion des enfants*)
POUR I  1 à 100 FAIRE
DPOUR
REPETER
AFFICHER ('Entrez l'age de l'enfant');
SAISIR (age) ;
JUSQU'A (age  6) ET (age  20);;
SUIVANT age FAIRE
6,7 : DEBUT
AFFICHER ('Poussin') ;
nbp  nbp + 1;
FIN;
8, 9, 10 : DEBUT
AFFICHER ('Pupille');
nbpu  nbpu + 1;
FIN;
11, 12, 13 : DEBUT
AFFICHER ('Minime') ;
nbm  nbm + 1;
FIN;
SINON (* C'est-à-dire si l'âge  {6, 7, 8, 9, 10, 11, 12, 13} *)
DSINON
AFFICHER ('Cadet') ;
nbc  nbc + 1 ;
FSINON ;
FIN SUIVANT ;
FPOUR;
AFFICHER ('Le nombre d'enfant poussin est :', nbp) ;
AFFICHER ('Le nombre d'enfant pupille est :', nbpu) ;
AFFICHER ('Le nombre d'enfant minime est :', nbm) ;
AFFICHER ('Le nombre d'enfant cadet est :', nbc) ;
FIN.
EXERCICE19
Posons le problème

− Saisir le nombre de postulants,

− Comptabiliser le nombre de boursiers en Afrique et en Europe, suivant leur moyenne.
− Enfin afficher le nombre de boursiers dans chaque zone.
ALGORITHME bourse;
VAR
moy: REEL; (* moy=moyenne annuelle de l'étudiant *)
I, nbp, nbA, nbE: ENTIER; (* I pour parcourir les différents étudiants, nbp=nombre de postulants, nbA= Nombre de boursiers pour l'Afrique,
nbE = Nombre de boursiers pour l'Europe et *)
DEBUT
AFFICHER ('Entrer le nombre de postulation’);
SAISIR (nbp) ;
nbE  0 ; nbA  0 ; (* Il faut initialiser ces variables à 0 ici, avant la gestion des étudiants*)
POUR i  1 à nbp FAIRE
DPOUR
AFFICHER ('Entrer la moyenne annuelle du postulant n°' , I);
SAISIR (moy);
SI moy >15 ALORS
DSI
nbE  nbE + 1 ;
FSI;
SI (moy >12) ET (moy<15) ALORS
DSI
nbA  nbA +1 ;
FSI;
FPOUR;
AFFICHER ('Le nombre de boursiers pour l’Afrique est :' , nbA) ;
AFFICHER ('Le nombre de boursiers pour l’Europe est :' , nbE) ;
FIN.
EXERCICE 20
1) Posons le problème
-Saisir le montant des ventes réalisées
-Calculer la commission de 5%
-Calculer le bonus de 10%
-Déduire le salaire.
ALGORITHME salaire;
VAR
Mt_V, Cms, fd, sal: REEL; (* Mt_v= Montant des ventes réalisées, Cms= commission, fd=frais de déplacement, sal= salaire *)
DEBUT
AFFICHER ('Entrez le montant des ventes par le vendeur');
SAISIR (Mt_V) ;
Cms  Mt_V* 5/100 ;
fd  (600 000 + Cms)*10/100 ;
sal  600 000 + Cms + fd ;
AFFICHER ('Le salaire du vendeur est:' , sal);
FIN.
- Saisir le montant des ventes réalisées un vendeur,
- Calculer la commission de 5%,
- Calculer le bonus de 10%,
- Déduire son salaire,
− Refaire les opérations ci-dessus pour les autres vendeurs.

ALGORITHME salaire;
VAR
Mt_V, Cms, fd, sal: REEL; (* Mt_v= Montant des ventes réalisées, Cms= commission, fd=frais de déplacement, sal= salaire *)
j, nbv: ENTIER; (* nbv= Nombre de vendeurs et j pour parcourir les différents vendeurs *)
DEBUT
AFFICHER ('Entrez le nombre de vendeurs');
SAISIR (nbv) ;
POUR j  1 à nbv FAIRE (* Pour parcourir les différents vendeurs *)
DPOUR
AFFICHER ('Entrez le montant des ventes du vendeur n°' , j) ;
SAISIR (Mt_V);
Cms  Mt_V* 5/100;
fd  (600 000 + Cms)*10/100;
sal  600 000 + Cms + fd;
AFFICHER ('Le salaire du vendeur n°' , j , 'est:' , sal);
FPOUR;
FIN.
EXERCICE 21
Posons le problème
-Saisir le montant du retrait.
-Afficher le nombre de billets correspondants aux différentes valeurs (1000, 2000, 5000 et 10 000) en minimisant le nombre
de billets. Exemple: pour un retrait de 16 000F, on a naturellement plusieurs possibilités: soit 16 billets de 1000F, soit 8 billets de
2000F et ainsi de suite. Et comme l'on doit minimiser le nombre de billets, l'on retiendra ceci: 1 billet de 10 000F + 1 billet de 5 000F
+ 1 billet de 1000F.
Méthode
- Faire la division entière du montant à retirer par 10 000. Soit q1 le quotient et r1 le reste.
− Faire la division entière de r1 par 5 000. soit q2 le quotient et r2 le reste.
− Faire la division entière de r2 par 2 000. soit q3 le quotient et r3 le reste.
− Faire la division entière de r3 par 1 000. soit q4 le quotient. (le reste va forcement donner 0).
Ce qui donne finalement
q1 billets de 10 000F
et q4 billets de 1000F.
Note: L'on a débuté la division entière par 10 000, ensuite par 5 000 et enfin par 2 000; ceci afin de minimiser le
nombre de billets.
ALGORITHME distributeur_billets ;
VAR
Mt: REEL; (* Mt= Montant du retrait *)
q1, q2, q3, q4, r1, r2, r3: ENTIER;
DEBUT
AFFICHER ('Entrez le montant à retirer');
SAISIR (Mt) ;
q1  Mt DIV 10000;
r1  Mt MOD 10000;
q2  r1 DIV 5000;
r2  r1 MOD 5000;
q3  r2 DIV 2000;
r3  r2 MOD 2000;
q4  r3 DIV 1000;
AFFICHER ('Le nombre de billets de 10 000F est:' , q1);
FIN.
Amélioration: L'on peut améliorer cet algorithme en n'affichant que les billets dont leur nombre est  0. Par exemple
pour un retrait de 25000F, avec l'algorithme précédent, l'on verra afficher:
2 billets de 10 000F
1 billet de 5 000F

0 billet de 2 000F
0 billet de 1 000F
Avec l'amélioration, l'on désirerait avoir:
2 billets de 10 000F
1 billet de 5 000F.
Cet algorithme amélioré est le suivant:
VAR
q1, q2, q3, r1, r2, r3: ENTIER;
DEBUT
SAISIR (Mt) ;
q1  Mt DIV 10000;
r1  Mt MOD 10000;
q2  r1 DIV 5000;
r2  r1 MOD 5000;
q3  r2 DIV 2000;
r3  r2 MOD 2000;
SI q1  0 ALORS
DSI
FSI;
SI q2  0 ALORS
DSI
FSI;
SI q3  0 ALORS
DSI
FSI;
SI r3  0 ALORS
DSI
AFFICHER ('Le nombre de billets de 1 000F est:' , r3);
FSI;
FIN.
EXERCICE 22
Posons le problème
-Saisir le capital initial, le taux d'intérêt et le nombre d'année,
-Calculer le montant de l'intérêt et le nouveau capital obtenu à la fin de chaque année; et les afficher.
Note: Le nouveau capital = capital précédent + intérêt. Il s'agit donc d'un intérêt composé.
Méthode:exemple
Soit capital initial = 10 000F, le taux d'intérêt = 10% et le nombre d'année = 5 ans
▪ A la fin de la 1ére année, on a:
Intérêt =10 000*10/100= 1 000F
Le nouveau capital = 10 000F + 1 000F soit 11 000F
▪ A la fin de la 2e année, on a:
Intérêt =11 000*10/100= 1 100F
Intérêt =12 100*10/100= 1 210F
Intérêt =13 310*10/100= 1 331F
Intérêt =14 641*10/100= 1 464,1F
Le nouveau capital = 14 641F + 1 464,1F soit 16 105,1F

ALGORITHME capital_interet;
VAR
S, T, interet: REEL; (* S= Somme initiale placée, T=taux d'intérêt, interet= Montant des intérêts *)
N, i: ENTIER; (* N= Nombre d'années de placement et i= compteur pour parcourir les années *)
DEBUT
AFFICHER ('Entrez le capital initial');
SAISIR (S);
AFFICHER ('Entrez le taux d'intérêt en %');
SAISIR (T);
AFFICHER ('Entrez le nombre d'année de placement');
SAISIR (N);
POUR i 1 à N FAIRE
DPOUR
interet  S*T/100;
S  S + interet; (* Le nouveau capital= précédent capital + montant des intérêts *)
AFFICHER ('Le montant des intérêts à la fin de l'année n°' , i, 'est:' , interet);
AFFICHER ('Le montant du capital à la fin de l'année n°' , i, 'est:' , S);
FPOUR;
FIN.
EXERCICE 23
- Saisir le nombre de catégories d'articles présents dans le panier.
− Pour chaque catégorie d'article, saisir son nombre d'exemplaires et son prix unitaire. Puis calculer son prix d'achat.
- Répéter les 2 points ci-dessus pour chaque client.
- A la fin de la journée (lorsqu'il n'y a plus de client parce que la magasin aura fermé), afficher le montant total de tous les
achats
ALGORITHME caisse;
VAR
nbc, nba, i: ENTIER; (* nbc= nombre total de catégories d'articles, nba= nombre d'articles dans une catégorie et i= compteur pour par-
courir les  catégories d'articles *)
(* pu= prix unitaire d'une catégorie d'article, prix= prix d'achat d'une catégorie d'article, to-
pu, prix, total, totalJ, vers, mon: REEL;
tal=Montant total des achats d'un client, totalJ= Montant total de tous les achats effectués dans le magasin pendant la
journée, vers= somme versée par un client et mon = montant de la monnaie d'un client *)
rep: CARACTERE; (* rep= réponse pour savoir si le magasin est fermé ou pas *)
DEBUT
totalJ  0;
REPETER
total  0;
AFFICHER ('Entrez le nombre de catégories d'article');
SAISIR (nbc);
POUR i  1 à nbc FAIRE
DPOUR
AFFICHER ('Entrez le nombre d'articles de la catégorie n°' , i);
SAISIR (nba);
AFFICHER ('Entrez le prix unitaire de la catégorie d'article n°' , i);
SAISIR (pu);
prix  nba * pu;
total  total + prix;
FPOUR;
AFFICHER ('Le total des achats du client est:' , total);
AFFICHER ('Entrez la somme versée par le client');
SAISIR (vers);
mon  vers – total;
AFFICHER ('La monnaie à rendre est:' , mon);
totalJ  totalJ + total;
AFFICHER ('Un autre client? O pour OUI et N pour NON');
SAISIR (rep);
JUSQU'A (rep ='N') OU (rep ='n');
AFFICHER ('Le total de la journée est:' , totalJ);

FIN.
- Saisir le nombre de catégories d'articles présents dans le panier.
-Pour chaque catégorie d'article, saisir son nombre d'exemplaires et son prix unitaire. Puis calculer son prix d'achat.
- Répéter les 2 points ci-dessus pour chaque client.
- A la fin de la journée (lorsqu'il n'y a plus de client parce que la magasin aura fermé), afficher le montant total de tous les achats.
- Refaire le 4 points précédents pour les 30 jours du mois.
ALGORITHME caisse;
VAR
nbc, nba, i,j: ENTIER; (* nbc= nombre total de catégories d'articles, nbc= nombre d'articles dans une catégorie et i= compteur pour parcourir
les  catégories d'articles et j pour les jours du mois *)
pu, prix, total, totalJ, total_mois, vers, mon: REEL; (* pu= prix unitaire d'une catégorie d'article, prix= prix d'achat d'une catégorie
d'article, total=Montant total des achats d'un client, totalJ= Montant total de tous les achats effectués dans le magasin pendant
la journée, total_mois= Montant total de tous les achats effectués dans le magasin pendant le mois, vers= somme versée par
un client et mon = montant de la monnaie d'un client *)
rep: CARACTERE; (* rep= réponse pour savoir si le magasin est fermé ou pas *)
DEBUT
total_mois  0; (* A initialiser avant d'entamer la gestion des jours *)
POUR j  1 à 30 FAIRE (* Gestion des différents jours *)
DPOUR
AFFICHER('NOUS SOMMES AU JOUR n°' , j);
totalJ  0; (* A initialiser avant d'entamer la gestion de l'ensemble de tous les  clients *)
REPETER
total  0; (* A initialiser avant d'entamer la gestion d'un client *)
AFFICHER ('Entrez le nombre de catégories d'article');
SAISIR (nbc);
POUR i  1 à nbc FAIRE
DPOUR
AFFICHER ('Entrez le nombre d'articles de la catégorie n°' , i);
SAISIR (nba);
AFFICHER ('Entrez le prix unitaire de la catégorie d'article n°' , i);
SAISIR (pu);
prix  nba * pu;
total  total + prix;
FPOUR;
AFFICHER ('Le total des achats du client est:' , total);
AFFICHER ('Entrez la somme versée par le client');
SAISIR (vers);
mon  vers – total;
AFFICHER ('La monnaie à rendre est:' , mon);
totalJ  totalJ + total;
AFFICHER ('Un autre client? O pour OUI et N pour NON');
SAISIR (rep);
JUSQU'A (rep ='N') OU (rep ='n');
AFFICHER ('Le total de la journée n°' , j, 'est:' , totalJ);
total_mois  total_mois + totalJ;
FPOUR;
AFFICHER ('Le montant des achats du mois est' , total_mois); (* Après FPOUR, ns sommes à la fin du mois *)
FIN.

EXERCICE 24
Posons le problème
- Pour chaque matière, saisir les  notes,
- Puis calculer les moyennes dans les  matières,
- Par la suite calculer la moyenne de l'étudiant,
- Refaire les points ci-dessus pour chaque étudiant, puis déterminer le 1er dans chaque matière,
- Ensuite, déterminer le 1er de classe,
- Enfin, calculer et afficher la moyenne générale de la classe.
ALGORITHME moyenne;
VAR
moy, moy_max, som, moy_gle, moy_mat, moy_max_mat, moy_info, moy_max_info, moy_A, moy_max_A, noteTL, noteD:
REEL; (* moy=Moyenne de classe de l'étudiant, moy_max=moyenne maximale de classe, som=somme de toutes les moyennes,
moy_gle=moyenne générale de la classe, moy_mat=moyenne en math, moy_max_mat=moyenne maximale en math, moy-info=
moyenne en informatique, moy_max_info= moyenne maximale en informatique, moy_A=moyenne en anglais, moy_max_A=moyenne
maximale en anglais, noteTL= note du test lourd, noteD= note de devoir *)
I, j, k, l, m: ENTIER; (* i= pour parcourir les étudiants, j, k, l=Pour identifier les 1ers dans les matières et m pour le 1er de classe *)
DEBUT
som  0; moy_max_mat  0; moy_max_info  0; moy_max_A 0; moy_max  0;
DPOUR
AFFICHER ('Entrez la note de test lourd d'informatique');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir d'informatique');
SAISIR (noteD);
moy_info  (noteTL*5 + noted*3)/8;
SI moy_info > moy_max_info ALORS
DSI
moy_max_info  moy_info;
j  I;
FSI;
AFFICHER ('Entrez la note de test lourd de mathématiques');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir de mathématiques');
SAISIR (noteD);
moy_mat  (noteTL*5 + noted*3)/8;
SI moy_mat > moy_max_mat ALORS
DSI
moy_max_mat  moy_mat;
k  I;
FSI;
AFFICHER ('Entrez la note de test lourd d'anglais');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir d'anglais');
SAISIR (noteD);
moy_A  (noteTL*5 + noted*3)/8;
SI moy_A > moy_max_A ALORS
DSI
moy_max_A  moy_A;
l  I;
FSI;
(* Calcul de la moyenne de classe de l'étudiant *)
moy  (moy_info*4 + moy_mat*3 + moy_A*2)/9;
AFFICHER ('La moyenne de l'étudiant n°' , i, 'est:' , moy);
SI moy > moy_max ALORS
DSI
moy_max  moy;
m  I;
FSI;
som  som + moy;
FPOUR;

moy_gle  som/25;
AFFICHER ('Le 1er en informatique est l'étudiant n°' , j ,' et il a obtenu ' , moy_max_info);
AFFICHER ('Le 1er en mathématique est l'étudiant n°' , k ,' et il a obtenu ' , moy_max_mat);
AFFICHER ('Le 1er en anglais est l'étudiant n°' , l ,' et il a obtenu ' , moy_max_A);
AFFICHER ('Le 1er de classe est l'étudiant n°' , m ,' et il a obtenu ' , moy_max);
AFFICHER ('La moyenne générale de la classe est:' , moy_gle);
FIN.

Rappels:
▪ Le choix d'utilisation d'une procédure ou d'une fonction dépend certes souvent de l'énoncé de l'exercice
mais en grande partie de vous, programmeur.
▪ Le nombre de fonctions et/ou de procédures utilisées dans un algorithme, dépend grandement de vous,
programmeur.
▪ Enfin, la manière de décomposer votre algorithme en fonctions et procédure, dépend grandement de vous,
programmeur.
▪ La présence, l'absence et le nombre d'arguments utilisés au niveau des fonctions et procédure, dépend
grandement de vous, programmeur.
▪ Si votre fonction ou procédure n'a pas d'argument, c'est que là, vous allez travailler sur les variables glo-
bales. Mais si elles en possèdent, c'est que vous travaillerez sur des variables formelles (arguments formels)
EXERCICE 1
ALGORITHME budget;
VAR
budgl : REEL; (* budgl=budget global *)
PROCEDURE calcul_budget(var p: REEL);
VAR
r, bud_sec, bud_se, bud_smi, bud_so: REEL; (*r va contenir le reste, bud_sec=budget du service des examens et concours,
bud_se= budget du service d'évaluation, bud_smi=budget du service du mobilier et l'immobilier, bud_so=busget du service de
l'orientation *)
DEBUT (* Début du corps de la procédure *)
bud_so  p * 10/100;
r  p – bud_so;
bud_sec  r*1/3;
bud_se  bud_sec *3/4;
bud_smi  p – (bud_so + bud_sec + bud_se);
AFFICHER ('Le budget alloué au service de l'orientation est:' , bud_so);
AFFICHER ('Le budget alloué au service des examens et concours est:' , bud_sec);
AFFICHER ('Le budget alloué au service d'évaluation est:' , bud_se);
AFFICHER ('Le budget alloué au service du mobilier et de l'immobilier est:' , bud_smi);
FIN; (* Fin de la procédure *)
AFFICHER ('Entrez le budget global alloué au ministère') ;
SAISIR (budgl);
calcul_budget(budgl); (* Appel de la procédure calcul_budget *)
EXERCICE 2
ere
1 méthode: Utilisation d'une fonction
ALGORITHME pgcd;
VAR
a, b, pg: ENTIER; (* a et b vont contenir les entiers à saisir et pg =pgcd de a et de b *)

FONCTION calcul_pgcd(VAR x, y: ENTIER): ENTIER;
VAR
min: ENTIER;
DEBUT (* Début du corps de la fonction *)
SI x < y ALORS
DSI
min  x;
FSI;
SINON (* y  x *)
DSINON
min  y;
FSINON;
TQ (min 1) ET ( (x MOD min  0) ou ( y MOD min  0) ) FAIRE
DTQ
min  min – 1;
FTQ;
calcul_pgcd  min;
FIN; (* Fin de la fonction *)
SAISIR (a, b) ;
pg  calcul_pgcd(a,b); (* Appel de la fonction calcul_pgcd *)
AFFICHER ('Le PGCD de' , a, 'et de' , b , 'est:' , pg);
2e méthode: Utilisation d'une procédure

ALGORITHME pgcd;
VAR
a, b: ENTIER (* a et b vont contenir les entiers à saisir *)
PROCEDURE calcul_pgcd(VAR x, y: ENTIER);
VAR
min: ENTIER;
SI x < y ALORS
DSI
min  x;
FSI;
SINON (* y  x *)
DSINON
min  y;
FSINON;
TQ (min 1) ET ( (x MOD min  0) ou ( y MOD min  0) ) FAIRE
DTQ
min  min – 1;
FTQ;
AFFICHER ('Le PGCD de' , a, 'et de' , b , 'est:' , min);
SAISIR (a, b) ;
calcul_pgcd(a,b); (* Appel de la procédure calcul_pgcd *)
EXERCICE3
ALGORITHME tarif ;
VAR
tarif_N: REEL ; (* tarif_N=tarif normal *)
cat: CARACTERE; (* cat =catégorie *)

PROCEDURE tarif_payer (VAR X: REEL; C: CARACTERE);

VAR
tarif_Ap: REEL;
SUIVANT C FAIRE
'N', 'n' : tarif_Ap  X ;
'A', 'a' : tarif_Ap  X - (X * 40 /100) ;
'E', 'e', ’T’, ‘t’ : tarif_Ap  0;
'P', 'p' : tarif_Ap  X - (X * 50/100) ;
'V', 'v' :tarif_Ap  X - (X * 30 /100) ;
FSUIVANT;
AFFICHER ('Le tarif à payer est :' ,tarif_Ap) ;
AFFICHER ('Entrer le tarif Normal');
SAISIR (tarif_N) ;
REPETER
AFFICHER ('Entrez la catégorie du voyageur') ;
SAISIR (cat) ;
JUSQU'A (cat = ‘N’) OU (cat = 'n') OU (cat = 'A') OU (cat = 'a') OU (cat = 'E') OU (cat = 'e') OU (cat = 'T') OU (cat = 't') OU (cat =
'P') OU (cat = 'p') OU (cat = 'V') OU (cat = 'v');
tarif_payer(tarif_N, cat); (* Appel de la procédure tarif_payer *)
EXERCICE 4
ALGORITHME menu;
VAR
a, b, c, op: REEL ; (* a,b, c pour les 3 réels et op= résultat de l'opération *)
choix: ENTIER; (* choix pour le choix de l'opération *)
FONCTION somme (VAR x, y, z: REEL): REEL;
VAR
p: REEL;
DEBUT (* Début du corps de la fonction somme *)
p  x + y + z;
somme  p;
FIN; (* Fin du corps de la fonction somme *)
FONCTION moyenne (VAR q, v, n: REEL): REEL;
VAR
k: REEL;
DEBUT (* Début du corps dela fonction moyenne *)
k  (q + v + n)/3;
moyenne  k;
FIN; (* Fin du corps de la fonction moyennne *)
FONCTION produit (VAR x, y, z: REEL): REEL;
VAR
p: REEL;
DEBUT (* Début du corps de la fonction produit *)
p x*y*z;
produit p;
FIN; (* Fin du corps de la fonction produit *)
AFFICHER ('Entrez 1 pour effectuer la somme des trois nombres') ;
AFFICHER ('Entrez 2 pour effectuer le produit des trois nombres') ;
AFFICHER ('Entrez 3 pour effectuer la moyenne des trois nombres') ;
REPETER
AFFICHER ('Faites votre choix') ;
SAISIR (choix) ;

JUSQU'A (choix = 1) ou (choix = 2) ou (Choix = 3 ) ;

AFFICHER ('Entrez les trois nombres réels') ;
SAISIR (a, b, c) ;
SI choix = 1 ALORS
DSI
op  somme(a, b, c); (* Appel de la fonction somme *)
FSI;
SI choix = 2 ALORS
DSI
op  produit(a, b, c); (* Appel de la fonction produit *)
FSI;
SI choix = 3 ALORS
DSI
op  moyenne(a, b, c); (* Appel de la fonction moyenne *)
FSI;
AFFICHER ('Le résultat de l'opération est :', op);
EXERCICE 5
ALGORITHME calcul_salaire;
VAR
part_ent, part_globale :REEL ; (* part_ent=ce que la société gagne sur 1 chauffeur et part_global=le total des part_ent *)
j: ENTIER; (* j pour parcourir les 20 chauffeurs et i pour effectuer les 26 versements *)
PROCEDURE versements;
VAR
i: ENTIER;
som_vers, salaire, vers: REEL;
DEBUT
som_vers  0;
POUR i  1 à 26 FAIRE (* Gestion des 26 versements *)
DPOUR
AFFICHER ('Entrez le versement n°' , i, 'du chauffeur n°' , j);
SAISIR(vers);
som_vers  som_vers + vers;
FPOUR;
salaire som_vers *20/100;
AFFICHER ('Le salaire du chauffeur n°' , j, 'est:' , salaire);
part_ent  som_vers – salaire;
FIN;
part_globale  0;
POUR j  1 à 20 FAIRE (* Parcours des 20 chauffeurs *)
DPOUR
versements; (* Appel de la procédure versements *)
part_globale  part_globale + part_ent;
FPOUR;
AFFICHER ('La part globale de la société est:' , part_globale);
Remarques:
▪ Vous constatez que dans la procédure versements, nous y avons utilisé des variables globales qui sont: part_ent et j
; parce qu'on aura besoin de ces variables après être sorti de la procédure versements.
▪ De surcroît, la procédure versements n'a pas d'argument.
EXERCICE6
ALGORITHME pensionnaires ;
VAR
nbp, nbpu, nbc, nbm, age, I: ENTIER ;
PROCEDURE categorie (VAR g: ENTIER);


SUIVANT g FAIRE
6,7 : DEBUT
AFFICHER ('Poussin');
nbp  nbp + 1;
FIN;
8, 9, 10 : DEBUT
AFFICHER ('Pupille');
nbpu  nbpu + 1;
FIN;
11, 12, 13 : DEBUT
AFFICHER ('Minime') ;
nbm  nbm + 1;
FIN;
SINON (* C'est-à-dire si l'âge  {6, 7, 8, 9, 10, 11, 12, 13} *)
DSINON
AFFICHER ('Cadet') ;
nbc  nbc + 1 ;
FSINON ;
FIN SUIVANT ;
FIN; (* Fin du corps de la procédure *)
Nbp  0 ; nbpu  0 ; nbm  0 ; nbc  0 ;
DPOUR
REPETER
AFFICHER ('Entrez l'age de l'enfant n° ' , I);
SAISIR (age) ;
JUSQU'A (age  6) ET (age  20);
categorie(age); (* Appel de la procédure categorie *)
FPOUR;
AFFICHER ('Le nombre d'enfant poussin est :' , nbp) ;
AFFICHER ('Le nombre d'enfant pupille est :' , nbpu) ;
AFFICHER ('Le nombre d'enfant minime est :' , nbm) ;
AFFICHER ('Le nombre d'enfant cadet est :' , nbc) ;
Remarques:
▪ Vous constatez que dans la procédure versements, nous y avons utilisé des variables globales qui sont: nbp, nbpu,
nbc et nbm; parce qu'on aura besoin de ces variables après avoir sorti de la procédure categorie.
EXERCICE7
ALGORITHME bourse;
VAR
i, moy, nbA, nbE, nbp: REEL; (* i pr parcourir les candidats, moy= moyenne, nbE, nbA=nbr de boursiers en Afrqiue et Eur, nbp= nbre de postulatns *)
PROCEDURE examiner_dossier (VAR n: REEL);
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure examiner_dossier *)
POUR i  1 à n FAIRE
DPOUR
AFFICHER (‘Entrer la moyenne annuelle du postulant n°' , i);
SAISIR (moy);
SI moy >15 ALORS
DSI
nbE  nbE + 1 ;
FSI;
SI (moy >12) ET (moy<15) ALORS
DSI
nbA  nbA +1 ;

FSI;
FPOUR;
(* Fin du corps de la procédure examiner_dossier *)
FIN;
AFFICHER (‘Entrez le nombre de postulants’);
SAISIR (nbp) ;
nbE  0 ; nbA  0 ;
examiner_dossier(nbp); (* Appel de la procédure examiner_dossier *)
AFFICHER ('Le nombre de boursiers pour l’Afrique est :' , nbA);
AFFICHER ('Le nombre de boursiers pour l’Europe est :' , nbE);
EXERCICE 8
1)
ALGORITHME salaire ;
VAR
Mt_V, salaire: REEL;
FONCTION calcul_salaire (Var p: REEL): REEl;
VAR
Cms, fd, sal: REEL;
DEBUT (* Début du corps de la fonction *)
Cms  p* 5/100 ;
fd  (600 000 + Cms)*10/100 ;
sal  600 000 + Cms + fd ;
calcul_salaire  sal;
FIN; (* Fin de la fonction *)
AFFICHER ('Entrez le montant des ventes réalisées par le vendeur');
SAISIR (Mt_V) ;
salaire  calcul_salaire (Mt_V); (* Appel de la fonction calcul_salaire *)
AFFICHER ('Le salaire du vendeur est:' , salaire);
2)
ALGORITHME salaire_vendeurs;
VAR
nbv, j: ENTIER; (* nbv = Nombre de vendeurs et j pour parcourir les différents vendeurs *)
Mt_V, salaire: REEL; (* j pour parcourir les différents vendeurs, Mt_V= montant des ventes *)
FONCTION calcul_salaire (Var p: REEL): REEL;
VAR
Cms, fd, sal: REEL;
DEBUT
Cms  p* 5/100 ;
fd  (600 000 + Cms)*10/100 ;
sal  600 000 + Cms + fd ;
calcul_salaire  sal;
FIN;
AFFICHER ('Entrez le nombre de vendeurs');
SAISIR (nbv) ;
POUR j  1 à nbv FAIRE (* Pour parcourir les différents vendeurs *)
DPOUR
AFFICHER ('Entrez le montant des ventes réaliées par le vendeur n°' , j);
SAISIR (Mt_V) ;
salaire  calcul_salaire (Mt_V); (* Appel de la fonction calcul_salaire *)
AFFICHER ('Le salaire du vendeur est:' , salaire);
FPOUR;

EXERCICE 9
VAR
PROCEDURE nombre_billets (Var N: REEL);
VAR
q1, q2, q3, q4, r1, r2, r3: ENTIER;
q1  N DIV 10000;
r1  N MOD 10000;
q2  r1 DIV 5000;
r2  r1 MOD 5000;
q3  r2 DIV 2000;
r3  r2 MOD 2000;
q4  r3 DIV 1000;
SAISIR (Mt) ;
nombre_billets(Mt); (* Appel de la procédure nombre_billets *)
EXERCICE 10
ALGORITHME capital_interet;
VAR
S, T: REEL; (* S= Somme initiale placée, T=taux d'intérêt *)
N: ENTIER; (* N= Nombre d'années de placement *)
PROCEDURE calcul_cap_int (VAR a, b: REEL; VAR C: ENTIER);
VAR
I: ENTIER;
interet: REEL;
POUR I 1 à C FAIRE
DPOUR
interet  a*b/100;
a  a + interet;
AFFICHER ('Le montant des intérêts à la fin de l'année n°' , i, 'est:' , interet);
AFFICHER ('Le montant du capital à la fin de l'année n°' , i, 'est:' , a);
FPOUR;
AFFICHER ('Entrez le capital initial');
SAISIR (S);
AFFICHER ('Entrez le taux d'intérêt en %');
SAISIR (T);
AFFICHER ('Entrez le nombre d'année de placement');
SAISIR (N);
calcul_cap_int(S, T, N); (* Appel de la procédure calcul_cap_int *)

EXERCICE 11
ALGORITHME moyenne;
VAR
moy, moy_max, som, moy_gle, moy_mat, moy_max_mat, moy_info, moy_max_info, moy_A, moy_max_A, noteTL, noteD:
REEL;
I, j, k, l, m: ENTIER;
PROCEDURE calcul_moyenne_matieres;
DEBUT (* Début du corps de la procédure calcul_moyenne_matieres *)
AFFICHER ('ETUDAINT n°', I);
AFFICHER ('Entrez la note de test lourd d'informatique');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir d'informatique');
SAISIR (noteD);
moy_info  (noteTL*5 + noteD*3)/8;
AFFICHER ('Entrez la note de test lourd de mathématiques');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir de mathématiques');
SAISIR (noteD);
moy_mat  (noteTL*5 + noteD*3)/8;
AFFICHER ('Entrez la note de test lourd d'anglais');
SAISIR (noteTL);
AFFICHER ('Entrez la note de devoir d'anglais');
SAISIR (noteD);
moy_A  (noteTL*5 + noteD*3)/8;
FIN; (* Fin du corps de la procédure calcul_moyenne_matieres *)
PROCEDURE moyenne_max_info;
DEBUT (* Début du corps de la procédure moyenne_max_info *)

SI moy_info > moy_max_info ALORS
DSI
moy_max_info  moy_info;
j  I;
FSI;
FIN; (* Fin du corps de la procédure moyenne_max_info *)
PROCEDURE moyenne_max_mat;
DEBUT (* Début du corps de la procédure moyenne_max_mat *)

SI moy_mat > moy_max_mat ALORS
DSI
moy_max_mat  moy_mat;
k  I;
FSI;
FIN; (* Fin du corps de la procédure moyenne_max_mat *)
PROCEDURE moyenne_max_A;
DEBUT (* Début du corps de la procédure moyenne_max_A *)

SI moy_A > moy_max_A ALORS
DSI
moy_max_A  moy_A;
l  I;
FSI;
FIN; (* Fin du corps de la procédure moyenne_max_A *)

PROCEDURE moyenne_max_classe;
DEBUT (* Début du corps de la procédure moyenne_max_classe *)
SI moy > moy_max ALORS
DSI
moy_max  moy;
m  I;
FSI;
FIN; (* Fin du corps de la procédure moyenne_max_classe *)
PROCEDURE calcul_moyenne_classe(VAR a, b, c: REEL);
DEBUT (* Début du corps de la procédure calcul_moyenne_classe *)

moy  (a*4 + b*3 + c*2)/9;
AFFICHER ('La moyenne de l'étudiant n°' , I, 'est:' , moy);
FIN; (* Fin du corps de la procédure calcul_moyenne_classe *)

som  0; moy_max_mat  0; moy_max_info  0; moy_max_A 0; moy_max  0;
DPOUR
calcul_moyenne_matieres; (*Pour le calcul des moyennes dans les  matières *)
moyenne_max_info; (*Pour déterminer la moyenne maximale en informatique *)
moyenne_max_mat; (*Pour déterminer la moyenne maximale en mathématiques *)
moyenne_max_A; (*Pour déterminer a moyenne maximale en anglais *)
calcul_moyenne_classe(moy_info, moy_mat, moy_A); (*Pour le calcul de la moyenne de classe de l'étudiant *)
moyenne_max_classe; (*Pour déterminer le 1er de la classe *)
som  som + moy;
FPOUR;
moy_gle  som/25;
AFFICHER ('Le 1er en informatique est l'étudiant n°' , j ,' et il a obtenu ' , moy_max_info);
AFFICHER ('Le 1er en mathématique est l'étudiant n°' , k ,' et il a obtenu ' , moy_max_mat);
AFFICHER ('Le 1er en anglais est l'étudiant n°' , l ,' et il a obtenu ' , moy_max_A);
AFFICHER ('Le 1er de classe est l'étudiant n°' , m ,' et il a obtenu ' , moy_max);
AFFICHER ('La moyenne générale de la classe est:' , moy_gle);


۩ Par moment, certains exercices demandent un peu plus de concentrations, d'effort, d'intuition et de logique!
EXERCICE 1
Posons le problème
- Les afficher par la suite, du plus petit au plus grand.
Méthode
▪ Saisir les 10 réels, en les mettant dans un tableau de 10 cases, en raison d'un réel par case.
▪ Trier par la suite le tableau par ordre croissant.
Exemple: Tableau initial:
25 78 45 -2 12.5 47.95 -50 0 35 480
Tableau trié:
-50 -2 0 12.5 25 35 45 47.95 78 480
Remarque: Dans tout exercice où il est question de tri, il faudra nécessairement recourir au(x) tableau(x).
1ère méthode: Utilisation de POUR…FAIRE

ALGORITHME tri_croissant;
VAR
T: TABLEAU[10] de REEL; (* Le tableau va servir à contenir les 10 réels *)
temp: REEL; (* temp va servir de variable intermédiaire lors de l'échange des valeurs *)
i, j: ENTIER; (* i et j vont servir à parcourir le tableau T *)
DEBUT
(* Remplissage du tableau T *)
DPOUR
AFFICHER ('Entrez le réel n°' , i);;
SAISIR(T[i]);
FPOUR;
(* Tri par ordre croissant à présent du tableau T *)
DPOUR
POUR j  i+1 à 10 FAIRE
DPOUR
SI T[j] < T[i] ALORS
DSI
temp  T[i];
T[i]  T[j]
T[j]  temp;
FSI;
FPOUR;
FPOUR;
AFFICHER('Les éléments triés du tableau par ordre croissant sont:' );
DPOUR
AFFICHER(T[i]);
FPOUR;
FIN.

Reprise de la 1ere méthode de l'exercice 1 mais en utilisant des fonctions et procédures

VAR
PROCEDURE saisie_nombres;
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure saisie_nombres *)
DPOUR
AFFICHER ('Entrez le réel n°' , i);
SAISIR(T[i]);
FPOUR;
FIN; (* Fin du corps de la procédure saisie_nombres *)
PROCEDURE trier_croissant;
VAR
i, j: ENTIER;
temp: REEL;
DEBUT (* Début du corps de la procédure trier_croissant *)
DPOUR
DPOUR
DSI
temp  T[i];
T[i]  T[j]
T[j]  temp;
FSI;
FPOUR;
FPOUR;
FIN; (* Fin du corps de la procédure trier_croissant *)
PROCEDURE affichage;
VAR
k: ENTIER;
DEBUT (* Début du corps de la procédure affichage *)
AFFICHER('Les nombres triés par ordre croissant sont:');
POUR k  1 à 10 FAIRE
DPOUR
AFFICHER (T[k]);
FPOUR;
FIN; (* Fin du corps de la procédure affichage *)

saisie_nombres; (* Appel de la procédure saisie_nombres pour le remplissage du tableau T *)
trier_croissant; (* Appel de la procédure trier_croissant le tri par ordre croissant du tableau T *)
affichage; (*Appel de la procédure affichage pour afficher les données triées du tableau *)

2e méthode: Utilisation de TANT QUE …FAIRE

VAR
DEBUT
i  1;
TQ i  10 FAIRE
DTQ
SAISIR(T[i]);
i  i + 1; (* Pour modifier la valeur du compteur i *)
FTQ;
i  1;
TQ i  9 FAIRE
DTQ
j  i + 1;
TQ j  10 FAIRE
DTQ
DSI
temp  T[i];
T[i]  T[j]
T[j]  temp;
FSI;
j  j + 1; (* Pour modifier la valeur du compteur i *)
FTQ;
i  i + 1;
FTQ;
i  1;
TQ i  10 FAIRE
DTQ
AFFICHER(T[i]);
i  i + 1;
FTQ;
FIN.
3e méthode: Utilisation de REPETER…JUSQU'A

VAR
DEBUT
i  0;
REPETER
i  i + 1; (* Pour modifier la valeur du compteur i *)
SAISIR(T[i]);
JUSQU'A i =10;
i  0;
REPETER

i  i + 1;
j  i + 1;
REPETER
DSI
temp  T[i];
T[i]  T[j]
T[j]  temp;
FSI;
j  j + 1;
JUSQU'A j = 10;
JUSQU'A i = 9;
i  0; (* on pouvait aussi utiliser j à la place de i *)
REPETER
i  i + 1;
AFFICHER(T[i]);
JUSQU'A i = 10;
FIN.
Remarque: Pour le tri, vous remarquerez que l'utilisation de la boucle POUR…FAIRE, est plus simple à utiliser.
EXERCICE 2
Posons le problème
- Chercher le plus petit parmi les 20 réels saisis et sa position (dans l'ordre de saisie).
- Enfin, les afficher.
Méthode
▪ Saisir les 20 réels, en les mettant dans un tableau de 20 cases, en raison d'un réel par case.
▪ Chercher par la suite le plus petit. Démarrer cette recherche en considérant que le 1er réel saisi est le plus petit.
ALGORITHME minimum ;
VAR
tab :TABLEAU[20] de REEL ; (* Pour recueillir les 20 réels *)
min : REEL ; (* Pour accueillir le minimum des 20 réels *)
i, pos : ENTIER ; (* i pour parcourir les 20 réels et pos pour la position du plus petit réel *)
DEBUT
POUR i  1 à 20 FAIRE (* Remplissage du tableau tab *)
DPOUR
AFFICHER (‘Entrez le nombre n°’ , i) ;
SAISIR (tab[i]) ;
FPOUR ;
min  tab[1]; (* L'on considère que le 1er élément du tableau est le plus petit *)
pos  1; (* Par conséquent, pos prend pour valeur 1, 1 comme 1er élément *)
POUR i  2 à 20 FAIRE (* On démarre les comparaisons à partir du 2e élément *)
DPOUR
SI tab[i]< min ALORS
DSI
min  tab[i] ;
pos i ;
FSI;
FPOUR ;
AFFICHER ('Le minimum est :' , min, 'et sa position est' , pos);
FIN.

Reprise de l'exercice 2 mais en utilisant des fonctions et procédures

ALGORITHME minimum ;
VAR
tab :TABLEAU[20] de REEL ; (* Pour recueillir les 20 réels *)
PROCEDURE saisie_nombres;
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure saisie_nombres *)
DPOUR
AFFICHER ('Entrez le nombre n°' , i);;
SAISIR(tab[i]);
FPOUR;
FIN; (* Fin du corps de la procédure saisie_nombres *)
PROCEDURE recherche_minimum;
VAR
i, pos: ENTIER; (* i pour parcourir les 20 réels et pos pour la position du plus petit réel *)
min :REEL ; (* Pour accueillir le minimum des 20 réels *)
DEBUT (* Début du corps de la procédure recherche_minimum *)
min  tab[1]; (* L'on considère que le 1er élément du tableau est le plus petit *)
pos  1; (* Par conséquent, pos prend pour valeur 1, 1 comme 1er élément *)
POUR i  2 à 20 FAIRE (* On démarre les comparaisons à partir du 2e élément *)
DPOUR
SI tab[i]< min ALORS
DSI
min  tab[i] ;
pos i ;
FSI;
FPOUR ;
AFFICHER ('Le minimum est :' , min, 'et sa position est' , pos);
FIN; (* Fin du corps de la procédure recherche_minimum *)
saisie_nombres; (* Appel de la procédure saisie_nombres pour le remplissage du tableau T *)
recherche_minimum; (* Appel de la procédure recherche_minimum *)
FIN. (* Fin du corps du programme prinicipal *)
EXERCICE 3
Posons le problème
- Saisir la phrase. Mais veillez à ce qu'elle soit une phrase correcte (comportant un et un seul point et celui-ci est à la fin
de la phrase. Aussi après le point, la phrase ne doit plus continuer),
- Saisir par la suite la lettre à remplacer et celle remplaçante.
- Enfin, afficher le nombre de mots que comporte la phrase saisie et la nouvelle phrase obtenue (après la substitution d'une
lettre par une autre).
Méthode
▪ Pour déterminer le nombre de mots que comporte cette phrase.
Parcourir la phrase du début à la fin (caractère par caractère). Dès qu'une virgule ou un espace est trouvé, l'on conclut
qu'on a trouvé un mot. Utiliser un compteur pour compter le nombre de mots que l'on aura trouvé dans la phrase saisie.
▪ Pour remplacer une lettre par une autre.
Parcourir la phrase du début à la fin (caractère par caractère). Et à chaque fois que l'on trouve le caractère à remplacer,
faire la substitution.

ALGORITHME manipuler_phrase;
TYPE
ponct = ENSEMBLE de CARACTERE;
VAR
P: ponct; (* Ensemble contenant les ponctuations *)
phrase: CHAINE; (* Pour contenir la phrase à saisir *)
i, nbre_mot: ENTIER; (* i pour parcourir la phrase, nbre_mot= nombre de mot *)
lettre_R, lettre_AR, C: CARACTERE; (* lettre_R=lettre remplaçante, lettre_AR=lettre à remplacer *)
d: BOOLEEN;
FONCTION verifier_phrase( Var m: CHAINE): BOOLEEN; (* Vérifie si la phrase saisie est correcte ou pas *)
VAR
e, npt: ENTIER;
DEBUT (* Début du corps de la fonction verifier_phrase *)
npt 0; (* Compte le nombre de point dans la phrase *)
e 1;
TQ (e  LONGUEUR(m) ) ET (npt  1) FAIRE
DTQ
SI m[e] = '.' ALORS (* Pour savoir s'il y a plus d'1 point dans la phrase *)
DSI
npt  npt + 1;
SI e+1  LONGUEUR(m) ALORS (* La phrase continue après le point *)
DSI
npt  2; (* En tout cas donner à npt, une valeur >1 afin de sortir de la TQ…FAIRE *)
FSI;
FSI;
e  e +1;
FTQ;
SI (npt >1) ou (npt = 0) ALORS (* n>1=Il y a plus d'1 point dans la phrase et n= 0, pas de point *)
DSI
verifier_phrase  FAUX; (* Pour dire que ce qui a été saisi n'est pas une phrase correcte *)
FSI;
SINON
DSINON
verifier_phrase  VRAI; (* Pour dire que ce qui a été saisi est une phrase correcte *)
FSINON;
FIN; (* Fin de la fonction verifier_phrase *)
DEBUT
p  [' ', '.', ',']; (* ' ' = espace *)
REPETER
AFFICHER ('Entrez la phrase');
SAISIR (phrase);
AFFICHER ('Entrez la lettre remplaçante');
SAISIR (lettre_R);
AFFICHER ('Entrez la lettre à remplacer');
SAISIR (lettre_AR);
JUSQU'A phrase  ""; (* Jusqu'à ce que l'utilisateur saisisse quelque chose *)
d  verifier_phrase(phrase);
SI d = FAUX ALORS
DSI
AFFICHER('Vous n'avez pas saisi une phrase correcte');
FSI;
SINON
DSINON
d  FAUX;
nbre_mot  0;
POUR i  1 à LONGUEUR(phrase) FAIRE
DPOUR
C  phrase[i];
SI C DANS P ALORS

DSI
SI (phrase[i-1]  ' ') ET (phrase[i-1]  ',') ALORS 
DSI
nbre_mot  nbre_mot + 1;
FSI;
FSI;
FPOUR;
AFFICHER('Le nombre de mots contenu dans la phrase est:' , nbre_mot);
POUR i  1 à LONGUEUR(phrase) FAIRE (* Remplacement de la lettre dans la phrase *)
DPOUR
SI phrase[i] = lettre_AR ALORS
DSI
phrase[i]  lettre_R;
d  VRAI;
FSI;
FPOUR;
SI d = FAUX ALORS
DSI
AFFICHER('La lettre à remplacer n'existe pas dans la phrase saisie');
FSI;
SINON
DSINON
AFFICHER ('La nouvelle phrase obtenue est:' , phrase);
FSINON;
FSINON;
FIN.
 Pour gérer des cas comme par exemples:
Il dort. (Plusieurs espaces de suite entre il et dort),
Il dort . (Plusieurs espaces de suite entre dort et le point),
Il dort, et parle. . (Plusieurs espaces après la virgule),
Il dort,,,. . (Plusieurs virgules de suite).
ALGORITHME manipuler_phrase;
TYPE
ponct = ENSEMBLE de CARACTERE;
VAR
P: ponct; (* Ensemble contenant les ponctuations *)
phrase: CHAINE; (* Phrase à saisir *)
lettre_R, lettre_AR, C: CARACTERE; (* lettre_R=lettre remplaçante, lettre_AR=lettre à remplacer *)
d: BOOLEEN;
PROCEDURE saisie_donnees;
DEBUT
REPETER
AFFICHER ('Entrez la phrase');
SAISIR (phrase);
AFFICHER ('Entrez la lettre remplaçante');
SAISIR (lettre_R);
AFFICHER ('Entrez la lettre à remplacer');
SAISIR (lettre_AR);
JUSQU'A phrase  "" (* Jusqu'à ce que l'utilisateur saisisse quelque chose *)
FIN;
FONCTION verifier_phrase( Var m: CHAINE): BOOLEEN;(* Vérifie si la phrase saisie est correcte ou pas *)
VAR
e, npt: ENTIER;
DEBUT (* Début du corps de la fonction verifier_phrase *)
npt 0; (* Compte le nombre de point dans la phrase *)
e 1;
TQ (e  LONGUEUR(m) ) ET (npt  1) FAIRE

DTQ
SI m[e] = '.' ALORS (* Pour savoir s'il y a plus d'1 point dans la phrase *)
DSI
npt  npt + 1;
SI e+1  LONGUEUR(m) ALORS (* La phrase continue après le point *)
DSI
npt  2; (* En tout cas donner à npt, une valeur >1 afin de sortir de la TQ…FAIRE *)
FSI;
FSI;
e  e +1;
FTQ;
SI (npt >1) ou (npt = 0) ALORS (* n>1=Il y a plus d'1 point dans la phrase et n= 0, pas de point *)
DSI
verifier_phrase  FAUX; (* Pour dire que ce qui a été saisi n'est pas une phrase correcte *)
FSI;
SINON
DSINON
verifier_phrase  VRAI; (* Pour dire que ce qui a été saisi est une phrase correcte *)
FSINON;
FIN; (* Fin de la fonction verifier_phrase *)
PROCEDURE compte_mots;
VAR
nbre_mot, i: ENTIER; (* i pour parcourir la phrase, nbre_mot= nombre de mot *)
DEBUT (* Début de la procédure compte_mots *)
nbre_mot  0;
DPOUR
C  phrase[i];
SI C DANS P ALORS
DSI
SI (phrase[i-1]  ' ') ET (phrase[i-1]  ',') ALORS
DSI
nbre_mot  nbre_mot + 1;
FSI;
FSI;
FPOUR;
AFFICHER('Le nombre de mots contenu dans la phrase est:' , nbre_mot);
FIN; (* Fin de la procédure compte_mots *)
PROCEDURE remplacement_lettre;
VAR
i: ENTIER;
ver: BOOLEEN;
DEBUT (* Début de la procédure remplacement_lettre *)
ver  FAUX;
DPOUR
SI phrase[i] = lettre_AR ALORS
DSI
phrase[i]  lettre_R;
ver  VRAI;
FSI;
FPOUR;
SI ver = FAUX ALORS
DSI
AFFICHER('La lettre à remplacer n'existe pas dans la phrase saisie');
FSI;
SINON
DSINON
AFFICHER ('La nouvelle phrase obtenue est:' , phrase);
FSINON;

FIN; (* Fin de la procédure remplacement_lettre *)
p  [' ', '.', ',']; (* ' ' = espace *)
saisie_donnees; (* Appel de la procédure saisie_donnees *)
d  verifier_phrase(phrase); (* Appel de la fonction verifier_phrase *)
SI d = FAUX ALORS
DSI
AFFICHER ('Vous n'avez pas saisi une phrase correcte');
FSI;
SINON
DSINON
compte_mots; (* Appel de la procédure compte_mots *)
remplacement_lettre; (* Appel de la procédure remplacement_lettre *)
FSINON;
EXERCICE 4
Posons le problème
- Saisir les 5 noms (1 par 1).
- Les trier selon l'ordre alphabétique, puis les afficher suivant cet ordre.
Méthode
Il s'agit ici d'un tri, donc l'on a recours nécessairement au tableau (pour le tri, voir l'exercice 1). Pour comparer 2 noms, il faut
comparer la 1ère lettre du 1er nom à la 1ère lettre du 2e nom. Là déjà, l'on peut savoir quel nom vient avant l'autre. Si l'on ne peut pas
conclure à ce niveau (cas où les deux 1ers caractères sont égaux), continuer les comparaisons sur les 2e caractères, et ainsi de
suite.
Exemple: Tableau initial:
Digbeu Yao Mel Adama Soro
Tableau trié dans l'ordre alphabétique
Adama Digbeu Mel Soro Yao
ALGORITHME ordre_alphabetique;
VAR
T: TABLEAU[5] de CHAINE; (* T pour contenir les 5 noms *)
temp: CHAINE; (* temp = variable intermédiaire qui sera utilisée lors de l'échange *)
i, j, k, min, Li, Lj: ENTIER;(* i et j pour parcourir les caractères, k permet de continuer la comparaison ou pas, min=le nom le + court, Li et Lj=
longueur des noms à comparer *)
verifier: BOOLEEN; (* Pour arrêter la comparaison des 2 noms *)
DEBUT
POUR i  1 à 5 FAIRE (* Remplissage du tableau par les différents noms *)
DPOUR
AFFICHER(' Entrez le nom n°' , i);
SAISIR(T[i]);
FPOUR;
POUR i  1 à 4 FAIRE (* Tri du tableau *)
DPOUR
DPOUR
Li  LONGUEUR (T[i]);
Lj  LONGUEUR (T[j]);
SI Li < Lj ALORS
DSI
min  Li;
FSI;
SINON
DSINON
min  Lj;
FSINON;
verifier  FAUX;

K  1;
TQ (k  min) ET (verifier = FAUX) FAIRE
DTQ
SI T[j][k] < T[i][k] ALORS (* Comparaison des caractères n°k *) 
DSI
temp  T[i];
T[i]  T[j];
T[j]  temp;
verifier  VRAI; (* Pour arrêter la comparaison *)
FSI;
SINON (* T[j][k] > T[i][k] ou T[j][k] = T[i][k] *)
DSINON
SI T[j][k] > T[i][k] ALORS 
DSI
FSI;
SI T[j][k] = T[i][k] ALORS 
DSI
K  k+1; (* On continue la comparaison *)
FSI;
FSINON;
FTQ;
SI (k > min) ET (Li > Lj) ALORS 
DSI
temp  T[i];
T[i]  T[j];
T[j]  temp;
FSI;
FPOUR;
FPOUR;
AFFICHER ('Le classement par ordre alphabétique est:');
DPOUR
AFFICHER (T[i]);
FPOUR;
FIN.
Explications:
 Comparaison des caractères de même rang k, des 2 noms à comparer (Ici les caractères en gras sont de rang 1
donc k=1)
Yao Mathieu
i j
 Ici les 2 noms sont déjà classés dans l'ordre alphabétique
Mathieu Yao
i j
 C'est la cas où les caractères à comparer des 2 noms, sont identiques (ceux en gras).
Mathias Mathieu
i j
 C'est ce cas par exemple où les 2 noms ont la même racine (Math) et le 1er nom continue après la racine tant disque
le second s'arrête.
Mathieu Math
i j

ALGORITHME ordre_alphabetique;
VAR
T: TABLEAU[5] de CHAINE; (* T pour contenir les 5 noms *)
PROCEDURE saisir_noms;
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure saisir_noms *)
POUR i  1 à 5 FAIRE (* Remplissage du tableau par les différents noms *)
DPOUR
AFFICHER(' Entrez le nom n°' , i);
SAISIR(T[i]);
FPOUR;
FIN; (* Fin du corps de la procédure saisir_noms *)
PROCEDURE trier_noms;
VAR
i, j, k, Li, Lj, min: ENTIER;
temp: CHAINE;
verifier: BOOLEEN;
DEBUT (* Début du corps de la procédure trier_noms *)
POUR i  1 à 4 FAIRE (* Tri du tableau *)
DPOUR
DPOUR
Li  LONGUEUR (T[i]);
Lj  LONGUEUR (T[j]);
SI Li < Lj ALORS
DSI
min  Li;
FSI;
SINON
DSINON
min  Lj;
FSINON;
verifier  FAUX;
K  1;
TQ (k  min) ET (verifier = FAUX) FAIRE
DTQ
SI T[j][k] < T[i][k] ALORS (* Comparaison des caractères n°k *)
DSI
temp  T[i];
T[i]  T[j];
T[j]  temp;
FSI;
SINON (* T[j][k] > T[i][k] ou T[j][k] = T[i][k] *)
DSINON
SI T[j][k] > T[i][k] ALORS
DSI
FSI;
SI T[j][k] = T[i][k] ALORS
DSI
K  k+1; (* On continue la comparaison *)
FSI;
FSINON;
FTQ;
SI (k > min) ET (Li > Lj) ALORS

DSI
temp  T[i];
T[i]  T[j];
T[j]  temp;
FSI;
FPOUR;
FPOUR;
FIN; (* Fin du corps de la procédure trier_noms *)
PROCEDURE affichage_resultat;
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure affichage_resultat *)
AFFICHER ('Le classement par ordre alphabétique est:');
DPOUR
AFFICHER (T[i]);
FPOUR;
FIN; (* Fin du corps de la procédure affichage_resultat *)
saisir_noms; (* Appel de la procédure saisir_noms *)
trier_noms; (* Appel de la procédure trier_noms *)
affichage_resultat; (* Appel de la procédure affichage_resultat *)
EXERCICE 5
Poser le problème
- Saisir les 12 salaires. Il faudra utiliser pour cela un tableau de 12 cases.
- Rechercher le salaire max, le salaire min et le salaire le plus fréquemment payé. Puis il faudra les afficher.
ALGORITHME salaire;
VAR
tab: TABLEAU[12] de REEL; (* tab va contenir les 12 salaires *)
P: TABLEAU[12] de ENTIER; (* P va contenir la fréquence des 12 salaires *)
sal_min , sal_max: REEL; (* sal_min = salaire mini et sal_max = salaire maxi *)
max, i, j : ENTIER ; (* i et j pour parcourir les 12 salaires et les manipuler et max=fréquence la + élevée *)
DEBUT
POUR i  1 à 12 FAIRE (* Remplissage du tableau par les différents salaires *)
DPOUR
AFFICHER ('Entrez le salaire n°' , i);
SAISIR (tab[i]);
FPOUR;
sal_max  tab [1];
sal_min  tab[1];
POUR i  2 à 12 FAIRE (* Détermination du salaire mini et maxi *)
DPOUR
SI tab[i ]  sal_max ALORS
DSI
sal_max  tab[i];
FSI;
SI tab[i]  sal_min ALORS
DSI
sal_min  tab[i];
FSI;
FPOUR ;
POUR i  1 à 12 FAIRE (* Attribution de la fréquence 1 à chaque salaire *)
DPOUR;
P[i]  1;
FPOUR;
POUR i  1 à 11 FAIRE (* Détermination de la fréquence de chaque salaire *) 
DPOUR

POUR j  (i+1) à 12 FAIRE

DPOUR
SI tab[i] = tab[j] ALORS
DSI
P[i]  p[i] +1;
FSI;
FPOUR;
FPOUR;
(* Harmonisation de la fréquence des salaires *)
POUR i  1 à 11 FAIRE 
DPOUR
DPOUR
DSI
P[j]  p[i];
FSI;
FPOUR;
FPOUR;
max  p[1] ;
DPOUR
SI p[i] > max ALORS
DSI
max  P[i];
FSI;
FPOUR;
AFFICHER ('Le salaire minimum est :' , sal_min);
AFFICHER ('Le salaire maximum est :' , sal_max );
AFFICHER ('Le(s) salaire(s) le(s) plus fréquemment payé(s) est:' );
POUR i  1 à 12 FAIRE (* Parcours des salaires pour voir les + fréquemment payés, à l'aide de max *) 
DPOUR
SI P[i] = max ALORS
DSI
AFFICHER(tab[i]);
FSI;
FPOUR;
FIN.
Explications:

Soit le tableau tab des salaires:
1 2 3 4 5 6 7 8 9 10 11 12
250000 300000 500000 250000 800000 280000 250000 300000 750000 900000 800000 300000
Le contenu du tableau P des fréquences, après le déroulement de l'algorithme, est le suivant:

1 2 3 4 5 6 7 8 9 10 11 12
3 3 1 2 1 1 1 1 1 1 1 1
Il y a des anomalies car des salaires identiques n'ont pas les mêmes fréquences! C'est donc pour palier cela, qu'on a
fait le  au niveau de l'algorithme. Ce qui va donner ceci désormais:
1 2 3 4 5 6 7 8 9 10 11 12
250000 300000 500000 250000 800000 280000 250000 300000 750000 900000 800000 300000
Le contenu du tableau P des fréquences, après le déroulement de l'algorithme, est le suivant désormais:
1 2 3 4 5 6 7 8 9 10 11 12
3 3 1 3 1 1 3 3 1 1 2 3
 Exemple
Soit le tableau tab des salaires:
1 2 3 4 5 6 7 8 9 10 11 12
250000 300000 500000 250000 800000 280000 250000 300000 750000 900000 800000 300000

Le contenu du tableau P des fréquences, après le déroulement de l'algorithme, est le suivant:

1 2 3 4 5 6 7 8 9 10 11 12
3 3 1 3 1 1 3 3 1 1 2 3
Ainsi en parcourant le tableau P (au  au niveau de l'algorithme), l'on verra que le maximum des fréquences est: 3
(soit P[1] et P[2]). Donc, les salaires les plus fréquemment payés sont: tab[1] et tab[2], soit 250 000 et 300 000.
Mais tel que c'est fait, à l'exécution, l'on va afficher 3 fois 250 000; pareil pour 300 000, comme les salaires les + fré-
quemment payés. La logique voudrait que l'on affiche une seule fois 250 000 et 300 000. Pour réussir cela, je propose
ce code:
(* Il faudra déclarer une variable de type BOOLEEN, du nom de existe qui permettra de savoir si la salaire a déjà été
affiché ou pas *)
POUR i  1 à 12 FAIRE (* Parcours des salaires pour voir les + fréquemment payés, à l'aide de max *)
DPOUR
SI (i = 1) ET (P[i] = max) ALORS (* C'est que nous sommes sur le 1 er salaire *)
DSI
AFFICHER(tab[i]);
FSI;
SINON (* Nous avons dépassé le 1er salaire *)
DSINON
existe  FAUX; j  1;
TQ (j i-1) ET (existe = FAUX) FAIRE
DTQ
DSI
existe  VRAI; (* Ce qui veut dire que ce salaire existe déjà *)
FSI;
j  j+1;
FTQ;
SI (P[i] = max) ET (existe = FAUX) ALORS (* Il est + fréquent et n'a pas encore été affiché *)
DSI
AFFICHER(tab[i]);
FSI;
FSINON;
FPOUR;

ALGORITHME salaire;
VAR
tab: TABLEAU[12] de REEL; (* tab va contenir les 12 salaires *)
PROCEDURE saisir_salaires;
VAR
i: ENTIER;
DEBUT (* Début du corps de la procédure saisir_salires *)
POUR i  1 à 12 FAIRE (* Remplissage du tableau par les différents salaires *)
DPOUR
AFFICHER ('Entrez le salaire n°' , i);
SAISIR (tab[i]);
FPOUR;
FIN; (* Fin du corps de la procédure saisir_salires *)
PROCEDURE salaire_max_min;
VAR
i: ENTIER;
sal_max, sal_min: REEL;
DEBUT (* Début du corps de la procédure salaire_max_min *)
sal_max  tab [1];
sal_min  tab[1];
POUR i  2 à 12 FAIRE (* Détermination du salaire mini et maxi *)
DPOUR
SI tab[i ]  sal_max ALORS
DSI
sal_max  tab[i];

FSI;
SI tab[i]  sal_min ALORS
DSI
sal_min  tab[i];
FSI;
FPOUR ;
AFFICHER ('Le salaire minimum est :' , sal_min);
AFFICHER ('Le salaire maximum est :' , sal_max );
FIN; (* Fin du corps de la procédure salaire_max_min *)
PROCEDURE salaire_freq;
VAR
i, j, max: ENTIER;
P: TABLEAU[12] de ENTIER; (* P va contenir la fréquence des 12 salaires *)
DEBUT (* Début du corps de la procédure salaire_freq *)
POUR i  1 à 12 FAIRE (* Attribution de la fréquence 1 à chaque salaire *)
DPOUR
P[i]  1;
FPOUR;
POUR i  1 à 11 FAIRE (* Détermination de la fréquence de chaque salaire *)
DPOUR
DPOUR
DSI
P[i]  p[i] +1;
FSI;
FPOUR;
FPOUR;
(* Harmonisation de la fréquence des salaires *)
DPOUR
DPOUR
DSI
P[j]  p[i];
FSI;
FPOUR;
FPOUR;
max  p[1] ;
DPOUR
SI p[i] > max ALORS
DSI
max  P[i];
FSI;
FPOUR;
AFFICHER ('Le(s) salaire(s) le(s) plus fréquemment payé(s) est:' );
POUR i  1 à 12 FAIRE (* Parcours des salaires pour voir les + fréquemment payés, à l'aide de max *)
DPOUR
SI P[i] = max ALORS
DSI
AFFICHER(tab[i]);
FSI;
FPOUR;
FIN; (* Fin du corps de la procédure salaire_freq *)
saisir_salaires; (* Appel de la procédure saisir_salaires *)
salaire_max_min; (* Appel de la procédure salaire_max_min *)
salaire_freq; (* Appel de la procédure salaire_freq *)

EXERCICE 6
Posons le problème
- Saisir le mot,
- Faire l'inversion du mot et l'afficher.
Méthode
Déclarer 2 variables de type CHAINE. L'une va contenir le mot à saisir et l'autre le mot inversé. Pour obtenir le mot inversé, il faudra
prendre le dernier caractère du mot saisi qui sera le 1 er caractère de la 2e variable; prendre l'avant dernier caractère du mot saisi
qui sera le 2e caractère de la 2e variable, prendre le caractère qui précède l'avant dernier caractère du mot saisi qui sera le 3 e carac-
tère de la 2e variable, et ainsi de suite.
1ère méthode
ALGORITHME inversion_mot;
VAR
mot, mot_inverse, C: CHAINE;
i, j: ENTIER;
DEBUT
AFFICHER('Entrez le mot');
SAISIR(mot);
mot_inverse  ""; (* mot_inverse est initialisé à la chaîne nulle *)
POUR i  1 à LONGUEUR(mot) FAIRE
DPOUR
j  i – 1;
C  COPIER(mot, LONGUEUR(mot), -j, 1); (* Permet de prendre les caractères, du dernier au 1 er *)
mot_inverse  mot_inverse + C;
FPOUR;
AFFICHER('Le mot inversé obtenu est:' , mot_inverse);
FIN.
2e méthode
VAR
mot, mot_inverse: CHAINE;
i, j: ENTIER;
DEBUT
SAISIR(mot);
mot_inverse  ""; (* mot_inverse est initialisé à la chaîne nulle *)
POUR i  0 à LONGUEUR(mot)-1 FAIRE
DPOUR
mot_inverse  mot_inverse + mot[LONGUEUR(mot) – i]; (* Permet de prendre les caractères, du dernier au 1er *)
FPOUR;
AFFICHER('Le mot inversé obtenu est:' , mot_inverse);
FIN.
Reprise de la 2e méthode de l'exercice 6 mais en utilisant des fonctions et procédures

VAR
mot, inverse: CHAINE;
FONCTION inverser_mot( pt: CHAINE): CHAINE;
VAR
i: ENTIER;
C: CHAINE;
DEBUT
C  ""; (* C est initialisé à la chaîne nulle *)
POUR i  0 à LONGUEUR(pt)-1 FAIRE
DPOUR
C  C + pt[LONGUEUR(pt) – i]; (* Permet de prendre les caractères, du dernier au 1er *)
FPOUR;
inverser_mot  C;

FIN;
SAISIR(mot);
inverse  inverser_mot (mot); (* Appel de la fonction inverser_mot *)
AFFICHER('Le mot inversé est:' , inverse);
EXERCICE 7
Posons le problème
- Saisir les informations concernant les étudiants qui viendront payer leur droit d'examen,
- A la fin, afficher le nombre total d'étudiant qui ont payé leur droit, le nombre de ceux n'ayant pas payé, le nombre d'étudiant
s'ayant acquitté de leur droit d'examen et ceux ne l'ayant pas fait et ceci par filière.
Méthode
Il faudra déclarer un tableau de 150 cases (150 = l'effectif de tous les étudiants). Et dans chaque case, il faudra y mettre le nom, le
prénom, la filière et le matricule d'un étudiant. Ce qui donne la structure suivante:
1 2 3 ……………..…………………………… 150
- Nom - Nom - Nom - Nom
- Prénom - Prénom - Prénom ………………………. - Prénom
- Filière - Filière - Filière - Filière
- Matricule - Matricule - Matricule - Matricule
Un enregistrement
Ce qui revient à déclarer un tableau d'enregistrements. Le tableau
ALGORITHME droit_examen;
TYPE
etudiant = ENREGISTREMENT (* Définition de l'enregistrement *)
nom: CHAINE[25];
prenom: CHAINE[50];
filiere: CHAINE[15];
matricule: CHAINE[15];
FINENRG;
VAR
T: TABLEAU[150] de etudiant;
i, ntp, nbIG, nbNTIC, nbELN, nbTLCOM: ENTIER;
rep: CARACTERE;
DEBUT
ntp  0; nbIG  0; nbNTIC 0; nbELN 0; nbTLCOM 0;
REPETER (* Ici on ne peut utiliser POUR…FAIRE car l'on ne sait pas d'avance le nbre d'étudiant qui vont soldé leur droit *)
ntp  ntp + 1;
AFFICHER('Entrez le nom de l'étudiant n°' , ntp);
SAISIR(T[ntp].nom);
AFFICHER('Entrez le prénom de l'étudiant n°' , ntp);
SAISIR(T[ntp].prenom);
AFFICHER('Entrez la filière de l'étudiant n°' , ntp);
SAISIR(T[ntp].filiere);
AFFICHER('Entrez le matricule de l'étudiant n°' , ntp);
SAISIR(T[ntp].matricule);
SI T[ntp].filiere = "IG" ALORS
DSI
nbIG  nbIG + 1;
FSI;
SI T[ntp].filiere = "NTIC" ALORS
DSI
nbNTIC  nbNTIC + 1;
FSI;

SI T[ntp].filiere = "ELN" ALORS

DSI
nbELN  nbELN + 1;
FSI;
SI T[ntp].filiere = "TLCOM" ALORS
DSI
nbTLCOM  nbTLCOM + 1;
FSI;
AFFICHER('Y a t il un autre étudiant? O pour OUI et N pour NON');
SAISIR(rep);
JUSQU'A (rep= 'N') OU (rep='n');
AFFICHER('Le nombre total des étudiants s'ayant acquitté de leur droit d'examen est:' , ntp);
AFFICHER('Le nombre total des étudiants n'ayant pas payé leur droit d'examen est:' , 150-ntp);
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit d'examen en IG est:' , 25-nbIG);
AFFICHER('Le nombre total des étudiants ayant payé leur droit d'examen en IG est:' , nbIG);
AFFICHER('Leur nom, prénom et matricule sont:');
POUR i  1 à ntp FAIRE (* Ici ntp et non 150 car il se peut que tout le monde n'ait pas payé *)
DPOUR
SI T[i].filiere = "IG" ALORS
DSI
AFFICHER(T[i].nom);
AFFICHER(T[i].prenom);
AFFICHER(T[i].matricule);
FSI;
FPOUR;
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en NTIC est:' , 50-nbNTIC);
AFFICHER('Le nombre total des étudiants ayant payé leur droit d'examen en NTIC est:' , nbNTIC);
DPOUR
SI T[i].filiere = "NTIC" ALORS
DSI
AFFICHER(T[i].nom);
FSI;
FPOUR;
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en ELN est:' , 30-nbELN);
AFFICHER('Le nombre total des étudiants ayant payé leur droit d'examen en ELN est:' , nbELN);
DPOUR
SI T[i].filiere = "ELN" ALORS
DSI
AFFICHER(T[i].nom);
FSI;
FPOUR;
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en TLCOM est:' , 45-nbTLCOM);
AFFICHER('Le nombre total des étudiants ayant payé leur droit en TLCOM est:' , nbTLCOM);
DPOUR
SI T[i].filiere = "TLCOM" ALORS

DSI
AFFICHER(T[i].nom);
FSI;
FPOUR;
FIN.
Ici j'ai fait le programme avec une procédure qui appelle une autre procédure.
ALGORITHME droit_examen;
TYPE
etudiant = ENREGISTREMENT (* Définition de l'enregistrement *)
nom: CHAINE[25];
prenom: CHAINE[50];
filiere: CHAINE[15];
matricule: CHAINE[15];
FINENRG;
VAR
T: TABLEAU[150] de etudiant; (* 150 = nombre total de tous les étudiants *)
ntp: ENTIER;
PROCEDURE affichage_info (VAR n: CHAINE);

VAR i: ENTIER;
DEBUT (* Début du corps de la procédure affichage_info *)
DPOUR
SI T[i].filiere = n ALORS
DSI
AFFICHER(T[i].nom);
FSI;
FPOUR;
FIN; (* Début du corps de la procédure affichage_info *)
PROCEDURE saisir_info;
VAR
nbIG, nbNTIC, nbELN, nbTLCOM: ENTIER;
rep: CARACTERE;
C: CHAINE;
DEBUT (* Début du corps de la procédure saisir_info *)
ntp  0; nbIG  0; nbNTIC  0; nbELN  0; nbTLCOM  0;
REPETER
ntp  ntp + 1;
AFFICHER('Entrez le nom de l'étudiant n°' , ntp);
SAISIR(T[ntp].nom);
AFFICHER('Entrez le prénom de l'étudiant n°' , ntp);
SAISIR(T[ntp].prenom);
AFFICHER('Entrez la filière de l'étudiant n°' , ntp);
SAISIR(T[ntp].filiere);
AFFICHER('Entrez le matricule de l'étudiant n°' , ntp);
SAISIR(T[ntp].matricule);
SI T[ntp].filiere = "IG" ALORS
DSI
nbIG  nbIG + 1;
FSI;
SI T[ntp].filiere = "NTIC" ALORS

DSI
nbNTIC  nbNTIC + 1;
FSI;
SI T[ntp].filiere = "ELN" ALORS
DSI
nbELN  nbELN + 1;
FSI;
SI T[ntp].filiere = "TLCOM" ALORS
DSI
nbTLCOM  nbTLCOM + 1;
FSI;
AFFICHER('Y a t il un autre étudiant? O pour OUI et N pour NON');
SAISIR(rep);
JUSQU'A (rep= 'N') OU (rep='n');
AFFICHER('Le nombre total des étudiants s'ayant acquitté de leur droit d'examen est:' , ntp);
AFFICHER('Le nombre total des étudiants n'ayant pas payé leur droit d'examen est:' , 150-ntp);
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en IG est:' , 25-nbIG);
AFFICHER('Le nombre total des étudiants ayant payé leur droit d'examen en IG est:' , nbIG);
C  "IG";
affichage_info (C); (* Appel de la procédure affichage_info avec pour paramètre C qui vaut "IG" *)
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en NTIC est:' , 50-nbNTIC);
AFFICHER('Le nombre total des étudiants ayant payé leur droit en NTIC est:' , nbNTIC);
C  "NTIC";
affichage_info (C); (* Appel de la procédure affichage_info avec pour paramètre C qui vaut "NTIC" *)
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en ELN est:' , 30-nbELN);
AFFICHER('Le nombre total des étudiants ayant payé leur droit d'examen en ELN est:' , nbELN);
C  "ELN";
affichage_info (C); (* Appel de la procédure affichage_info avec pour paramètre C qui vaut "ELN" *)
AFFICHER('Le nbre total des étudiants n'ayant pas payé leur droit en TLCOM est:' , 45-nbTLCOM);
AFFICHER('Le nombre total des étudiants ayant payé leur droit en TLCOM est:' , nbTLCOM);
C  "TLCOM";
affichage_info (C); (* Appel de la procédure affichage_info avec pour paramètre C qui vaut "TLCOM" *)
FIN; (* Fin du corps de la procédure saisir_info *)

saisir_info; (* Appel de la procedure saisir_info *)
EXERCICE 8
1)
Posons le problème
-Saisir les noms
-saisir les notes et leurs coefficients, calculer la moyenne
-Ranger les moyennes par ordre croissant et déterminer le rang
-Afficher le nom, la moyenne et le rang de chaque élève par classe.
Méthode
Il faudra déclarer un 1er tableau de 6 cases représentant les 6 classes. Et comme par classe il y a 30 élèves, il faudra là, un 2e tableau
de 30 cases. Ce 2e tableau sera inclus dans le 1er. Enfin par élève, il faut connaître son nom, sa moyenne et son rang. Là, on fera
recours à un enregistrement. Finalement l'enregistrement sera inclus dans chacune des 30 cases du 2e tableau, et ce 2e tableau sera
à son tour inclus dans le 1er tableau de 6 aces.
Ce qui donne la structure ci-après:

1 ………………………………. 6
-Nom -Nom -Nom -Nom

-Moyenne …….. -Moyenne …………….. . .
-Moyenne ……. -Moyenne
-Rang -Rang -Rang -Rang
1 ………… 30 1 ……. 30
Il faudra définir les structures de la plus interne vers la plus externe, c'est-à-dire l'enregistrement d'abord, puis le tableau de 30
cases et enfin le tableau de 6 cases.
ALGORITHME ecole;
TYPE
classe = ENREGISTREMENT (* Définition de l'enregistrement *)
nom: CHAINE[30];
moyenne: REEL;
rang: ENTIER;
FENRG;
P = TABLEAU[30] de classe; (* Définition du tableau P pour gérer les 30 élèves de chaque classe. L'enregistrement se retrouve dans le tableau *)
T= TABLEAU[6] de P; (* Définition du tableau de 6 cases. Il y a imbrication de tableaux. Ce qui donne une sorte de tableau à 2 dimensions *)
VAR
cl: T; (* Il faut définir une variable de type, la + grande structure, c'est-à-dire T. Avec cl, ns allons pouvoir atteindre les structures internes*)
k, c , cof ,i , j: ENTIER; (* i, j, k=compteurs et cof=coefficient des notes *)
note, som , t_moy: REEL; (*som=somme des notes coefficientées, t_moy=va servir lors de la permutation *)
t _nom: CHAINE; (* Va servir lors de la permutation *)
DEBUT
POUR i  1 à 6 FAIRE (* Parcours des 6 classes *)
DPOUR
POUR j 1 à 30 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
AFFICHER ('Entrez le nom de l'élève' , j );
SAISIR (cl[i][j].nom );
som  0;
cof  0;
DPOUR
AFFICHER ('Entrez la note :’ , k);
SAISIR (note);
AFFICHER ('Entrez le coefficient de la note n°' , k);
SAISIR (c);
som  som +(c* note); (* Addition des notes coefficientées *)
cof  cof + c; (* Addition des coefficients *)
FPOUR;
cl[i][j].moyene  som / cof; (* Calcul de la moyenne *)
FPOUR;
FPOUR;
(* Tri du tableau cl par ordre croissant *)
DPOUR
POUR j  1 à 29 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
POUR k  j+1 à 30 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
SI cl[i][j].moyenne < cl[i][k].moyenne ALORS 
DSI
t_nom  cl[i][j].nom;
t_moy  cl[i][j].moyenne;
cl[i][j].nom  cl[i][k].nom;
cl[i][j].moyenne  cl[i][k].moyenne;
cl[i][k].nom  t_nom;
cl[i][k].moyenne  t_moy;

FSI;
FPOUR;
FPOUR;
FPOUR;
POUR i  1 à 6 FAIRE (* Attribution du rang. Elle se fait après avoir calculé toutes les moyennes *)
DPOUR
POUR j  1 à 30 FAIRE
DPOUR
Cl[i][j].rang  j;
FPOUR;
FPOUR;
POUR i  1 à 6 FAIRE (* Affichage du classement *)
DPOUR
AFFICHER ('CLASSEMENT DE LA CLASSE n°' , i);
DPOUR
AFFICHER (cl[i][j].nom, 'est', cl[i][j].rang, 'e avec' , cl[i][j].moyenne, 'comme moyenne');
FPOUR;
FPOUR;
FIN.
Explications:
 Si la condition est remplie alors l'on ne permute pas seulement les moyennes, mais aussi les noms.
2)
Posons le problème
Pareil que le précédent mais en plus il faut gérer la mention.
Méthode
Idem que le précédent mais avec la mention en plus.
1 ………………………………. 6
-Nom -Nom -Nom -Nom

-Moyenne …….. -Moyenne …………….. . .
-Moyenne ……. -Moyenne
-Rang -Rang -Rang -Rang
-Mention -Mention -Mention -Mention
1 ………… 30 1 ……. 30
ALGORITHME ecole;
TYPE
classe = ENREGISTREMENT
nom: CHAINE[30];
moyenne: REEL;
rang: ENTIER;
mention: CHAINE[15];
FENRG;
P = TABLEAU[30] de classe;
T= TABLEAU[6] de P;
VAR
cl: T;
k, c , cof ,i, j: ENTIER;
som, note, t_moy: REEL;
t _nom, t_mention: CHAINE; (* t_mention va servir lors de la permutation *)
DEBUT
DPOUR
DPOUR
som  0;
cof  0;

DPOUR
AFFICHER ('Entrez la note :’ , k);
SAISIR (note);
AFFICHER ('Entrez le coefficient de la note n°' , k);
SAISIR (c);
som  som +(c* note); (* Addition des notes coefficientées *)
cof  cof + c; (* Addition des coefficients *)
FPOUR;
cl[i][j].moyenne  som / cof; (* Calcul de la moyenne *)
(* Détermination de la mention *)
SI cl[i][j].moyenne < 10 ALORS
DSI
cl[i][j].mention  "Médiocre";
FSI;
SI (cl[i][j].moyenne  10) ET (cl[i][j].moyenne < 12) ALORS
DSI
cl[i][j].mention  "Passable";
FSI;
DSI
cl[i][j].mention  "Assez Bien";
FSI;
DSI
cl[i][j].mention  "Bien";
FSI;
SI (cl[i][j].moyenne  16) ET (cl[i][j].moyenne  18) ALORS
DSI
cl[i][j].mention  "Très Bien";
FSI;
SI (cl[i][j].moyenne > 18) ET (cl[i][j].moyenne  20) ALORS
DSI
cl[i][j].mention  "Excellent";
FSI;
FPOUR;
FPOUR;
(* Tri du tableau cl par ordre croissant *)
POUR i  1 à 6 FARE (* Parcours des 6 classes *)
DPOUR
POUR j  1 à 29 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
POUR k  j+1 à 30 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
SI cl[i][j].moyenne < cl[i][k].moyenne ALORS 
DSI
t_nom  cl[i][j].nom;
t_moy  cl[i][j].moyenne;
t_mention  cl[i][j].mention;
cl[i][j].nom  cl[i][k].nom;
cl[i][j].moyenne  cl[i][k].moyenne;
cl[i][j].mention  cl[i][k].mention;
cl[i][k].nom  t_nom;
cl[i][k].moyenne  t_moy;
cl[i][k].mention  t_mention;
FSI;
FPOUR;
FPOUR;
FPOUR;
POUR i  1 à 6 FAIRE (* Attribution du rang. Elle se fait après avoir calculé toutes les moyennes *)

DPOUR
DPOUR
Cl[i][j].rang  j;
FPOUR;
FPOUR;
POUR i  1 à 6 FAIRE (* Affichage du classement *)
DPOUR
AFFICHER('CLASSEMENT DE LA CLASSE n°' , i);
DPOUR
AFFICHER ( cl[i][j].nom, 'est', cl[i][j].rang, ' e avec' , cl[i][j].moyenne, 'comme moyenne et' , cl[i][j].mention, ' pour
mention');
FPOUR;
FPOUR;
FIN.
Explications:
 Si la condition est remplie alors l'on ne permute pas seulement les moyennes et les noms mais dormais les mentions aussi.
La version du 2) de l'exercice 8 avec des fonctions et procédures

ALGORITHME ecole;
TYPE
classe = ENREGISTREMENT
nom: CHAINE[30];
moyenne: REEL;
rang: ENTIER;
mention: CHAINE[15];
FENRG;
P= TABLEAU[30] de classe;
T= TABLEAU[6] de P;
VAR
cl: T;
i , j: ENTIER;
FONCTION calcul_moyenne: REEL;
VAR
e, cof, C: ENTIER;
som, note: REEL;
DEBUT (* Début du corps de la fonction calcul_moyenne *)
cof  0; som  0;
DPOUR
AFFICHER ('Entrez la note n°:’ , e);
SAISIR (note);
AFFICHER ('Entrez le coefficient de la note n°' , e);
SAISIR (C);
som  som +(C* note); (* Addition des notes coefficientées *)
cof  cof + C; (* Addition des coefficients *)
calcul_moyenne  som / cof;
FPOUR;
FIN; (* Fin du corps de la fonction calcul_moyenne *)
PROCEDURE attribution_mention (Var F: REEL);
DEBUT (* Début du corps de la procédure attribution_mention *)
SI F < 10 ALORS
DSI
cl[i][j].mention  "Médiocre";
FSI;
SI (F  10) ET (F < 12) ALORS
DSI
cl[i][j].mention  "Passable";

FSI;
SI (F  12) ET (F < 14) ALORS
DSI
cl[i][j].mention  "Assez Bien";
FSI;
SI (F  14) ET (F < 16) ALORS
DSI
cl[i][j].mention  "Bien";
FSI;
SI (F  16) ET (F  18) ALORS
DSI
cl[i][j].mention  "Très Bien";
FSI;
SI (F > 18) ET (F  20) ALORS
DSI
cl[i][j].mention  "Excellent";
FSI;
FIN; (* Fin du corps de la procédure attribution_mention *)
PROCEDURE trier_tableau;
VAR
e, f, k: ENTIER;
t_moy: REEL;
t_nom, t_mention: CHAINE;
DEBUT (* Début du corps de la procédure trier_tableau *)
POUR e  1 à 6 FAIRE (* Parcours des 6 classes *)
DPOUR
POUR f  1 à 29 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
POUR k  f+1 à 30 FAIRE (* Parcours des 30 élèves de la classe en cours *)
DPOUR
SI cl[e][f].moyenne < cl[e][k].moyenne ALORS
DSI
t_nom  cl[e][f].nom;
t_moy  cl[e][f].moyenne;
t_mention  cl[e][f].mention;
cl[e][f].nom  cl[e][k].nom;
cl[e][f].moyenne  cl[e][k].moyenne;
cl[e][f].mention  cl[e][k].mention;
cl[e][k].nom  t_nom;
cl[e][k].moyenne  t_moy;
cl[e][k].mention  t_mention;
FSI;
FPOUR;
FPOUR;
FPOUR;
FIN; (* Fin du corps de la procédure trier_tableau *)
PROCEDURE attribuer_rang;
VAR
g, h: ENTIER;
DEBUT (* Début du corps de la procédure attribution_rang *)
POUR g  1 à 6 FAIRE (* Attribution du rang. Elle se fait après avoir calculé toutes les moyennes *)
DPOUR
POUR h  1 à 30 FAIRE
DPOUR
cl[g][h].rang  h;
FPOUR;
FPOUR;
FIN; (* Début du corps de la procédure attribution_rang *)
PROCEDURE afficher_classement;

VAR
p, l: ENTIER;
DEBUT
POUR p  1 à 6 FAIRE (* Affichage du classement *)
DPOUR
AFFICHER('CLASSEMENT DE LA CLASSE n°' , p);
POUR l  1 à 30 FAIRE
DPOUR
AFFICHER ( cl[p][l].nom, 'est', cl[p][l].rang, ' e avec' , cl[p][l].moyenne, 'comme moyenne et' , cl[p][l].mention, '
pour mention');
FPOUR;
FPOUR;
FIN;

DPOUR
AFFICHER('CLASSE n°' , i);
DPOUR
cl[i][j].moyenne  calcul_moyenne; (* Calcul de la moyenne *)
attribution_mention(cl[i][j].moyenne); (* Détermination de la mention *)
trier_tableau; (* Tri du tableau afin d'atttribuer les rang *)
attribuer_rang; (* attribution du rang *)
FPOUR;
FPOUR;
afficher_classement; (* Affichage du classement et seulement après avoir géré tous les élèves des 6 classes *)
Rappel: Au niveau des fonctions et procédures, l'absence ou la présence d'argument, dépend majoritairement de vous, programmeur. Si votre fonc-
tion ou procédure n'a pas d'argument, c'est que là, vous allez travailler sur les variables globales. Mais si elles en possèdent, c'est que vous travail-
lerez sur des variables formelles (arguments formels). Voir les conseils au niveau de la correction du test n°2.
EXERCICE 9
Posons le problème
- Pour chacun des 30 jours de chaque mois, saisir les dépenses quotidiennes à savoir les frais de transport, alimentaires, de com-
munication et les divers. A la fin de chaque mois, il faudrait gérer les frais liés au loyer et à l'argent de poche.
- Au niveau du mois en cours, il faudrait voir si nous sommes à un bimensuel (période de 2 mois) ou à un trimestre (période de 3
mois), pour ainsi gérer les dépenses y afférentes, c'est-à-dire respectivement le montant de la facture CIE et de SODECI.
1)
ALGORITHME gestion_familiale;
VAR
F_t, F_a, F_c, F_d, Loy, arg_p, Mt_cie, Mt_sod, Mt_gf, d_m, d_an: REEL; (* F_t pour contenir les frais de transport, F_a= frais ali-
mentaires, F_c=frais de communication, F_d=frais divers, Loy=loyer, arg_p=argent de poche, Mt_cie= montant facture cie, Mt_sod= montant
facture sodeci, Mt_gf=montant grande famille, d_m=dépenses mensuelles, d_an=dépenses annuelles *)
i, j: ENTIER; (* i et j pour parcourir les mois et les jours du mois *)
DEBUT
d_an  0; (* Initialisation de d_an avant d'entamer la gestion des mois *)
POUR j  1 à 12 FAIRE (* Parcours des 12 mois de l'année *)
DPOUR
d_m  0; (* Initialisation de d_m avant d'entamer la gestion des jours du mois en cours *)
POUR 1  1 à 30 FAIRE (* Parcours des 30 jours du mois en cours *)
DPOUR
AFFICHER ('Entrez les frais de transport du jour n°' , i ,'du mois n°' , j);
SAISIR (F_t);
AFFICHER ('Entrez les frais alimentaires du jour n°' , i ,'du mois n°' , j);
SAISIR (F_a);
AFFICHER ('Entrez les frais de communication du jour n°' , i ,'du mois n°' , j);

SAISIR (F_c);
AFFICHER ('Entrez les frais divers du jour n°' , i ,'du mois n°' , j);
SAISIR (F_d);
d_m  d_m + F_t + F_a + F_c + F_d;
FPOUR; (* A la sortie de cette boucle, nous sommes nécessairement à la fin du mois *)
AFFICHER ('Entrez les frais de loyer');
SAISIR (Loy);
AFFICHER ('Entrez le montant de l'argent de pocher');
SAISIR (arg_p);
d_m  d_m + Loy + arg_p;
SI j MOD 2 = 0 ALORS (* C'est que nous sommes à un bimensuel *)
DSI
AFFICHER ('Entrez le montant de la facture de CIE');
SAISIR (Mt_cie);
AFFICHER ('Entrez le montant destiné à la grande famille');
SAISIR (Mt_gf);
d_m  d_m + Mt_cie + Mt_gf;
FSI;
SI j MOD 3 = 0 ALORS (* C'est que nous sommes à un trimestre *)
DSI
AFFICHER ('Entrez le montant de la facture de SODECI');
SAISIR (Mt_sod);
d_m  d_m + Mt_sod;
FSI;
AFFICHER ('Le montant des dépenses du mois n°' , j , 'est:' , d_m);
d_an  d_an + d_m;
FPOUR;
AFFICHER ('Le montant des dépenses annuelles vaut' , d_an);
FIN.
2)
Posons le problème
- Pareil que le précédent. Mais contrairement au précédent algorithme où l'on n'était pas obligé de mémoriser le montant des
dépenses de chacun des mois, ici nous sommes obligés de le faire car il nous est demandé de connaître le mois où M NEKOMAT a le
plus dépensé. Or pour le savoir, il va falloir disposer des dépenses de chacun des 12 mois, puis les comparer entre elles.
Méthode
Pour connaître le mois où M NEKOMAT a le plus dépensé, il faudra utiliser un tableau de 12 cases pour contenir les dépenses des
12 mois; en raison d'une case pour les dépenses d'un mois. Après, parcourir les 12 cases à la recherche du maximum.
VAR
T: TABLEAU[12] de REEL; (* Pour contenir les dépenses de chacun des mois, en raison d'une case par mois *)
F_t, F_a, F_c, F_d, Loy, arg_p, Mt_cie, Mt_sod, Mt_gf, d_an, max: REEL; (* max=le mois où il le + dépensé *)
i, j: ENTIER;
DEBUT
d_an  0; (* Initialisation de d_an avant d'entamer la gestion des mois *)
POUR j  1 à 12 FAIRE (* Parcours des 12 mois de l'année *)
DPOUR
T[j]  0; (* Initialisation de T[j] avant d'entamer la gestion des jours du mois en cours *)
POUR i  1 à 30 FAIRE (* Parcours des 30 jours du mois en cours *)
DPOUR
SAISIR (F_t);
SAISIR (F_a);
SAISIR (F_c);
SAISIR (F_d);
T[j]  T[j] + F_t + F_a + F_c + F_d;

SAISIR (Loy);
SAISIR (arg_p);
T[j]  T[j] + Loy + arg_p;
DSI
SAISIR (Mt_cie);
SAISIR (Mt_gf);
T[j]  T[j] + Mt_cie + Mt_gf;
FSI;
DSI
SAISIR (Mt_sod);
T[j]  T[j] + Mt_sod;
FSI;
AFFICHER ('Le montant des dépenses du mois n°' , j , 'est:' , T[j] );
d_an  d_an + T[j];
FPOUR;
(* Détermination à présent du mois où il a le plus dépensé. On pourra le faire seulement après avoir géré les 12 mois *)
max  T[1]; j  1; (* Ici on considère par défaut que le 1er mois est celui où il a le + dépensé *)
POUR i  2 à 12 FAIRE (* Parcours des 11 autres mois de l'année *) 
DPOUR
SI T[i]  max ALORS
DSI
max  T[i];
j  i; (* Pour mémoriser le mois *)
FSI;
FPOUR;
AFFICHER ('Le mois où il a le plus dépensé est le mois n°' , j);
FIN.
Amélioration:
Au niveau du , si l'on a le cas suivant concernant les dépenses des 12 mois de l'année:
1 2 3 4 5 6 7 8 9 10 11 12
180000 218000 150000 300000 200000 156000 130000 125000 300000 137000 158000 129000
Tel que la partie  est, si l'on déroule l'algorithme, l'on obtiendra que le mois où il a le plus dépensé est le mois n°4.
Or l'on devrait afficher le mois n°4 et le mois n°9. La solution est donc la suivante:
max  T[1]; j  1; (* Ici on considère par défaut que le 1er mois est celui où il a le + dépensé *)
POUR i  2 à 12 FAIRE (* Parcours des 11 autres mois de l'année *) 
DPOUR
SI T[i]  max ALORS
DSI
max  T[i];
FSI;
FPOUR;
POUR i  1 à 12 FAIRE (* Parcours à nouveau des 12 mois de l'année *)
DPOUR
SI T[i] =max ALORS
DSI
AFFICHER ('Le mois où il a le plus dépensé est le mois n°' , i);
FSI;
FPOUR;
FIN.
Une autre méthode mais en utilisant le type énuméré

TYPE
mois = (janvier, fevrier, mars, avril, mai, juin, juillet, aout, septembre, octobre, novembre, decembre);

VAR
Ms, k: mois;
T: TABLEAU[12] de REEL; (* Pour contenir les dépenses de chacun des mois, en raison d'une case par mois *)
F_t, F_a, F_c, F_d, Loy, arg_p, Mt_cie, Mt_sod, Mt_gf, d_an, max: REEL; (* max=le mois où il le + dépensé *)
I, j: ENTIER;
DEBUT
d_an  0; j1 (* Initialisation de d_an avant d'entamer la gestion des mois. J=1 pour débuter les mois par le n°1 *)
POUR Ms  janvier à decembre FAIRE (* Parcours des 12 mois de l'année *)
DPOUR
T[j]  0; (* Initialisation de T[j] avant d'entamer la gestion des jours du mois en cours *)
POUR i  1 à 30 FAIRE (* Parcours des 30 jours du mois en cours *)
DPOUR
SAISIR (F_t);
SAISIR (F_a);
SAISIR (F_c);
SAISIR (F_d);
T[j]  T[j] + F_t + F_a + F_c + F_d;
SAISIR (Loy);
SAISIR (arg_p);
T[j]  T[j] + Loy + arg_p;
DSI
SAISIR (Mt_cie);
SAISIR (Mt_gf);
T[j]  T[j] + Mt_cie + Mt_gf;
FSI;
DSI
SAISIR (Mt_sod);
T[j]  T[j] + Mt_sod;
FSI;
AFFICHER ('Le montant des dépenses du mois de' , Ms , 'est:' , T[j] );
d_an  d_an + T[j];
j  j+1; (* Pour passer à un autre mois au niveau du tableau *)
FPOUR;
(* Détermination à présent du mois où il a le plus dépensé. On pourra le faire seulement après avoir géré les 12 mois *)
max  T[1]; i  1; (* Ici on considère par défaut que le 1er mois est celui où il a le + dépensé *)
J  2;
POUR k  fevrier à decembre FAIRE (* Parcours des 11 autres mois de l'année *)
DPOUR
SI T[j]  max ALORS
DSI
max  T[j];
i  j; (* Pour mémoriser le mois *)
FSI;
j  j+1; (* Pour passer à un autre mois au niveau du tableau *)
FPOUR;
AFFICHER ('Le mois où il a le plus dépensé est ' , i);
FIN.
EXERCICE 10
Posons le problème + Méthode
- Saisir le numéro à composer par l'usager,
- Si ce numéro débute par

* 00, c'est qu'il s'agit d'un appel international,

*  00, c'est qu'il s'agit d'un appel national.
- Pour les appels internationaux :
* orienter l'appel vers le commutateur 2,
* Si le code (les trois 1ers chiffres après les 00) est 226, c'est que l'appel est en direction du BF.
* Si le code (les trois 1ers chiffres après les 00) est 223, c'est que l'appel est en direction du Mali.
* Si le code (les trois 1ers chiffres après les 00) est 221, c'est que l'appel est en direction du Sénégal.
* Si le code (les trois 1ers chiffres après les 00) est 233, c'est que l'appel est en direction du Ghana.
- Pour les appels nationaux (ici, il n' y a pas de 00. Le n° du correspondant est composé directement):
* Si les quatre 1ers chiffres = 3685 ou 3686, c'est que l'appel est en direction de Korhogo. Donc orienter l'appel vers le com-
mutateur 3.
* Si les quatre 1ers chiffres = 3278, c'est que l'appel est en direction de Daloa. Donc orienter l'appel vers le commutateur 4.
* Si les quatre 1ers chiffres = 3163 ou 3164, c'est que l'appel est en direction de Bouaké. Donc orienter l'appel vers le commu-
tateur 5.
* Si les quatre 1ers chiffres = 3064, c'est que l'appel est en direction de Yamoussoukro. Donc orienter l'appel vers le commuta-
teur 6.
* Si les deux 1ers chiffres = 20, 21, 22, 23 ou 24, c'est que l'appel est local (à Abidjan). Donc orienter l'appel directement vers
le destinataire.
ALGORITHME gestion_commuateur;
VAR
num: CHAINE[15];
PROCEDURE destination (VAR t: CHAINE[15]);
CONST
Tab: TABLEAU[5] de CHAINE[2] ={"20", "21", "22", "23", "24"} (* Le début des n° d'Abidjan *)
VAR
I: ENTIER; (* Pour parcourir les n° d'Abidjan *)
F: BOOLEEN; (* Pour effectuer les différents tests *)
code: CHAINE[2]; (* Pour l'appel international: le 00 *)
Ch: CHAINE[3]; (* Pour le code indicatif du pays *)
DEBUT (* Début du corps de la procédure destination *)
F  FAUX;
Ch  COPIER (t, 1, 2); (* Copie 2 caractères de t, à partir de son caractère n° 1 *)
SI ch = "00" ALORS
DSI
AFFICHER ('L'APPEL EST INTERNATIONAL');
AFFICHER ('Orienter l'appel vers le commutateur 2');
SI ch = "226" ALORS
DSI
AFFICHER ('Appel en direction du Burkina Faso');
F  VRAI;
FSI;
SI ch = "223" ALORS
DSI
AFFICHER ('Appel en direction du Mali');
F  VRAI;
FSI;
SI ch = "221" ALORS
DSI
AFFICHER ('Appel en direction du Sénégal');
F  VRAI;
FSI;
SI ch = "233" ALORS
DSI
AFFICHER ('Appel en direction du Ghana');
F  VRAI;
FSI;
SI F= FAUX ALORS
DSI
AFFICHER ('Destination autre que nos 4 pays ou n° d'appel inexistant');

FSI;
FSI;
SINON
DSINON
AFFICHER ('APPEL NATIONAL');
SI (ch = "3685") OU (ch = "3686") ALORS
DSI
AFFICHER ('Appel en direction de Korhogo');
F  VRAI;
FSI;
SI ch = "3278" ALORS
DSI
AFFICHER ('Appel en direction de Daloa');
F  VRAI;
FSI;
SI (ch = "3163") OU (ch = "3164") ALORS
DSI
AFFICHER ('Appel en direction de Bouaké');
F  VRAI;
FSI;
SI ch = "3064" ALORS
DSI
AFFICHER ('Appel en direction de Yamoussoukro');
F  VRAI;
FSI;
POUR I  1 à 5 FAIRE (* Parcours du début des n° d'Abidjan *)
DPOUR
SI Tab[i] = ch ALORS
DSI
AFFICHER ('Appel local au niveau d'Abidjan');
AFFICHER ('Orienter l'appel directement vers le destinataire');
F  VRAI;
FSI;
FPOUR;
SI F = FAUX ALORS
DSI
AFFICHER ('Appel national mais en direction d'une autre ville autre que nos 5 viles ou n°
d'appel inexistant');
FSI;
FSINON;
FIN; (* Fin du corps de la procédure destination *)
AFFICHER ('Entrez le numéro de téléphone à composer');
SAISIR (num);
destination (num); (* Appel de la procédure destination *)

EXERCICE 1

Posons le problème
-Saisir le nom du produit dont on voudrait modifier le prix de vente,
-Rechercher le produit dans le fichier,
-Mettre à jour le prix de vente du produit,
-Enfin fermer le fichier.
1 ère méthode
ALGORIHME mise_a_jour;
TYPE
produit=ENREGISTREMENT
nom :CHAINE[15];
refer :CHAINE[10];
prix_v :REEL;
FINENRG;
VAR
fichier_prod: FICHIER de produit;
prdt: produit;
critere: CHAINE[10];
reponse: CARACTERE;
i: ENTIER;
DEBUT
ASSIGNER(fichier_prod, 'C\TP\produit.txt');
RELIRE(fichier_prod); (* Ouverture du fichier sans écrasement *)
REPETER
RECHERCHER(fichier_prod, 0); (* Positionne l’index sur le 1er enregistrement *)
AFFICHER('Entrez le critère');
SAISIR(critere);
POUR i  0 à TAILLE_FICHIER(fichier_prod)-1 FAIRE
DPOUR
LIRE(fichier_prod, prdt);
SI critere = prdt.nom ALORS
DSI
AFFICHER ('Les anciennes valeurs sont:');
AFFICHER ('Nom:' , prdt.nom);
AFFICHER ('Référence' , ,prdt.refer);
AFFICHER ('Prix de vente' ,,prdt.prix_v);
AFFICHER ('Entrez le nouveau prix de vente');
SAISIR (prodt.prix_v);
RECHERCHER (fichier_prod, i); (* Positionne l’index sur l'enregistrement n° i *)
ECRIRE (fichier_prod, prdt); (* Ecriture des nlles données sur le disque dur *)
FSI;
FPOUR;
AFFICHER ('Un autre produit à modifier O / N ?');
SAISIR (reponse);
JUSQU'A (reponse='N') OU (reponse='n');
FERMER (fichier_prod); (* Fermeture du fichier parce que nous sommes à la fin de son utilisation *)
FIN.

2e méthode
Cet algorithme ci, après avoir trouvé le produit recherché arrête la recherche dans le fichier. C'est donc une petite amélioration du
1er algorithme.
ALGORIHME mise_a_jour;
TYPE
produit=ENREGISTREMENT
nom :CHAINE[15];
refer :CHAINE[10];
prix_v :REEL;
FINENRG;
VAR
fichier_prod: FICHIER de produit;
prdt: produit;
reponse: CARACTERE;
i: ENTIER;
trouver: BOOLEEN;
DEBUT
ASSIGNER(fichier_prod, 'C\TP\produit.txt');
RELIRE(fichier_prod); (* Ouverture du fichier sans écrasement *)
REPETER
RECHERCHER(fichier_prod, 0); (* Positionne l’index sur le 1er enregistrement *)
AFFICHER('Entrez le critère');
SAISIR(critere);
i  0; trouver  FAUX;
TQ (NON FIN_FICHIER (fichier_prod)) ET (trouver= FAUX) FAIRE 
DTQ
LIRE(fichier_prod, prdt);
SI critere = prdt.nom ALORS
DSI
trouver  VRAI;
AFFICHER ('Les anciennes valeurs sont:');
AFFICHER ('Nom:' , prdt.nom);
AFFICHER ('Référence' , ,prdt.refer);
AFFICHER ('Prix de vente' , prdt.prix_v);
AFFICHER ('Entrez le nouveau prix de vente');
SAISIR (prodt.prix_v);
RECHERCHER (fichier_prod, i); (* Positionne l’index sur l'enregistrement n° i *)
ECRIRE (fichier_prod, prdt); (* Ecriture des nlles données sur le disque dur *)
FSI;
i  i + 1; (* Permet de repérer la position de l'index *)
FTQ;
AFFICHER ('Un autre produit à modifier O / N ?');
SAISIR (reponse);
JUSQU'A (reponse='N') OU (reponse='n');
FERMER (fichier_prod); (* Fermeture du fichier parce que nous sommes à la fin de son utilisation *)
FIN.
 = Tant qu'on n'est pas à la fin du fichier et qu'on n'a pas encore trouvé ce qu'on recherche.

EXERCICE 2
1)
Posons le problème
-Créer le fichier nommé répertoire,
-Saisir les données concernant les personnes,
-Puis les enregistrer dans le fichier répertoire,
-A la fin de la saisie, fermer le fichier répertoire.
ALGORITHME personne;
TYPE
personne=ENREGISTREMENT;
nom: CHAINE[20];
Prenom:CHAINE[25];
age: ENTIER;
num_tel: CHAINE[11];
FENRG;
VAR
reper: FICHIER de personne;
pers: personne;
DEBUT
ASSIGNER (reper, 'C:\repertoire.txt’) ;
REECRIRE (reper); (* Ouverture avec écrasement car le fichier vient d'être créé donc vierge *)
REPETER
AFFICHER ('Entrez le nom de la personne');
SAISIR(pers.nom);
SI pers.nom  "" ALORS
DSI
AFFICHER('Entrez le prénom');
SAISIR(pers.prenom);
AFFICHER ('Entrez son age');
SAISIR (pers.age);
AFFICHER ('Entrez son numéro de téléphone');
SAISIR (pers.num_tel);
ECRIRE (reper, pers); (* Ecriture des nouvelles données sur le disque dur *)
JUSQU'A pers.nom="";
FERMER (reper);
FIN.
2) (*lecture du fichier précédemment crée.*)
Méthode : Parcourir le fichier du début à la fin, et à chaque fois, lire et afficher les données (enregistrements) contenues dans le
fichier.
ALGORITHME lecture;
TYPE
personne = ENREGISTREMENT
nom: CHAINE[20];
prenom: CHAINE[25];
age : ENTIER;
num_tel: CHAINE[11];
FINENRG;
VAR
reper: Fichier de personne;
pers: personne;
DEBUT
ASSIGNER(reper, 'C:\repertoire.text');
RELIRE(reper); (* Ouverture sans écrasement car le fichier contient des données *)
TQ NON FIN_FICHIER(reper) FAIRE
DTQ

LIRE(reper, pers);
AFFICHER('Nom', pers.nom);
AFFICHER('Prénom:', pers.prenom);
AFFICHER('Age:', pers.age);
AFFICHER('Numéro de téléphone:’, pers.num_tel);
FTQ;
FERMER(reper);
FIN.
EXERCICE 3
Posons le problème
- Créer le fichier, puis saisir le nombre d'enregistrements à sauvegarder sur le support de stockage,
- Saisir par la suite les données et les enregistrer à chaque fois, dans le fichier,
- Enfin, à la fin de la saisie, afficher toutes les informations saisies précédemment puis fermer le fichier.
ALGORITHME famille;
TYPE
Fam=ENRG
nom_f: CHAINE[20];
prenom_p: CHAINE[40];
prenom_m: CHAINE[40];
nombre_e: ENTIER;
prenom_e: CHAINE[50];
FINENRG;
VAR
ft :FICHIER de fam ;
pt: fam;
i, nb_enrg: ENTIER;
DEBUT
ASSIGNER (ft, 'C:\famille.txt');
REECRIRE (ft); (* Ouverture avec écrasement car le fichier vient d'être créé donc vierge *)
AFFICHER ('Entrez le nombre d’enregistrements');
SAISIR (nb_enrg);
POUR i  1 à nb_enrg FAIRE (* Saisie et enregistrement des données dans le fichier *)
DPOUR
AVEC pt FAIRE
AFFICHER ('Entrez le nom de famille');
SAISIR (nom_f);
AFFICHER ('Entrez le prénom du père');
SAISIR (prenom_p);
AFFICHER ('Entrez le prénom de la mère');
SAISIR (prenom_m);
AFFICHER ('Entrez le nombre d’enfants');
SAISIR (nombre_e);
SI nombre_e=0 ALORS
DSI
prenom_e  "";
FSI;
SINON
DSINON
AFFICHER ('Entrez les prénoms des enfants');
SAISIR (prenom_e);
FSINON;
FIN AVEC;
ECRIRE (ft, pt); (* Enregistrement des données dans le fichier, sur le disque dur. *)
FPOUR;
TQ NON FIN_FICHIER(ft) FAIRE (* Lecture à présent des informations précédemment saisies *)
DTQ
LIRE (ft, pt);
AFFICHER ('Le nom de famille est:', pt.nom_f);
AFFICHER ('Le prénom du père est:', pt.prenom_p);
AFFICHER ('Le prénom de la mère est::', pt.prenom_m);

AFFICHER ('Le nombre d'enfant est:', pt.nombre_e);
SI pt.nombre_e  0 ALORS (* S'il a des enfants *)
DSI
AFFICHER ('Le prénom des enfants est:', pt.prenom_e);
FSI;
FTQ;
FERMER (ft);
FIN.
EXERCICE 4
Posons le problème
- Faire le choix de l'opération que l'on désire,
- Pour chaque choix, effectuer les opérations conséquentes.
- Fermer le fichier à la fin.
ALGORITHME extrait_nais;
TYPE
Extrait=ENRG
num_ext : CHAINE[10];
np_int : CHAINE[50];
dat_nais: CHAINE[10];
np_par : CHAINE[60];
FIN ENRG;
VAR
rep: CARACTERE; Choix : ENTIER;
f: FICHIER de Extrait;
nom_fichier: CHAINE; (* Pour le nom du fichier à créer *)
PROCEDURE ajout;
VAR
n: Extrait; rp: CARACTERE;
DEBUT (* Début du corps de la procédure ajout *)
REPETER
AFFICHER ('Entrez le n° de l’extrait');
SAISIR (n.num_ext);
AFFICHER (Entrez le nom et prénom de l'intéressé') ;
SAISIR (n.np_int);
AFFICHER ('Entrez la date et le lieu de naissance');
SAISIR (n.dat_nais);
AFFICHER ('Entrez le nom et le prénom des parents');
SAISIR (n.np_par);
RECHERCHER (f, TAILLE_FICHIER(f) ); (* Permet de positionner l'index à la fin du fichier *)
ECRIRE (f, n);
AFFICHER ('Une autre données à ajouter au fichier ?');
SAISIR(rp);
JUSQU'A (rp ='N') OU (rp= 'n');
FIN ; (* Fin du corps de la procédure ajout *)
PROCEDURE modification;
VAR
p: EXTRAIT;
trouver : BOOLEEN;
C : CARACTERE;
i :ENTIER;
DEBUT (* Début du corps de la procédure modification *)
trouver  FAUX;
AFFICHER ('Entrez le numéro de l'extrait recherché');
SAISIR (critere);
RECHERCHER (f, 0); (* Permet de positionner le curseur au début du fichier *)
i  0;
TQ (trouver= FAUX) ET (NON FIN_FICHIER( f ) FAIRE 
DTQ

LIRE (f, p).

SI p.num_ext = critere Alors
DSI
trouver  VRAI;
AFFICHER ('Les anciennes valeur sont');
AFFICHER ('N°extrait', p.num_ext);
AFFICHER ('Nom et prénom de l’interessé', p.np_int);
AFFICHER ('Date de naissance', p.dat_nais);
AFFICHER ('Nom et prénom des parents :', p.np_par);
AFFICHER ('Entrez le numéro du champ à modifier');
AFFICHER ('1 pour n°extrait');
AFFICHER ('2 pour nom et prénom de l’intéressé');
AFFICHER (‘3 pour date et le lieu de naissance’);
AFFICHER ('4 pour nom et prénom des parents');
SAISIR(C)
SUIVANT C FAIRE
'1' : DEBUT
AFFICHER ('Entrez le nouveau n°de l'extrait');
SAISIR (p.num_ext);
FIN;
'2' : DEBUT
AFFICHER ('Entrez le nom et prénom de l’intéressé’);
SAISIR (p.np_int);
FIN;
'3' : DEBUT
AFFICHER ('Entrez la date et le lieu de naissance l’intéresse');
SAISIR (p.dat_nais);
FIN;
'4' : DEBUT
AFFICHER ('Entrer le nom et prénom des parents');
SAISIR (p.np_par);
FIN;
FIN SUIVANT;
FSI;
i + 1;
FTQ;
SI trouver = VRAI ALORS (* Ce qui veut dire qu'on a trouvé le n° de l'extrait recherché *)
DSI
RECHERCHER (f, i - 1); (* Permet de positionner l'index sur l'enregistrement n° i-1 *)
ECRIRE (f, p);
FSI;
SINON (* Ce qui veut dire trouver=FAUX. Donc on n'a pas trouvé le n° de l'extrait recherché *)
DSINON
AFFICHER ('Le numéro de l'extrait saisi, n'existe pas dans le fichier');
FSINON;
FIN; (* Fin du corps de la procédure modification *)
 Tant qu'on n'a pas encore trouver ce qu'on recherche et que nous ne sommes pas à la fin du fichier également.
PROCEDURE consultation;
VAR
E: Extrait; critere: CHAINE[10]; trouver: B00LEEN;
DEBUT (* Début du corps de la procédure consultation *)
AFFICHER ('Entrer le numéro de l'extrait à consulter');
SAISIR (critere);
trouver  FAUX;
RECHERHER (f, 0); (* Permet de positionner l'index au début du fichier *)
TQ (trouver= FAUX) ET (NON FIN_FICHIER( f ) FAIRE
DTQ
LIRE (f, E);
SI E.num_ext = critere ALORS

DSI
trouver  VRAI;
AFFICHER ('Le numéro de l'extrait est:' , E.num_ext);
AFFICHER('Le nom et prénom est:' , E.np_int);
AFFICHER('La date et le lieu de naissance est:' , E.dat_ nais);
AFFICHER('Le nom et prénom des parents:' , E.np_par);
FSI;
FTQUE;
SI trouver = FAUX ALORS (* Ce qui veut dire qu'on n'a pas trouvé l'extrait à consulter *)
DSI
AFFICHER ('Le numéro de l'extrait à consulter, n'existe pas dans le fichier');
FSI;
FIN; (* Fin du corps de la procédure consultation *)
PROCEDURE supprimer;
VAR
critere : CHAINE[10]; pt : FICHIER de Extrait; t : Extrait; (* pt va servir de fichier intermédiaire lors de la suppression de la
donnée *)
DEBUT (* Début du corps de la procédure supprimer *)
ASSIGNER (pt, 'C:\tempo txt');
REECRIRE (pt);
RECHERCHER (f, 0);
AFFICHER ('Entrez le numéro de l'extrait à supprimer');
SAISIR (critere);
TQ NON FIN_FICHIER (f) FAIRE
DTQ
LIRE (f, t);
SI critere  t.num_ext ALORS
DSI
ECRIRE (pt, t);
FSI;
FTQ;
REECRIRE (f ); ( * Ecrasement de tout le contenu du fichier f * )
RECHERCHER (pt, 0); (* Positionnement de l'index sur le début du fichier pt * )
TQ NON FIN_FICHIER (pt) FICHIER
DTQ
LIRE (pt, t);
ECRIRE (f, t); (* On va écrire à nouveau les données dans le fichier f * )
FTQ;
FERMER (pt);
DETRUIRE (pt); ( * On n'a plus besoin de lui donc on va l'effacer pour ne pas occuper inutilement d'espace sur le disque dur * )
FIN ; (* Fin du corps de la procédure supprimer *)
DEBUT (*Début du corps du programme principal *)
AFFICHER('Entrez le nom du fichier à créer');
SAISIR(nom_fichier);
ASSIGNER (f, nom_fichier);
REECRIRE( f ); (* Ouverture du fichier avec écrasement car le fichier vient d'être créé *)
AFFICHER ('LE MENU PRINCIPAL');
AFFICHER ('1 pour l'ajout des données dans le fichier');
AFFICHER ('2 pour la modification des données du fichier')
AFFICHER ('3 pour la consultation des données du fichier');
AFFICHER ('4 Pour la suppression de données dans le fichier');
REPETER
SAISIR (choix);
SUIVANT choix FAIRE
'1' : ajout; (* Appel de la procédure ajout *)
'2' : modification; (* Appel de la procédure modification *)
'3' : consultation; (* Appel de la procédure consultation *)
'4' : supprimer; (* Appel de la procédure supprimer *)
FINSUIVANT;

AFFICHER ('Voulez–vous continuer effectuer une autre opération ? O → OUI et N → NON ?');
SAISIR (rep);
JUSQU'A (rep = 'N') ou (rep = 'n');
FERMER (f);
EXERCICE 5
Posons le problème
- Opérer le choix entre la création d'un nouveau fichier ou l'exploitation d'un déjà existant.
- Effectuer le choix de l'opération, puis exécuter l'opération choisie, tout en tenant compte des spécifications de l'exercice.
- Fermer le fichier à la fin.
ALGORITHME extrait_nais;
TYPE
Extrait=ENRG
FIN ENRG;
VAR
rep: CARACTERE;
Choix : ENTIER;
nom_fichier: CHAINE; (* Pour le nom du fichier à créer *)
volonte: ENTIER;
test: BOOLEEN;
PROCEDURE ajouter_donnees;
VAR
n: Extrait;
rp: CARACTERE;
DEBUT (* Début du corps de la procédure ajouter_donnees *)
REPETER
SAISIR (n.num_ext);
AFFICHER (Entrez le nom et prénom de l'intéressé') ;
SAISIR (n.np_int);
SAISIR (n.np_par);
ECRIRE (f, n);
SAISIR(rp);
test  VRAI; (* Pour dire que le fichier contient désormais des données donc les autres opérations sont dorénavant possibles *)
FIN ; (* Fin du corps de la procédure ajouter_donnees *)
PROCEDURE modifier_donnees;
VAR
p: EXTRAIT;
trouver : BOOLEEN;
C : CARACTERE;
i :ENTIER;
DEBUT (* Début du corps de la procédure modifier_donnees *)
trouver  FAUX;
SAISIR (critere);
i  0;

DTQ
LIRE (f, p).
SI p.num_ext = critere Alors
DSI
trouver  VRAI;
AFFICHER ('Date et lieu de naissance', p.dat_nais);
SAISIR(C)
SUIVANT C FAIRE
'1' : DEBUT
SAISIR (p.num_ext);
FIN;
'2' : DEBUT
SAISIR (p.np_int);
FIN;
'3' : DEBUT
AFFICHER ('Entrez la date et le lieu de naissance l’intéresse');
FIN;
'4' : DEBUT
SAISIR (p.np_par);
FIN;
FIN SUIVANT;
FSI;
i + 1;
FTQ;
DSI
ECRIRE (f, p);
FSI;
DSINON
FSINON;
FIN; (* Fin du corps de la procédure modifier_donnees *)
PROCEDURE consulter;
VAR
DEBUT (* Début du corps de la procédure consulter *)
SAISIR (critere);
trouver  FAUX;
DTQ
LIRE (f, E);

DSI
trouver  VRAI;
AFFICHER('La date de naissance est:' , E.dat_ nais);
FSI;
FTQUE;
DSI
FSI;
FERMER(f);
FIN; (* Fin du corps de la procédure consulter *)
PROCEDURE supprimer_donnees;
VAR
critere : CHAINE[10]; pt : FICHIER de Extrait; t : Extrait; (* pt va servir de fichier intermédiaire lors de la suppression de la
donnée *)
DEBUT (* Début du corps de la procédure supprimer_donnees *)
ASSIGNER (pt, 'C:\tempo txt');
REECRIRE (pt);
RECHERCHER (f, 0); (* Permet de positionner l'index au début du fichier *)
SAISIR (critere);
DTQ
LIRE (f, t);
DSI
ECRIRE (pt, t);
FSI;
FTQ;
REECRIRE (f ); ( * Ecrasement de tout le contenu du fichier f * )
TQ NON FIN_FICHIER (pt) FICHIER
DTQ
LIRE (pt, t);
FTQ;
FERMER (pt); ( * Fermeture du fichier pt car on a fini de l'utiliser * )
DETRUIRE (pt); ( * On n'a plus besoin de lui donc on va l'effacer pour ne pas occuper inutilement d'espace sur le disque dur * )
FIN ; (* Fin du corps de la procédure supprimer_donnees *)

test  VRAI;
REPETER
AFFICHER ('Que voulez-vous faire ?');
AFFICHER (' Saisissez 1 pour la création d'un nouveau ficher');
AFFICHER (' Saisissez 2 pour l'exploitation d'un fichier déjà existant');
SAISIR (volonte);
JUSQU'A (volonte = 1) OU (volonte = 2);
SI volonte = 1 ALORS
DSI
test  FAUX;
AFFICHER ('Entrez le nom du nouveau fichier à créer');
SAISIR (nom_fichier);
ASSIGNER (f, nom_fichier); (* Création du nouveau fichier *)

FSI;
SI volonte = 2 ALORS
DSI

AFFICHER ('Entrez le nom du fichier déjà existant, à exploiter');

RELIRE ( f ); (* Ouverture du fichier cette fois-ci, sans écrasement car le fichier est non vide *)
FSI;
AFFICHER ('2 pour la modification des données du fichier')
REPETER
AFFICHER ('Faites le choix de l'opération à effectuer');
SAISIR (choix);
SUIVANT choix FAIRE
'1' : ajouter_donnees; (* Appel de la procédure ajout *)
'2' : DEBUT
SI test = VRAI ALORS
DSI
modifier_donnees; (* Appel de la procédure modification *)
FSI;
SINON
DSINON
AFFICHER('OPERATION IMPOSSIBLE! car le fichier est vide');
FSINON;
FIN;
'3' : DEBUT
DSI
consulter; (* Appel de la procédure consulter *)
FSI;
SINON
DSINON
FSINON;
FIN;
'4' : DEBUT
DSI
supprimer_donnees; (* Appel de la procédure supprimer_donnees *)
FSI;
SINON
DSINON
AFFICHER ('OPERATION IMPOSSIBLE ! car le fichier est vide');
FSINON;
FIN;
FINSUIVANT;
SAISIR (rep);
FERMER (f); ( * Fermeture du fichier f car on a fini de l'utiliser * )

EXERCICE 6
Posons le problème + Méthode
Pour la réussite de cet exercice, il va falloir créer 2 programmes différents :
▪ Le 1er programme va permettre de créer le fichier contenant les comptes utilisateurs initiaux (La catégorie 1 : administra-
teur avec pour mot de passe initail admin1usagerroot et la catégorie 2 : Utilisateur avec pour mot de
passe initial util2azert45d)). Une fois ce programme exécuté et donc qui va aboutir à la création du fichier contenant les
comptes utilisateurs initiaux, celui-ci pourra à présent être exploité dans le 2e programme. (donc le 1er programme être
exécuté avant le 2e programme).
▪ Le 2e programme est l'application principale mais dépendant en certain point de 1er programme.
Pour le 2e programme, il faut :
- Entrez votre compte utilisateur (la catégorie et le mot de passe). Veillez à ce que le compte soit valide, c'est-à-dire que la catégo-
rie et le mot de passe, saisis, existent dans le fichier crée par le 1er programme.
- Une fois le compte utilisateur valide, suivant la catégorie, il faudrait afficher l'ensemble des opérations auxquelles l'usager a droit.
- Procéder à présent au choix de l'opération, puis l'exécuter, tout en tenant compte des spécifications de l'exercice.
- Pour l'opération consistant à modifier le mot de passe : Le nouveau mot de passe saisi va remplacer le précédent mot de passe.
- Enfin, à la fin de l'utilisation des fichiers, il faudra les fermer.
Note: Ces deux programmes sont indépendants, bien que 2 e programme ait besoin de temps à autre du 1er programme.
ALGORITHME compte_utilisateur; ( * Ce 1er prog crée le fichier contenant les comptes utilisateur et qui sera utilisé par le 2e prog *)
TYPE
MP=ENREGISTREMENT
categorie : CHAINE[15];
mot_passe: CHAINE[20];
FIN ENRG;
VAR
cpt: MP; ft: FICHIER de MP;
DEBUT
ASSIGNER (ft, 'C:\mot de passe.txt');
REECRIRE(ft); ( * Ouverture avec écrasement car le fichier est nouveau *)
cpt.categorie  "administrateur";
cpt.mot_passe  "adm1usagerroot";
ECRIRE(ft, cpt); ( * Mémorisation sur le disque dur du 1er compte utilisateur *)
cpt.categorie  "utilisateur";
cpt.mot_passe  "util2azert45d";
ECRIRE(ft, cpt); ( * Mémorisation sur le disque dur du 2e compte utilisateur *)
AFFICHER('Le fichier des comptes utilisateurs a été créé avec succès');
FERMER (ft); ( * Fermeture du fichier ft car on a fini de l'utiliser * )
FIN.
ALGORITHME extrait_nais; ( * Voici le 2e programme *)

TYPE
Extrait=ENREGISTREMENT
FIN ENRG;
VAR
rep: CARACTERE;
mpas, categ: CHAINE; (* Pour le mot de passe à saisir et categ pour la catégorie saisie*)
valide, test: BOOLEEN; (* Pour vérifier si le mot de passe et la catégorie, saisis sont valides ou pas et test pr savoir si le fichier est vide ou pas *)
choix, volonte : ENTIER;

PROCEDURE creer_fichier;
VAR nom_fichier: CHAINE;
DEBUT (* Début du corps de la procédure creer_fichier *)
test  FAUX;
AFFICHER ('Entrez le nom du nouveau fichier à créer');
ASSIGNER (f, nom_fichier); (* Création du nouveau fichier *)
AFFICHER ('FICHIR CREE AVEC SUCCES');
FIN; (* Fin du corps de la procédure créer_fichier *)
PROCEDURE ajouter_donnees;
n: Extrait;
rp: CARACTERE;
DEBUT (* Début du corps de la procédure ajouter_donnees *)
RELIRE ( f ); (* Ouverture du fichier cette fois-ci, sans écrasement car le fichier est non vide *)
REPETER
SAISIR (n.num_ext);
AFFICHER ('Entrez le nom et prénom de l'intéressé') ;
SAISIR (n.np_int);
SAISIR (n.np_par);
ECRIRE (f, n);
SAISIR(rp);
test  VRAI; (* Rend effectif les autres opération, pour le choix de la création d'1 nouveau fichier *)
FIN ; (* Fin du corps de la procédure ajouter_donnees *)
PROCEDURE modifier_donnees;
p: EXTRAIT;
trouver : BOOLEEN;
C : CARACTERE;
i :ENTIER;
DEBUT (* Début du corps de la procédure modifier_donnees *)
trouver  FAUX;
RELIRE ( f );
SAISIR (critere);
i  0;
TQ (trouver= FAUX) ET (NON FIN_FICHIER(f) ) FAIRE
DTQ
LIRE (f, p);
SI p.num_ext = critere ALORS
DSI
trouver  VRAI;

AFFICHER ('Date et lieu de naissance', p.dat_nais);
SAISIR(C);
SUIVANT C FAIRE
'1' : DEBUT
SAISIR (p.num_ext);
FIN;
'2' : DEBUT
SAISIR (p.np_int);
FIN;
'3' : DEBUT
AFFICHER ('Entrez la date de naissance l’intéresse');
FIN;
'4' : DEBUT
SAISIR (p.np_par);
FIN;
FIN SUIVANT;
FSI;
i  i + 1;
FTQ;
DSI
ECRIRE (f, p);
FSI;
DSINON
FSINON;
FIN; (* Fin du corps de la procédure modifier_donnees *)
PROCEDURE consulter;
DEBUT (* Début du corps de la procédure consulter *)
RELIRE ( f );
SAISIR (critere);
trouver  FAUX;
DTQ
LIRE (f, E);
DSI
trouver  VRAI;
AFFICHER('La date et le lieu de naissance est:' , E.dat_nais);


FSI;
FTQ;
DSI
FSI;
FIN; (* Fin du corps de la procédure consulter *)
PROCEDURE supprimer_donnees;
critere : CHAINE[10]; pt : FICHIER de Extrait; t : Extrait; trouver: BOOLEEN;
(* pt va servir de fichier intermédiaire lors de la suppression de la donnée *)
DEBUT (* Début du corps de la procédure supprimer_donnees *)
RELIRE ( f );
ASSIGNER (pt, 'C:\tempo.txt');
REECRIRE (pt);
RECHERCHER (f, 0); (* Se positionne au début du fichier f *)
SAISIR (critere);
trouver  FAUX;
TQ NON FIN_FICHIER (f) FAIRE (* Il faut vérifier si l'extrait à supprimer existe dans le fichier *)
DTQ
LIRE(f, t);
SI t.num_ext = critere ALORS
DSI
trouver  VRAI;
FSI;
FTQ;
SI trouver = FAUX ALORS ( * C'est que l'extrait à supprimer n'existe pas dans le fichier * )
DSI
AFFICHER ('L'extrait à supprimer n'existe pas dans le fichier');
FSI;
SINON (* C'est que l'extrait à supprimer existe dans le fichier *)
DSINON
RECHERCHER (f, 0); (* Se positionne à nouveau au début du fichier f *)
DTQ
LIRE (f, t);
DSI
ECRIRE (pt, t);
FSI;
FTQ;
REECRIRE (f ); ( * Ecrasement de tout le contenu du fichier f pour accueillir les nlles données* )
TQ NON FIN_FICHIER (pt) FAIRE
DTQ
LIRE (pt, t);
FTQ;
FERMER (pt);
DETRUIRE (pt); ( * On n'a plus besoin de lui .On va l'effacer pour ne pas occuper inutilement d'espace sur le disque dur * )
FSINON;
FIN ; (* Fin du corps de la procédure supprimer_donnees *)

PROCEDURE modifier_motdepasse;
TYPE
MP=ENREGISTREMENT
FIN ENRG;
VAR motpas1, motpas2, cat: CHAINE; ok: BOOLEEN; motP: MP; compt_util: FICHIER de MP; I: ENTIER;
( * oK= pour savoir si les 2 mots de passe saisis sont identiques, I permet suivre l'index du fichier *)
DEBUT (* Début du corps de la procédure modifier_motdepasse *)
ok  FAUX; I  0;
REPETER
REPETER
AFFICHER ('Entrez la catégorie dont on voudrait modifier le mot de passe');
SAISIR (cat);
JUSQU'A (cat ="administrateur") OU (cat = "utilisateur");
AFFICHER ('Entrez le nouveau mot de passe');
SAISIR (motpas1);
AFFICHER ('Confirmez le nouveau mot de passe'); ( * Pour être sûr de ce qu'il a saisi *)
SAISIR (motpas2);
SI motpas1 = motpas2 ALORS
DSI
ok  VRAI;
ASSIGNER (compt_util, 'C:\mot de passe.txt'); ( * On accède au fichier crée par le 1er programme *)
RELIRE(compt_util); ( * Ouverture sans écrasement au fichier crée par le 1er programme *)
LIRE(compt_util, motP); ( * Lecture des données contenues dans le fichier crée par le 1er prog *)
I  I + 1; ( * Pour dire que l'index a bougé d'un pas vers l'avant *)
motP.categorie  cat;
motP.mot_passe  motpas1; ( * ou motP.mot_passe  motpas2; *)
RECHERCHER(compt_util, I–1); ( * I-1 car l'enregistrement à mettre à jour, est le précédent et non celui en cours*)
ECRIRE(compt_util, motP); ( * Ecriture du nouveau mot de passe dans le fichier crée par le 1er prog *)
FSI;
SINON
DSINON
AFFICHER('MOTS DE PASSE NON IDENTIQUES! Veillez les ressaisir');
FSINON;
JUSQU'A ok = VRAI;
FERMER(compt_util); ( * Fermeture du fichier compt_util car on a fini de l'utiliser *)
FIN; (* Fin du corps de la procédure modifier_motdepasse *)
FONCTION verifier_compte(VAR cg: CHAINE[20]; VAR mt: CHAINE[15]): BOOLEEN;
TYPE
MP=ENREGISTREMENT
FIN ENRG;
VAR trouver: BOOLEEN; com: MP; compt_util: FICHIER de MP;
DEBUT (* Début du corps de la fonction verifier_compte *)
trouver  FAUX;
ASSIGNER (compt_util, 'C:\mot de passe.txt'); ( *On accède au fichier crée par le 1er programme *)
RELIRE(compt_util);
TQ (NON FIN_FICHIER(compt_util)) ET (trouver = FAUX) FAIRE
DTQ
LIRE(compt_util, com); ( * Lecture du fichier pour avoir accès à ses données *)
SI (com.categorie = cg) ET (com.mot_passe = mt) ALORS (* Les 2 doivent être vraies à la fois *)
DSI
trouver  VRAI;
verifier_compte  VRAI;
FSI;
FTQ;
SI trouver = FAUX ALORS (* Le compte utilisateur saisi n'existe pas dans le fichier des mots de passe*)

DSI
verifier_compte  FAUX;
FSI;
FERMER (compt_util); ( * Fermeture du fichier compt_util car on a fini de l'utiliser *)
FIN; (* Début du corps de la fonction verifier_compte *)

test  VRAI;
REPETER
AFFICHER ('Entrez votre catégorie');
SAISIR (categ);
AFFICHER ('Entrez votre mot de passe');
SAISIR (mpas);
valide  verifier_compte(categ, mpas);
SI valide = FAUX ALORS
DSI
AFFICHER ('COMPTE UTILSATEUR INEXISTANT !');
FSI;
JUSQU'A valide = VRAI; (* Saisie du compte jusqu'à ce qu'il soit valide *)
(* A la sortie de REPETER…JUSQU'A, le compte utilisateur saisi est nécessairement valide *)
SI categ = "utilisateur" ALORS (* On affiche les opérations qu'il peut effectuer *)
DSI
FSI;
SI categ = "administrateur" ALORS (* On affiche les opérations qu'il peut effectuer (elles toutes) *)
DSI
AFFICHER ('1 pour la création d'un nouveau fichier');
AFFICHER ('3 pour la modification des données du fichier');
AFFICHER ('6 Pour la modification des mots de passe');
FSI;
REPETER
SI categ = "utilisateur" ALORS

DSI
REPETER
SAISIR (choix);
JUSQU'A (choix=2) OU (choix = 4);
FSI;
SI categ = "administrateur" ALORS
DSI
REPETER
SAISIR (choix);
JUSQU'A (choix=1) OU (choix = 2) OU (choix = 3) OU (choix = 4) OU (choix = 5) OU (choix = 6);
FSI;
SUIVANT choix FAIRE
1 : creer_fichier; (* Appel de la procédure creer_fichier *)
2: ajouter_donnees; (* Appel de la procédure ajouter_donnees *)
3 : DEBUT
DSI
modifier_donnees; (* Appel de la procédure modification *)
FSI;

SINON
DSINON
FSINON;
FIN;
4 : DEBUT
DSI
consulter; (* Appel de la procédure consulter *)
FSI;
SINON
DSINON
FSINON;
FIN;
5 : DEBUT
DSI
supprimer_donnees; (* Appel de la procédure supprimer_donnees *)
FSI;
SINON
DSINON
FSINON;
FIN;
6 : DEBUT
DSI
modifier_motdepasse; (* Appel de la procédure modifier_motdepasse *)
FSI;
SINON
DSINON
FSINON;
FIN;
FINSUIVANT;
SAISIR (rep);
FERMER (f); ( * A la fin, fermer le fichier f car on a fini de l'utiliser * )


Posons le problème + méthode:
- Décomposer l'algorithme en fonctions et procédures.
▪ Concernant la procédure pour la création de la liste chaînée, il faudra créer une 1ère cellule et y insérer les données saisies(
nom, prenom et pays), puis faites pareil pour les autres cellules à créer et cela, jusqu'à ce qu'on décide d'arrêter la création
(en répondant à une question du genre: "Voulez-vous continuer?"). Veuillez à ce qu'il y ait un pointeur, pointant
sur le début de la chaîne afin de pouvouir accéder aux différentes cellules de la liste.
▪ Concernant la procédure pour lire le contenu de la chaîne créée, il faudra se servir du pointeur pointant sur le début de la
liste, puis passer d'une cellule à une autre et à chaque parcours de cellule, il faudra afficher le contenu de la cellule en cours.
A la fin, il faudra garder un pointeur pointant sur le début de la liste.
▪ Concernant la procédure pour ajouter un élément à la fin de la liste, il faudra toujours se servir du pointeur pointant sur le
début de la liste, puis se positionner à la fin de la liste(en parcourant la liste cellule après cellule). Une fois à la fin de la cel-
lule(c'est-à-dire étant au niveau de la dernière cellule de la liste), il faudra créer une nouvelle cellule qui sera pointée par la
dernière cellule, puis y enregistrer les données à saisir. N'oublier pas de pointer cette nouvelle cellule créée à la fin sur NULL.
▪ Concernant la procédure pour la suppression d'un élément de la liste, il faudra d'abord saisir le nom à supprimer. Puis se
servant toujours du pointeur pointant sur le début de la liste, parcourir la liste à la recherche du nom. Une fois trouvé, poin-
ter la cellule qui précéde celle contenant le nom recherché sur la cellule qui suit celle contenant le nom à supprimer. Enfin,
supprimer la cellule contenant le nom.
Note: Les opérations d'ajout, de suppression et de listage doit être précédées de celle pour concernat la création de la liste.
ALGORITHME creation_liste_chainee;
TYPE
lien = ^cel; (* Déclaration d'un pointeur sur la structure cel *)
cel = ENREGISTREMENT (* Définition de la structure cel *)
nom: CHAINE[20];
prenom: CHAINE[40];
pays: CHAINE[20];
suivant: lien;
FIN;
VAR
r; CARACTERE;
t: lien; (* Déclaration d'un pointeur sur la structure cel *)
I, choix: ENTIER;
PROCEDURE afficher_liste(VAR f: lien); (* Le pointeur f pointe sur le début de la liste *)
DEBUT
SI I = 0 ALORS
DSI
AFFICHER('OPERATION IMPOSSIBLE CAR LA LISTE EST VIDE!')
FSI;
SINON (* C'est-à-dire I  0 *)
DSINON
AFFICHER(f^.nom);
AFFICHER(f^.prenom);
AFFICHER(f^.pays);
AFFICHER('-------------------------'); (* C'est-juste pour séparer les différentes données lors de l'affichage *)
SI f^.suivant  NULL ALORS
DSI
Afficher_liste(f^.suivant); (* Appel recursif en utilisant f^.suivant car il ft maintenir 1 pointeur sur le début de la liste: ici f *)
FSI;
FSINON;
FIN;

PROCEDURE créer_liste(VAR e: lien);

VAR rep: CARACTERE;
DEBUT
NOUVEAU( e );
AFFICHER('Donnez le nom');
SAISIR(e^.nom);
AFFICHER('Donnez le prénom');
SAISIR(e^.prenom);
AFFICHER('Donnez le pays');
SAISIR(e^.pays);
e^.suivant  NULL;
I  1; (* Pour dire qu'il y a désormais au moins une cellule dans la liste *)
AFFICHER('Désirez-vous continuer ?');
SAISIR(rep);
SI (rep = 'O') OU (rep = 'o') ALORS
DSI
créer_liste(e^.suivant); (* Appel recursif en utilisant e^.suivant car il ft maintenir 1 pointeur sur le début de la liste: ici e *)
FSI;
FIN; (* A la sortie de cette procédure, le pointeur e pointe sur la première cellule *)
PROCEDURE ajouter_element(VAR pt: lien);

VAR
temp: lien;
reponse: CARACTERE;
DEBUT
SI I  0 ALORS
DSI
temp  pt; ; (* pt pointe sur le début de la liste. Et Il ft y faire pointer 1 autre pointeur également(temp); et c'est ce dernier qui
va nous permettre de parcourir la liste tout en maintenant 1 pointeur sur le début de la liste pour les autres opérations. D'où cette affectation.) ) *.
TQ temp^.suivant  NULL FAIRE (* Permet de se positionner à la fin de la liste *)
DTQ
temp  temp^.suivant;
FTQ; (* A la fin, temp pointera sur la dernière cellule *)
REPETER
NOUVEAU(temp^.suivant); (* Création d'une nouvelle cellule qui sera pointée par le pointeur temp^.suivant *)
AFFICHER('Entrez le nom');
SAISIR(temp^.suivant^.nom);
AFFICHER('Entrez le prénom');
SAISIR(temp^.suivant^.prenom);
AFFICHER('Entrez le pays');
SAISIR(temp^.suivant^.pays);
temp^.suivant^.suivant  NULL;
AFFICHER(' Continuer ?');
SAISIR(reponse);
SI (reponse = 'o') OU (reponse = 'o') ALORS
DSI
temp  temp^.suivant;
FSI;
JUSQU'A (reponse = 'N') OU (reponse = 'n');
AFFICHER('Le nouveau contenu de la liste est:');
afficher_liste(pt); (* Appel de la procédure afficher_liste pour afficher le nouveau contenu de la liste *)
FSI;
SINON
DSINON
AFFICHER('OPERATION IMPOSSIBLE CAR LA LISTE EST VIDE');
FSINON;
FIN;

PROCEDURE supprimer_element(VAR sp: lien); (* sp pointe sur le début de la liste *)

VAR n: CHINE[25];
temp, tp: lien;
j: ENTIER;
DEBUT
SI I = 0 ALORS
DSI
AFFICHER(''OPERATION IMPOSSIBLE CAR LA LISTE EST VIDE');
FSI;
SINON
DSINON
AFFICHER('Entrez le nom à supprimer');
SAISIR(n);
tp  sp; (* sp pointe sur le début de la liste. Et Il ft y faire pointer 1 autre pointeur également; et c'est ce dernier qui va
nous permettre de parcourir la liste tout en maintenant 1 pointeur sur le début de la liste pour les autres opérations. D'où cette affectation) ) *.
j  0;
TQ (tp^.nom  n) ET (tp^.suivant  NULL) FAIRE (*Parcours de la liste à la recherche du nom *)
DTQ
temp  tp; (* Pour pointer sur la cellule précédente *)
tp  tp^.suivant;
j  j+1; (* si j=0, la cellule à supprimer est la 1ère cellule. Dans le cas contraire, c'est une autre cellule *)
FTQ;
SI (tp^.nom = n) ET (j = 0) ALORS (* j=0: cela signifie que c'est la 1ère cellule qui contient l'élément à supprimer *)
DSI
SI tp^.suivant = NULL ALORS (* C'est qu'il y a une seule cellule dans la liste *)
DSI
DETRUIRE(tp);
tp  NULL;
sp  NULL;
AFFICHER('La liste est désormais vide');
I  0; (* Pour signifier que la liste est désormais vide *)
FSI;
SINON (* C'est qu'il y a plusieurs cellules dans la liste *)
DSINON
sp  tp^.suivant;
DETRUIRE(tp);
tp  sp; (* Pour que tp puisse à nveau pointer sur la liste après la suppression de la cellule qu'il pointait *)
AFFICHER('L'élément a été supprimé avec succès');
afficher_liste(sp); (* Ici sp car sp pointe sur le début de la liste *)
FSINON;
FSI;
SINON (* IMPORTANT! Sans le else, et si tp pointe sur NULL(voir plus haut), l'on va continuer l'exécution du programme sur
la 2e ligne juste en bas, en testant tp^.nom. Or tp^.nom n'a plus de sens. On recevra donc un message d'erreur *)
DSINON
SI(tp^.nom = n) ET (j  0) ALORS (* Ce n'est pas la 1ère cellule qui est à supprimer *)
DSI
temp^.suivant  tp^.suivant; (* Comme l'on doit supprimer la cellule contenant le nom, il faut relier la
cellule qui précède celle qu'on doit supprimer à celle qui suit celle qu'on doit supprimer, pour ne pas casser la liste *)
DETRUIRE(tp);
AFFICHER('L'élément a été supprimé avec succès');
afficher_liste(sp);
FSI;
SINON
DSINON
SI (tp^.nom  n) ET (tp^.suivant= NULL) ALORS
DSI
AFFICHER('L'élément à supprimer n'existe pas dans la liste');
FSI;
FSINON;
FSINON;
FSINON;

FIN;
I  0;
AFFICHER('MENU PRINCIPAL');
REPETER
REPETER
AFFICHER('1__Pour la création de la liste');
AFFICHER('2__Pour la lecture du contenu de la liste');
AFFICHER('3__Pour l'ajout d'un élément à la fin de la liste');
AFFICHER('4__Pour la suppression d'un élément de la liste');
AFFICHER('Faites votre choix');
SAISIR(choix);
JUSQU'A (choix = 1) OU (choix = 2) OU (choix = 3) OU (choix = 4);
SUIVANT choix FAIRE
1: DEBUT
AFFICHER('*********CREATION DE LA LISTE***********');
creer_liste(t); (* Appel de la procédure créer_liste *)
FIN;
2: afficher_liste(t); (* Appel de la procédure afficher_liste *)
3: ajouter_element(t); (* Appel de la procédure ajouter_element *)
4: supprimer_element(t); (* Appel de la procédure supprimer_element *)
FIN;
AFFICHER('Une autre opération ? ');
SAISIR ( r );
JUSQU'A (r = 'N') OU (r = 'n');

TABLE DES CODES ASCII

Fascicule ALGORITHME

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fascicule ALGORITHME

Uploaded by

Copyright:

Available Formats

FASCICULE D'ALGORITHME © 1

SECTION1 : CONNAISSANCES GENERALES INFORMATIQUES………………………………………………………...Page 7

CHAPITRE 1 : NOTIONS GENERALES D’INFORMATIQUE…………………………………………………………..........…...Page 8

CHAPITRE2 : LES LOGICIELS……………………………………………………………………………………………………………………..........Page 18

CHAPITRE 3 : INTRODUCTION A L’ALGORITHMIQUE……………………………………………………………………...........Page 23

CHAPITRE 4 : INTRODUCTION AUX ELEMENTS DE L’ALGORITHME………………………………………….....…..Page 25

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

CHAPITRE 6 : LES SOUS PROGRAMMES…………………………………………………………………………………..................…...Page 48

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

CHAPITRE 8 : LES FICHIERS…………………………………………………………………………………………………………............................Page 83

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

e_Suppression d'un fichier……………………………………………………………………………………………………..................................Page 90

SECTION 3 : ANNEXES……………………………………………………………………………………………………………………………………….........Page 107

Table des codes ASCII…………………………………………………………………………………………………………………………….........................Page 190

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

La deuxième section intitulée L’ALGORITHME est constituée de sept (7) chapitres:

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

STATISTIQUES CONCERNANT LE CONTENU DE CE DOCUMENT

 Nombre de tests: 5 mais qui regroupent au total 52 exercices.

۩ Je vous prie donc de suivre ces derniers conseils !

BON APPRENTISSAGE DONC !

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

CHAPITRE 1 : NOTIONS GENERALES D’INFORMATIQUE

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

Vue d’ensemble de l’ENIAC, installé dans une salle machine

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

Deux opératrices en train de câbler un "programme" sur l'ENIAC

Ça y est, le "programme" est câblé sur l’ENIAC

c) Les caractéristiques de l’ordinateur

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

d) Les applications de l’ordinateur

e) La configuration d’un ordinateur

Boîtier de l’unité centrale

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

Une carte mère

Un microprocesseur (l’élément se trouvant dans la main du monsieur)

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

Une barrette de mémoire centrale Un disque dur

Rôle de certains éléments de l’ordinateur :

f) Les différents types d’ordinateur

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

Photos de mini ordinateur

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

g) Les familles d’ordinateur

Photos d’ordinateurs MACINTOSH

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

1) Que signifie « Traitement de l’information » ?

1) Répondre par vrai (V) ou faux (F) aux affirmations suivantes

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

CHAPITRE 2 : LES LOGICIELS

OBJECTIF : À la fin de ce chapitre, vous devez être à mesure de savoir :

3) L’intérêt des logiciels

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

4) Les différents types de logiciels

b) Les logiciels d’application ou progiciels

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

c) Les langages de programmation et logiciels outils

5) Les différentes classes de logiciels

6) Mise en place d’un programme informatique

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB

1) Qu’est ce qu’un logiciel ?

NGUESSAN KOFFI MATHIEU INGENIEUR INFORMATICIEN INPHB