République Algérienne Démocratique et Populaire

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Centre Universitaire Belahdj Bouchaib - Ain Témouchent
Préambule
Ce polycopié est destiné essentiellement aux étudiants de la 1ère année du tronc commun
Mathématiques et Informatique (MI), ainsi qu’aux étudiants des autres domaines (ST et SM)
désirant acquérir des bases solides en programmation sans connaissances préalables. Il s’agit
d’un support pédagogique qui couvre une partie fondamentale et essentielle de
l’algorithmique constituant ainsi un prérequis indispensable pour la programmation.

L'objectif de ce support est d’initier le lecteur à la résolution des problèmes par la

programmation, commençant par l’analyse du problème, la recherche de la solution ou la
Initiation à l’Algorithmique méthode pour résoudre ce problème, l’écriture de cette solution sous forme d’un algorithme,
et enfin la traduction de l’algorithme en programme exécutable par la machine en utilisant
Cours et exercices corrigés un langage de programmation tel que le langage C.

Il convient de noter que ce support de cours est un manuel d’accompagnement de

l’étudiant et sa lecture ne constitue en aucun cas une dispense de la présence attentive aux
1ère année tronc commun MI, ST et SM
séances de cours et de travaux dirigés ou pratiques.

Dr MEDEDJEL Mansour

Maître de conférences en Informatique

Département de Mathématiques et Informatique

Centre Universitaire Belhadj Bouchaib - Ain Temouchent

 Chapitre 4 - Les instructions itératives (les boucles) .................................................................. 21
Table des matières 1. Introduction ............................................................................................................................. 21
2. Définition ................................................................................................................................ 21
Introduction générale......................................................................................................................1 3. L’instruction « Pour ».............................................................................................................. 21
Partie I - Cours ................................................................................................................................3 4. L’instruction « Tant que… faire » ........................................................................................... 23

Chapitre 1 - Introduction aux algorithmes....................................................................................4 6. L’instruction « Répéter… jusqu’à » ........................................................................................ 23

1. Contexte ....................................................................................................................................4 7. La notion du compteur ............................................................................................................ 24

2. Notions élémentaires .................................................................................................................4 8. La notion d’accumulation ........................................................................................................ 25
3. L'algorithmique .........................................................................................................................5 9. Les boucles imbriquées ........................................................................................................... 25
3.1. Définition ..........................................................................................................................5 10. Conclusion .............................................................................................................................. 26
3.2. Principe général .................................................................................................................6 Chapitre 5 - Les tableaux.............................................................................................................. 27

4. Caractéristiques des algorithmes ...............................................................................................6 1. Introduction ............................................................................................................................. 27

4.1. Structure générale ..............................................................................................................6 2. Tableaux à une seule dimension .............................................................................................. 27

4.2. Les variables et les constantes ...........................................................................................7 2.1. Déclaration ...................................................................................................................... 27

4.2.1. Les variables ..............................................................................................................8 2.2. Manipulation ................................................................................................................... 28

4.2.2. Les constantes ............................................................................................................8 2.2.1. L’affectation ............................................................................................................28

4.3. Les types de base ...............................................................................................................8 2.2.2. La lecture .................................................................................................................29

4.3.1. Type entier .................................................................................................................9 2.2.3. L’écriture .................................................................................................................29

4.3.2. Type réel ....................................................................................................................9 3. Tableaux à deux dimensions ................................................................................................... 30

4.3.3. Type caractère ...........................................................................................................9 3.1. Déclaration d’un tableau à deux dimensions ................................................................... 31

4.3.4. Type booléen .............................................................................................................9 3.2. Manipulation d’un tableau à deux dimensions................................................................. 31

Chapitre 2 - Les instructions simples ........................................................................................... 11 4. Tableaux à n dimensions ......................................................................................................... 32

1. Introduction ............................................................................................................................. 11 5. La recherche dans un tableau................................................................................................... 32

2. L’instruction d’affectation ....................................................................................................... 11 5.1. La notion du drapeau ....................................................................................................... 32

3. L’instruction de lecture ........................................................................................................... 12 6. Le tri d’un tableau ................................................................................................................... 35

4. L’instruction d’écriture............................................................................................................ 13 6.1. Tri par sélection ............................................................................................................... 35

Chapitre 3 - Les instructions conditionnelles (les alternatives) ................................................. 15 6.2. Tri par insertion ............................................................................................................... 37

1. Introduction ............................................................................................................................. 15 6.3. Comparaison.................................................................................................................... 39

2. Structure d’un test ................................................................................................................... 15 7. Conclusion .............................................................................................................................. 39

2.1. Forme simple ................................................................................................................... 15 Chapitre 6 - Les enregistrements (structures)............................................................................. 40

2.2. Forme complète ............................................................................................................... 16 1. Introduction ............................................................................................................................. 40

3. Tests imbriqués ....................................................................................................................... 16 2. Définition ................................................................................................................................ 40

4. Les choix multiples ................................................................................................................. 19 3. Déclaration et manipulation .................................................................................................... 40

5. Conclusion .............................................................................................................................. 20 4. Tableau de structures ............................................................................................................... 41

5. Structure membre d’une autre structure ................................................................................... 42
6. Conclusion .............................................................................................................................. 42

i ii
Chapitre 7 - Les fonctions et les procédures ................................................................................ 43 Corrigé série 6 ................................................................................................................................. 92
1. Introduction ............................................................................................................................. 43 Partie III – Travaux pratiques en C ............................................................................................ 96
2. La notion de sous-programme ................................................................................................. 44 TP 1 ................................................................................................................................................ 97
2.1. La portée d’une variable .................................................................................................. 44 TP 2 .............................................................................................................................................. 100
2.2. Les paramètres ................................................................................................................. 46 TP 3 .............................................................................................................................................. 101
2.3. Le passage de paramètres ................................................................................................ 46 TP 4 .............................................................................................................................................. 102
3. Les fonctions ........................................................................................................................... 46 TP 5 .............................................................................................................................................. 104
3.1. Définition d’une fonction ................................................................................................ 47 TP 6 .............................................................................................................................................. 107
3.2. Appel d’une fonction ....................................................................................................... 47 TP 7 .............................................................................................................................................. 110
4. Les procédures ........................................................................................................................ 48 Conclusion générale .................................................................................................................... 112
4.1. Définition d’une procédure .............................................................................................. 48 Références bibliographiques ...................................................................................................... 113
4.2. Appel d’une procédure .................................................................................................... 48
5. Fonctions et procédures récursives .......................................................................................... 50
5.1. Exemple illustratif ........................................................................................................... 50
5.2. Interprétation ................................................................................................................... 50
5.3. Mécanisme de fonctionnement ........................................................................................ 51
6. Conclusion .............................................................................................................................. 52
Chapitre 8 - Les pointeurs ............................................................................................................ 53
1. Introduction ............................................................................................................................. 53
2. Notion de pointeur ................................................................................................................... 54
2.1. Définition ................................................................................................................................ 54
3. Allocation dynamique ............................................................................................................. 56
4. Application des pointeurs ........................................................................................................ 57
5. Conclusion .............................................................................................................................. 59
Partie II - Exercices corrigés ........................................................................................................ 60
Série 1 : Initiation aux algorithmes.................................................................................................. 61
Série 2 : Instructions algorithmiques de base .................................................................................. 64
Série 3 : Les instructions conditionnelles ........................................................................................ 65
Série 4 : Les instructions itératives .................................................................................................. 66
Série 5 : Les tableaux et les structures ............................................................................................. 69
Série 6 : Les fonctions et les procédures ......................................................................................... 70
Corrigé série 1 ................................................................................................................................. 74
Corrigé série 2 ................................................................................................................................. 77
Corrigé série 3 ................................................................................................................................. 79
Corrigé série 4 ................................................................................................................................. 82
Corrigé série 5 ................................................................................................................................. 86

iii iv
 Introduction générale

Table des figures

Introduction générale
Figure 1. Etapes de développement. .................................................................................................5
Figure 2. Principe du traitement automatisé. ....................................................................................6
Figure 3. Organisation de la mémoire. .............................................................................................7 Dans ce support, le lecteur est initié à la notion d’algorithmique, ses concepts et ses
Figure 4. Opération de lecture. ....................................................................................................... 13
fondements de base. L’accent est mis également sur les structures de données nécessaires au
Figure 5. Opération d’écriture. ....................................................................................................... 14
développement algorithmique tout en insistant sur le côté pratique à travers des exemples et
Figure 6. Organigramme « Etat de l’eau » ...................................................................................... 18
des exercices corrigés à la fin du polycopié. Le côté programmation est aussi fort présent
Figure 7. Calcul de la factorielle par récursivité. ............................................................................ 51
dans ce support à travers des exemples typiques de travaux pratiques. Le langage C est utilisé
Figure 8. Représentation d’une variable en mémoire. .................................................................... 53
à cette fin pour ses caractéristiques plus proches aux algorithmes ce qui le rend un langage
Figure 9. Le pointeur et la variable pointée en mémoire ………………………………………….54
de programmation pédagogique convenable aux étudiants en phase d’initiation à la
programmation.

Ce manuscrit est constitué également de trois parties :

 Partie I – Cours

Cette partie couvre le côté théorique nécessaire à la compréhension du concept

d’algorithmique et de programmation. Cette partie est composée également de
huit chapitres.
- Chapitre 1 : est une initiation à la discipline d’algorithmique.
- Chapitre 2 : présente les instructions de base et fondamentales pour
l’écriture des algorithmes.
- Chapitres 3 et 4 : traitent les instructions qui permettent de contrôler le flux
d’instructions de base, il s’agit notamment des instructions conditionnelles
(les alternatives) et des instructions d’itération (les boucles).
- Chapitres 5 et 6 : sont consacrés aux structures de données indispensables
à la manipulation et au stockage des données dans la phase de traitement, à
savoir les tableaux et les enregistrements (ou les structures).
- Chapitre 7 : présente une initiation à la modularité algorithmique à travers
la notion des sous-programmes (fonctions et procédures). Les modes de
passage de paramètres par valeur et par adresse sont également mis en
évidence ainsi qu’un aperçu sur la notion de la récursivité.
- Chapitre 8 : introduit le lecteur à la notion des pointeurs avec des exemples
d’application, ainsi qu’au mécanisme de gestion dynamique de la mémoire.

-1-
Introduction générale

 Partie II – Exercices corrigés

Cette partie est consacrée à la mise en œuvre des connaissances acquises dans
les cours à travers un ensemble de travaux dirigés qui couvrent globalement tous
les chapitres de la partie I.

 Partie III – Travaux pratiques en C

Cette partie présente une initiation à la programmation à travers des exemples

de travaux pratiques à réaliser en langage C avec quelques exemples de code
source.

Partie I - Cours

-2- -3-
Chapitre 1 - Introduction aux algorithmes Chapitre 1 - Introduction aux algorithmes

Exemple : Appel téléphonique

Chapitre 1 - Introduction aux algorithmes a. Ouvrir son téléphone,

b. Chercher/Composer le numéro du destinataire,
c. Appuyer sur le bouton « Appel ».
1. Contexte
Ce mode d’emploi précise comment faire un appel téléphonique. Il est composé d’une suite
Le terme Informatique est un néologisme proposé en 1962 par Philippe Dreyfu 1 s pour ordonnée d’instructions (ouvrir, chercher/composez, appuyer) qui manipulent des données
caractériser le traitement automatique de l’information, c’est une contraction de l’expression (téléphone, numéro, bouton) pour réaliser la tâche d’appel.
« information automatique ». Ce terme a été accepté par l’Académie française en avril 1966,
3. L'algorithmique
et l’informatique devint alors officiellement la science du traitement automatique de
3.1. Définition
l’information, où l’information est considérée comme le support des connaissances
L’algorithmique est la science des algorithmes. Elle s’intéresse à l’art de construire des
humaines et des communications dans les domaines techniques, économiques et sociaux [3].
algorithmes ainsi qu’à déterminer leur validité, leur robustesse, leur réutilisabilité, leur
2. Notions élémentaires complexité ou leur efficacité [3]. L’algorithmique permet ainsi de passer d’un problème à

 Informatique résoudre à un algorithme qui décrit la démarche de résolution du problème. Par conséquent,

L’informatique est la science du traitement automatique de l’information. Elle traite de deux la programmation consiste à traduire un algorithme dans un langage « compréhensible » par

aspects complémentaires : l’ordinateur afin qu’il puisse être exécuté automatiquement.

- les programmes ou logiciels (software) qui décrivent un traitement à réaliser,

- les machines ou le matériel (hardware) qui exécute ce traitement.

 Hardware
C’est l’ensemble des éléments physiques (microprocesseur, mémoire, disques durs, ...)
utilisés pour traiter les informations.

 Software
C’est un programme (ou ensemble de programmes) décrivant un traitement d’informations
à réaliser par un matériel informatique.

 Algorithme
La notion d'algorithme est à la base de toute la programmation informatique [8]. La
Figure 1. Etapes de développement.
définition la plus simple que l’on peut associer à cette notion est qu’un algorithme est une
La figure 1 ci-dessus illustre les deux phases nécessaires pour obtenir un code source :
suite ordonnée d’instructions qui indique la démarche à suivre pour résoudre un problème
 Phase d’algorithmique qui implique la recherche et l’écriture d’un algorithme ;
ou effectuer une tâche. Le mot algorithme vient du nom latinisé du mathématicien perse Al-
 Phase de programmation qui consiste à traduire l’algorithme obtenu en un
Khawarizmi, surnommé « le père de l'algèbre » [11].
programme à l’aide d’un langage de programmation (C, Java, Python,…).
Dans la première phase, on doit définir les données qu’on dispose et les objectifs qu’on
1
Informaticien Français
souhaite atteindre, ainsi que prévoir des réponses à tous les cas possibles.

-4- -5-
Chapitre 1 - Introduction aux algorithmes Chapitre 1 - Introduction aux algorithmes

Exemple : résolution d’une équation de second degré ax2+bx+c =0 Partie corps de l’algorithme : constituée d’une ou plusieurs séquences d’instructions
→ Les données sont a, b et c faisant appel à des opérations de base à exécuter par l’ordinateur.
→ Les sorties sont x1 et x2
Syntaxe :
→ Les cas : a=0 et b≠0, a = 0 et b = 0, a ≠0 , ……
Algorithme nom_de_l’algorithme ;
3.2. Principe général Partie déclarative (Entête)
< Liste de variables/constantes > ;
Le traitement automatique de l’information consiste à exécuter des instructions (opérations
Début
élémentaires et complexes) sur des données d’entrée afin de générer d’autres informations < Séquence d’instructions > ; Partie corps de l’algorithme
appelées résultats ou données de sortie.
Fin

4.2. Les variables et les constantes

Données Traitement Résultat
L’élément unitaire de stockage de l’information est appelé bit. Un bit ne peut avoir que deux

Entrée (Input) Sortie (Output) états distincts : 0 ou 1 (vrai ou faux dans la logique). Dans la mémoire de l’ordinateur, les

Figure 2. Principe du traitement automatisé. données sont manipulées par groupes de 8 bits (octets), ou plus (mots de 16, 32, 64 bits,…).
Une case mémoire est donc appelée mot et pour que l’unité centrale puisse stocker une
Exemple : Calcul de la moyenne d’un étudiant
information et la retrouver dans la mémoire, chaque mot est repéré par une adresse [4].
Supposons qu’on doit calculer la moyenne d’un étudiant pour un ensemble de matières.
Dans la programmation, les adresses mémoire sont représentées par des noms. Le
Donc, on doit :
programmeur ne connait pas donc l’adresse d’une case mais plutôt son nom. Il y a donc deux
i. Définir le nombre des matières concernées ainsi que les notes et les coefficients ; façons de voir la mémoire centrale de l’ordinateur : côté programmeur et côté ordinateur tel
ii. Réaliser les opérations suivantes : qu’il est illustré, à titre d’exemple, dans le schéma suivant (figure 3).
- Multiplier chaque note d’une matière par son coefficient,
- Calculer la somme des résultats des multiplications, Mémoire

- Diviser la somme obtenue par le total des coefficients, Adresses Mots

iii. Afficher le la moyenne de l’étudiant (résultat final).
10000000 6 x
Remarque :
10000001 8 y Variables
Lorsqu’on écrit un algorithme, les questions suivantes doivent être considérées :
 Quel est le résultat attendu ? 10000010 7 moyenne

 Quelles sont les données nécessaires (informations requises) ? 10000011

 Comment faire (le traitement à réaliser) ?
…
4. Caractéristiques des algorithmes
4.1. Structure générale
Côté ordinateur Côté programmeur
Un algorithme se compose généralement de deux parties :
Figure 3. Organisation de la mémoire.
Partie déclarative : appelée aussi entête de l’algorithme, elle contient généralement les
déclarations (des constantes, des variables, etc.).

-6- -7-
Chapitre 1 - Introduction aux algorithmes Chapitre 1 - Introduction aux algorithmes

4.2.1. Les variables 4.3.1. Type entier

Une variable est une case mémoire destiné à contenir des valeurs de type défini au préalable
C’est un type numérique représentant l’ensemble des entiers relatifs, tels que: -9, 0, 31, ….
(nombres, caractères, chaînes de caractères,…). Elle possède un nom, un type, et un contenu
Les opérations permises sur ce type sont : +, - , *, div (division entière) et mod (modulo ou
qui peut être modifié au cours de l’exécution de l’algorithme.
reste de la division entière).
Le mot clé est: Var. Le mot clé est : entier.
4.2.2. Les constantes Exemple : Var x : entier ;
La définition d’une constante est la même que celle d’une variable à la différence que sa
4.3.2. Type réel
valeur reste inchangée tout au long du déroulement (exécution) de l’algorithme.
C’est un type numérique aussi représentant l’ensemble des nombres réels, tels que : 0.25, -
Le mot clé est: Const.
1.33, 2.5 e+10,… . Les opérations permises sur ce type sont : +, -, * et /.
Les variables et les constantes sont déclarées selon la syntaxe suivante :
Le mot clé est : réel.
Syntaxe : Exemple : Var y : réel ;
Var nom_variable : type ;
4.3.3. Type caractère
Const nom_constante = valeur ;
Ce type représente tous les caractères alphanumériques tels que : ′a′, ′A′, ′3′, ′%′, ′ ′, …
Remarque :
Les opérations supportées par ce type sont : =, ≠, <, <=, >, >=.
Dans la partie déclarative, les variables et les constantes sont caractérisées essentiellement
Le mot clé est : caractère.
par :
Exemple : Var a : caractère ;
 Un identificateur : est un nom attribué à la variable ou à la constante, qui peut être
4.3.4. Type booléen
composé de lettres et de chiffres mais sans espaces.
 Un type : qui définit la nature et la taille de la variable. Ce type est utilisé dans la logique pour représenter les deux valeurs : vrai et faux.

Exemple : Les opérations prises en charge sont : NON, ET, OU.

Var x, y : entier; Le mot clé est : booléen.

Const alpha = 0,5 ; Exemple : Var b : booléen ;

Dans cet exemple, nous avons déclaré :
4.3.5. Chaîne de caractères
- Deux variables (x et y) de type entier, ce type est décrit dans la sous-section suivante.
Ce type représente les mots et les phrases tels que "Algorithmique", "Cours", etc. Le mot clé
- Une constante (alpha) égale à la valeur 0,5 à titre d’exemple.
utilisé est : chaîne
4.3. Les types de base
Exemple : Var c : chaîne ;
Le type d’une variable définit l’ensemble des valeurs que peut prendre la variable, ainsi que
Globalement, la partie déclarative d’un algorithme peut être représentée comme suit.
l’ensemble des opérations que l’on peut appliquer sur cette variable. Il existe des types
simples prédéfinis tels que : entier, réel, caractère et booléen.

-8- -9-
Chapitre 1 - Introduction aux algorithmes Chapitre 2 - Les instructions simples

Exemple :

Var x, y : entier ;
Chapitre 2 - Les instructions simples
z, w : réel ;
lettre : caractère ;
nom : chaîne ; 1. Introduction
Etat : booléen ;
Un algorithme, par définition, est un ensemble d’instructions qui peuvent être simples ou
Const n = 100 ;
arobase = ′@′ ; complexes. Dans ce chapitre, on s’intéressera aux instructions simples notamment : les

mot = "bonjour" ; instructions d’affectation, de lecture et d’écriture.

2. L’instruction d’affectation
5. Conclusion
Cette instruction est élémentaire en algorithmique, elle permet d’assigner une valeur à une
Ce chapitre constitue une initiation aux notions basiques de l’écriture des algorithmes. La variable selon la syntaxe suivante :
syntaxe d’un algorithme, la notion de variable et de constante, ainsi que leurs types sont
variable ← expression ;
définis et expliqués à travers des exemples simples. Ceci constitue pour le lecteur un
prérequis de base qui lui permettra de comprendre la notion d’instructions algorithmiques Une instruction d’affectation est exécutée comme suit :
- évaluation de l’expression située à droite de l’instruction, et
dans les prochains chapitres.
- affectation du résultat à la variable située à gauche de l’instruction.
L’expression peut être :
• une constante ( c ← 10 )
• une variable ( v ← x )
• une expression arithmétique ( e ← x + y )
• une expression logique ( d ← a ou b )

Remarque :

 Une constante ne figure jamais à gauche d’une instruction d’affectation.

Exemple d’instruction fausse : Const z = 1 ;
z ← 2 ; « Faux »
 Après une affectation, l’ancien contenu d’une variable est substitué (écrasé) par le
nouveau contenu.
Exemple : Var a : entier ;
a←1;
a←2;
Après la deuxième affectation, la valeur de a est devenue 2 (la valeur 1 est écrasée).
 Une instruction d’affectation doit se faire entre deux types compatibles.
Exemple : Var x, y : entier ; z : réel ; a, b : caractère ;

- 10 - - 11 -
Chapitre 2 - Les instructions simples Chapitre 2 - Les instructions simples

Instructions correctes Instructions incorrectes Exemple :

Lire(x) : lit et stocke une valeur donnée dans la case mémoire associée à x.
x←y; x←z;
y←x; x←a; Lire(x, y) : lit et stocke deux valeurs, la première dans x et la deuxième dans y.
z←x; b←y; Illustration :
a←b; a←z;
b←a;

Les expressions arithmétiques ou logiques sont composées d’au moins deux termes reliés
par un ou plusieurs opérateurs dont on peut distinguer :

a) Les opérateurs arithmétiques (par ordre de priorité) :

^ ou ** : Puissance
* , / , mod : Multiplication, Division et Modulo
+ , - : Addition et Soustraction
b) Les opérateurs logiques ou booléens :
NON : Non logique (négation)
Figure 4. Opération de lecture.
ET : Et logique (conjonction)
OU : Ou logique (disjonction) 4. L’instruction d’écriture

NON ET : négation de conjonction Cette instruction est aussi d’une grande importance dans les algorithmes. Elle permet
NON OU : négation de disjonction d’écrire en sortie (output) les données résultant d’un traitement effectué par l’algorithme

c) Les opérateurs de comparaison ou relationnels : (valeur, texte, …) en les affichant par exemple sur un périphérique de sortie tel que l’écran.

> , >= : supérieur et supérieur ou égal Syntaxe :

< , <= : inférieur et inférieur ou égal Ecrire (var1, var2, expr1, expr2, …) ;
= , ≠ (ou < >) : égal et différent
Remarque :
Remarque :
Dans le cas d’écriture d’une expression, c'est le résultat d’évaluation de cette expression qui
Les expressions logiques peuvent être composées des opérateurs logiques et/ou relationnels.
est affiché et non pas l’expression elle-même. Par exemple :
Par exemple, (A<20) ET (B>=10) est Vrai si A est inférieur à 20 et B est égal ou supérieur
Soient deux variables x et y tel que x=5 et y=7, l’instruction :
à 10, et faux sinon.
Ecrire (x+y) ;
3. L’instruction de lecture
Affiche en sortie le résultat d’addition de x et y (soit 12).
Cette instruction est très primordiale dans un algorithme. Elle permet de lire des valeurs en
entrée (input) et les affecter aux variables stockées dans la mémoire. Les valeurs affectées
sont souvent des données introduites à partir d’un périphérique d’entrée tel que le clavier.

Syntaxe :
Lire (var1, var2,…) ;

- 12 - - 13 -
Chapitre 2 - Les instructions simples Chapitre 3 - Les instructions conditionnelles (les alternatives)

Illustration :

Chapitre 3 - Les instructions conditionnelles (les

alternatives)

1. Introduction

Les algorithmes comportent généralement deux types d’instructions :

- Les instructions simples : qui permettent la manipulation des variables telles que
l’affectation, la lecture et l’écriture.
- Les instructions de contrôle : qui précisent l’enchainement chronologique des
instructions simples. C’est en particulier le cas des instructions conditionnelles ou
les tests.
Figure 5. Opération d’écriture.
2. Structure d’un test
Exemple d’algorithme contenant les trois instructions précédentes :
Il existe deux formes de test : forme simple (ou réduite) et forme complète.
Algorithme Moyenne_deux_réels
Var x, y, z : réel ; 2.1. Forme simple
Début
Dans cette forme, une action qui correspond à une ou plusieurs instructions, est exécuté si
Ecrire (″Donner la première valeur :″) ;
une condition est vérifiée. Sinon l’algorithme passe directement au bloc d’instruction qui
Lire (x) ;
suit immédiatement le bloc conditionnel.
Ecrire (″Donner la deuxième valeur :″) ;
Lire (y) ; Syntaxe :
z ← (x + y)/2 ;
Si (condition) Alors
Ecrire (″La moyenne est : ″, z) ;
instruction(s) ; // action
// On peut remplacer les deux dernières instructions par une seule :
Finsi
Ecrire (″La moyenne est : ″, (x + y)/2 ) ; // dans ce cas on a pas besoin de z
Fin
Dans cet algorithme, si l’utilisateur introduit 10 pour x et 20 pour y alors l’affichage sera :
La moyenne est : 15 Remarque :
La condition évaluée après l’instruction « Si » est une variable ou une expression booléenne
5. Conclusion
qui, à un moment donné, est Vraie ou Fausse. par exemple : x=y ; x <= y ; ...
Dans ce chapitre, nous avons présenté les instructions algorithmiques fondamentales à savoir
Exemple :
l’affectation, la lecture et l’écriture. Ces trois simples instructions sont incontournables dans
x←5;y←9;
l’écriture d’un algorithme et constituent l’un des moyens les plus simples qui permettent au Si (x = y) Alors Ecrire (″x est égale à y″) ;
programmeur d’interagir avec son ordinateur à travers à travers des actions d’entrées/sorties.
Dans cet exemple, le message « x est égale à y » ne sera pas affiché puisque la condition (x
= y) n’est pas vérifiée.

- 14 - - 15 -
Chapitre 3 - Les instructions conditionnelles (les alternatives) Chapitre 3 - Les instructions conditionnelles (les alternatives)

2.2. Forme complète …

Sinon instruction(s) N ;
Cette forme permet de choisir entre deux actions selon qu’une condition est vérifiée ou non. FinSi
Syntaxe : FinSi
Si (condition) Alors FinSi

instruction(s) 1 ; // action1 Exemple : Etat de l’eau [10]

Sinon instruction(s) 2 ; // action2 Dans les conditions normales de température et de pression, l’eau est sous forme de glace si

Finsi la température est inférieure ou égale à 0° C, sous forme de liquide si la température est
comprise entre 0° C et 100° C et sous forme de vapeur au-delà de 100° C. Ecrivons
l’algorithme qui permet de vérifier l’état de l’eau selon sa température.
Remarque :
La solution pourrait être comme suit :
Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas être
Algorithme Etat_Eau ;
exprimées sous la forme d’une simple comparaison. Par exemple, la condition x ∈ [0, 1[ Var t : réel ;
s’exprime par la combinaison de deux conditions x >= 0 et x < 1 qui doivent être vérifiées Début
Ecrire ("Donner la température de l’eau :") ;
en même temps. Lire (t) ;
Pour combiner ces deux conditions, on utilise les opérateurs logiques. Ainsi, la condition x ∈ Si (t <= 0) Alors Ecrire ("Etat solide") ;
FinSi
[0, 1[ pourra s’écrire sous la forme : (x >= 0) ET (x < 1). Cette dernière est appelée une
Si (t > 0 ET t < 100) Alors Ecrire ("Etat liquide") ;
condition composée ou complexe. Finsi
Si (t >= 100) Alors Ecrire ("Etat gazeux") ;
Exemple (sur la forme complète d’un test) : Finsi
Fin
x←5;y←9;
Cet algorithme est correct mais il évalue les trois conditions qui portent sur la même variable
Si (x = y) Alors Ecrire (″x est égale à y ″) ;
et qui sont exclusives. En effet, si (t <= 0), alors on ne peut pas avoir (t>= 0 et t < 100) ni (t
Sinon Ecrire (″x est différente de y ″) ;
> 100). Il est donc inutile d’évaluer les deux dernières conditions si la première est vérifiée,
Avec cette forme, on peut traiter les deux cas possibles. Si la condition (x=y) est vérifiée, le
ou d’évaluer la dernière condition si la deuxième est vérifiée. Pour éviter ce cas de figure, il
premier message est affiché, si elle n’est pas vérifiée, le deuxième message est affiché.
sera préférable d’utiliser des tests imbriqués comme suit :
3. Tests imbriqués …
Début
La forme « Si … Alors…Sinon » permet deux choix correspondants à deux traitements
Ecrire ("Donner la température de l’eau:") ;
différents. Dans d’autres situations, on pourra avoir plus de deux cas ce qui rend cette
Lire (t) ;
alternative insuffisante pour traiter tous les cas possibles (voir exemple ci-dessous).
Si (t <= 0) Alors Ecrire ("Etat solide") ;
La forme complète permet de choisir entre plusieurs actions en imbriquant des formes
Sinon Si (t < 100) Alors Ecrire (" Etat liquide") ;
simples selon la syntaxe ci-dessous. Sinon Ecrire ("Etat gazeux") ;
Syntaxe : Finsi
Si (condition1) Alors instruction(s) 1 ; Finsi
Sinon Si (condition2) Alors instruction(s) 2 ; Fin
Sinon Si (condition3) Alors instruction(s) 3 ;

- 16 - - 17 -
Chapitre 3 - Les instructions conditionnelles (les alternatives) Chapitre 3 - Les instructions conditionnelles (les alternatives)

L’organigramme correspondant est illustré dans la figure 6. Ainsi, toute structure de test avec l’opérateur logique ET peut être exprimée d’une manière
équivalente avec l’opérateur logique OU et vice-versa. Par conséquent, les deux alternatives
suivantes sont équivalentes [7].

Si A ET B Alors Si NON A OU NON B Alors

instruction(s) 1 ; instruction(s) 2 ;
Sinon Sinon
instruction(s) 2 ; instruction(s) 1 ;
Finsi Finsi

4. Les choix multiples

Il existe une autre variante d’instructions conditionnelles qui permet d’effectuer des actions
différentes suivant les différentes valeurs que peut avoir une variable. Cette structure est
décrite comme suit :

Syntaxe :

Selon (variable)
valeur1 : instruction(s) 1 ;
valeur2 : instruction(s) 2 ;
…
valeurN : instruction(s) N ;
défaut : instruction(s) par défaut;
FinSelon ;
Figure 6. Organigramme « Etat de l’eau ».
Remarque :
Donc, l’utilisation de tests imbriqués permet de :
Dans la structure de test à choix multiples :
 Simplifier le (pseudo-) code : à travers l’imbrication nous n’avons utilisé que deux
- L’action peut être une suite d’instructions ;
conditions simples au lieu de trois conditions dont une est composée.
- La valeur est une constante de même type que la variable ;
 un algorithme (ou programme) plus simple et plus lisible.
- La partie « défaut » est exécutée si aucun des autres cas n’est vérifié ;
 Optimiser le temps d’exécution : dans le cas où la première condition est vérifiée,
- L’exécution des différents cas (y compris le cas par défaut) est exclusive c’est-à-
l’algorithme passe directement à la fin, sans tester le reste qui est forcément faux.
dire l’exécution d’un seul cas provoque la sortie de cette structure.
 un algorithme (ou programme) plus performant à l’exécution.

Remarque :
Nous avons les équivalences suivantes :
NON (A ET B) ⇔ NON A OU NON B

NON (A OU B) ⇔ NON A ET NON B

- 18 - - 19 -
Chapitre 3 - Les instructions conditionnelles (les alternatives) Chapitre 4 - Les instructions itératives (les boucles)

Exemple :
Dans ce qui suit, le nom du jour de la semaine correspondant est affiché selon la valeur de
la variable « jour ».
Chapitre 4 - Les instructions itératives (les boucles)
jour ← 5 ;
Selon jour 1. Introduction
1 : Ecrire ("Dimanche") ;
Considérons le même exemple qu’on a vu précédemment concernant le calcul de la moyenne
2 : Ecrire ("Lundi") ;
générale d’un étudiant. Pour se faire, on doit :
3 : Ecrire ("Mardi") ;
 Lire toutes les notes (et leurs coefficients) de l’étudiant,
4 : Ecrire ("Mercredi") ;
5 : Ecrire ("Jeudi") ;  Calculer la somme des notes,
6 : Ecrire ("Vendredi") ;  Diviser la somme obtenue sur le nombre (ou sur la somme des coefficients).
7 : Ecrire ("Samedi") ; Si l’on veut maintenant calculer la moyenne d’un autre étudiant, les mêmes instructions
Défaut : Ecrire ("Numéro de jour invalide.") ; doivent être répétées.
FinSelon Pour N d’étudiants, il nous faudra donc répéter N fois la même séquence d’instructions.
Donc, l’expression « Jeudi » est affichée dans ce cas. Cet exemple soulève deux questions importantes :
5. Conclusion 1- Comment éviter d’écrire plusieurs fois la même séquence d’instructions ?
2- Combien de fois doit-on répéter l’exécution de la séquence d’instructions pour
Dans ce chapitre, nous avons présenté le principe de la condition, suivant lequel un
obtenir le résultat attendu ?
algorithme peut effectuer une action ou prendre une décision. Ceci est mis en œuvre à
Pour répondre à ces questions, de nouvelles instructions de contrôle sont introduites. Il s’agit
travers les instructions conditionnelles ou tout simplement les tests avec leurs différentes
des instructions itératives (appelées aussi les boucles ou les itérations).
formes vues précédemment.
2. Définition

Une boucle (ou itération) est une instruction de contrôle qui permet de répéter plusieurs fois
un ensemble d’instructions. Généralement, deux cas sont distingués :
- Le nombre de répétitions est connu.
- Le nombre des répétitions est inconnu ou variable.

3. L’instruction « Pour »

Lorsque le nombre de répétitions est déterminé (connu), l’utilisation de l’instruction « Pour »

est privilégiée. Une structure de boucle avec l’instruction « Pour » s’arrête une fois que le
nombre de répétitions est atteint. Cette structure possède un indice (compteur) de contrôle
d’itérations caractérisé par :
- une valeur initiale,
- une valeur finale,
- un pas de variation.

- 20 - - 21 -
Chapitre 4 - Les instructions itératives (les boucles) Chapitre 4 - Les instructions itératives (les boucles)

Syntaxe : 4. L’instruction « Tant que… faire »

Pour indice de début à fin Pas valeur_du_pas Cette instruction permet de tester une condition et répéter le traitement associé tant que cette

instruction(s) ; condition est vérifiée.

FinPour Syntaxe:
Tant que condition faire
instruction(s) ;
FinTq

Exemple : Réécrivons l’algorithme précédent avec cette instruction.

Var i : entier ;
Début
i←1;
Tant que (i<=100) faire
Ecrire (i) ; i ← i+1 ;
FinTq
Fin

6. L’instruction « Répéter… jusqu’à »

Dans cette instruction, un traitement est exécuté au moins une fois puis sa répétition se
Cette structure est dite « croissante » lorsque la valeur initiale de l’indice est inférieure à sa poursuit jusqu’à ce que la condition soit vérifiée.
valeur finale, le pas de variation est par conséquent positif. Autrement, elle est dite Syntaxe:
« décroissante ». Répéter
Exemple : un compteur croissant/décroissant instruction(s) ;

Les deux algorithmes suivants comptent de 1 à N et de N à 1 respectivement. Jusqu’à (condition) ;

Algorithme compteur_croissant ; Algorithme compteur_decroissant ;

Var i : entier ; Var i : entier ; Exemple : Soit l’algorithme suivant :
Const N=100 ; Const N=100 ;
Var n, p : entier ;
Début Début
Pour i de 1 à N /* par défaut le pas = 1 */ Pour i de N à 1 /* par défaut le pas = -1 */ Début
Ecrire (i); Ecrire (i); Répéter
FinPour FinPour
Ecrire ("Donner un nombre :") ; Lire (n) ;
Fin Fin
p ← n*n ; Ecrire (p);
Résultat d’exécution : 1,2, 3, … , 99, 100 Résultat d’exécution : 100, 99, 98, … , 2, 1 Jusqu’à (n=0)
Ecrire ("Fin de l’algorithme") ;
Remarque : Si la valeur du « pas » n’est pas précisée dans l’instruction « Pour », elle est
Fin
par défaut égale à un (1).

- 22 - - 23 -
 Chapitre 4 - Les instructions itératives (les boucles) Chapitre 4 - Les instructions itératives (les boucles)

Les instructions encadrées par les mots répéter et jusqu’à constituent le bloc de la boucle Exemple :
qu’il faut répéter jusqu’à ce que la condition (n=0) soit vérifiée. Donc le nombre de i←0; i←0;
Répéter Tant que (i<5) faire
répétitions de cette boucle dépend des données fournies par l’utilisateur.
Ecrire (i); Ecrire (i);
i ← i +1 ; i ← i +1 ;
Question ?
Jusqu’à (i=5) ; FinTant que ;
Réécrire l’algorithme précédent avec « Tant que… faire » puis avec « Pour ».
Résultat d’exécution : 0, 1, 2, 3, 4 Résultat d’exécution : 0, 1, 2, 3, 4
Remarque :
Dans la boucle « Répéter… jusqu’à », la condition telle qu’elle est exprimée ci-dessus, 8. La notion d’accumulation
constitue une condition d’arrêt de la boucle ; mais réellement, cela diffère selon le langage Cette notion est fondamentale en programmation. Elle est utilisée notamment pour calculer
de programmation utilisé. Par exemple, en Pascal, la condition de cette boucle est une la somme d’un ensemble de valeurs. L’instruction correspondante se présente ainsi :
condition d’arrêt. Alors qu’en langage C, cette condition est exprimée en tant qu’une variable ← variable + valeur ;
condition de continuation. Cette instruction consiste à ajouter une valeur à une variable numérique, puis affecter le
7. La notion du compteur résultat dans la variable elle-même. En d’autres termes, la nouvelle valeur de variable égale
à l’ancienne plus une certaine valeur [4].
Un compteur est une variable associée à la boucle dont la valeur est incrémentée de un à
chaque itération. Elle sert donc à compter le nombre d’itérations (répétitions) de la boucle. Exemple : calcul de la somme de n valeurs données par l’utilisateur :
La notion du compteur est associée particulièrement aux deux Var i, n : entier ; som, val : réel ;
boucles : « Répéter…jusqu’à » et « Tant que…faire ». Par contre, dans la boucle Début
Écrire ("Donner le nombre de valeurs :") ; Lire (n) ;
« Pour », c’est l’indice qui joue le rôle du compteur.
som ← 0 ;
L’utilisation du compteur dans les deux premières boucles est exprimée ainsi : Pour i de 1 à n
Écrire ("Enter une valeur :") ; Lire (val) ;
compt ← 0 ; compt ← 0 ; som ← som + val ;
Répéter Tant que (condition) faire Finpour
Écrire ("La somme des valeurs est égale à :", som) ;
instruction(s) ; instruction(s) ;
Fin
Bloc de la boucle … …
9. Les boucles imbriquées
compt ← compt +1 ; compt ← compt +1 ;
Les boucles peuvent être imbriquées les unes dans les autres. Deux ou plusieurs boucles
Jusqu’à (condition) ; FinTant que ;
imbriquées peuvent être aussi les mêmes ou différentes.

Remarque : Exemple :

Il faut toujours initialiser le compteur avant de commencer le comptage. La variable Pour i de 1 à 2

« compt » (utilisée ci-dessus comme compteur), a été initialisée à zéro (0) avant le début de Écrire ("i = ", i) ;
Pour j de 1 à 3 boucle 1
chaque boucle. Écrire ("j = ", j) ; boucle 2
L’instruction « compt ← compt +1 » incrémente la valeur de « compt » de un (1). Elle peut Finpour
Finpour
être placée n’importe où à l’intérieur du bloc de la boucle.
Dans l’exemple ci-dessus, chaque itération de la boucle extérieure (boucle 1) exécute la
boucle intérieure (boucle 2) jusqu’à la fin avant de passer à l’itération suivante, et ainsi de

- 24 - - 25 -
Chapitre 4 - Les instructions itératives (les boucles) Chapitre 5 - Les tableaux

suite jusqu’à la fin des deux boucles. Ainsi, le résultat d’exécution peut être représenté
comme suit : Chapitre 5 - Les tableaux
i=1
j=1
j=2 1. Introduction
j=3
i=2 Supposons que l’on a besoin de stocker et de manipuler les notes de 100 étudiants. On doit,
j=1 par conséquent, déclarer 100 variables : n1, n2,…, n100. Vous pouvez remarquer que c’est
j=2
un peu lourd de manipuler une centaine de variables (avec 100 fois de lecture/écriture…).
j=3
Imaginons maintenant le cas pour une promotion de 1000 étudiants, alors là devient notre
Remarque :
cas un vrai problème.
Des boucles peuvent être imbriquées ou successives. Cependant, elles ne peuvent jamais être
En algorithmique (et en programmation), on peut regrouper toutes ces variables en une seule
croisées. Par exemple, l’algorithme suivant est faux puisqu’il comporte deux boucles
structure qui s’appelle tableau.
croisées :
Un tableau est un ensemble de variables de même type ayant toutes le même nom.
Var i, j : entier ;
Suite à cette définition, la question suivante se pose :
Début
i←1 ; j←1 ; - Comment peut-on différencier entre des variables ayant le même nom ?
Répéter
La réponse est dans la notion du tableau lui-même où chaque élément est repéré par un
Écrire i ;
Répéter indice. Ce dernier est un numéro (généralement un entier) qui permet de différencier chaque
Écrire j ; élément du tableau des autres. Ainsi, les éléments du tableau ont tous le même nom, mais
i←i+1 ;
Jusqu’à i>2 pas le même indice. Pour accéder à un élément d’un tableau, on utilise le nom du tableau
j←j+1 ; suivi de l’indice de l’élément entre crochets [4].
Jusqu’à j>3
Exemple
Fin
Soit le tableau T contenant les valeurs suivantes : 5, 10, 29, 3, 18 et 14 :
10. Conclusion L’organisation du tableau T dans la mémoire peut être représentée comme suit :
Ce chapitre a été consacré aux structures itératives ou boucles qui permettent de répéter indices : i=0 i=1 i=2 i=3 i=4 i=5
l’exécution d’une séquence d’instructions plusieurs fois selon un nombre fixe ou certains T
valeurs : T[0]=5 T[1]=10 T[2]=29 T[3]=3 T[4]=18 T[5]=14
critères dont l’utilisation a été explicitée à travers différents exemples. Ainsi, ces instructions
sont d’une grande importance dans la manipulation de certaines structures de données telles 2. Tableaux à une seule dimension
que les tableaux que nous aborderons dans le prochain chapitre. Dans ce type de tableaux, chaque élément est accessible (pour lecture ou modification) par
un seul indice.
2.1. Déclaration

La syntaxe de déclaration d’un tableau à une seule dimension est la suivante :

Tableau nom_du_tableau [taille] : type ;

Exemple : Tableau Notes [100] : réel ;

- 26 - - 27 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

Remarque : 2.2.2. La lecture

L’indice d’un élément dans un tableau, peut être exprimé comme un nombre, mais aussi il
Il est possible aussi d’affecter des valeurs aux éléments d’un tableau par une instruction de
peut être exprimé comme une variable ou une expression calculée [10].
lecture.
La valeur de l’indice doit être toujours :
Exemple :
 Supérieur ou égal à 0 : dans quelques langages, le premier élément d’un tableau
Ecrire "Entrer une note :" ;
porte l’indice 1 (comme en Pascal). Mais dans d’autres, comme c’est le cas en Lire T[0] ;
langage C, la numérotation des indices commence à zéro. Par exemple Notes[1] est
Dans cet exemple, la valeur saisie est affectée au premier (1er) élément du tableau T.
le deuxième élément du tableau Notes.
 de type entier : quel que soit le langage, l’élément Notes[1,…] n’existe jamais. Illustration :
 Inférieur ou égal au nombre des éléments du tableau (moins 1 si l’on commence indices : i=0 i=1 i=2 i=3 i=4 i=5
T
à zéro): En langage C, si un tableau T est déclaré comme ayant 10 éléments, la valeurs : 0
présence, dans une ligne du corps de l’algorithme, de l’expression T[10] déclenchera
2.2.3. L’écriture
automatiquement une erreur.
De même que la lecture, l’écriture de la valeur d’un élément du tableau s’écrira comme suit :
2.2. Manipulation
Ecrire T[i] ; Cette instruction permet d’afficher la valeur de l’élément i du tableau T.
Une fois déclaré, un tableau peut être manipulé comme un ensemble de variables simples.
Remarque :
Les trois manipulations de base sont l’affectation, la lecture et l’écriture [4].
Les éléments d’un tableau sont manipulés de la même façon que les variables simples. S’il
2.2.1. L’affectation s’agit d’un tableau de type numérique, les éléments peuvent être utilisés dans l’évaluation
L’affectation d’une valeur v à un élément i d’un tableau T de type numérique, se fait par : des expressions numériques du genre :

T[i] ← v ; x ← (Notes [1] + Notes [2]) / 2 ;

Notes [0] ← Notes [0] + 1 ;
Par exemple, l’instruction : T[0] ← 5 ; affecte la valeur 5 au premier élément du tableau T.

Illustration : Exemple :
Soit Notes un tableau de valeurs réelles tel qu’il est illustré dans le schéma qui suit.
indices : i=0 i=1 i=2 i=3 i=4 i=5
T
valeurs : 5 Illustration :

Supposons maintenant que l’on veut affecter la même valeur à tous les éléments du tableau indices : i=0 i=1 i=2 i=3 i=4 i=5
Notes
T, on utilisera pour cela une boucle : valeurs : 10 15 7 8.25 11.5 16

Pour i de 0 à n-1 // n est la taille de T

T[i] ← 5 ; L’exécution de l’instruction : x ← (Notes [1] + Notes [2]) / 2 ;
FinPour 𝟏𝟓+𝟕
Est équivalente à l’opération : x = = 11
Cette boucle permet de parcourir tout le tableau T en affectant à chaque élément la valeur 5. 𝟐

Illustration : 2.3. Application 1

indices : Ecrivons un algorithme qui permet de lire des valeurs saisies par l’utilisateur dans un tableau
i=0 i=1 i=2 i=3 i=4 i=5
T
valeurs : 5 5 5 5 5 5 de taille 20, et les afficher par la suite.

- 28 - - 29 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

Algorithme : Exemple : le tableau T ci-dessous possède 3 lignes et 4 colonnes.

Var i : entier ;
j=0 j=1 j=2 j=3
Tableau Tab [20] : réel ; i : indice des lignes
Début i=0 j : indice des colonnes

Pour i de 0 à 19 i=1
Ecrire ("Donner une valeur :") ; i=2 x
Lire (Tab[i]) ;
FinPour Donc, T[2][1] (i=2 et j=1) désigne l’élément de la 3ème ligne et la 2ème colonne (en
Pour i de 0 à 19 commençant de zéro bien sûr).
Ecrire ("Valeur ", i, "=", Tab[i]) ;
3.1. Déclaration d’un tableau à deux dimensions
FinPour
Fin Syntaxe :
Tableau nom_tableau [taille1][taille2] : type ;
L’exécution du programme correspondant à l’algorithme ci-dessus, permet d’initialiser le
tableau Tab comme suit : Exemple : Tableau Notes [10][20] : réel ;

- Après la fin de la 1ère boucle (boucle de lecture) : Le tableau Notes est composé de 10 lignes et 20 colonnes. Ce tableau pourra contenir donc
10*20 soit 200 valeurs réelles.
indices : i=0 i=1 … i=18 i=19
Tab
valeurs : 5 34 … 14.5 60 Remarque :
L’utilité d’un tableau à deux dimensions réside dans la possibilité de déclarer un seul tableau
au lieu de déclarer plusieurs tableaux identiques. En effet, le tableau de l’exemple précédent
- Après la fin de la 2ème boucle (boucle d’affichage), on aura, sur écran par exemple,
est équivalant à 10 tableaux simples de 20 éléments chacun. En d’autres termes, la
l’affichage suivant :
déclaration :
Valeur 0 = 5
Tableau Notes [10][20] : réel ;
Valeur 1 = 34
… remplace celle-ci :
Valeur 18 = 14,5 Tableau Notes1 [20], Notes2 [20],…, Notes10 [20] : réel ;
Valeur 19 = 60
3.2. Manipulation d’un tableau à deux dimensions
Remarque : les valeurs : 5, 34, 14.5 et 60 sont un exemple d’échantillon de valeurs saisies
Un tableau à deux dimensions est manipulé de la même façon qu’un tableau simple (à une
par l’utilisateur.
seule dimension) que ce soit pour l’affectation, la lecture ou l’écriture. Ces trois opérations
3. Tableaux à deux dimensions sont illustrées dans la sous-section suivante.

Les tableaux à deux dimensions se présentent généralement sous forme d’un ensemble de 3.3. Application 2
lignes et de colonnes (Matrice). Par conséquent, chaque élément est repéré par deux indices.
Reprenons l’algorithme de la sous-section 2.3 mais cette fois-ci pour un tableau de 5 lignes
et 20 colonnes :

Var i, j : Entier ;
Tableau Tab [5][20] : réel ;

- 30 - - 31 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

Début ce nombre dans le tableau. La première étape consiste à écrire les instructions de lecture du
Pour i de 0 à 4 nombre N et de parcours du tableau :
Pour j de 0 à 19 Tableau Tab[N] : Entier ;
Ecrire ("Donner une valeur :") ; Lire (Tab [i][j]) ; Var val, i : Entier ;
Finpour Début
Finpour Ecrire ("Entrer la valeur à rechercher :") ; Lire (val) ;
Pour i de 0 à 4 Pour i de 0 à N-1
Pour j de 0 à 19 …
Ecrire (Tab [i][j]) ; Finpour
Finpour Fin
Finpour
Illustration :
Fin
On suppose que N=6 et les valeurs saisies sont celles figurant dans le schéma suivant :
4. Tableaux à n dimensions
indices : i=0 i=1 i=2 i=3 i=4 i=5
Les tableaux à n dimensions (n>2), peuvent être utilisés pour diverses raisons telles que la Tab
valeurs : 10 22 31 46 5 7
création et le traitement des objets 3D par exemple qui nécessitent des tableaux de 3
dimensions au minimum. La déclaration de ce type de tableaux est comme suit : Revenons à l’algorithme, maintenant, il faut combler les points de la boucle (le bloc qui
Syntaxe : devra contenir les instructions de la recherche). Évidemment, il va falloir comparer « val »
Tableau nom_tableau [taille1][taille2] … [tailleN] : type ; à chaque élément du tableau, s’il y a une égalité quelque part, alors « val » fait partie du
tableau. Cela va se traduire, bien entendu, par l’instruction conditionnelle « Si … Alors …
Exemple : Tableau T [10][20][50] : réel ; // un tableau T à 3 dimensions
Sinon ».
La manipulation d’un tableau à plusieurs dimensions suit le même principe que celle des
…
tableaux à deux dimensions. Ceci s’appuie sur l’utilisation des boucles imbriquées pour Début
parcourir le tableau, de sorte qu’il y aura autant de boucles qu’il y a de dimensions. Ecrire ("Entrez la valeur à rechercher ") ; Lire (val) ;
Pour i de 0 à N-1
5. La recherche dans un tableau
Si (val = Tab[i]) Alors
5.1. La notion du drapeau
Ecrire (val, "figure") ;
Le drapeau (ou flag en Anglais) est une variable booléenne initialisée à Faux (drapeau
Sinon ?
baissé). Dès qu’un évènement attendu se produit, la variable change de valeur à Vrai
Ecrire (val, "ne figure pas") ;
(drapeau levé). Donc, la valeur finale du drapeau permet de savoir si un évènement a eu lieu Finsi
ou pas. Cela devrait s’éclairer à l’aide d’un exemple extrêmement fréquent : la recherche de Finpour
l’occurrence d’une valeur dans un tableau [10]. Fin
Exemple :
En supposant l’existence d’un tableau comportant N valeurs entières. On doit écrire un
algorithme qui lit un nombre donné et informe l’utilisateur de la présence ou de l’absence de

- 32 - - 33 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

Illustration : Si (existe) Alors Ecrire (val, "fait partie du tableau") ;

On suppose que la valeur à rechercher (val) est égale à 31 : Sinon Ecrire (val, "ne fait pas partie du tableau") ;
Finsi
Fin

Illustration :
En utilisant un drapeau (la variable « Existe ») :

On peut constater qu’on a deux possibilités :

- ou bien la valeur « val » figure dans le tableau,
- ou bien elle n'y figure pas.
Mais dans tous les cas, l'algorithme ne doit produire qu'une seule réponse, quel que soit le
nombre d'éléments du tableau. Or, l'algorithme ci-dessus affiche autant de messages qu'il y  Question ?
a de valeurs dans le tableau. Il y a donc une erreur quelque part. Réécrire le même algorithme mais cette fois-ci, la boucle de recherche doit être arrêtée dès
En fait, on ne peut savoir si la valeur recherchée existe dans le tableau ou non que lorsque le que la valeur du drapeau change.
parcours du tableau est entièrement accompli.
6. Le tri d’un tableau
Pour pallier à cette erreur, on doit réécrire l’algorithme en plaçant le test après la boucle et
Qu’est-ce qu’un tri ?
en utilisant cette fois-ci une variable booléenne (drapeau) que l’on appelle « Existe ».
Le tri est une opération consistant à ordonner un ensemble d’éléments suivant une relation
Cette variable doit être gérée comme suit :
d’ordre prédéfinie. Le problème du tri est un grand classique en algorithmique. Trier un
- La valeur de départ de « Existe » doit être évidemment Faux (drapeau baissé).
tableau numérique c’est donc ranger ses éléments en ordre croissant ou décroissant. Il existe
- La valeur de la variable « Existe » doit devenir Vrai (drapeau levé), si un test dans
plusieurs algorithmes de tri, parmi lesquels le tri par sélection, tri par insertion, tri à bulles,
la boucle est vérifié (lorsque la valeur de « val » est rencontrée dans le tableau). mais
tri par fusion, etc. Nous illustrons dans ce qui suit deux types de tri, à savoir le tri par
le test doit être asymétrique, c.à.d. qu’il ne comporte pas de "sinon".
sélection et le tri par insertion.
Donc l’algorithme correct devrait être comme suit :
6.1. Tri par sélection
Tableau Tab[N] : entier ;
Var val, i : entier ; Cette technique est parmi les plus simples, elle consiste à sélectionner, pour une place
existe : booléen ;
donnée, l’élément qui doit y être positionné. Par exemple pour trier un tableau en ordre
Début
Ecrire ("Entrez la valeur à rechercher ") ; croissant, on met en première position le plus petit élément du tableau et on passe à la
Lire (val) ; position suivante pour mettre le plus petit élément parmi les éléments restants et ainsi de
existe ← faux ;
Pour i de 0 à N-1 suite jusqu’au dernier [2].
Si (val = Tab[i]) Alors existe ← vrai; Finsi
Finpour

- 34 - - 35 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

Exemple : Donc, cela s’écrit :

Soit à trier, en ordre croissant, le tableau suivant : /* boucle principale : le point de départ se décale à chaque tour */
25 10 13 31 22 4 2 18 Pour i de 0 à 6
/* on considère provisoirement que T(i) est le plus petit élément */
Nous commençons par la recherche de la plus petite valeur et sa position. Une fois identifiée
posmin ← i ; // posmin est la position du minimum initialisée par i
(dans ce cas, c’est le nombre 2 en 7ème position), nous l’échangeons avec le 1er élément (le
/* on examine tous les éléments suivants */
nombre 25). Le tableau devient ainsi :
Pour j de (i + 1) à 7
2 10 13 31 22 4 25 18 Si (T(j) < T(posmin)) Alors posmin ← j ; Finsi

Finpour
Nous recommençons la recherche, mais cette fois, à partir du 2ème élément (puisque le 1er
/* on sait maintenant où est le plus petit élément. Il ne reste plus qu'à effectuer la permutation
est à sa position correcte). Le plus petit élément se trouve en 6ème position (le nombre 4).
*/
Nous échangeons donc le 2ème élément avec le 6ème élément :
temp ← T(posmin) ;
2 4 13 31 22 10 25 18 T(posmin) ← T(i) ;
T(i) ← temp ;
Nous recommençons la recherche à partir du 3ème élément (puisque les deux premiers sont
/* On a placé correctement l'élément numéro i, on passe à présent au suivant */
maintenant bien placés), Le plus petit élément se trouve aussi en 6ème position (10), en
FinPour
l’échangeant avec le 3ème, ça donnera:
6.2. Tri par insertion
2 4 10 31 22 13 25 18
Soit à trier un tableau d’éléments en ordre croissant.
Nous recommençons maintenant à partir du 4ème élément et de la même façon nous
Le principe de ce type de tri repose à chaque itération sur trois phases [2] :
procédons jusqu’à l’avant dernier :
a) On prend le premier élément dans la partie non encore triée du tableau (la clé).
2 4 10 13 22 31 25 18 b) On cherche la place de la clé dans la partie déjà triée du tableau, en commençant par
la droite de cette partie.
2 4 10 13 18 31 25 22 c) Une fois cette place trouvée, on y insère la clé après qu’on ait décalé vers la droite
tous les éléments de la partie triée dont la valeur est plus grande ou égale à la valeur
2 4 10 13 18 22 25 31 de la clé.
Il faut noter qu’initialement, la partie triée est constituée seulement du premier élément du
2 4 10 13 18 22 25 31 tableau, autrement dit, le processus du tri commence à partir du deuxième élément.

Algorithmiquement, nous pouvons décrire ce processus de la manière suivante : Exemple :

 Boucle principale : prenant comme point de départ le premier élément, puis le second, Soit à trier, en ordre croissant, le même tableau précédent en appliquant le tri par insertion :
etc, jusqu’à l’avant dernier. i=1 25 10 13 31 22 4 2 18
 Boucle secondaire : à partir de ce point de départ mouvant, nous recherchons jusqu’à la
fin du tableau le plus petit élément. Une fois trouvé, nous l’échangeons avec le point de Clé Partie non encore triée

départ.

- 36 - - 37 -
Chapitre 5 - Les tableaux Chapitre 5 - Les tableaux

On décale le 1er élément de la partie triée vers la droite puisque sa valeur est supérieure à la Algorithme Tri_Insertion ;
clé. Cette dernière est déplacée à la 1ère position : Var i, j, n, clé : Entier; // n est la taille du tableauT
i=2 10 25 13 31 22 4 2 18 T : Tableau d’entiers ;
Début
Pour i de 1 à n-1 // on commence par le 2ème élément (début de la partie non triée)
On recommence le processus avec une nouvelle clé. Le 1er élément à droite de la partie triée
clé  T[i] ;
(25) est décalé vers la droite puisque sa valeur est supérieure à la clé. Le 2 ème élément ne sera
pas décalé puisqu’il est inférieur à la clé. Par conséquent, la clé est insérée dans la 2ème j  i - 1 ; // indice du 1er élément à droite de la partie triée
position du tableau : Tant que ((j >= 0) ET (clé < T[j])) Faire
T[j +1]  T[j]; // Décalage
i=3 10 13 25 31 22 4 2 18
j  j - 1;
FinTant que
On ne déplace pas cette clé (31) puisque sa valeur est supérieure à celles des éléments qui la T[j +1]  clé; // Insertion de la clé
précèdent. FinPour
i=4 10 13 25 31 22 4 2 18 Fin

6.3. Comparaison
ème
On décale les deux premiers éléments (31 et 25) vers la droite et la clé est insérée à la 3 Dans l’algorithme de tri par sélection, nous avons dans tous les cas, la boucle interne est
position :
exécuté pour i=1, 2, 3 jusqu’à i=(n-1) par conséquent, nous avons (n-1) + (n-2) + (n-3) + …
i=5 10 13 22 25 31 4 2 18 + 1 étant n (n-1) / 2 exécutions. Par exemple, pour un tableau de 100 éléments, la boucle est
exécutée 4950 fois dans tous les cas.

On décale tous les éléments de la partie triée vers la droite puisque leurs valeurs sont Dans l’algorithme de tri par insertion, nous avons dans le pire des cas un tableau trié à
supérieures à celle de la clé. Cette dernière est déplacée à la 1 ère position : l’envers (en ordre décroissant dans ce cas), et la boucle interne est exécuté (n-1) + (n-2) +

i=6 4 10 13 22 25 31 2 18 (n-3) + … + 1 fois, étant n (n-1) / 2 exécutions au maximum. Au meilleur des cas, le tableau

La même opération est répétée pour cette clé (2) : est trié en ordre voulu (croissant dans ce cas) et la boucle interne ne s’exécutera jamais. En
moyenne, le nombre d’exécutions est n (n-1) / 4. Par exemple, pour un tableau de 100
i=7 2 4 10 13 22 25 31 18
éléments, la boucle est exécutée 4950 fois au maximum et 2475 en moyenne.

7. Conclusion
Les trois éléments (22,25 et 31) sont décalés vers la droite et la clé est déplacée vers la 5ème
position : Dans ce chapitre, nous avons vu comment mémoriser et manipuler un ensemble de valeurs

2 4 10 13 18 22 25 31 représentées par le même nom et identifiées par des numéros à travers la notion du tableau.
En fait, un tableau n’est pas un type de données mais plutôt une liste d’éléments d’un type

Nous obtenons donc un tableau qui est trié en ordre croissant. donné. Le problème du tri qui est un grand classique de l’algorithmique, a été abordé par la
suite à travers deux algorithmes parmi les plus simples, à savoir le tri par sélection et le tri
L’algorithme correspondant à ce type de tri est présenté dans ce qui suit :
par insertion. Une comparaison entre les deux algorithmes a été donnée à la fin de ce
chapitre.

- 38 - - 39 -
Chapitre 6 - Les enregistrements (structures) Chapitre 6 - Les enregistrements (structures)

La manipulation d’une variable structure se fait par champ (membre) et l’accès à une
Chapitre 6 - Les enregistrements (structures) information contenue dans un champ se fait en précisant le nom de la variable structure
suivie du champ concerné. Les deux séparés par un point.
Exemple :
1. Introduction [Link] ←123 ; // affecte le nombre 123 au champ num
Lire ([Link]) ; // lire le champ nom
Nous avons vu dans le chapitre précédent, que les tableaux nous permettent de stocker
[Link] ←13.5 ; // affecte le nombre 13.5 au champ moyenne
plusieurs éléments de même type, tel que stocker les notes des étudiants dans un tableau de
type réel. Supposons maintenant qu’en plus des notes des étudiants, nous voulons stocker 4. Tableau de structures
aussi leurs informations (nom, prénom, matricule, …). Il nous faut dans ce cas de figure, une Il est possible de déclarer un tableau dont les éléments sont des structures avec la syntaxe
suivante :
autre structure qui permet de stocker des données de différents types. Donc, une nouvelle
structure appelée enregistrement est plus adaptée dans ce cas. Tableau nom_tableau [taille] : Structure nom_structure ;

Exemple : Tableau T[10] : Structure Etudiant ;

2. Définition
Un enregistrement (ou structure) permet de regrouper un ensemble de données de différents Donc, T est un tableau de 10 éléments de type structure (« Etudiant » dans ce cas).
types sous le même nom (un seul objet). Il est défini par un ensemble d’éléments appelés L'accès à un champ d’élément i d’un tableau de structure se fait comme suit :
champs. Ces derniers sont des données élémentaires ou composées qui peuvent être de types
nom_tableau [i].champ
différents.
Par exemple, les instructions :
3. Déclaration et manipulation T[0].nom ← "Mohamed" ;
La syntaxe de déclaration d’une structure est la suivante : T[0].num ← 1 ; et
Structure nom_structure T[0].moyenne ← 12.5 ;

champ1 : type1 ; affectent respectivement la valeur entière « 1 », la chaîne de caractères « Mohamed » et la

valeur réelle « 12.5 » aux champs « num », « nom » et « moyenne » du 1er élément du
champ2 : type2 ;
tableau T.
...
Illustration :
champN : typeN ;
indices : i=0 i=1 … i=9
FinStructure ;
T num : 1 num : num :
Tel que « nom_structure » est le nom d’enregistrement défini par l’utilisateur. « champ1, Eléments : nom : Mohamed nom : … nom :
moyenne : 12.5 moyenne : moyenne :
champ2, …, champN » sont les variables membres de la structure déclarée.
Exemple : De même, les instructions :

Structure Etudiant Ecrire (T[0].num) ;

num : entier ; Ecrire (T[0].nom) ;
nom : chaîne ; Ecrire (T[0]. moyenne) ;
moyenne : réel; Affichent les contenues des trois champs du 1er élément du tableau T.
FinStructure ;
Par la suite, des variables de type Etudiant peuvent être déclarées comme suit :
Var x,y : Structure Etudiant ; /* Deux variables structures x et y de type Etudiant */

- 40 - - 41 -
Chapitre 6 - Les enregistrements (structures) Chapitre 7 - Les fonctions et les procédures

5. Structure membre d’une autre structure

Une structure peut figurer parmi les champs d'une autre structure. Dans ce cas, elle doit être
déclarée avant la structure qui la contient [6].
Chapitre 7 - Les fonctions et les procédures
Exemple :
Structure Date 1. Introduction
jour, mois, annee : entier ;
Finstructure ; La fiabilité, la lisibilité et la réutilisabilité des programmes, reposent sur l’utilisation des
Structure Compte sous-programmes. Ces derniers permettent :
Ncpt: entier;
nom: chaine ; - La réduction de la taille des programmes : il est possible de déterminer les blocs
DtOuverture : Date ;
analogues, les substituer par un sous-programme, ensuite l’appeler dans des points
Finstructure ;
déterminés au niveau du programme principal.
Où « DtOuverture » est une variable structure de type « Date », champ de la structure «
- L’organisation du code : le problème initial peut être découpé en sous-problèmes
Compte ». Donc, la structure « Date » est déclarée obligatoirement avant la structure «
(modules) où chacun sera résolu par un sous-programme [1].
Compte ».
Lorsqu'un champ d'une structure est lui-même une structure, l’accès à ce champ se fait Exemple : Codage en base b [3]
comme suit : Un entier positif en base b est représenté par une suite de chiffres (c n cn−1 . . . c1c0)b où les ci
variable_structure.variable_sous_structure.champ sont des chiffres de la base b (0 ≤ ci < b).
Par exemple : [Link] ← 2019 ; affecte la valeur 2019 au champ année de L’équivalent décimal de ce nombre est :
l’enregistrement « DtOuverture » qui est lui-même un champ de l’enregistrement « c ». Tel
cnbn + cn-1bn-1 + … + c1b1 + c0b0 = ∑𝑛𝑖=0 𝑐𝑖 𝑏𝑖
que « c » est une variable de type « Compte ».
On suppose que le nombre x est représenté par un tableau de chiffres (code) en base b ; par
Dans le cas d'un tableau, l'accès se fait comme suit :
exemple si b = 2 et code = [1,0,1], alors en base 10 le nombre entier x correspondant vaudra
nom_tableau[indice].variable_sous_structure.champ 1×22 + 0×21 + 1×20 = 4+0+1 = 5. Etant donné code et b, l’algorithme qui permet de calculer
Par exemple : T[i].[Link] ← 2019 ; x en base 10 est le suivant :

Où T[i] fait référence au i ème

élément du tableau T de type « Compte ». x←0;
Pour i de 0 à L-1 // L est la longueur du code
6. Conclusion
x ← x + code[i]*b^(L-1-i);
Nous avons vu dans le cinquième chapitre que les tableaux sont très pratiques, cependant ils
Supposons que l’on veut calculer successivement la valeur décimale x des nombres (123)5
ne permettent pas de répondre à tous les besoins de stockage tels que le regroupement de
et (123)8, on devra donc recopier deux fois l’algorithme ci-dessus.
plusieurs données de types différents en un seul objet. A cet effet, la notion de structure (ou
b←5; b←8;
d’enregistrement) abordée dans le présent chapitre permet de pallier ce problème en créant
code ← [1,2,3] ; code ← [1,2,3] ;
un nouveau type permettant le stockage des données de types différents ou non. Un
x←0; x←0;
enregistrement qui est composé de plusieurs champs où chaque champ correspond à une
Pour i de 0 à L-1 Pour i de 0 à L-1
donnée, constitue la brique de base pour les structures de données telles que les listes, les x ← x + code[i]*b^(l-1-i); x ← x + code[i]*b^(l-1-i);
piles et les files qui ne font pas l’objet d’étude dans ce polycopié.

- 42 - - 43 -
Chapitre 7 - Les fonctions et les procédures Chapitre 7 - Les fonctions et les procédures

Dans la pratique, il n’est pas souhaitable d’écrire deux fois le même programme, d’autant Exemple :
plus, si celui-ci nécessite de très nombreuses lignes de code source. Pour améliorer la Supposons qu’une partie de notre programme sera le sous-programme suivant :
réutilisabilité de l’algorithme la solution est d’encapsuler le code à répéter au sein d’un sous- Algorithme Secondaire ;
Var x : entier ; // variable locale
programme.
Début
x←3;
2. La notion de sous-programme
Ecrire (x, y) ;
Un sous-programme est une portion de code analogue à un programme, destiné à réaliser Fin
Supposons maintenant que nous appelons ce sous-programme « Secondaire » depuis une
une certaine tâche à l’intérieur d’un autre programme. Il est identifié par un nom unique et
autre partie du programme « Principal » qui utilise également deux variables globales :
un bloc d’instructions qui peut être exécuté plusieurs fois par des appels. Un appel est une
Algorithme Principal ;
instruction qui fait partie d’un autre programme ou sous-programme appelé le (sous-) Var x, y : entier ; // variables globales
programme appelant. Début
x←5;y←8;
Pour résumer, un sous-programme est utilisé pour deux raisons essentielles :
… ; // Appel au sous-programme Secondaire
- Lorsqu’une tâche est répétée plusieurs fois : on écrit un sous-programme pour cette Ecrire (x, y) ;
Fin
tâche et l’on appelle à chaque endroit où l’on en a besoin c.à.d. on évite de réécrire
le même code à plusieurs endroits dans le même programme. L’exécution de ce programme peut être illustrée comme suit :

- Pour réaliser la structuration d’un problème en sous-problèmes : on divise le Programme Espace mémoire Résultat d’affichage
problème en sous-problèmes pour mieux le contrôler (diviser pour régner).
-Principal
Il existe deux types de sous-programmes : les fonctions et les procédures. Cependant, avant
Début
Appel au sous-
de détailler ces deux concepts, il sera utile de définir quelques notions utiles. 5,8
… programme
x=5
2.1. La portée d’une variable …
Fin y=8
Dans cette sous-section, nous illustrons une notion appelée portée d’une variable. L'idée
principale est qu'il est possible d'avoir deux variables différentes avec le même nom toutefois
-Secondaire x=3
qu'elles ont des portées différentes. Le cas le plus connus que l'on peut citer, est qu'une
Début 3,8
variable définie au niveau du programme principal (celui qui résout le problème initial) est
…
appelée variable globale et sa portée est totale, par conséquent, tout sous-programme du Fin
programme principal peut utiliser cette variable. Alors qu'une variable définie au sein d'un
sous-programme est appelée variable locale dont la portée est limitée au sous-programme
Dans cet exemple, la variable « x », ayant la valeur 5 dans le programme principal, est une
dans lequel elle est déclarée [7].
variable globale. Une autre variable qui porte le même nom « x » est utilisée au niveau du
Remarque : programme secondaire ayant comme valeur 3. Cet variable locale a masqué la variable
Si l’identificateur (le nom) d'une variable locale est identique à celui d’une variable globale, globale « x » au niveau du programme secondaire, par conséquent, l’affichage de « x » au
cette dernière est localement masquée. Autrement dit, la variable globale devient niveau de ce sous-programme correspond à la valeur 3. Par contre, la variable globale y est
inaccessible dans le sous-programme contenant la variable locale de même nom. quant à elle accessible, ce qui justifie l’affichage de la valeur 8 au niveau du sous-
programme.

- 44 - - 45 -
Chapitre 7 - Les fonctions et les procédures Chapitre 7 - Les fonctions et les procédures

2.2. Les paramètres 3.1. Définition d’une fonction

Les paramètres d'un sous-programme sont un ensemble de variables locales (paramètres On définit une fonction comme suit :
formels) associées à un ensemble de variables ou constantes du (sous-) programme appelant Fonction nom_fonction (paramètres : types) : type de la valeur retournée
(paramètres effectifs). Var var1, var2,…: types; // variables_locales
Début
Remarque : instructions de la fonction ;
Retourner (résultat) ; // (au moins une fois)
- Un paramètre est une variable locale, donc il admet un type. Fin
- L’appel d’un sous-programme possédant un ou plusieurs paramètres, implique une Où :
association entre ces paramètres et les paramètres effectifs du programme (ou sous-  Les paramètres sont en nombre fixe (n≥0)
programme) appelant, respectivement de même type.  Le type de la valeur retournée est le type de la fonction.

Par exemple, si le sous-programme Racine permet de calculer la racine carrée d'un réel :  La valeur de retour (ou le résultat) est spécifiée par l'instruction Retourner.

- Ce sous-programme admet un seul paramètre de type réel positif. 3.2. Appel d’une fonction
- Le programme appelant Racine doit fournir le réel positif dont il veut calculer la
On fait appel à une fonction comme suit :
racine carrée, cela peut être une variable (Racine (y)) ou une constante (Racine (9)).
var ← nom_fonction (paramètres) ;
2.3. Le passage de paramètres Où les paramètres d’appel peuvent être des variables, des constantes ou même des résultats

L'association entre les paramètres effectifs et les paramètres formels est appelé passage de d’une autre fonction.

paramètres. Il existe deux types de passage de paramètres : Remarque :

- Le passage par valeur. A la définition ou à l’appel d’une fonction, les parenthèses sont toujours présentes même

- Le passage par référence (ou adresse). lorsqu'il n'y a pas de paramètres.

Dans le premier type, la valeur du paramètre effectif est affectée (copiée) au paramètre Exemple 1 :

formel correspondant. Sachant que les paramètres formels ne sont que des variables locales Soit l’algorithme A qui calcule la valeur absolue d’un entier en utilisant une fonction :

de la fonction. Ce type de passage sera illustré dans la section qui suit. Algorithme A ;
Var a, b : entier ;
Dans le second type, c’est l’adresse du paramètre effectif qui est affectée au paramètre
Fonction Abs (n : entier) : entier /* Définition de la fonction */
formel correspondant. Ceci rend possible au sous-programme d’accéder directement à Var valabs : entier
l’adresse de la variable concernée (le paramètre effectif) et par conséquent la modifier si Début
Si (n >= 0) alors valabs ← n ;
nécessaire. Ce type de passage nécessite d’utiliser la notion des pointeurs [5] [9]. Sinon valabs ← -n ;
FinSi
Remarque :
Retourner valabs ;
Fin Passage de paramètre par valeur : la valeur de la
Une illustration du passage de paramètre par valeur est donnée dans l’exemple 3 de la section
variable a est copiée dans la variable n.
Début /* Algorithme principal */
4. Le passage de paramètre par adresse sera illustré dans le chapitre suivant.
Ecrire (" Donner une valeur ") ;
3. Les fonctions Lire (a) ;
b ← Abs(a) ;
Une fonction est un sous-programme qui admet un nom, un type et des paramètres. Une Ecrire (b) ;
Fin
fonction admet un type et retourne toujours un résultat.

- 46 - - 47 -
Chapitre 7 - Les fonctions et les procédures Chapitre 7 - Les fonctions et les procédures

Lors de l’exécution de la fonction Abs(), il y a une association entre le paramètre effectif a Exemple 3 :
et le paramètre formel n d’où la valeur de a est copiée dans n. Ce type d’association s’appelle Soit un algorithme utilisant une procédure comme suit :
passage de paramètre par valeur. Algorithme C ;
Var x : entier ;
4. Les procédures
Procédure Modif (x : entier)
Une procédure est un sous-programme qui admet également un nom et des paramètres mais
Début
ne retournant aucun résultat.
x ← x + 1 ; /* le x local est modifié, pas le x du programme principal */

4.1. Définition d’une procédure Fin

On définit une procédure comme suit : Début /* Algorithme principal */

Procédure nom_procédure (paramètres : types) x←1;
Var var1, var2,…: types; // variables_locales Ecrire ("Valeur de x avant l’appel :", x) ;
Début Modif (x) ;
instructions de la procédure ;
Ecrire ("Valeur de x après l’appel :", x) ;
Fin
Fin
4.2. Appel d’une procédure
L’appel d’une procédure se fait comme suit : L’exécution de l’algorithme C peut être illustrée comme suit :

nom_procédure (paramètres) ; Programme Espace mémoire Résultat d’affichage

Exemple 2 :
Algorithme C x 1
Soit l’algorithme B calculant la valeur absolue d’un entier mais cette fois-ci en utilisant une
Début
procédure : Valeur de x avant l’appel : 1
x←1;
Algorithme B ; Ecrire (…) ;
Valeur de x après l’appel : 1
Var a : entier ; Modif (x) ;

Procédure Abs (n : entier) /* Définition de la procédure */ Ecrire (…) ;

Début Fin
Appel avec passage de
Si (n >= 0) alors paramètre par valeur
Ecrire n ;
Procédure Modif()
Sinon x 12
Début
Ecrire -n ;
x←x+1;
FinSi Fin
Fin

Début /* Algorithme principal */ Lorsqu’on passe un paramètre à une fonction (ou à une procédure), cette dernière ne peut
Ecrire (" Donner une valeur ") ; pas modifier la variable. La variable est automatiquement recopiée et la fonction travaille
Lire (a) ; sur une copie de la variable. La modification de la copie n’entraîne pas une modification de
Abs(a) ; la variable originale. C’est ce qu’on appelle le passage de paramètre par valeur [3].
Fin

- 48 - - 49 -
Chapitre 7 - Les fonctions et les procédures Chapitre 7 - Les fonctions et les procédures

5. Fonctions et procédures récursives Alors…Sinon » qui permet de stopper la récurrence si la condition d’arrêt est satisfaite. Dans
le cas contraire, la fonction ou la procédure continue à exécuter les appels récursifs.
La récursivité est une méthode de description d’algorithmes qui permet à une fonction (ou
D’autre part, le paramètre de l’appel récursif doit converger toujours vers la condition
procédure) de s’appeler elle-même directement ou indirectement.
d’arrêt. Un processus récursif remplace en quelque sorte une boucle, ainsi tout processus
5.1. Exemple illustratif
récursif peut être également formulé en tant qu’un processus itératif.
On peut définir la factorielle d’un nombre N non négatif de deux manières :
5.3. Mécanisme de fonctionnement
Définition non récursive : N ! = N * N-1 * …* 2 * 1 Considérons, à titre d’exemple, le calcul de la factorielle de 4 en appliquant la fonction

Définition récursive : N ! = N * (N – 1) ! et 0 ! = 1 récursive FACT(). Pour calculer FACT(4), il faut calculer FACT(3). Pour calculer FACT(3),
il faut calculer FACT(2). Pour calculer FACT(2), il faut calculer FACT(1). Pour calculer
Par conséquent, deux solutions sont possibles pour le calcul de la factorielle.
FACT(1), il faut connaître FACT(0), ce dernier vaut 1. Ensuite, on revient à rebours pour
a) Solution itérative : terminer le calcul pour 1, 2, 3 puis 4.
Fonction FACT ( n : entier ) : entier Il y a donc autant d’occurrences de paramètre n et d’appel récursif que de niveaux de
Var i, F: entier ; récursivité. A chaque niveau, un nouvel environnement, comprenant les paramètres et les
Début variables locales de la fonction, est créé. Cette gestion des variables est invisible à
Si (n = 0) alors F ← 1 ; l’utilisateur et effectuée automatiquement par le système si le langage admet la récursivité
Sinon
[5]. Une illustration de ce mécanisme est donnée dans la figure 6.
F←1;
FACT(4) = 24
Pour i de 2 à n
F ← F * i;
Si (4=0) alors …
Finpour Sinon Retourner 4 * FACT (3) ;
Retourner F; 6
Finsi Si (3=0) alors …
Fin Sinon Retourner 3 * FACT (2) ;
2
b) Solution récursive :
Si (2=0) alors …
Fonction FACT ( n : entier ) : entier Sinon Retourner 2 * FACT (1) ;
1
Début
Si (n=0) alors Retourner 1 ; Si (1=0) alors …
Sinon Retourner 1 * FACT (0) ;
Sinon Retourner n * fact (n-1) ; // Appel récursif de la fonction FACT
1
Finsi
Si (0=0) alors Retourner 1 ;
Fin

5.2. Interprétation
Une procédure ou une fonction récursive doit comporter une condition d’arrêt (n=0 dans 6. Conclusion
l’exemple étudié ci-dessus). Cette condition empêche des appels récursifs sans arrêt.
Généralement, la condition d’arrêt se présente sous la forme d’une instruction « Si… Figure 7. Calcul de la factorielle par récursivité.

- 50 - - 51 -
Chapitre 7 - Les fonctions et les procédures Chapitre 8 - Les pointeurs

6. Conclusion

La notion du sous-programme est très importante en programmation. Elle résulte de la

Chapitre 8 - Les pointeurs
décomposition du programme initial en de plus petites unités ou parties réutilisables qui sont
ensuite appelées le moment opportun par le programme principal. Un sous-programme évite
1. Introduction
la répétition inutile de code et permet de clarifier le programme. En algorithmique, un sous-
Lorsqu’une variable est déclarée et ce, quel que soit le langage de programmation, le
programme correspond à une fonction ou à une procédure dont la description et le
compilateur réserve, à une adresse donnée en mémoire, l’espace nécessaire au contenu de
mécanisme de fonctionnement sont présentés plus haut dans ce chapitre. Aussi, une initiation
cette variable. Donc, toute variable possède :
à la notion de récursivité, une des outils puissants de la programmation, a été donnée à la fin
de ce chapitre. - Un identificateur (nom),
Le prochain chapitre traite l’un des concepts utiles et indispensables au passage de - Une valeur (donnée),
- Une adresse en mémoire.
paramètres par adresse (ou référence), c’est le concept de pointeur.
Une donnée peut s’étaler sur plusieurs octets, donc occuper une plage d’adresses (par
exemple 2 octets pour un entier, 4 ou 8 octets pour un réel, plus encore pour une chaîne).

Exemple :

Var n : entier ; // déclaration d’un entier (sur 2 octets)

n ← 5 ; // affectation de la valeur 5 à n
Dans cet exemple, le nom de la variable c’est n, la valeur c’est 5 et l’adresse c’est son emplacement
dans la mémoire.

Espace réservée à l’entier

n pour stocker sa valeur 5 Variable n

Figure 8. Représentation d’une variable en mémoire [10].

On peut donc accéder à une variable de deux façons :
 par son identificateur,
 par l'adresse mémoire à partir de laquelle elle est stockée (pointeur).

- 52 - - 53 -
Chapitre 8 - Les pointeurs Chapitre 8 - Les pointeurs

2. Notion de pointeur Par exemple :

2.1. Définition p : *entier ; // p est un pointeur vers un entier (il contient l’adresse d’un entier)

Un pointeur est une variable qui contient l’adresse d’une autre variable. 2.2.2. Initialisation
Le pointeur pointe sur une autre variable dont il contient l’adresse mémoire, cette dernière
Lorsqu’un pointeur ne pointe aucune variable, il faut l’initialiser avec la constante
étant dite variable pointée. Si l’on affiche le contenu d’un pointeur, on obtient une adresse
symbolique NIL. Un pointeur non initialisé pointe n’importe quoi dans la mémoire.
qui est celle de la variable pointée, tandis que si l’on affiche le contenu de la variable pointée,
Par exemple :
on obtient la valeur associée à cette dernière.
p : *entier ;
Un pointeur est une variable. De ce fait, elle doit être déclarée, dispose elle-même de sa p ← NIL ; // p est un pointeur qui ne pointe rien
propre adresse en mémoire, et se voit définir un type. Le type d’un pointeur ne décrit pas ce
2.2.3. Accès aux données
qu’il contient (c’est une adresse, donc en principe d’une longueur de 32 ou 64 bits selon les
architectures) mais le type de la variable qu’il pointe. Un pointeur sur une variable de type L’accès aux données se fait en utilisant les deux opérateurs suivants :
réel devrait donc être déclaré avec un type réel [10]. * : opérateur unaire qui permet de déréférencer un pointeur (accéder directement à la
valeur de l’objet pointé).
& : opérateur unaire permettant d’obtenir l’adresse d’une variable.
Il convient de noter que ces opérateurs sont les mêmes utilisés en langage C, d’autres
Pointeur p
opérateurs peuvent être rencontrés par le lecteur tels que ^ et @ en Pascal à titre d’exemple.
Exemple :
Algorithme Exemple_pointeur ;
Var x : entier ;
p1, p2 : *entier ;

Début
5 Variable n
x←3;
p1 ← &x ; // p1 contient l’adresse de x
p2 ← NIL ; // p2 ne contient aucune adresse
Figure 9. Le pointeur et la variable pointée en mémoire [10]. Ecrire ("Le contenu de la variable pointé par p1 est :", *p1) ;
*p1 ← 5 ; // modification de x à travers p1
Dans ce qui suit, nous décrivons comment déclarer et manipuler un pointeur avec quelques
Ecrire ("x=", x, "*p1=", *p1) ;
cas d’applications par la suite.
p2 ← p1 ; // affectation de l’adresse contenue dans p1 à p2
2.2. Opérations sur les pointeurs Ecrire ("Le contenu de la variable pointé par p2 est :", *p2) ;
2.2.1. Déclaration Fin
En algorithmique, un pointeur est déclaré comme suit : L’exécution de cet algorithme donne :
nom_pointeur : pointeur sur type ; ou Le contenu de la variable pointé par p1 est : 3

nom_pointeur : *type ; // où type est le type de l’élément pointé. x=5 , *p1=5

Le contenu de la variable pointé par p2 est : 5
Dans ce qui suit, nous utilisons la deuxième syntaxe qui est plus proche du langage C.

- 54 - - 55 -
Chapitre 8 - Les pointeurs Chapitre 8 - Les pointeurs

Remarque : Exemple :
Dans l’algorithme qui suit, un pointeur « p » sur un entier est déclaré. Pour placer une valeur
Avant toute utilisation, un pointeur doit être initialisé :
entière dans la zone mémoire pointée, il faut d’abord réserver l’emplacement nécessaire.
 par la valeur générique NIL, par exemple p ← NIL ;
Puis on accède à l’élément pointé et on y place un entier.
 par l'affectation de l'adresse d'une autre variable, par exemple p ← &v;
Algorithme libérer ;
 par allocation dynamique d'un nouvel espace-mémoire. Var p : *entier

3. Allocation dynamique Début

p ← nouveau Entier ;
Nous avons vu dans la section précédente qu’un pointeur reçoit l’adresse d’une variable qui
*p ← 12345 ;
existe déjà par affectation. Il est aussi possible de réserver un emplacement mémoire pour Ecrire ("Le contenu de p est :", *p) ;
une donnée pointée directement. Dans ce cas, on peut créer un pointeur sur un entier par Libérer p ; // libérer l’espace mémoire pointé par p
exemple, et réserver un espace mémoire (qui contiendra cet entier) sur lequel la variable p ← NIL ; // réinitialiser p
pointeur pointera. C’est le principe de l’allocation dynamique de mémoire. Fin
On peut employer la syntaxe suivante : Quand on libère un pointeur, on libère la zone mémoire sur laquelle il pointait, cette zone
pointeur ← nouveau type ; redevient disponible pour toute autre utilisation. Après chaque libération, il est préférable de
Le type doit bien entendu être celui de la valeur qui sera contenue à l’emplacement mémoire réinitialiser le pointeur par la valeur NIL, et de penser à tester le pointeur avant de l’utiliser.
alloué. Après cette instruction, le pointeur reçoit l’adresse mémoire de la zone réservée. En Dans le cas où l’adresse de la zone mémoire libérée est conservée dans un autre pointeur, il
cas d’échec (plus de mémoire disponible par exemple) il reçoit la valeur NIL. faut faire attention au fait que ce pointeur pointe sur une zone éventuellement réaffectée à
Exemple : autre chose. Y accéder risque de fournir une valeur arbitraire, y écrire risque d’occasionner
Dans l’algorithme qui suit, un pointeur « p » sur un entier est déclaré. Pour placer une valeur des problèmes, voire des plantages [10].
entière dans la zone mémoire pointée, il faut d’abord réserver l’emplacement nécessaire.
4. Application des pointeurs
Puis on accède à l’élément pointé et on y place un entier.
Algorithme allouer ;
Les applications des pointeurs sont nombreuses, à titre d’exemple en langage C :

Var p : *entier - Une fonction ne peut pas retourner plus d’une valeur, un tableau ou un
Début enregistrement. En utilisant un pointeur, ceci est possible en retournant l’adresse de
p ← nouveau Entier ; // allocation d’un espace mémoire dont l’adresse est affectée à p l’ensemble ou de la structure des données à travers un pointeur.
*p ← 12345 ; // affectation d’un entier - Les tableaux se manipulent très facilement via des pointeurs, puisqu’il est possible
Ecrire ("Le contenu de p est :", *p) ; de faire des calculs sur les adresses : +1 va au contenu de l’adresse suivante, et ainsi
Fin de suite.
Quand une zone mémoire est allouée dynamiquement, elle reste occupée tout le temps de - Les pointeurs offrent la possibilité d’utiliser des structures de données plus
l’existence du pointeur. Sans rien d’autre, la mémoire est récupérée uniquement à la sortie complexes telles que listes chainées, les arbres, etc.
du programme. Il est aussi facile de libérer un espace alloué de la mémoire dès que le ou les - Le passage de paramètres par adresse n’est possible aussi que par l’utilisation des
pointeurs ne sont plus utiles. Pour ceci on applique la syntaxe suivante : pointeurs où un sous-programme peut modifier le contenu d’une case mémoire à
Libérer pointeur ; l’adresse passée via un pointeur (voir l’exemple suivant).

- 56 - - 57 -
Chapitre 8 - Les pointeurs Chapitre 8 - Les pointeurs

Exemple : 5. Conclusion
Nous reprenons dans ce qui suit le même exemple vu dans le chapitre précédent concernant
Dans ce dernier chapitre de la partie « cours », nous avons présenté la notion des pointeurs
le passage de paramètres en utilisant le deuxième mode : passage par adresse.
avec des exemples sur leur utilisation. Le lecteur est initié aussi au mécanisme de gestion
Algorithme D ;
dynamique de mémoire à travers les opérations d’allocation et de libération. A la fin de ce
Var x : entier ;
chapitre, un survol sur les principales applications des pointeurs notamment en langage C a
Procédure Modif (px : *entier) // Procédure utilisant un pointeur comme paramètre local
été présenté dans lequel le mode de passage de paramètres par adresse a été pris comme
Début
exemple d’application.
*px ← *px + 1 ; // le contenu pointé par px est modifié
Fin Passage de paramètre par adresse : l’adresse de
la variable x est affectée au pointeur px.
Début /* Algorithme principal */
x←1;
Ecrire ("Valeur de x avant l’appel :", x) ;
Modif (&x) ;
Ecrire ("Valeur de x après l’appel :", x) ;
Fin

L’exécution de l’algorithme D peut être illustrée comme suit :

Programme Espace mémoire Résultat d’affichage

Algorithme D
Début x 12
x←1; Valeur de x avant l’appel : 1
Ecrire (…) ;
Modif (&x) ; Valeur de x après l’appel : 2
Ecrire (…) ;
Fin
Appel avec passage de
paramètre par adresse

Procédure Modif()
Début px (&x)
*px ←*px + 1 ;
Fin

Lorsqu’on passe l’adresse d’une variable à une fonction (ou à une procédure), cette dernière
peut modifier directement cette variable à travers le pointeur contenant son adresse. Donc
l’accès au contenu pointé (*px) est équivalent à l’accès à la variable (x) dans ce cas. La
modification se fait directement sur la variable originale. C’est le passage de paramètre par
adresse.

- 58 - - 59 -
 Exercices

Série 1 : Initiation aux algorithmes

Exercice 1
Soit l’algorithme suivant :

Algorithme A ;
Var a, b, c : entier ;
Début
a5 ;
ba+1 ;
ca+b ;
Fin

a) Expliquer chaque ligne, mot et symbole dans cet algorithme.

b) Sur la base de cette explication, ajouter des commentaires à cet algorithme.
c) A quoi servent ces commentaires ? Est-ce qu’ils sont obligatoires ?
Partie II - Exercices corrigés d) Dérouler l’algorithme et donner les valeurs des variables a, b et c.

Exercice 2
Soit l’algorithme suivant :
Algorithme B ;
Var a, b, c, d : entier ;
Début
Ecrire (″Donner a et b″) ;
Lire (a, b) ;
ca+b ;
da*b ;
Ecrire (c, d) ;
Fin
a) Que fait cet algorithme ?
b) Dérouler l’algorithme pour a=5 et b=6.
c) Même question pour a=6 et b=5.

- 60 - - 61 -
Exercices Exercices

Exercice 3 z ← 20 ;
m ← (x + y + z) / 2 ;
Soit l’algorithme suivant :
Ecrire (m) ;
Algorithme C ;
Ecrire (x + y + z / 2) ;
Var x,y :entier ;
Fin
Début
Ecrire (Donner x, y) ; Exercice 6
Lire (x,y) ; a) Quel résultat produira-t-il le déroulement de l’algorithme suivant ?
x  y+1 ;
Algorithme B ;
z  z+x ;
Var val, double, triple : entier ;
Ecrire (‘x,z’) ;
Début
Fin
val ← 1000 ;
a) Corriger l’algorithme s’il y a des erreurs. double ← val * 2 ;
b) Dérouler l’algorithme pour x=9 et y=3. triple ← val * 3 ;

Exercice 4 Ecrire val ;

Ecrire double ;
Soit l’algorithme suivant :
Ecrire triple ;
Algorithme D ; Fin
Var a, b, c : entier ;
b) Proposer une simplification de cet algorithme en produisant le même résultat.
Début
Ecrire (donner a et b) ; Exercice 7
Lire (‘a, b’) ;
Supposons que l’on veut afficher à l’écran de l’utilisateur le message « Bonjour à tous ».
ca*a ;
a) Essayer d’écrire l’algorithme correspondant.
db*b ;
b) Quelle est la sortie (output) de cet algorithme ? et l’entrée (input) ?
Ecrire (c, d) ;
c) Quelles sont les instructions à utiliser pour manipuler les entrées (et les sorties)
Fin
a) L’algorithme contient-il des erreurs ? d’un algorithme ?

b) Dérouler l’algorithme pour a=5 et b=7 et déduire qu’est-ce qu’il fait. d) Reformuler votre algorithme pour qu’il y ait une entrée et une sortie.

Exercice 5

Corriger l’algorithme suivant, s’il le faut, et donner son résultat :

Algorithme A ;
Var x, y, z, s : entier ;
Début
x ← 10 ;
y ← 15 ;

- 62 - - 63 -
Exercices Exercices

Série 2 : Instructions algorithmiques de base

Série 3 : Les instructions conditionnelles

Exercice 1
Exercice 1
a. Ecrire un algorithme qui permet de lire un nombre (donné par l’utilisateur), puis il
Ecrire un algorithme qui permet d’afficher la valeur absolue d’un nombre donné.
calcule et affiche son carré.
b. Même question pour calculer et afficher le cube, ensuite l’inverse de ce nombre. Exercice 2

Ecrire un algorithme qui permet de déterminer si un entier donné est pair ou impair.
Exercice 2
Exercice 3
a. Ecrire un algorithme qui permet de lire les notes de trois matières ensuite il calcule et
affiche leur moyenne. Ecrire un algorithme qui demande trois lettres à l’utilisateur, et l’informe ensuite si leur ordre
de lecture et le même que l’ordre alphabétique.
b. Modifier l’algorithme dans le cas où les matières ont des coefficients qui doivent être
donnés avec les notes. Exercice 4

a) Écrire un algorithme qui lit trois variables au clavier et affiche le maximum des trois.
Exercice 3
b) Même question pour plus de trois variables.
Ecrire un algorithme qui permet de lire deux variables numériques a et b et de les afficher
avant et après leur permutation. Exercice 5

Par exemple, avant : a=5 et b=7, après : a=7 et b=5. a) Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite
si leur produit est négatif ou positif mais sans le calculer. (On laisse de côté le cas où
Exercice 4 le produit est nul).
Proposer un algorithme qui réalise la permutation de deux variables numériques sans avoir b) Même question en incluant cette fois-ci le cas où le produit peut être nul.
utiliser une troisième variable.
Exercice 6
Ecrire un algorithme qui permet de lire un numéro du jour de la semaine (numéro entre 1 et
7) et d’afficher le nom du jour correspondant. Par exemple, le dimanche correspond au
numéro 1.

- 64 - - 65 -
Exercices Exercices

Série 4 : Les instructions itératives Exercice 2

Ecrire l’algorithme qui affiche la somme des prix d'une suite d'articles saisie par l'utilisateur
Exercice 1
et se terminant par zéro (Justifier le choix de la boucle à utiliser).
Donner les affichages produits par l'exécution des algorithmes suivants :
Exercice 3
Algorithme 1 :
a) Ecrire l’algorithme qui demande un entier, ensuite il affiche les dix entiers suivants.
Var i : entier ;
Début Par exemple, si l’on entre le nombre 10, l’algorithme affichera les nombres 11, 12,…,
Pour i←2 à 8 20, 21.
Écrire (''Bonjour'') ; b) Modifier l’algorithme pour qu’il affiche les dix nombres pairs suivants.
Écrire (i) ;
Exercice 4
Fin pour
Écrire (''fin'') ; a) Ecrire l’algorithme qui demande un nombre entier n, ensuite il affiche la somme des
Fin entiers positifs jusqu’à n.
Algorithme 2 : Par exemple, si n=5, l’algorithme affiche : 1 + 2 + 3 + 4 + 5 = 15
Var encore : booléen ; b) Réécrire le même algorithme mais cette fois ci pour le calcul d’un produit.
Début Par exemple, pour n=5, l’algorithme affiche : 1 x 2 x 3 x 4 x 5 = 120
encore ← Vrai ;
Répéter Remarque. On souhaite afficher uniquement le résultat sans la décomposition du calcul.

Écrire (''Bonjour'') ; Exercice 5

Jusqu'à (encore)
Ecrire un algorithme qui permet de calculer la factorielle d’un entier (qui doit être positif).
Écrire (''fin'') ;
Où n! = n x (n-1) x (n-2) x … x 1, si n ≥ 1 et n! = 1 si n = 0.
Fin

Algorithme 3 : Exercice 6
Var encore : booléen ;
a) Ecrire un algorithme qui demande successivement dix nombres à l’utilisateur,
Début
ensuite il affiche le plus petit parmi eux (le minimum).
encore ← Faux ;
Tant que (encore) faire Exemple :
Écrire (''Salut'') ; Entrer le nombre numéro 1 : 12
Fin tant que Entrer le nombre numéro 2 : 3
Écrire (''fin'') ; ... (on suppose que les autres nombres sont ≥ 3)
Entrer le nombre numéro 10 : 6
Fin
Résultat :
Le minimum est : 3
b) Modifier l’algorithme pour qu’il affiche, en plus, la position de ce nombre.
Pour l’exemple précédent, le minimum se trouve à la position : 2

- 66 - - 67 -
Exercices Exercices

c) Réécrire l’algorithme précédent dans le cas où l’on ne connaît pas à l’avance combien
Série 5 : Les tableaux et les structures
de nombres l’utilisateur souhaite saisir, mais la saisie des nombres s’arrête lorsque
l’utilisateur entre un zéro. Exercice 1
Exercice 7 a) Ecrire un algorithme qui permet de lire 10 valeurs données par l’utilisateur en les
Ecrire un algorithme qui demande un nombre puis vérifier si ce nombre est premier ou non stockant dans un tableau, ensuite l’algorithme doit afficher seulement les valeurs
impaires.
Exercice 8
b) Modifier l’algorithme (a) pour que le nombre de valeurs soit donné par l’utilisateur.
a) Supposons que le code pin d’un utilisateur est 5454. Ecrire un algorithme qui
c) Réécrire l’algorithme (b) en divisant cette fois-ci le tableau initial en deux tableaux, l’un
demande à cet utilisateur de saisir son code pin jusqu’à ce que la réponse convienne.
contenant les valeurs paires et l’autre contenant les valeurs impaires, et en les affichant
b) Ajouter une condition qui annule la saisie après trois tentatives erronées.
par la suite.

Exercice 2

a) Soit un tableau de 10 éléments réels, écrire un algorithme qui permet de lire ce tableau
et rechercher le maximum des éléments ainsi que sa position, ensuite l’afficher.

b) Même question pour un tableau de 10 lignes et 5 colonnes.

Exercice 3

Ecrire un algorithme qui permet de rechercher une valeur numérique saisie par l’utilisateur
dans une matrice de taille N*M (N et M sont données).

Exercice 4

Ecrire l’algorithme qui permet de compter le nombre d’occurrences d’un élément donné dans
une matrice de taille N*M.

Exercice 5

Définir une structure Rationnel permettant de coder un nombre rationnel, avec numérateur
et dénominateur. Ecrire ensuite l’algorithme qui permet la saisie, l ’ affichage, la
multiplication et l’addition de deux rationnels. Pour l’addition, afin de simplifier, on ne
cherchera pas nécessairement le plus petit dénominateur commun.

Exercice 6

Soit une structure Compte qui code un compte bancaire défini par un numéro, nom et prénom
et date d’ouverture. Donner la définition des structures nécessaires.
Ecrire ensuite l’algorithme qui permet de saisir un tableau de N comptes et de l’afficher.

- 68 - - 69 -
Exercices Exercices

Chaque produit possède une référence (qui est un nombre entier), un prix en DA et
Série 6 : Les fonctions et les procédures
une quantité disponible.

Exercice 1 a) Définir une structure Produit qui code un produit.

b) Ecrire une fonction qui permet la saisie et l’affichage des données d’un produit.
Supposons qu’on veut écrire un sous-programme MoySom qui prend en paramètres trois
c) Ecrire une fonction qui permet à un utilisateur de saisir une commande d’un produit.
entiers a, b et c, et qui affiche leur somme et renvoie leur moyenne.
L’utilisateur saisit la quantité commandée et les données du produit. L’ordinateur
Quelle est la déclaration correspondante ?
affiche toutes les données de la commande, y compris le prix.
- Fonction MoySom (a : entier, b: entier, c: entier) : entier ;
- Fonction MoySom (a : entier, b: entier, c: entier) : réel ;
- Procédure MoySom (a : entier, b: entier, c: entier, som: entier, moy: réel) ;
- Fonction MoySom (a : entier, b: entier, c: entier) : entier, réel ;

Justifier la réponse choisie.

Exercice 2

a) Écrire deux fonctions Min et Max qui retournent le minimum et le maximum de deux
nombres réels donnés comme paramètres.

b) Écrire deux autres fonctions Min_4 et Max_4 utilisant les fonctions Min et Max pour
retourner le minimum et le maximum de quatre nombres réels passés en paramètres.

c) Incorporer ces fonctions dans un algorithme complet.

Remarque : On suppose que tous les nombres donnés sont différents.

Exercice 3

Ecrire un algorithme qui permet de lire une liste de N étudiants ayant comme informations :
numéro, nom, prénoms et moyenne du bac. L’algorithme doit afficher cette liste triée par
moyenne en ordre décroissant.

Remarque : utiliser une fonction ou une procédure pour le tri.

Exercice 4

Un magasin de vente des composants électroniques vend quatre types de produits :

• Des cartes mères (code 1) ;

• Des processeurs (code 2) ;
• Des barrettes de mémoire (code 3) ;
• Des cartes graphiques (code 4).

- 70 - - 71 -
Exercices Exercices

1. Donner la fonction ou la procédure qui permet de :

Exercice de réflexion (sans correction)
- rechercher un employé par son matricule et afficher ses informations.
- afficher les nom et prénoms des employés qui habitent une même ville donnée.
Exercice A :
2. Ecrire l’algorithme qui permet de créer la liste des employés et de faire appel à ces
On se propose de réaliser une calculatrice qui permet de faire les opérations arithmétiques fonctions (ou procédures).
de base (+, -, * et /) de deux nombres a et b, ainsi que de savoir :
- si la somme a + b est paire ;
- si le produit a*b est pair ;
- le signe de la somme a + b ;
- le signe du produit a*b.
Ecrire l’algorithme correspondant.

Exercice B :
On se propose de faire la rotation (décalage des positions) des éléments d’un tableau.
1. Proposer un algorithme pour ce problème sachant que le degré de rotation doit être
défini par l’utilisateur. Exemple pour un degré de rotation égal à 2 :
Avant rotation : 1,3,9,4,5,2  Après rotation : 5,2,1,3,9,4
2. Modifier l’algorithme pour que la rotation puisse être faite dans les deux sens (avant-
arrière).

Exercice C :
Une société désire organiser un concours de recrutement en deux spécialités S1 et S2.
Le concours se porte sur trois (03) matières : M1, M2 et M3.
Un candidat est retenu si les conditions suivantes sont toutes remplies :
- Il doit se classer parmi les dix (10) premiers,
- Il ne doit pas avoir eu un zéro dans l’une des trois matières,
- Sa spécialité doit correspondre à l’une des deux spécialités concernées.
La note de classement est la moyenne des notes des trois matières.
Ecrire l’algorithme qui permet de lire les informations nécessaires, de classer tous les
candidats par ordre de mérite, ensuite afficher la liste des candidats retenus pour le
recrutement.

Exercice D :
Une entreprise veut gérer la liste de ses employés en les stockant dans un tableau.
Sachant que chaque employé possède comme information : un matricule, un nom et prénom,
une date de naissance, une situation familiale et une adresse. Cette dernière est définie par
un numéro, rue, ville et code postale.

- 72 - - 73 -
Corrigés Corrigés

Solution 4 :
Corrigé série 1
a)
Solution 1 : Algorithme D ;

a) Algorithme A ; Var a, b, c : entier ;

Début
Var a, b, c : entier ; // déclaration des variables
Ecrire ("donner a et b") ;
Début
Lire (a, b) ;
a← 5 ; // affectation de la valeur 5 à la variable a
c← a ;
b← a+1 ; // affectation du résultat de a+1 à la variable b
a← b ;
c← a+b ; // affectation de la somme de a et b à la variable c
b← c ;
Fin
Ecrire (a, b) ;
b) Les commentaires dans un algorithme (ou programme) sont ajoutés à titre indicatif pour
Fin
le rendre plus lisible et compréhensible mais ils ne sont pas obligatoires.
b) Déroulement de l’algorithme pour a=5 et b=7
c) Le résultat du déroulement de cet algorithme est comme suit :
c=5
a=5
a=7
b=5+1=6
b=5
c=6+5=11
Affichage : a=7 et b=5
Solution 2 : Donc, l’algorithme réalise la permutation de a et b.
a) L’algorithme calcule la somme et le produit de deux entiers
Solution 5 :
b) C=5+6=11
c) D=5×6=30 s : variable déclarée sans être utilisée
m : doit être de type réel
Solution 3 :
Affichage : 22.5 ; 35
a) Algorithme C ;
Var x,y :entier ; Solution 6 :
Const z =10 ;
a) val=1000 ; double=2000 ; triple=3000
Début
Ecrire ("donner x, y") ; b) Simplification :
Lire (x,y) ;
Var val : entier ;
x ← y+1 ;
Début
z ← z+x ; (z est une constante)
val ← 1000 ;
Ecrire (’x,z’) ;
Ecrire (val, val*2, val*3) ;
Fin
Fin
b) Déroulement de l’algorithme pour x=9 et y=3
x=3+1=4
Affichage : x=4, z=10

- 74 - - 75 -
Corrigés Corrigés

Solution 7 : Corrigé série 2

a) Algorithme Un_Bonjour ;
Début Solution 1 :
Ecrire ("Bonjour à tous") ;
a) Algorithme carré ;
Fin
Var nb, carr : réel ;
Cet algorithme n’a qu’une sortie, le message « Bonjour à tous ». Début
b) Pour manipuler les entrées et les sorties d’un algorithme, on utilise respectivement Lire (nb) ;

les deux instructions : Lire() et Ecrire(). carr ← nb * nb ; // ou carr ← nb^2

Ecrire (carr) ;
c) Algorithme Un_ReBonjour ;
Fin
Var mge : chaine ;
Début b) Algorithme cube ;
Ecrire ("Veuillez saisir un message :") ; Var nb, cub : réel ;
Lire (mge) ; Début
Ecrire (mge) ; Lire (nb) ;
Fin cub ← cub ^ 3
Ecrire (cub) ;
Fin

Algorithme inverse ;
Var nb, inv : réel ;
Début
Lire (nb) ;
inv← 1/ nb ; // tel que nb ≠ 0
Ecrire (inv) ;
Fin

Solution 2 :

a. Algorithme moyenneA ;
Var n1, n2, n3, moy : réel ;
Début
Ecrire ("Donner trois notes :") ; // ce message est optionnel
Lire (n1, n2, n3) ;
moy ← (n1+n2+n3) / 3 ;
Ecrire (moy) ;
Fin

- 76 - - 77 -
Corrigés Corrigés

b. Algorithme moyenneB ; Corrigé série 3

Var n1, n2, n3, moy : réel ; c1, c2, c3 : entier ;
Début Solution 1 : (L’écriture des entêtes d’algorithmes est omise dans quelques solutions)
Lire (n1, n2,n 3) ;
Var n : réel ;
Lire (c1, c2, c3) ;
Début
moy ← (n1*c1+n2*c2+n3*c3) / (c1+c2+c3) ;
Ecrire ("Entrez un nombre : ") ;
Ecrire (moy) ;
Lire (n) ;
Fin
Si (n < 0) Alors n← -n ;

Solution 3 : FinSi
Ecrire ("la valeur absolue est", n) ;
Algorithme permutation ;
Fin
Var a,b,c : réel ;
Début Solution 2 :
Ecrire (″Entrer la valeur de a :″) ;
Var n : entier ;
Lire (a) ;
Début
Ecrire (″Entrer la valeur de b :″) ;
Ecrire ("Entrez un nombre : ") ;
Lire (b) ;
Lire (n) ;
Ecrire (″a=″,a) ;
Si (n mod 2 = 0) Alors Ecrire ("Ce nombre est pair") ;
Ecrire (″b=″,b) ;
c←a; Sinon Ecrire ("Ce nombre est impair") ;
La permutation est réalisée à travers ces trois affectations.
FinSi
a←b; La variable « c » est une variable temporaire qui doit être
de même type que a et b. Fin
b←c;
Solution 3 :
Ecrire (″a=″,a) ;
Ecrire (″b=″,b) ; Var a, b, c : caractère ;
Fin Début
Ecrire ("Entrez successivement trois lettres : ") ;
Solution 4 :
Lire (a, b, c) ;
Algorithme permutation2 ; Si (a < b ET b < c) Alors Ecrire ("Les lettres sont classées alphabétiquement") ;
Var x, y : réel ; Sinon Ecrire ("Les lettres ne sont pas classées") ;
Début FinSi
Lire (x,y) ; Fin
x←x+y;
Solution 4 :
y←x-y;
x←x-y ; a) Var a, b, c, max ;

Ecrire (x,y) ; Début

Fin Ecrire ("Entrez trois nombres réels : ") ;

Lire (a, b, c) ;

- 78 - - 79 -
Corrigés Corrigés

Si (a < b) Alors max ← b; Solution 6 :

Sinon max ← a;
Var j : entier ;
FinSi
Début
Si (max < c) Alors max ← c; FinSi
Ecrire ("Donner le numéro du jour :") ; Lire (j) ;
Ecrire ("Le maximum des trois nombres est :", max);
Selon j
Fin
1 : Ecrire ("Dimanche") ;
Autre variante :
2 : Ecrire ("Lundi") ;
...
3 : Ecrire ("Mardi") ;
Lire (a, b, c) ;
4 : Ecrire ("Mercredi") ;
max ← a ;
5 : Ecrire ("Jeudi") ;
Si (max<b) Alors max←b ; FinSi
6 : Ecrire ("Vendredi") ;
Si (max<c) Alors max←c ; FinSi
7 : Ecrire ("Samedi") ;
Ecrire ("Le maximum des trois nombres est : ", max) ;
Défaut : Ecrire ("Donner un numéro de jour valide (entre 1 et 7).") ;
Fin
FinSelon
b) Même principe pour 4 et 5 variables (juste pour illustrer l’utilité de la variable max). Fin

Solution 5 :
a)
Var m, n : entier ;
Début
Ecrire ("Entrez deux nombres : ") ;
Lire (m, n) ;
Si ((m > 0 ET n > 0) OU (m < 0 ET n < 0)) Alors Ecrire ("Le produit est positif") ;
Sinon Ecrire ("Le produit est négatif") ;
FinSi
Fin
b)
Var m, n : entier ;
Début
Ecrire ("Entrez deux nombres : ") ; Lire (m, n) ;
Si (m = 0 OU n = 0) Alors Ecrire ("Le produit est nul") ;
Sinon Si ((m < 0 ET n < 0) OU (m > 0 ET n > 0)) Alors
Ecrire ("Le produit est positif") ;
Sinon Ecrire ("Le produit est négatif") ;
FinSi
FinSi
Fin

- 80 - - 81 -
Corrigés Corrigés

Corrigé série 4 Puisque le nombre d’articles n’est pas connu à l’avance ainsi qu’il faut faire au moins une
saisie pour terminer, la boucle « Répéter » est appliquée dans ce cas.
Solution 1 : Solution 3 :

Algorithme 1 : a) Var N, i : Entier ;

Début
Bonjour
2 Ecrire ("Entrer un entier : ") ; Lire (N) ;
Bonjour Ecrire ("Les 10 nombres suivants sont : ")
3 Pour i de (N + 1) à (N + 10)
Bonjour Ecrire (i) ; /* Si (i mod 2 = 0) Ecrire i ; */
4
FinPour
Bonjour
5 Fin
Bonjour b) Pour le deuxième cas, il suffit de remplacer l’instruction : « Ecrire (i) » par
6
Bonjour « Si (i mod 2 = 0) Alors Ecrire i » dans la 6ème ligne.
7
Bonjour Solution 4 : (les instructions correspondantes à la question b sont mises en commentaires)
8
Var N, i, som : Entier ;
Fin
Début
Algorithme 2 :
Ecrire ("Donner un entier : ") ;
Bonjour Lire (N) ; som ← 0 ; // prod← 1 ;
Fin Pour i de 1 à N
som ← som + i ; // prod← prod * i ;
Algorithme 3 :
FinPour
Fin Ecrire ("La somme = ", som ); // Ecrire ("Le produit = ", prod );

Solution 2 : Fin

Var p, s : réel ; Solution 5 :

Début
Var N, i, F : entier ;
s←0;
Début
Répéter
Ecrire ("Entrer un entier positif : ") ; Lire (N) ;
Ecrire ("Entrer le prix de l'article (0 si fin):");
Si (N<0) Alors Ecrire ("Erreur !") ;
Autre possibilité :
Lire (p) ;
Sinon Sinon
s←s+p; F←N;
F←1;
Jusqu'à (p = 0) Tant que (N>1) faire
Si (N>1) Alors
Ecrire (" La somme des prix des articles est ", s) ; N ← N-1 ;
F←F*N;
Fin
FinTq
Fsi

- 82 - - 83 -
Corrigés Corrigés

Pour i de 2 à N Solution 7 :
F←F*i;
Algorithme nombre_premier
FinPour
Var i, N : entier ;
Fsi
x : booleen;
Ecrire ("La factorielle est ", F) ;
Début
Fsi
Ecrire ("entrer N"); Lire(N);
Fin
x ← faux;
Solution 6 : i ← 2;
a) et b) Tant que (i<N et x = faux) Faire
Var N, i, min, pmin : Entier ; Si (N mod i = 0) alors
Début Ecrire ("le nombre n’est pas premier") ;
min ← 0 ; // juste pour initialiser la var x← vrai ;
Pour i de 1 à 10 i ← i+1;
Ecrire ("Entrer le nombre numéro ", i) ; Lire (N) ; Finsi
Si (i = 1 ou N < min) Alors min ← N ; pmin ← i ; Fin Tq
FinSi Si (x=faux) alors Ecrire ("le nombre est premier") ;
FinPour Fin
Ecrire ("Le minimum est : ", min ); Solution 8 :
Ecrire ("Il a été saisi en position :", pmin) ;
a) et b)
Fin
Algorithme codePin ;
c/ Var codePin, monCode, tentative: Entier ;

Var N, i, min, pmin : Entier ; Début

Début codePin ← 5454 ;

i ← 1 ; min ← 0 ; tentative ← 3 ;

Répéter Répéter

Ecrire ("Entrer le nombre numéro ", i) ; Lire (N) ; Ecrire ("Entrez le code PIN :") ; Lire (monCode) ;

Si (i = 1 ou N < min) Alors tentative  tentative – 1 ;

min ← N ; pmin ← i ; Si (monCode ≠ codePin) Alors Ecrire ("Code incorrect”) ; FinSi

FinSi Jusqu’à (monCode = codePin ou tentative=0)

i←i+1; Si (tentative=0) Alors

Jusqu’à (N=0) Ecrire ("Vous ne pouvez plus saisir de code") ;

Ecrire ("Le minimum est ", min), Sinon

Ecrire ("Il a été saisi en position numéro ", pmin), Ecrire ("Bienvenue") ;

Fin FinSi
Fin

- 84 - - 85 -
Corrigés Corrigés

Corrigé série 5 j←0 ; k←0 ;

Pour i de 0 à n-1
Si (T[i] mod 2 <>0) Alors Ti[j] ← T[i] ; j←j+1 ;
Solution 1 :
Sinon Tp[k] ← T[i] ; k←k+1 ;
Algorithme a ;
FinPour
Var i : entier ;
Pour i de 0 à j-1
Tableau T[10] : entier ;
Ecrire Ti[i] ;
Début
FinPour
Pour i de 0 à 9
Pour i de 0 à k-1
Ecrire ("Donner un entier : ") ; Lire T[i] ;
Ecrire Tp[i] ;
FinPour
FinPour
Pour i de 0 à 9
Fin
Si (T[i] mod 2 <> 0) Alors Ecrire T[i] ;
FinPour Solution 2:
Fin a)
Algorithme b ; Algorithme Max_tableau1D
Var i, n: entier ; Var i, pos: entier ; max : réel ;
Tableau T[n] : entier ; Tableau A [10]: réel ;
Début Début
Ecrire ("Donner le nombre de valeurs à saisir ") ; Lire (n) ; Pour i de 0 à 9
Pour i de 0 à n-1 Ecrire ("Entrer un nombre:"); Lire (A[i]) ;
Ecrire ("Donner un entier : ") ; Lire T[i] ; Si (i = 0 OU max< A[i]) Alors
FinPour max ← A[i]; pos ← i ;
Pour i de 0 à n-1 Finsi
Si T[i] mod 2 <>0 Alors Ecrire T[i] ; Finpour
FinPour Ecrire ("Le maximum du tableau est :" , max);
Fin Ecrire ("Il se trouve à la position", pos+1);
Fin
Algorithme_c ;
Var i, n, j, k: entier ; b)
Tableau T[n], Ti[n], Tp[n] : entier ; // on suppose par défaut que les trois tableaux ont la Algorithme Max_tableau2D
même taille Var i,j, pos: entier ; max : réel ;
Début Tableau A[5] [10]: réel ;
Ecrire ("Donner le nombre de valeurs à saisir ") ; Lire (n) ; Début
Pour i de 0 à n-1 Pour i de 0 à 4
Ecrire ("Donner un entier : ") ; Lire T[i] ; Pour j de 0 à 9
FinPour Ecrire ("Entrer un nombre:");

- 86 - - 87 -
Corrigés Corrigés

Lire (A[i][j]) ; Solution 4 :

Si (i = 0 ET j = 0 OU max< A[i] [j]) Alors
Algorithme Occurence_tableau2D
max ← A[i] [j] ; lin ← i ; col← j ;
Var i, j, n, m, compt: entier ; v : réel ;
Finsi
Tableau A[n][m]: réel ;
Finpour
Début
Finpour
Ecrire ("Donner le nombre de lignes:"); Lire(n) ;
Ecrire ("Le maximum du tableau est :" , max);
Ecrire ("Donner le nombre de colonnes:"); Lire(m) ;
Ecrire ("Il est positionné à la ligne", lin+1, "et la colonne", col+1);
Pour i de 0 à n-1
Fin
Pour j de 0 à m-1
Solution 3 : Ecrire ("Entrer un nombre:");
Lire (A[i][j]) ;
Algorithme Recherche_tableau2D
Finpour
Var i, j, n, m: entier ; v : réel ; drap : booléen ;
Finpour
Tableau A[n][m]: réel ;
Ecrire ("Donner une valeur:"); Lire(v) ;
Début
compt← 0 ; i←0 ; j←0 ;
Ecrire ("Donner le nombre de lignes:"); Lire(n) ;
Pour i de 0 à n-1
Ecrire ("Donner le nombre de colonnes:"); Lire(m) ;
Pour j de 0 à m-1
Pour i de 0 à n-1
Si (A[i][j]=v) Alors compt← compt+1 ;
Pour j de 0 à m-1
Finsi
Ecrire ("Entrer un nombre:"); Lire (A[i][j]) ;
Finpour
Finpour
Finpour
Finpour
Ecrire ("Le nombre d’occurrences de la valeur donnée est :", compt);
Ecrire ("Donner la valeur recherchée:"); Lire(v) ;
Fin
drap← Faux ; i←0 ; j←0 ;
Tan tque (i < n ET drap=Faux) faire Solution 5 :
Tant que (j < m ET drap=Faux) faire
Algorithme Calcul_rationnel ;
Si (A[i][j]=v) Alors drap ← Vrai ;
Structure Rationnel // Définition de la structure d’un nombre rationnel
Finsi
numerateur, denominateur: entier;
FinTantque
FinStructure ;
FinTantque
Var p, q, r : Structure Rationnel ;
Si (drap=Vrai) Alors
Début
Ecrire ("La valeur recherchée existe dans le tableau");
/* Saisie */
Sinon
Ecrire ("Entrez le numérateur et le dénominateur du premier nombre : ");
Ecrire ("La valeur recherchée n’existe pas dans le tableau");
Lire ([Link], [Link]);
Finsi
Fin Ecrire ("Entrez le numérateur et le dénominateur du deuxième nombre : ");
Lire ([Link], [Link]);

- 88 - - 89 -
Corrigés Corrigés

/* Affichage */ Pour i de 0 à n-1

Ecrire ([Link], [Link]); Ecrire ("N°:" C[i].num, "Nom et prénom:", C[i].nom,
Ecrire ([Link], [Link]); "Date de naissance:", C[i].[Link], C[i].[Link],

/* Multiplication*/ C[i].[Link]) ;

[Link] ← [Link] * [Link] ; Finpour

[Link] ← [Link] * [Link] ; Fin

Ecrire ([Link], [Link]);

/* Addition*/
[Link] ← [Link] * [Link] + [Link] * [Link];
[Link] ← [Link] * [Link];
Ecrire ([Link], [Link]);

Fin

Solution 6 :

Algorithme Tableau_comptes ;
Structure Date
jour, mois, annee : entier ;
FinStructure ;
Structure Compte
num: entier;
nom, pnom: chaine ;
dtOuvert : Date ;
FinStructure ;
Var i , n : entier ;
Tableau C[n] : Structure Compte ;
Début
Ecrire ("Nombre des comptes : ") ;
Lire (n) ;
Pour i de 0 à n-1
Ecrire ("No du compte: ") ;
Lire(C[i].num) ;
Ecrire ("Nom et prénom du client : ") ;
Lire(C[i].nom, C[i].pnom) ;
Ecrire ("Date de naissance du client : ") ;
Lire(C[i].[Link], C[i].[Link], C[i].[Link]) ;
Finpour

- 90 - - 91 -
Corrigés Corrigés

c.
Corrigé série 6 Algorithme Max_Min
Var a, b, c, d, min, max : réel;
Solution 1 : … /* Ici on écrit les fonctions définies ci-dessus */

La déclaration qui correspond à ce sous-programme est : b Début /* Algorithme principal */

Fonction MoySom (a : entier, b: entier, c: entier) : réel ; Ecrire (" Donner deux valeurs : ") ; Lire (a,b) ;
Cette fonction prend trois paramètres entiers et elle est de type réel puisqu’elle va envoyer min ← Min (a,b) ; // Appel de la fonction Min

une valeur réelle (la moyenne). max ← Max (a,b) ; // Appel de la fonction Max
Ecrire (" Le minimum et le maximum des deux valeurs données sont
Solution 2 :
respectivement: min, max") ;
a. /* Cas de quatre nombres */
Fonction Min (n1, n2 : réel) : réel Ecrire (" Donner quatre valeurs : ") ;
Début Lire (a,b,c,d) ;
Si (n1 < n2) Alors Retourner n1 ; min ← Min_4 (a,b) ; // Appel de la fonction Min
Sinon Retourner n2 ; max ← Max_4 (a,b) ; // Appel de la fonction Max
FinSi Ecrire (" Le minimum et le maximum des valeurs données sont respectivement:
Fin min, max") ;
Fonction Max (n1, n2 : réel) : réel Fin
Début
Solution 3 :
Si (n1 < n2) Alors Retourner n2 ;
Algorithme Tri_Liste ;
Sinon Retourner n1 ;
/* Déclaration de l’enregistrement Etudiant */
FinSi
Structure Etudiant
Fin
num: entier;
b.
nom, pnom: chaine ;
Fonction Min_4 (n1, n2, n3, n4 : réel) : réel
moy : réel ;
Début
FinStructure ;
Si (Min (n1, n2) < Min (n3, n4)) Alors Retourner Min (n1, n2) ;
/* Déclaration de la liste des étudiants et des autres variables nécessaires */
Sinon Min (n3, n4) ;
Var i , N : entier ;
FinSi
Tableau Liste [N] : Structure Etudiant ;
Fin
/*Déclaration du prototype de la procédure de tri, la définition est laissée à la fin*/
Fonction Max_4 (n1, n2, n3, n4 : réel) : réel
Procédure Tri (Tableau T : Structure Etudiant, N : entier) ;
Début
/* programme principal */
Si (Max (n1, n2) > Max (n3, n4)) Alors Retourner Max (n1, n2) ;
Début
Sinon Max (n3, n4) ;
Ecrire ("Donner le nombre des étudiants : ") ;
FinSi
Lire (N) ;
Fin
Pour i de 0 à N-1

- 92 - - 93 -
Corrigés Corrigés

Ecrire ("Numéro d’étudiant: ") ; Lire (Liste[i].num) ; Var p : Structure Produit ;

Ecrire ("Nom et prénom : ") ; Lire (Liste[i].nom, Liste[i].pnom) ; Début
Ecrire ("La moyenne du bac : ") ; Lire (Liste[i].moy) ;
Ecrire ("Entrez le type du produit : ");
Finpour
Lire ([Link]);
Tri(Liste,N) ; // Appel de la procédure Tri
Ecrire ("Entrez la référence : ");
Ecrire ("La liste des étudiants triés par moyenne est:") ;
Lire ([Link]);
Pour i de 0 à N-1
Ecrire ("Entrez le prix : ");
Ecrire ("N:"Liste[i].num,"Nom et prénom: ", Liste[i].nom,
Liste[i].pnom,"Moyenne:", Liste[i].moy) ; Lire ([Link]);
Finpour Ecrire ("Entrez la quantité : ");
Fin Lire ([Link]);
/* On applique dans ce qui suit l’algorithme de tri par sélection vu au cours selon un ordre Retourner(p) ;
décroissant sur la moyenne */ Fin
Procédure Tri (Tableau T : Structure Etudiant, N : entier) Procédure Affichage (p : Structure Produit )
Var i, posmax : entier ; temp : Structure Etudiant ; Début
Début Ecrire ("Type :", [Link]);
Pour i de 0 à N-2 Ecrire ("Référence : ", [Link]);
posmax ← i ; Ecrire ("Prix : ", [Link], "DA");
Pour j de i + 1 à N-1 Ecrire ("Quantité : ", [Link]);
Si (T(j) > T(posmax)) Alors posmax ← j ; Finsi Fin
Finpour Procédure Commande_prod ()
Si (posmax ≠ i) Alors Var qte : entier ;
temp ← T(posmax) ; p : Structure Produit ;
T(posmax) ← T(i) ; Début
T(i) ← temp ; p ← Saisie() ;
Finsi Ecrire ("Entrez la quantité commandée : ");
Finpour Lire (qte);
Fin Ecrire ("Récapitulatif de la commande :");
Affichage(p);
Solution 4 :
Ecrire ("Valeur de la commande : ", [Link] * qte, "DA");
Algorithme Gestion_vente ;
Fin
Structure Produit // Définition de la structure Produit
Début /* Programme principal */
ref, quantite : entier;
Commande_prod () ;
type : chaine;
prix : réel ; Fin
FinStructure ;
Var p : Structure Produit ;
/* Définition des sous-programmes */
Fonction Saisie () : Structure Produit

- 94 - - 95 -
Travaux pratiques Travaux pratiques

TP 1

1. Objectif
Initiation au langage C.

2. Présentation du langage C
Le langage C a été conçu en 1972 par Dennis Richie2 et Ken Thompson1, afin de développer
le système d’exploitation UNIX. Ensuite en 1978, Brian Kernighan et Denis Ritchie,
publient la définition classique du C dans le livre The C Programming language3.
Le C est un langage compilé (par opposition au langage interprété). Cela signifie qu’un
programme C est décrit par un fichier texte, appelé fichier source. Ce fichier n’étant pas
exécutable par le microprocesseur, il faut le traduire en langage machine. Cette opération est
effectuée par un programme appelé compilateur.

Partie III – Travaux pratiques en C  Les composants élémentaires du C

Un programme en langage C est constitué des groupes de composants suivants :
– les identificateurs,
– les mots-clés,
– les opérateurs,
– les signes de ponctuation.
On peut ajouter à ces groupes les commentaires, qui ne sont pas considérés dans la
compilation.
 Structure d’un programme C
Un programme C se présente sous la forme suivante :
[directives au préprocesseur]
main()
{
déclarations de variables internes
instructions /* commentaire */
}

2
Chercheurs aux Bell Laboratories.
3
Kernighan (B.W.) et Richie (D.M.), The C programming language. Prentice Hall, 1988, 2 nd edition.

- 96 - - 97 -
Travaux pratiques Travaux pratiques

 Le préprocesseur est un programme exécuté lors de la première phase de la  Les opérateurs relationnels (de comparaison):
compilation. Il effectue des modifications textuelles sur le fichier source à partir de
= = : égal à
directives. Les différentes directives au préprocesseur sont introduites par le != : différent de
caractère #, telles que: < , <= , >= , > : inférieur, inférieur ou égal, supérieur ou égal , supérieur

– l’incorporation de fichiers source ou fichiers de bibliothèque (#include),  Les opérateurs logiques :

– la définition de constantes symboliques (#define), ! : NON logique (unaire)
Par exemple, # include <fichier.h> où fichier.h est le nom d’un fichier entête. && : ET logique (binaire)
 La fonction principale main peut avoir des paramètres formels. On supposera dans || : OU logique (binaire)
un premier temps que la fonction main n’a pas de valeur de retour. Ceci est toléré par
Remarque : Il existe d’autres types d’opérateurs en C (pour plus de détails, voir par
le compilateur mais produit souvent un message d’avertissement.
exemple : [Link]
 Une instruction est une expression suivie d’un point-virgule. Plusieurs instructions
peuvent être rassemblées par des accolades { et } pour former un bloc (ou instruction  Les fonctions d’entrée et de sortie :
composée) qui est syntaxiquement équivalent à une instruction. Par exemple : - La fonction scanf() est une fonction de lecture (entrée).

if (x != 0) Syntaxe : scanf ("code format", &variable1, …, &variableN) ;

{
z = y / x; Le symbole & est obligatoire dans la fonction scanf devant toute variable sauf
t = y % x; pour les variables de type chaîne de caractères.
}
- La fonction printf() est une fonction d’affichage (sortie).
 Ainsi, toute variable doit faire l’objet d’une déclaration avant d’être utilisée.
Syntaxe : printf ("code format", variable1, …, variableN) ;
 Syntaxe du langage C
Le « code format » est un ensemble de codes associés aux types des variables lues ou
 Quelques mots-clés :
écrites :
const , int , char , float , double , signed , unsigned , short , long , if , else , switch ,
case , for , while , do , break , continue , struct , typedef , void , goto , return, ... Type Code format Interprétation
 Les types de base : int %d ce code est remplacé par un entier
char : codé en 1 octet (8 bits) float %f ce code est remplacé par un réel
int : codé en 2 octets (16 bits)
char %c ce code est remplacé par un caractère
float : codé en 4 octets
double : codé en 8 octets char %s ce code est remplacé par une chaîne de caractères

 Les opérateurs arithmétiques:

Remarque :
+ : Addition
- : Soustraction Les deux fonctions scanf() et printf() nécessitent l’utilisation du fichier entête <stdio.h>.
* : Multiplication
3. Travail demandé
/ : division
% : modulo (reste de la division entière) Ecrire un programme C qui emploie ces différentes notions. Essayer de le compiler et
l’exécuter.

- 98 - - 99 -
Travaux pratiques Travaux pratiques

TP 3
TP 2

1. Objectif 1. Objectif
Initiation à la résolution des problèmes et à l’implémentation des algorithmes. Initiation à la résolution des problèmes mathématiques.
2. Travail demandé 2. Exercice 1
Soit la facture suivante réalisée sous Excel : a) Ecrire un programme C qui permet de résoudre une équation du second degré :

Désignation Prix unitaire Quantité Prix total b  b 2  4ac

ax2 + bx + c = 0 ; solution x 
Art 1 1250,00 2 2500,00 2a
Art 2 230,00 5 1150,00 b) Utiliser votre programme pour remplir le tableau ci-dessous :
Art 3 450,50 4 1802,00
a 36 60 18 3 300
Art 4 880,33 2 1760,66 b -30 20 18 6 65
Art 5 190,00 10 1900,00 c 6 5 0 3 -15
x1
Montant total HT 9112,66 DA x2
Taxe (19%) 1731,40 DA
Montant total TTC 10844,06 DA 3. Exercice 2
a) Ecrire un programme C pour calculer la somme suivante :
S=1+2+3+…+N
A)
N est un entier donné par l’utilisateur.
1- Ecrire l’algorithme qui permet de réaliser cette facture. b) Exécuter votre programme pour remplir le tableau ci-dessous :
C’est-à-dire, on doit lire l’article, son prix unitaire et sa quantité, ensuite on calcule son N 100 150 700 800 1000
prix total. Enfin, on doit afficher le montant total de l’ensemble des articles (sans et avec S
la taxe).
c) Modifier votre programme pour calculer la somme suivante :
2- Traduire cet algorithme en programme C et tester-le sur votre machine.
S’ = 1 + 3 + 5 + … + (2k + 1)
B)
Tel que (2k+1) est un nombre impair.
1- Modifier le programme pour une facture qui peut contenir n articles (n est donné).
d) Si vous avez utilisé un pas égal à 2, réécrire le programme pour calculer la même
2- Modifier, une autre fois, le programme de sorte que l’utilisateur ait la possibilité de
somme mais cette fois avec un pas de boucle égal à 1 ( for (… ;… ; i++) ).
limiter le montant total de sa facture (un seuil donné qui ne doit pas être dépassé).
e) Exécuter votre programme pour remplir le tableau ci-dessous :
C) Supposons que l’on veut faire une réduction de 10% sur toute facture arrêtée entre 20000
et 30000 DA, et de 15% au-delà de 30000DA. Ajouter la modification nécessaire à votre N 5 20 300 900 1000
S
programme.

- 100 - - 101 -
Travaux pratiques Travaux pratiques

TP 4 Corrigé type

Cas c)

1. Objectif main()

Manipulation des tableaux (vecteurs et matrices). {

int x, y, z, i, j, k ;
2. Exercice
printf("Nombre de lignes de M1 :") ;

Ecrire un programme C qui permet de calculer : scanf("%d",&x) ;

printf("Nombre de colonnes de M1 :") ;
a) la somme de deux vecteurs,
scanf("%d",&y) ;
b) la somme de deux matrices, printf("Nombre de colonnes de M2:") ;
c) le produit de deux matrices. scanf("%d",&z) ;
float M1[x][y] , M2[y][z] , M3[x][z] ;
Tester vos programmes avec les exemples suivants:
//Lecture de M1
4 4 8
for(i=0 ;i<x ;i++)
1) 8 + 3 = 11
5 2 7 for(j=0 ;j<y ;j++)
scanf("%f",&M1[i][j]) ;

1 2 1 0 2 2
2) 4 0 + 6 9 = 10 9 //Lecture de M2
6 1 2 3 8 4 for(i=0 ;i<y ;i++)

1 2 5 14 20 for(j=0 ;j<z ;j++)

1 4 6
3) 4 0 x 2 5 7
= 4 16 24 scanf("%f",&M2[i][j]) ;
6 1 8 29 43
//Calcul du produit matriciel
Remarque :
for(i=0 ;i<x ;i++)
Dans les trois cas, le programme doit lire la taille du tableau et vérifier quelques for(j=0 ;j<z ;j++)
conditions nécessaires telles que : {

- Avoir la même taille pour la somme. M3[i][j] = 0 ;

for(k=0 ;k<y ;k++)
- Le nombre de colonnes du premier tableau doit être identique au nombre de lignes M3 [i][j] = M3 [i][j] + M1[i][k] * M2[k][j] ;
du deuxième tableau, dans le cas du produit. }
//Affichage du résultat
for(i=0 ;i<x ;i++)
{ for(j=0 ;j<z ;j++)
printf("%f", M3[i][j]) ;
printf("\n") ;
}
}

- 102 - - 103 -
Travaux pratiques Travaux pratiques

Corrigé type
TP 5 Ex1 :

int Deficient (int N) // la fonction Deficient permet de vérifier si un nombre est déficient ou pas
{
1. Objectif int i, som =0 ;
Utilisation des fonctions for (i=N-1 ; i>=1 ; i--)
if (N%i == 0) som = som+1 ;
2. Exercice 1
if (N > som) return 1 ;
Écrire un sous-programme qui détermine si un nombre entier positif est un nombre déficient. else return 0 ;

Écrire le programme appelant (fonction principale). }

main()// la fonction principale
Remarque : on rappelle qu'un nombre est déficient s'il est strictement supérieur à la somme
{
de ses diviseurs stricts (c.-à-d. sauf lui-même).
int N ;
Par exemple : printf("Entrez un entier N :") ; scanf("%d",&N) ;

8>1+2+4 est déficient, if(Deficient(N))

printf("%d est deficient \n", N) ;
6=1+2+3 n'est pas déficient,
else printf("%d n’est pas deficient \n", N) ;
12 < 1 + 2 + 3 + 4 + 6 n'est pas déficient. }

3. Exercice 2 Ex2 :

Écrire un sous-programme qui reçoit en paramètre deux valeurs représentant le numérateur /* Définition de la fonction de simplification */
et le dénominateur d’une fraction et puis affiche une fraction équivalente simplifiée. void Simplifier (int numerateur , int denominateur )
Par exemple, si les valeurs données initialement sont 15 et 25, le sous-programme affichera {

les messages suivants: printf ("\n La fraction initiale : %d/%d \n", numerateur , denominateur );

La fraction initiale est : 15/25

int diviseur = 2;
La fraction simplifiée est : 3/5 while ((numerateur >= diviseur)&&(denominateur >= diviseur))
{
if ((numerateur % diviseur == 0) && (denominateur % diviseur == 0))
{
numerateur = numerateur / diviseur ;
denominateur = denominateur / diviseur ;
}
else diviseur ++;
}
printf ("\n La fraction simplifiee : %d/%d \n", numerateur, denominateur );
}

- 104 - - 105 -
Travaux pratiques Travaux pratiques

/* La fonction principale */

main ()
TP 6
{
int N1, N2;
printf (" Entrer 2 entiers, numerateur et denominateur :"); 1. Objectif
scanf ("%d %d", &N1,&N2 ); Manipulation des structures à travers les fonctions.
Simplifier( N1, N2 );
2. Exercice
} Une société de menuiserie gère un stock de panneaux de bois. Chaque panneau possède
une largeur, une longueur et une épaisseur en millimètres, ainsi que le type de bois qui
peut être pin (code 0), chêne (code 1) ou hêtre (code 2).

a) Définir une structure Panneau contenant toutes les informations relatives à un

panneau de bois.

b) Écrire des fonctions de saisie et d’affichage d’un panneau de bois.

c) Écrire une fonction qui calcule le volume en mètres cube d’un panneau.

- 106 - - 107 -
Travaux pratiques Travaux pratiques

Corrigé type return ([Link] * [Link] * [Link]) / 1e9;

}
a)

typedef struct bois

{
float largeur, longueur, epaisseur;
char essence;
} Panneau;

b)
Panneau Saisie()
{

Panneau p;
printf("Entrez la largeur, la longueur et l’épaisseur : ");
scanf("%f %f %f", &[Link], &[Link], &[Link]);
printf("Entrez l’essence de bois : ");
scanf("%c", &[Link]);
return p;

void Affichage(Panneau p)

{
printf("Panneau en ");
switch ([Link])
{

case ’0’: printf("pin\n"); break;

case ’1’: printf("chêne\n"); break;
case ’2’: printf("hêtre\n"); break;
default: printf("inconnue\n");

printf("largeur = %f ; longueur = %f ; epaisseur = %f\n", [Link], [Link], [Link]);

c)

float Volume(Panneau p)
{

- 108 - - 109 -
Travaux pratiques Travaux pratiques

Corrigé type
TP 7 Ex1 :
int Somme(int n)
{
1. Objectif if (n <= 0) return 0;
else return (n * n + Somme(n - 1));
Applications de la récursivité. }

2. Exercice 1 /* fonction principale */

Écrire une fonction récursive pour calculer la somme : main ()

{
Un = 1 + 22 + 32 + · · · + n2 int n;

Ecrire la fonction principale. printf (" Entrez un entier :");

scanf ("%d ", &n);
3. Exercice 2
printf("La somme = %d", Somme(n));
Les coefficients binomiaux 𝐶𝑛𝑘 pour k ≤ n sont donnés par la formule de Pascal : }

𝐶𝑛0 = 1 ; 𝐶𝑛𝑛 = 1
Ex2 :
𝑘−1 𝑘
𝐶𝑛𝑘 = 𝐶𝑛−1 + 𝐶𝑛−1
a)
a) Proposer une fonction récursive pour calculer les coefficients binomiaux.
int Coeffbinom(int k, int n)
b) Proposer une fonction itérative pour réaliser le même calcul. {
if (k == 0 || k == n) return 1;
else return Coeffbinom(k - 1, n - 1) + Coeffbinom(k, n - 1);
}
b)
/*Cette fonction calcule tous les coefficients binomiaux en les mettant dans tab*/
void Coeffbinom(int k, int n, int **tab)
{
int i, j;
for (i = 0; i <= n; i++)
{
tab[i][0] = 1;
tab[i][i] = 1;
}
for (i = 2; i <= n; i++)
for (j = 1; j < i; j++)
tab[i][j] = tab[i - 1][j - 1] + tab[i - 1][j];
}

- 110 - - 111 -
Conclusion générale Références bibliographiques

Conclusion générale Références bibliographiques

[1] D. BOUCHIHA « Initiation à l'Algorithmique et à la Programmation en Pascal »

Ce polycopié constitue un manuel d’initiation à l’algorithmique et à la programmation
Errachad, 2019.
à travers un ensemble de cours et d’exercices corrigés destinés essentiellement aux étudiants
en début de parcours (Domaine MI, ainsi que ST et SM). [2] T. CORMEN, C. LEISERSON, R. RIVEST et C. STEIN « Introduction à
l'algorithmique : Cours et exercices corrigés » 2ème éd. Dunod, 2002.
Dans la première partie qui représente le volet théorique, les concepts et les fondements
préliminaires des algorithmes ont été abordés. Dans le premier chapitre, le lecteur est initié [3] P. DAMPHOUSSE « Petite introduction à l'algorithmique : à la découverte des
à la notion de variables et de constantes, ainsi qu’à la syntaxe générale d’écriture d’un mathématiques du pas à pas » Ellipses, 2005.
algorithme à travers des exemples de base. Au deuxième chapitre, l’accent a été mis sur les [4] F. DAOUDI « Introduction à l’algorithmique » l’Abeille, 2008.
trois instructions incontournables dans l’écriture d’un algorithme, à savoir l’affectation, la
[5] M. DIVAY « Algorithmes et structures de données génériques : Cours et exercices
lecture et l’écriture. Ces instructions qui sont à la base des entrées/sorties de l’ordinateur
corrigés en langage C » 2ème éd. Dunod, 2004.
sont illustrées à travers des exemples simplifiés. Le troisième et le quatrième chapitre, ont
été consacrés respectivement aux instructions conditionnelles et itératives. Ces instructions [6] S. GRAÏNE « Le langage C avec exercices corrigés » l’Abeille, 2009.

permettent de tester, de décider et de répéter certaines actions par l’algorithme sans [7] C. KHICHANE « Le leader de l'Algorithmique - Cours et exercices avec corrections »
intervention de l’utilisateur. Dans les chapitres cinq et six, les deux structures de base de El Maarifa, 2004.
mémorisation de données, à savoir les tableaux et les enregistrements, ont été présentées
[8] D.E. KNUTH « The art of computer programming: Volume 1: Fundamental
avec des exemples sur leur manipulation et leur utilisation. Le problème de tri a été évoqué
Algorithms » 3rd Ed. Addison-Wesley, 1997.
aussi à travers la description des deux algorithmes : tri par sélection et tri par insertion. Dans
[9] R. MALGOUYRES, R. ZROUR et F. FESCHET « Initiation à l'algorithmique et à la
le chapitre sept, la notion de sous-programme (fonctions et procédures) a été présentée avec
programmation en C : Cours avec 129 exercices corrigés » 2ème éd. Dunod, 2014.
des illustrations sur le principe de fonctionnement et les modes de passage de paramètres
associés. La notion de récursivité a été abordée aussi. Dans le dernier chapitre, le lecteur a [10] S. ROHAUT « Algorithmique Techniques fondamentales de programmation » ENI,
été initié à l’utilisation d’un nouveau type de variable à travers la notion des pointeurs et leur 2007.
utilité dans la gestion de la mémoire et la manipulation des différentes structures de données. [11] H. ZEMANEK « Al-khorezmi his background, his personality his work and his
La deuxième et la troisième partie de ce polycopié ont comme objectif de consolider les influence ». In : Algorithms in Modern Mathematics and Computer Science. Springer,
connaissances acquises dans la première partie à travers un ensemble d’exercices (avec ou Berlin, Heidelberg, 1981. p. 1-81.
sans correction) sous formes de travaux dirigés dans la deuxième partie, et travaux pratiques
dans la troisième partie qui constitue elle-même une initiation à la programmation avec le
langage C.

- 112 - - 113 -