Vous êtes sur la page 1sur 67

2018 / 2019

Algorithme et Programmation

M. Marc TEJIOGNI
Email : mtejiogni@yahoo.fr
Tél : 693 90 91 21 / 670 10 23 98
Algorithme et Programmation 2018 / 2019

SOMMAIRE
OBJECTIF GENERAL ................................................................................................................... 5
OBJECTIFS SPECIFIQUES ........................................................................................................... 5
CHAPITRE I : NOTIONS DE BASE.............................................................................................. 6
I. Objectifs .................................................................................................................................. 6
II. Notions générales ................................................................................................................... 6
II.1. Qu’est ce que l’informatique ? ......................................................................................... 6
II.2. Qu’est ce que traiter l’information ? ................................................................................. 6
II.3. Les étapes de traitement de l’information ......................................................................... 7
III. Notion d’algorithmique ......................................................................................................... 8
III.1. Définition ....................................................................................................................... 8
III.2. Les qualités d’un bon algorithme .................................................................................... 9
III.3. Principe d’élaboration d’un algorithme ......................................................................... 10
IV. Tests de connaissances ........................................................................................................ 10
CHAPITRE II : NOTIONS D’IDENTIFATEUR, D’OBJET ET TYPES DE DONNEES ............. 11
I. Objectifs ................................................................................................................................ 11
II. Notion d’identificateur .......................................................................................................... 11
III. Notion d’objet ..................................................................................................................... 11
IV. Intérêt des types de données ................................................................................................ 12
V. Les types de base et les opérations associées ......................................................................... 12
V.1. Les types de base ........................................................................................................... 12
V.2. Les opérations associées ................................................................................................ 13
VI. Notion de constantes ........................................................................................................... 14
VII. Notion de variables ............................................................................................................ 15
VIII. Notion de commentaires ................................................................................................... 16
IX. Structure générale d’un algorithme ...................................................................................... 17
X. Tests de connaissances ......................................................................................................... 19
CHAPITRE III : INSTRUCTIONS D’AFFECTION, DE LECTURE ET D’ECRITURE .............. 20
I. Objectifs ................................................................................................................................ 20
II. Définition ............................................................................................................................. 20
III. Instructions d’affectation ..................................................................................................... 20
IV. Instructions de lecture ......................................................................................................... 21
V. Instruction d'écriture ............................................................................................................. 22
VI. Exercice d’application ......................................................................................................... 23
VII. Tests de connaissances ....................................................................................................... 24
2 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98
Algorithme et Programmation 2018 / 2019

CHAPITRE IV : STRUCTURES CONDITIONNELLES ET ITERATIVES................................. 25


I. Objectifs ............................................................................................................................ 25
II. Structures conditionnelles .................................................................................................. 25
II.1. Expression logique ......................................................................................................... 26
II.2. Evaluation d'une expression logique ............................................................................... 26
II.3. Exercices d’application .................................................................................................. 27
II.3.1. Exercice 1 ............................................................................................................... 27
II.3.2. Exercice 2 ............................................................................................................... 28
III. Structures itératives ......................................................................................................... 28
III.1. Définition ..................................................................................................................... 29
III.2. Répétitions inconditionnelles ........................................................................................ 29
III.3. Répétitions conditionnelles ........................................................................................... 30
III.3.1. La Boucle TANTQUE ........................................................................................... 30
III.3.2. La boucle REPETER … JUSQU’A … ................................................................... 32
III.4. Boucles imbriquées ....................................................................................................... 33
IV. Exercice d’application ......................................................................................................... 34
V. Tests de connaissances ......................................................................................................... 35
CHAPITRE V : LES TABLEAUX ............................................................................................... 36
I. Objectifs ................................................................................................................................ 36
II. Définitions ............................................................................................................................ 36
II.1. La dimension ................................................................................................................. 36
II.2. Le type ........................................................................................................................... 36
II.3. Elément.......................................................................................................................... 37
II.4. Indice ............................................................................................................................. 37
III. Tableau à une dimension ..................................................................................................... 37
III.1. Définition du type de tableau ........................................................................................ 37
III.2. Déclaration d’objets tableaux ........................................................................................ 38
III.3. Utilisation d’un élément du tableau ............................................................................... 39
IV. Tableau à plusieurs dimensions ........................................................................................... 40
IV.1. Tableau à deux dimensions ........................................................................................... 40
IV.2. Tableau à n dimensions ................................................................................................ 42
V. Quelques algorithmes de base sur les tableaux ...................................................................... 42
V.1. La recherche .................................................................................................................. 42
V.1.1. La recherche séquentielle ........................................................................................ 42
V.1.2. Recherche dichotomique ......................................................................................... 44
V.2. Le tri.............................................................................................................................. 46
V.2.1. Tri par sélection ...................................................................................................... 46

3 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

V.2.2. Tri à bulles ou par propagation ................................................................................ 47


V.2.3. Tri par insertion ...................................................................................................... 48
VI. Tests de connaissances ........................................................................................................ 49
CHAPITRE VI : LES SOUS PROGRAMMES ............................................................................. 50
I. Objectifs ................................................................................................................................ 50
II. Notion de variables globales et variables locales ................................................................... 50
III. Les procédures .................................................................................................................... 51
III.1. Définition ..................................................................................................................... 51
III.2. Procédure sans paramètres ............................................................................................ 51
III.3. Procédure avec paramètres............................................................................................ 52
III.4. Modes de transmission des paramètres .......................................................................... 54
IV. Les fonctions ....................................................................................................................... 55
IV.1. Définition ..................................................................................................................... 55
IV.2. Syntaxe de déclaration d’une fonction .......................................................................... 56
IV.3. Appel d’une fonction .................................................................................................... 56
IV.4. Exemple de fonction ..................................................................................................... 56
IV.5. Bien à savoir................................................................................................................. 57
V. La Récursivité ...................................................................................................................... 57
VI. Exercices d’application ....................................................................................................... 58
VI.1. Exercice 1 .................................................................................................................... 58
VI.2. Exercice 2 .................................................................................................................... 58
VI.3. Exercice 3 .................................................................................................................... 59
VII. Tests de connaissances ....................................................................................................... 59
CHAPITRE VII : ENREGISTREMENT ET FICHIER ................................................................. 60
I. Objectifs ................................................................................................................................ 60
II. Définitions ............................................................................................................................ 60
III. Enregistrement .................................................................................................................... 60
IV. Fichier ................................................................................................................................. 63
IV.1. Supports séquentiel et adressable .................................................................................. 63
IV.2. Organisation et accès .................................................................................................... 64
IV.3. Association d’un fichier à un programme...................................................................... 64
IV.4. Parcours d’un fichier .................................................................................................... 66
V. Tests de connaissances ......................................................................................................... 67

4 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

OBJECTIF GENERAL
Il est question dans le cadre de ce cours de données à l’apprenant les concepts de bases de mise en
place des algorithmes.

OBJECTIFS SPECIFIQUES
La mise en place d’un algorithme passe par plusieurs étapes structurées comme suit :
• Le concept de base qui donne une idée plus claire sur la notion d’algorithme ;
• Les structures de données qui viennent donner un sens plus large à la mise sur pied
d’algorithme ;
• Les fonctions et procédures qui facilitent l’écriture des algorithmes
• Les tableaux qui décrivent l’aspect plus dynamique des algorithmes ;
• Les tris qui permettent d’ordonner les objets manipulés au cours de l’exécution d’un
algorithme ;

Il faut noter que l’algorithme viendra faciliter la programmation et la traduction de cet algorithme
dans un langage de programmation à l’instar du PASCAL, du C ou encore du VB .NET.

5 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE I : NOTIONS DE BASE


I. Objectifs
Au terme de ce chapitre l’apprenant devra définir les éléments qui permettront la compréhension
plus facile de l’algorithme.

II. Notions générales


II.1. Qu’est ce que l’informatique ?
L’informatique encore appelée « computer science » est la science du traitement rationnel et
automatique (notamment par des machines) de l’information. L’information est considérée comme
le support des connaissances humaines et des communications dans les domaines techniques et
sociaux.

Comme toute science, l’informatique a un objectif qui est le traitement et la circulation de


l’information. La méthode quelle utilise se doit comme toutes les autres sciences d’être rationnelle
et rigoureuse.

II.2. Qu’est ce que traiter l’information ?


Une information est considérée comme étant un élément de connaissances susceptible d’être
représenté à l’aide des symboles pour conserver, traiter ou communiquer. Nous donnons ci-dessous
quelques exemples de traitement de l’information en fonction de différents domaines :
• Dans un établissement scolaire : contrôler les absences, établir les notes, publier les
résultats scolaires.
• Dans une entreprise : la paie, la facturation, la gestion des stocks, la comptabilité…
• En mathématiques : calculer une intégrale, démontrer un théorème, résoudre une équation
différentielle, résoudre une équation ou un système d’équations, …
• Dans le domaine spatial : guider une fusée, …
• Dans l’armée : reconnaître un char d’assaut sur une image prise par satellite, intervenir en
terrain ennemi, guider un drone devant effectuer un bombardement, …

Comme on le constate la liste des domaines des domaines dans laquelle on peut extraire
l’information à traiter est loin d’être exostive. L’informatique apparaît donc comme une discipline
carrefour. Elle emprunte la rigueur des mathématiques, utilise les sciences sociales comme domaine
d’applications et l’électronique pour la technologie du matériel.

6 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Dans les exemples que nous avons listés plus haut les divers problèmes posés sont ceux qui
consistent tous à passer des informations (données) à d’autres informations (que nous appelons
résultats). C’est ce passage qu’on appelle traiter l’information.

Traitement de l’information
Données Résultats

Toute la difficulté du traitement de l’information est de dire comment on va opérer pour que partant
des données on aboutisse aux résultats. L’informatique consiste à automatiser le passage des
données vers les résultats c’est-à-dire de faire exécuter le traitement de l’information par des
machines.

II.3. Les étapes de traitement de l’information


La figure ci-dessous présente la démarche méthodique qu’il faut adopter pour résoudre un problème
portant sur le traitement de l’information grâce à l’informatique.

1 Enoncé du problème

2 Analyse du problème : c'est-à-dire détermination des données, des


résultats et du traitement

3 Algorithme : c'est-à-dire description ordonnée du processus de


é l i

3 Traduction en Programme : Algorithme codé dans un langage de


i

4 Exécution du programme : Le programme est chargé en mémoire

5 Résultats

Nous nous intéressons dans le cadre de ce cours à la 3ème étape qui consiste à déterminer une
méthode de résolution d’un problème, en particulier à fixer l’ordre dans les opérations : on dit qu’on
élabore un algorithme.

7 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III. Notion d’algorithmique


En raison de l’incapacité humaine à gérer trop de complexité, il a été indispensable de trouver des
méthodes de modélisation. Dans le domaine informatique, l’algorithmique est une de ces méthodes.
Il permet :
• Une démarche méthodique de programmation
• De maîtriser la complexité
• D’assurer plus facilement la maintenance
• De réduire des coûts
• …

Avez-vous déjà ouvert un livre de recettes de cuisine ?


Avez-vous déjà indiqué un chemin à un touriste égaré ?
Avez-vous fait chercher un objet à quelqu’un par téléphone ?
Si oui, sans le savoir, vous avez déjà exécuté des algorithmes.
Comme quoi, l’algorithmique n’est pas un savoir ésotérique réservé à quelques rares initiés touchés
par la grâce divine, mais une aptitude partagée par la totalité de l’humanité.

III.1. Définition
Un Algorithme est une suite finie de règles à appliquer dans un ordre déterminé et en nombre fini
de données pour arriver à un certain résultat.

Algorithmique : Science qui étudie les algorithmes.

Un algorithme peut être comme une suite finie d’instructions, qui une fois exécutée correctement,
conduit à un résultat donné.

Tout algorithme doit s’arrêter au bout d’un temps donné.

Si l’algorithme est juste, le résultat est le résultat voulu.


Si l’algorithme est faux, le résultat est si on peut le dire aléatoire.

Un algorithme doit donc contenir uniquement des instructions compréhensibles par celui qui devra
l’exécuter.

8 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Soit à définir l’ensemble des opérations élémentaires à réaliser entre le moment où le réveil sonne et
le moment où l’on sort travailler :
1. Le réveil sonne
2. Je me réveille
3. Je me lève
4. Je prépare le café
5. Je déjeune
6. Je me douche
7. Je m’habille
8. Je mets les chaussures
9. Je mets le manteau
10. J’ouvre la porte
11. Je sors
12. Je ferme la porte

Nous pouvons constater sur cette exemple que l’ordre des opérations à de l’importance. En effet, il
serait très gênant d’intervertir les actions 2 et 3, 7 et 8, …

Supposons alors que la personne décrite précédemment ai en sa possession un parapluie. Alors la


suite des opérations lui permettra de ne prendre son parapluie que dans l’éventualité ou il pleuvrait.
Pour cela, nous devons disposer d’une structure alternative permettant un choix.

De même, si cette personne doit respecter ces même gestes jusqu’à ce que par exemple elle soit
vacances, nous devons disposer d’une structure itérative ou répétitive permettant de respecter cette
suite d’action jusqu’à ce que le réveil ne sonne.

III.2. Les qualités d’un bon algorithme


Un bon algorithme possède les qualités suivantes :
• Il doit être clair, facile à comprendre et facile à interpréter ;
• Il doit être documenté c'est-à-dire contenir les commentaires ou être accompagné d’un guide
d’utilisation ;
• Il doit tourner sur tous les cas possibles (l’algorithme doit couvrir tous les cas possibles) ;
• Il doit être limité et minimiser le nombre d’opérations à effectuer ;
• Il doit occuper très peu de case mémoire pour être efficace.

9 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III.3. Principe d’élaboration d’un algorithme


Avant d’élaborer un algorithme, il est nécessaire de :
1. Comprendre la nature du problème posé et préciser les données fournies (« entrées » ou
« inputs » en anglais) ;
2. Préciser les résultats que l’on désire obtenir (« sorties » ou « output » en anglais) ;
3. Déterminer le processus de transformation des données en résultats.

Exemple :

Soit un programme chargé d’afficher sur un écran le résultat de l’équation AX+B=0.


Proposons une démarche algorithmique correspondant à ce programme.

Données : A, B
Résultat : X
Traitement : Déterminer X dans AX+B=0 en fonction des différents cas possibles.

IV. Tests de connaissances


1. Définir : informatique, information, algorithme, algorithmique.
2. Quelles sont les étapes de traitement d’une information ?
3. Quelles sont les qualités d’un bon algorithme ?
4. Quel est le principe d’élaboration d’un algorithme ?
5. Quelle différence faites-vous entre algorithme et langage de programmation ?
6. Selon-vous qui peut écrire des algorithmes ?
7. Soit à résoudre une équation du second degré AX2 +BX+C=0, Quel démarche algorithmique
proposez-vous ?

10 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE II : NOTIONS D’IDENTIFATEUR, D’OBJET


ET TYPES DE DONNEES
I. Objectifs
Il est question dans le cadre de ce chapitre de donner aux apprenants des notions préliminaires qui
leur permettront de maitriser les éléments de base en algorithme.

II. Notion d’identificateur


Un identificateur est un mot composé de lettres et des chiffres ainsi que certains caractères
spéciaux comme le souligné « _ ». Un identificateur doit commencer par une lettre et ne doit pas
contenir des caractères accentués. Il doit être choisit de façon à refléter le problème posé et à
facilement se rappeler.

Exemple : un_homme, unhomme

Les caractères proscrits dans les identificateurs sont :

‘’ ‘’ + - / * . ; , %

NB : Il est important de noter qu’identificateur ne doit pas également contenir d’espaces.

III. Notion d’objet


Un objet est un outil ou un être du monde réel que l’on manipule dans l’algorithme.

L’univers des objets du traitement d’une information est un ensemble fini d’éléments. Il est donc
possible de le décrire entièrement et sans ambigüité en décrivant chaque objet. Le traitement d’un
objet concerne la valeur de cet objet. Si cette valeur ne peut être modifiée nous parlons de
constante sinon nous parlons de variable.

Un objet est parfaitement définit si nous connaissons :


• Son nom
• Son type
• Sa valeur

11 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV. Intérêt des types de données


On y voit surtout deux avantages :
• Pour décrire les objets de même nature et admettant les mêmes opérations : il suffit
d’avoir décrit le type une fois pour tout et d’indiquer pour un type donné, la liste d’objets
associés. On évite ainsi les répétitions pénibles.
• On dispose d’un moyen pour détecter un certain nombre d’erreur sans exécuter le
programme : simplement par l’examen des opérations sur les objets et en contrôlant
qu’elles sont licites.

Exemple :

Définissons les types suivants :


• SOLIDE : matière ayant une forme propre. Comme exemple d’opérateur sur un SOLIDE,
on peut avoir « Fondre ».
• LIQUIDE : matière tendant à écouler. Comme opérateur on a « Bouillir », « Boire ».

Ainsi, l’on peut définir la suite suivante :

Objets Actions ou opérations possibles


caoutchouc, beurre : SOLIDE Fondre le caoutchouc, Fondre le beurre
eau, vin : LIQUIDE Boire le vin, Bouillir l’eau

Une opération telle que « Fondre le vin » serait erronée car le vin est un objet de type LIQUIDE et
l’opération « Fondre » n’est pas associée à ce type.

V. Les types de base et les opérations associées


V.1. Les types de base
On distingue cinq (05) types de bases qui sont : entier, réel, booléen, caractère, chaîne.

Le type entier

Permet de manipuler des entiers. Les entiers font référence à l’ensemble des nombres relatifs
utilisés couramment en mathématiques. Exemple : 26, 5, - 172, -10.

12 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Le type réel

Permet de manipuler des nombres réels. Leur notation est elle aussi classique, identique à celle
qu'on utilise pour les machines à calculer. Le séparateur décimal est le point (.). Exemple : 2.7,
3.14, 2.0, -3.4, 10,-3.

Le type booléen

Permet de manipuler des valeurs booléennes. Ce sont des objets particuliers qui peuvent prendre
uniquement deux valeurs : VRAI ou FAUX.

Le type caractère

Permet de manipuler des caractères alphabétiques et numériques, on les note entre apostrophes
comme par exemple 'A' (caractère A), 'a' (caractère a), '0' (caractère 0), ',' (caractère virgule)
etc. Les caractères spéciaux peuvent être désignés directement par leur symbole : ENTER (retour
chariot), TAB (tabulation), etc.

Le type chaîne

Permet de manipuler des chaînes de caractères permettant de représenter des mots ou des phrases.
Ce sont des suites de caractères délimitées par des guillemets. Exemple : "oui", "bonjour", "ceci",
"ceci est une chaîne".

V.2. Les opérations associées


Il faut noter qu'à un type donné, correspond un ensemble d'opérations définies pour ce type.

Les opérations associées au type entier

Les opérations utilisables sur les entiers sont :


• Les opérateurs arithmétiques classiques : + (addition), - (soustraction), * (produit)
• La division entière, notée "div", telle que n div p donne la partie entière du quotient de la
division entière de n par p, par exemple : 5 div 2 = 2
• Le modulo, noté mod, telle que n mod p donne le reste de la division entière de n par p, par
exemple : 5 mod 2 = 1. NB : Il est possible d’utiliser « % » à la place de « mod ».
• Les opérateurs de comparaison classiques : <, >, =, ...

13 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Les opérations associées au type réel

Les opérations utilisables sur les réels sont :


• Les opérateurs arithmétiques classiques : + (addition), - (soustraction), * (produit), /
(division)
• Les opérateurs de comparaison classiques : <, >, =, ...

Les opérations associées au type booléen

Il s'agit du domaine dont les seules valeurs sont VRAI ou FAUX. Les opérations utilisables sur les
booléens sont réalisées à l'aide des connecteurs logiques : et (pour le et logique), ou (pour le ou
logique), non (pour le non logique).

Les opérations associées au type caractère

Il s'agit du domaine constitué des caractères alphabétiques et numériques. Une variable de ce type
ne peut contenir qu'un seul et unique caractère. Les opérations élémentaires réalisables sont les
comparaisons : >, <, =, ...

Les opérations associées au type chaîne

Une chaîne est une séquence de plusieurs caractères. Les opérations élémentaires réalisables sont
les comparaisons : <, >, =, ... selon l'ordre lexicographique.

VI. Notion de constantes


Une constante est un objet donc la valeur ne peut être modifiée.

Une constante est caractérisée par :


• Un nom (identificateur)
• Une valeur

Syntaxe de déclaration d’une constante

Const identificateur = valeur;


Où « valeur » fait référence à l’une des valeurs de type de base.

L’identificateur ainsi définit, à pour type celui auquel la valeur appartient.

14 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple

Const PI = 3.14159;
N = 10;
BLANC = ' ';

VII. Notion de variables


Une variable est un objet dont la valeur peut être modifiée.

Lorsqu’on décompose un traitement T en sous traitements T1, T2, … ; il est fréquent que le sous
traitement T2 utilise par exemple le résultat intermédiaire produit par un Ti où i ϵ {1, 2, …}/{2}.
Ces résultats intermédiaires r1, r2, … qui aboutissent à un résultat définitif « r » n’ont pas souvent
besoin d’être conservés. Plutôt que de les désigner tous par des constantes différentes, on choisit de
les désigner par des valeurs successives d’un même objet appelé variable.

Ainsi, une variable apparaît comme une boîte donc le contenu peut être modifié au cours du
déroulement de l’algorithme.

Le contenu de cette boîte est appelé valeur de la variable.

Chaque variable est caractérisée par :


• Un nom (identificateur)
• Un type

Le type correspond au genre d'information que l'on souhaite utiliser : entier, réel, booléen,
caractère, chaîne.

Syntaxe de déclaration d’une variable

Var identificateur : type;


Où « type » désigne l’un des types de base.

Exemple

Var x : réel;
som : entier;

15 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Remarques

1. On peut factoriser la déclaration de plusieurs variables de même type en les séparant par des
virgules.

Var x, y : réel;
som, prod : entier;

2. Le choix de l’identificateur doit être judicieux et évoquer au tant que possible le rôle joué
par cette variable. Ce choix n’est pas toujours suffisant, on peut préciser le rôle de la
variable par un commentaire (co ….. fco).

Var x, y : réel; co coordonnées d’un point fco


som, prod : entier; co opérations sur des entiers fco

VIII. Notion de commentaires


Pour améliorer la lisibilité d’un programme on peut utiliser les commentaires.

Un commentaire est une suite de caractères quelconques encadrés par les symboles co et fco.

Syntaxe de déclaration d’un commentaire

co insertion du commentaire fco

Exemple

Const PI = 3.14; co valeur de PI fco

Var x, y : réel; co coordonnées d’un point fco


som, prod : entier; co opérations sur des entiers fco

Remarque

Il existe d’autres notations pour les commentaires à savoir :


• « // » pour les commentaires sur une ligne
• « /* */ » pour les commentaires sur plusieurs lignes

16 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IX. Structure générale d’un algorithme

Algorithme identificateur; En-tête de l’algorithme

<Liste des constantes>;


<Liste des structures>; La partie déclarative
<Liste des variables>;

<Liste des fonctions>;


<Liste des procédures>; Les fonctions et les procédures

Début

<Liste des instructions>; Le corps de l’algorithme

Fin.

En-tête de l’algorithme

Il permet tout simplement d’identifier un algorithme parmi d’autres.

La partie en-tête d’un algorithme permet tout simplement de donner un nom à notre algorithme
(identificateur). Ce nom n’influence en rien le bon déroulement de l’algorithme.

En générale il faut donner des noms parlants à nos algorithmes, ceci pour permettre au lecteur
d’avoir une idée de ce que fera l’algorithme qu’il lira.

Le nom de l’algorithme (identificateur) reflète le problème qui est résolu par celui-ci par exemple
pour un algorithme qui calcule la somme de deux nombres on peut écrire : Algorithme somme. Il
est important de savoir que le nom d’un algorithme ne doit pas contenir d’espaces et ni commence
par un chiffre (bref il doit respecter la nomenclature définit pour les identificateurs).

Partie déclarative

C’est une liste exhaustive de constantes, de structures et variables utilisées et manipulées dans le
corps de l’algorithme.

C’est une liste exhaustive des objets, grandeurs utilisés et manipulés dans le corps de l’algorithme.

• Les constantes : elles représentent des chiffres, des nombres, des caractères, des chaînes de
caractères. … dont la valeur ne peut pas être modifiée au cours de l’exécution de
l’algorithme.

17 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple : Const N = 3;
• Les variables : elles peuvent stocker des chiffres des nombres, des caractères, des chaînes
de caractères,… dont la valeur peut être modifiée au cours de l’exécution de l’algorithme.
Exemple : Var x : réel ;
• Les structures : elles permettent de rassembler plusieurs variables ou constantes sous un
même identificateur. Une structure est un objet contenant un ensemble d'objets de types
différents, appelés champs. Un type doit donc décrire l'ensemble des champs contenus dans
ses objets.
Exemple : Type etudiant = enregistrement
nom : chaîne
note : réel
fin ;

Les constantes, les variables et les structures sont définies dans la partie déclarative par deux
caractéristiques essentielles, à savoir :

• L’identificateur : il représente le nom de la variable, de la constante ou de la structure. Il


est composé généralement de lettres mais peut également contenir des chiffres. Il ne doit pas
commencer par des chiffres Il ne doit pas contenir d’espaces, de caractères de ponctuation
ou de caractères accentués ;
• Le type : il représente la nature de la constante ou de la variable, ou encore de la structure.

Les procédures et fonctions

Ce sont des sous-programmes. Les sous programmes en algorithme facilitent la visibilité du code et
surtout empêche la réécriture du même code plusieurs fois. Ils permettent de décomposer un
problème P en sous problèmes P1, P2…………Pn et surtout d’écrire plusieurs fois la même suite
d’instruction.

Corps de l’algorithme

C’est dans cette partie de l’algorithme que sont placées les tâches (instructions opérations …) à
exécuter par notre algorithme.

Le corps de l’algorithme contient le traitement que l’on désire effectuer.

18 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

X. Tests de connaissances
1. Définir : Identificateur, Objet, Constante, Variable, Structure, Type, Commentaire
2. Quelle est la différence entre une variable et une constante ?
3. Quel est la structure générale d’un algorithme ?
4. Quelles sont les caractéristiques d’un objet ?

19 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE III : INSTRUCTIONS D’AFFECTION, DE


LECTURE ET D’ECRITURE
I. Objectifs
Manipuler correctement les opérations d’affectation, de lecture et d’écriture.

II. Définition
Une instruction est la spécification d'une ou de plusieurs actions portant sur une ou des variables.

III. Instructions d’affectation


L'instruction la plus commune est l'affectation. Elle consiste à doter une variable d'une valeur
appartenant à son domaine (entier, réel, …), c'est à dire à lui donner une première valeur ou à
changer sa valeur courante. Elle se note «  ».

Syntaxe

identificateur  <expression>;
Une expression est une suite finie bien formée d'opérateurs portant sur des variables ou des valeurs
et qui a une valeur. La valeur de l'expression doit être conforme au domaine de la variable affectée.

Exemple

Algorithme monPremierAlgo;

Var x, y: entier;

Début
x  12;
y  x + 4;
x  3;
Fin.

Cet algorithme est constitué de trois instructions successives qui seront effectuées les unes après les
autres. Les variables x et y sont entières. La première instruction consiste à affecter à la variable x la
valeur 12. A la fin de cette instruction, la variable x vaut 12.
20 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98
Algorithme et Programmation 2018 / 2019

La deuxième instruction est un peu plus complexe. C'est l'affectation d'une expression (non réduite
à une valeur) à une variable entière. L'expression x + 4 est d'abord reconnue comme une somme à
effectuer portant sur deux valeurs entières. La première valeur est celle de la variable x, qui existe,
puisque l'instruction précédente a affecté 12 à x. Ainsi, l'addition a bien ses deux opérandes entières
et elle peut être effectuée. Elle l'est, et la valeur entière 16 est affectée à la variable y.

La troisième instruction modifie la valeur de la variable x, qui devient 3. L'ancienne valeur de x, qui
était 12, est définitivement perdue. Le déroulement séquentiel fait naturellement oublier les
instructions effectuées en ne conservant que les valeurs courantes des variables.

On remarque que les deux (02) premières instructions ne sont pas permutables car "x n'aurait alors
pas de valeur" au moment du calcul.

NB : Dans certains documents l’affectation sera représenté plutôt par « := ».

IV. Instructions de lecture


C’est l'instruction de prise de données sur le périphérique d'entrée (en général le clavier). Elle
permet de modifier le contenu d’une variable.

Syntaxe

lire(identificateur);

L’instruction « lire » provoque l’interruption de la machine qui attend qu’une valeur lui soit
fournie. L’utilisateur frappe alors une valeur au clavier qui est affectée à la variable désignée par
identificateur. La valeur lu doit être du type de la variable réceptrice.

Les instructions de lecture peuvent être factorisées ainsi :

lire(identificateur1, identificateur2, …, identificateurn);

Cette instruction correspond à :

lire(identificateur1) ; lire(identificateur2) ; … ; lire(identificateurn) ;

21 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple

Algorithme monPremierAlgo;

Var x, y: entier;

Début
lire(x);
y  x + 4;
x  3;
Fin.

V. Instruction d'écriture
C’est l'instruction de restitution de résultats sur le périphérique de sortie (en général l'écran).

Syntaxe

écrire(exp1, exp2, exp3, …, expn);


Où expi i ϵ {1, 2, 3, …, n} peut représenter une expression, un caractère, une chaîne de caractères,
un entier, …

Les différentes valeurs des expressions « expi » sont affichées l’une à la suite de l’autre dans l’ordre
indiqué. Notons que ces séquences sont séparées par des virgules (,) et non par des points virgules
(;).

Exemple :

Algorithme monPremierAlgo;

Var x, y: entier;

Début
lire(x);
y  x + 4;
x  3;
écrire(x, y);
Fin.

22 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

VI. Exercice d’application


On désire écrire un algorithme qui lit sur l'entrée standard (en général le clavier) une valeur
représentant une somme d'argent et qui calcule et affiche le nombre de pièces de 100 F, 50 F et 10
F, de 2 F et 1 F qu'elle représente.

Principe :

L'algorithme commence par lire sur l'entrée standard l'entier qui représente la somme d'argent et
affecte la valeur à une variable somme. Pour obtenir la décomposition en nombre de pièces de la
somme d'argent, on procède par des divisions successives en conservant à chaque fois le reste.

Solution :

Algorithme Nombre_de_Pieces;

Var somme : entier; co la somme d'argent à décomposer fco


p100 : entier; co le nombre de pièces de 100 F fco
p50 : entier; co le nombre de pièces de 50 F fco
p10 : entier; co le nombre de pièces de 10 F fco
p2 : entier; co le nombre de pièces de 2 F fco
p1 : entier; co le nombre de pièces de 1 F fco
reste : entier; co reste de la division entière fco

Début
écrire("Entrez une somme d’argent");
lire(somme);

p100 <- somme div 100;


reste <- somme mod 100;
p50 <- reste div 50;
reste <- reste mod 50;
p10 <- reste div 10;
reste <- reste mod 10;
p2 <- reste div 2;
reste <- reste mod 2;
p1 <- reste;

écrire(p100, p50, p10, p2, p1);


Fin.

23 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

VII. Tests de connaissances


1. Définir instruction, opération de lecture, opération d’écriture, affectation.
2. Ecrire un algorithme Bonjour1 qui imprime (affiche) sur la sortie standard "bonjour le
monde".
3. Ecrire un algorithme Bonjour2 qui lit sur l'entrée standard un nom de personne (par
exemple "Jean") et affiche sur la sortie standard: " Bonjour Jean, merci d'utiliser mon
programme. Nous avons été très heureux de faire votre connaissance; A plus et au plaisir
mon cher Jean".
4. Ecrire un algorithme Equation qui lit sur l'entrée standard deux entiers a et b et affiche la
solution (si elle existe) de l'équation du premier degré ax + b = 0.

24 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE IV : STRUCTURES CONDITIONNELLES ET


ITERATIVES
I. Objectifs
Construire des algorithmes comportant des traitements conditionnels et itératifs.

II. Structures conditionnelles


Ces structures sont utilisées pour décider de l'exécution d'un bloc d'instruction : est-ce-que ce bloc
est exécuté ou non. Ou bien pour choisir entre l'exécution de deux blocs différents.

Les exemples précédents montrent des algorithmes dont les instructions doivent s'exécuter dans
l'ordre, de la première à la dernière. Ici, nous introduisons une instruction précisant que le
déroulement ne sera plus séquentiel. Cette instruction est appelée une conditionnelle. Il s'agit de
représenter une alternative où, selon les cas, un bloc d'instructions est exécuté plutôt qu'un autre. La
syntaxe de cette instruction est :

si <condition> alors

<liste d'instructions>

sinon

<liste d'instructions>;

finsi

Cette instruction est composée de trois partie distinctes : la condition introduite par si, la clause
alors et la clause sinon. La condition est une expression dont la valeur est de type booléen (VRAI
OU FAUX). Elle est évaluée. Si elle est vraie, les instructions de la clause alors sont exécutées.
Dans le cas contraire, les instructions de la clause sinon sont exécutées.

25 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

II.1. Expression logique


Une expression logique est un énoncée ou proposition qui peut être vraie ou fausse selon ce qu’on
est entrain de parler. En mathématiques, c’est une expression contenant une ou plusieurs variables
et qui est susceptible de devenir une proposition vraie ou fausse selon les valeurs attribuées à ces
variables.

Exemple :

• (10 < 15) est une expression logique vrai


• (10 < 3) est une expression logique faux

II.2. Evaluation d'une expression logique


Une condition est une expression de type logique. Ils lui correspondent deux valeurs possibles
VRAI et FAUX qu'on note par V ou F.

Notation

Les opérateurs logiques et ordre de priorité :


1. La négation : "non"
2. L'intersection : "et"
3. L'union : "ou"

Négation d’une condition A

A non A
Vrai Faux
Faux Vrai

Intersection de deux conditions A et B

A B A et B
Vrai Vrai Vrai
Faux Faux Faux
Vrai Faux Faux
Faux Vrai Faux

26 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Union de deux conditions A et B

A B A ou B
Vrai Vrai Vrai
Faux Faux Faux
Vrai Faux Vrai
Faux Vrai Vrai

II.3. Exercices d’application


II.3.1. Exercice 1
Ecrire un algorithme qui permet d'imprimer le résultat d'un étudiant à un module sachant que ce
module est constitué par une note d'oral de coefficient 1 et une note d'écrit de coefficient 2. La
moyenne obtenue doit être supérieure ou égale à 10 pour valider le module.

Données: la note d'orale et la note d'écrit Résultat : impression du résultat pour le module (reçu ou
refusé)

Principe :

On calcule la moyenne et on la compare à 10.

Solution :

Algorithme moyenne;

Var ne : réel; co note d'écrit (coefficient 2) fco


no : réel; co note d'oral (coefficient 1) fco
moy : réel; co moyenne du module fco

Début
écrire("Entrez la note écrit");
lire(ne);
écrire("Entrez la note oral");
lire(no);
moy (2 * ne + no)/3;

si (moy >= 10) alors


écrire ("reçu")
sinon
écrire ("refusé");
finsi
Fin.

27 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

II.3.2. Exercice 2
On veut écrire un algorithme permettant de calculer le salaire d'un employé payé à l'heure à partir
du salaire horaire et du nombre d'heures de travail. Les règles de calcul sont les suivantes : le salaire
horaire est majoré pour les heures supplémentaires : 25% au-delà de 160 heures et 50% au-delà de
200 heures.

Solution :

Algorithme salaire;

Var sh : entier; co salaire horaire fco


nbh : entier; co nombre d'heures de travail fco
salaire : réel; co salaire de l'employé fco

Début
écrire("Entrez le salaire horaire");
lire(sh);
écrire("Entrez le nombre d’heures de travail");
lire(nbh);

si (nbh <= 160) alors


salaire  sh * nbh
sinon si (nbh <= 200) alors
salaire  160 * sh + (nbh - 160) * 1,25 * sh
sinon
salaire  160 * sh + 40 * sh * 1,25 + (nbh - 200)* sh * 1,5;
finsi
finsi

écrire("Le salaire de l’employé = ", salaire);


Fin.

III. Structures itératives


Il arrive souvent dans un algorithme qu'une même action soit répétée plusieurs fois, avec
éventuellement quelques variations dans les paramètres qui précisent le déroulement de l'action. Il
est alors fastidieux d'écrire un algorithme qui contient de nombreuses fois la même instruction. De
plus, ce nombre peut dépendre du déroulement de l'algorithme. Il est alors impossible de savoir à
l'avance combien de fois la même instruction doit être décrite. Pour gérer ces cas, on fait appel à des
instructions en boucle qui ont pour effet de répéter plusieurs fois une même instruction.

Deux formes existent :


• La première, si le nombre de répétitions est connu avant l'exécution de l'instruction de
répétition,
• La seconde s'il n'est pas connu.

28 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III.1. Définition
Une boucle permet de parcourir une partie d'un programme un certain nombre de fois.

Une itération est la répétition d'un même traitement plusieurs fois.

Un indice de boucle varie alors d’une valeur minimale (initiale) jusqu'à une valeur maximale
(finale).

III.2. Répétitions inconditionnelles


Il est fréquent que le nombre de répétitions soit connu à l'avance, et que l'on ait besoin d'utiliser le
numéro de l'itération afin d'effectuer des calculs ou des tests. Le mécanisme permettant cela est la
boucle Pour.

Syntaxe de la boucle Pour :

pour identificateur de valeur_initiale à valeur_finale faire

<liste d'instructions>;

finpour

L’identificateur (variable ou paramètre d’incrémentation) va prendre successivement toutes les


valeurs entières entre valeur_initiale (valeur initiale) et valeur_finale (valeur finale).

Pour chaque valeur prise par l’identificateur, la liste des instructions est exécutée. La valeur utilisée
pour énumérer les itérations est appelée valeur d'itération ou indice d'itération ou encore
compteur.

L'incrémentation par « pas de 1 » de l’identificateur est implicite.

Exemple :

Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres
de 18 à 27.

29 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme nombres;

Var nb, i : entier;

Début
écrire("Entrez un nombre de départ");
lire(nb);

pour i de 1 à 10 faire
ecrire(nb + i);
finpour
Fin.

Exemple 2 :

Ecrire l'algorithme permettant d'afficher la table de multiplication par 9.

Algorithme table_de_multiplication;

Var i : entier;

Début
écrire("Table de multiplication de 9");

pour i de 1 à 10 faire
ecrire("9 x ", i , " = ", 9*i);
finpour
Fin.

III.3. Répétitions conditionnelles


III.3.1. La Boucle TANTQUE
L'utilisation d'une boucle pour nécessite de connaître à l'avance le nombre d'itérations désiré, c'est-
à-dire la valeur finale du compteur. Dans beaucoup de cas, on souhaite répéter une instruction tant
qu'une certaine condition est remplie, alors il est à priori impossible de savoir à l'avance au bout de
combien d'itérations cette condition cessera d'être satisfaite. Le mécanisme permettant cela est la
boucle Tantque.

30 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Syntaxe de la boucle Tantque :

tantque (<condition>) faire

<liste d'instructions>;

fintantque

Cette boucle a une condition de poursuite dont la valeur est de type booléen et une liste
d'instructions qui est répétée si la valeur de la condition de poursuite est vraie : la liste d'instructions
est répétée autant de fois que la condition de poursuite à la valeur vraie. Le déroulement pas à pas
de cette instruction équivaut à :

si <condition> alors
<liste d'instructions>
si <condition> alors
<liste d'instructions>
si <condition> alors
<liste d'instructions>
….

Etant donné que la condition est évaluée avant l'exécution des instructions à répéter, il est possible
que celles-ci ne soient jamais exécutées. Il faut que la liste des instructions ait une incidence sur la
condition afin qu'elle puisse être évaluée à faux et que la boucle se termine. Il faut toujours s'assurer
que la condition devienne fausse au bout d'un temps fini.

Exemple 1 :

On veut laisser un utilisateur construire des rectangles de taille quelconque, à condition que les
largeurs qu'il saisit soient supérieures à 1 pixel. On peut utiliser une répétition conditionnelle qui
permet de redemander à l'utilisateur de saisir une nouvelle valeur tant que celle-ci n'est pas valide.

Algorithme saisirLargeurRectangle;

Var largeur : entier; co largeur courante saisie fco

Début
écrire ("Indiquez la largeur du rectangle :");
lire(largeur);

tantque (largeur < 1) faire


écrire("Erreur : indiquez une valeur supérieure à 1");
écrire("Indiquez la largeur du rectangle :");
lire(largeur);
fintantque

écrire(largeur);
Fin.

31 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple 2 :

Un poissonnier sert un client qui a demandé 1Kg de poisson. Il pèse successivement différents
poissons et s'arrête dès que le poids total égale ou dépasse 1Kg.

Donner le nombre de poissons servis.

Remarque : 1kg = 1000g

Algorithme nbre_poisson;

Var poids_poisson : réel; co poids du ième poisson en grammes fco


poids_total : réel; co poids total des i premiers poissons fco
nb_poisson : entier; co nombre de poissons vendus fco

Début
poids_total <- 0;
nb_poisson <- 0;

tantque poids_total < 1000 faire


écrire("Entrez le poids du poisson en gramme :");
lire(poids_poisson);
poids_total <- poids_total + poids_poisson;
nb_poisson <- nb_poisson + 1;
fintantque

écrire("Nombre de poissons vendus = ", nb_poisson);


Fin.

III.3.2. La boucle REPETER … JUSQU’A …


Ici, une instruction ou un groupe d’instructions sont exécutés répétitivement jusqu'à ce qu’une
condition soit vérifiée.

Avec la boucle Tant que, la condition doit d’abord être vérifiée avant exécution des instructions
alors qu’avec la boule Repeter …. Jusqu’à … les instructions sont d’abord avant vérification de la
condition.

Syntaxe de la boucle Repeter …. Jusqu’à ….

Répéter

<liste d'instructions>;

Jusqu'à (<condition>)

La vérification de la condition s’effectue après les instructions. Celles-ci sont donc exécutées au
moins une fois.

32 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple :

Ecrire un algorithme qui demande successivement 10 nombres à l’utilisateur, et qui lui dit ensuite
quel était le plus grand parmi ces 10 nombres.

On peut avoir par exemple :

Entrez le nombre numéro 1 : 7


Entrez le nombre numéro 2 : 24
…….etc.
Entrez le nombre numéro 10 : 13
Le plus grand de ces nombres est : 24

Algorithme Plus_Grand;

Var i, nb, plus_grand : entier;

Début
i <- 1;
écrire("Entrez le nombre ", i ," : ");
lire(nb);
plus_grand <- nb;

répéter
i <- i + 1;
écrire("Entrez le nombre ", i ," : ");
lire(nb);

si (plus_grand < nb) alors


plus_grand <- nb;
finsi
jusqu’à(i = 10)

écrire("Le plus grand nombre = ", plus_grand);


Fin.

III.4. Boucles imbriquées


Le corps d'une boucle est une liste d'instructions. Mais cette boucle est elle-même une instruction.
Donc le corps d'une boucle peut contenir une boucle dite imbriquée, qui utilise un compteur
différent. Il faut alors faire attention à l'ordre d'exécution des instructions : à chaque passage dans le
corps de la boucle principale, la boucle imbriquée va être exécutée totalement.

Exemple :

Ecrire l'algorithme permettant d'imprimer un triangle suivant le nombre de lignes donné par
l'utilisateur.

33 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

On peut avoir par exemple pour 10 lignes le triangle suivant :

1
12
123
1234
12345
123456
1234567
12345678
123456789
12345678910

Algorithme Triangle;

Var nblignes: entier; co nombre de lignes à imprimer fco


i: entier; co indice d'itération sur les lignes fco
j: entier; co indice d'itération sur les éléments de la ième ligne fco

Début
écrire("Entrez le nombre de ligne");
lire(nblignes);

pour i de 1 à nblignes faire


Pour j de 1 à i faire
écrire (j);
finpour

ENTER; co retour à la ligne fco


finpour
Fin.

Notons qu’il est aussi possible d’imbriquer une boucle tantque dans une boucle pour et
inversement ainsi que une boucle tantque dans une autre de même type.

IV. Exercice d’application


On veut imprimer, pour n donné, la somme des carrés des n premiers entiers. Cette somme, notée s,
est obtenue en calculant le n-ième terme d'une suite définie par récurrence : sn = sn-1 + i2.

Principe

Algorithmiquement, le calcul d'une telle suite se fait en deux étapes :


• Initialisation (ici, s0=0)
• Répétition de : calcul du i-ème terme en fonction du terme d'indice i-1

34 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Solution

Algorithme recurrence_somme;

Var s : entier; co somme des carré des n premiers entiers fco


n : entier;
i : entier; co indice d'itération fco

Début
écrire("Entrez la valeur de n");
lire(n);
s <- 0;

pour i de 1 à n faire
s <- s + (i*i);
finpour

écrire(s);
Fin.

V. Tests de connaissances
1. Définir boucle, itération, condition.
2. Quelle est la différence entre une structure conditionnelle et une structure itérative ? Donnez
des exemples.
3. Quelle est la différence entre une répétition inconditionnelle et une structure conditionnelle ?
Donnez des exemples.
4. Quelle différence faites-vous entre une boucle pour et une boucle tant que. Est-il possible
d'exprimer une boucle pour en fonction d'une boucle tant que et vice-versa? Expliquez ou
illustrez.
5. Même question de la question 4 mais entre une boucle tant que et une boucle répéter …
jusqu’à.
6. Écrire l'algorithme qui, à partir d'un nombre entier positif n, affiche tous les nombres par
ordre décroissant jusqu'à 0. Exemple : pour n=5, le résultat sera 5 4 3 2 1 0.
7. Ecrire un algorithme qui demande 10 entiers, compte le nombre d’entiers positifs saisis, et
affiche ce résultat.
8. Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle. NB : la
factorielle de 8, notée 8 !, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8

35 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE V : LES TABLEAUX


I. Objectifs
L’un des inconvenant des algorithmes écrits jusqu’ici est que, en cas d’erreur sur la saisie d’un
objet, on est oblige de tout recommencer. De plus il n’y a aucun moyen de voir dans sa totalité les
différents objets saisis. Il existe une structure (tableau) capable de stocker plusieurs valeurs. Il sera
dont question dans le cadre de ce chapitre d’apprendre à manipuler les tableaux et en mettant avant
tout l’accent sur les procédures de création des tableaux (notion de dimension, type, élément et
indice).

Ainsi ce chapitre à pour but de permettre à l’apprenant de manipuler les tableaux en maitrisant les
concepts de bases qui seront directement mise en valeurs dans les exercices. Ainsi les compétences
seront développées dans les aspects suivants :
• Création d’un tableau ;
• Manipulation des tableaux ;
• Recherche dans un tableau ;
• Sommes de deux tableaux ;
• Trié un tableau.

II. Définitions
Un tableau est une structure de donnée ayant une dimension et un type déterminés qui permet de
stocker en mémoire plusieurs valeurs de même type. Ces valeurs sont appelées éléments du
tableau. Chacun de ces éléments est repéré par un indice indiquant sa position relative par rapport
au début du tableau.

II.1. La dimension
Le nombre d’élément que peut contenir un tableau détermine la dimension du tableau.

II.2. Le type
Il désigne la nature des valeurs stockées dans le tableau (entier, réel, caractère, chaîne de caractères
…..)

36 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

II.3. Elément
C’est la façon de designer une valeur du tableau.

II.4. Indice
C’est un entier naturel donc les valeurs varient de 1 à la dimension du tableau. A chaque valeur de
l’indice correspond une seule valeur dans le tableau.

Selon la dimension, on distingue différents types de tableau à savoir :

III. Tableau à une dimension


Soit un tableau nommé VECTEUR à une dimension de taille 7. On a :

Elément 12 20 30 0 5 8 9
1 2 3 4 5 6 7 Indice

• Le premier élément du tableau est noté VECTEUR[1] et sa valeur est 12.


• Le deuxième élément du tableau est noté VECTEUR[2] et sa valeur est 20.
• ……………
• Le septième élément du tableau est noté VECTEUR[7] et sa valeur est 9.

III.1. Définition du type de tableau


Syntaxe

Type identificateur = tableau[inf .. sup] de <type de base>;

• identificateur : représente le nom du type nouvellement créé.


• tableau[inf .. sup] de <type de base> : c’est le constructeur permettant de définir le type de
tableau
• [inf .. sup] : représente la borne inférieure (inf) et la borne supérieure (sup) du tableau tel
que inf ≤ sup. Ces valeurs définissent l’intervalle de variation de l’indice du tableau.
• <type de base> : représente un type de base tel que entier, réel, booléen, caractère, chaîne

37 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple :

Type VECTEUR = tableau[1 .. 7] de entier;

VECTEUR est un nouveau type représentant un nouveau type d’entier.

III.2. Déclaration d’objets tableaux


Syntaxe

Var identificateur : <type tableau>;

• identificateur : représente le nom de la variable de type <type tableau>


• <type tableau> : désigne un type tableau définit dans la partie déclaration de type tableau.

Exemple

Type VECTEUR = tableau[1 .. 7] de entier;


Var vectentier : VECTEUR;

vectentier désigne un tableau d’entiers de taille 7.

Remarque

Il est aussi possible d’adopter la syntaxe suivante pour déclarer un tableau :

Var identificateur : tableau[inf .. sup] de <type de base>;

• identificateur : désigne le nom de la variable déclaré comme type tableau


• inf et sup sont toujours les bornes de définition de l’indice tel que inf ≤ sup

Ainsi, on peut avoir :

Var vectentier : tableau[1 .. 7] de entier;

38 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III.3. Utilisation d’un élément du tableau


Il faut être capable de sélectionner un élément du tableau, ceci est réalisé à l’aide de la fonction
d’adressage nommée indexation. La variable ainsi désignée est dite variable indicée.

Syntaxe

identificateur[indice];

• identificateur : représente le nom utilisé lors de la déclaration du tableau


• indice : c’est une expression arithmétique à résultat entier dont la valeur doit être comprise
dans l’intervalle de définition de borne du tableau, c'est-à-dire inf ≤ indice ≤ sup.

Exemple

Ecrire un algorithme permettant de lire 100 entiers puis d’afficher la liste de ces entiers dans l’ordre
inverse de lecture.

Algorithme inverse_liste_entiers;

Var tab : tableau[1 .. 100] de entier;


i : entier;

Début
écrire("Entrez une liste de 100 entiers");
i <- 1;

répéter
écrire("Entrez l’entier numéro ", i);
lire(tab[i]);
i <- i+1;
jusqu’à (i = 101)

écrire("Le tableau inverse est :");


i <- 100;

tantque (i > 0) faire


écrire(tab[i]);
i <- i-1;
fintantque
Fin.

39 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV. Tableau à plusieurs dimensions


On généralise la définition du tableau à une dimension au tableau à deux dimensions, trois
dimensions…

IV.1. Tableau à deux dimensions


Soit un tableau nommé MATRICE à deux (02) dimensions de taille 7 x 4. On a :

1 2 3 4 5 6 7 Indice de ligne (i)


1 5 40 30 60 80 90 55
2 8 9 26 25 75 51 31
3 50 12 23 6 78 52 11
4 20 15 24 27 65 63 17

Indice de colonne (j)

MATRICE[i][j] correspond à l’élément ou valeur en position (i, j) c'est-à-dire l’élément ou valeur


se trouvant à la iième ligne et jième colonne.

Ainsi on a par exemple MATRICE[2][5] qui correspond à 75.

Définition de type de tableau

Type identificateur = tableau[inf1 .. sup1, inf2 .. sup2] de <type de base>;

Déclaration d’objets tableaux

Var identificateur : <type de tableau>;

Utilisation d’un élément tableau

identificateur[indice1][indice2];

40 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple

Ecrire un algorithme permettant de :


• Lire deux (02) matrices d’entiers de taille NxN
• Faire la somme des deux matrices
• Afficher le résultat

Algorithme Somme_Matrices;

Const N = 10;

Var mat, mat1, mat2 : tableau[1 .. N, 1 .. N] de entier;


i, j : entier;

Début
écrire("Entrez la liste d’éléments de la matrice 1");
pour i de 1 à N faire
pour j de 1 à N faire
écrire("Entrez l’élément en position (", i, ",", j, ")");
lire(mat1[i][j]);
finpour
finpour

écrire("Entrez la liste d’éléments de la matrice 2");


pour i de 1 à N faire
pour j de 1 à N faire
écrire("Entrez l’élément en position (", i, ",", j, ")");
lire(mat2[i][j]);
finpour
finpour

pour i de 1 à N faire
pour j de 1 à N faire
mat[i][j] <- mat1[i][j] + mat2[i][j];
finpour
finpour

écrire("Somme Matrice1 + Matrice2 : ");


pour i de 1 à N faire
pour j de 1 à N faire
écrire("Elément en position (", i, ",", j, ")=", mat[i][j]);
finpour
finpour

Fin.

41 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV.2. Tableau à n dimensions


On peut généraliser la définition du tableau à une dimension.

Définition de type de tableau

Type identificateur = tableau[inf1 .. sup1, inf2 .. sup2, …,


infn .. supn] de <type de base>;

Déclaration d’objets tableaux

Var identificateur : <type de tableau>;

Utilisation d’un élément tableau

identificateur[indice1][indice2]…[indicen];

V. Quelques algorithmes de base sur les tableaux


V.1. La recherche
En informatique, on est généralement amené à manipuler un ensemble de données présentant des
caractéristiques communes. Une des opérations les plus usuelles est la recherche dans ces
ensembles.

Par exemple, un annuaire téléphonique est destiné à fournir le numéro d’un abonné étant donné son
nom et éventuellement des caractéristiques complémentaires comme le prénom ou l’adresse.
Un autre exemple assez différent est celui d’un dictionnaire où on cherche la définition des mots en
faisant d’abord une recherche du mot que l’on veut définir.

V.1.1. La recherche séquentielle


La façon de procéder la plus naïve consiste à comparer l’élément cherché x successivement à tous
les éléments de la liste L selon le schéma séquentiel suivant :
Les index de L sont compris entre 1 et longueur (L)

42 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Comparer x et l’ième élément de la liste L. On s’intéresse dans un premier temps à la recherche


d’une solution quelconque, puis on arrête la progression dans la liste dès qu’on trouve un élément
égal à x.

Dans le cas où la liste est représentée par un tableau t, t[i] désigne l’ième élément de la liste.

Algorithme rechercheSequentielle;

Const N = 100;

Var t : tableau[1 .. N] de entier;


x : entier;
i : entier;

Début
écrire("Entrez les éléments du tableau");
pour i de 1 à N faire
écrire("Entrez le ", i, "ième élément");
lire(t[i]);
finpour

écrire("Entrez l’élément à rechercher");


lire(x)
i <- 1;
tantque ((i <= N) et (x <> t[i])) faire
i <- i+1;
fintantque

si (i = N+1) alors
écrire("Elément inexistant")
sinon
écrire("Elément existant en position : ", i);
finsi
Fin.

Dans cet algorithme la condition de la boucle tantque est double, on effectue donc à chaque
itération un test de fin de liste (i <= N), en plus de la comparaison entre deux éléments.

Autre méthode

Une façon plus élégante est d’utiliser une sentinelle c'est-à-dire on rajoute au tableau une place
t[n+1] contenant l’élément cherché x de telle sorte que la sortie de la boucle tantque se fait toujours
sur la rencontre de l’élément x. Ainsi, à la sortie de la boucle, si le rang est n+1 alors l’élément x
n’appartient pas à la liste initiale.

43 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme rechercheSentinelle;

Const N = 100;
M = 101;

Var t : tableau[1 .. M] de entier;


x : entier;
i : entier;

Début
écrire("Entrez les éléments du tableau");
pour i de 1 à N faire
écrire("Entrez le ", i, "ième élément");
lire(t[i]);
finpour

écrire("Entrez l’élément à rechercher");


lire(x)
i <- 1;
t[M] <- x;
tantque (x <> t[i]) faire
i <- i+1;
fintantque

si (i = M) alors
écrire("Elément inexistant")
sinon
écrire("Elément existant en position : ", i);
finsi
Fin.

V.1.2. Recherche dichotomique


Supposons à présent qu’il existe un ordre total sur les éléments et que la liste est triée par ordre
croissant. Pour rechercher un élément x on peut encore évidemment parcourir séquentiellement la
liste jusqu’à ce qu’on trouve soit x, soit un élément strictement supérieur à x, auquel cas x n’est pas
dans la liste puisque les éléments sont rangés par ordre croissant. L’algorithme prenant cela en
compte est appelé : Recherche dichotomique.

Le principe par recherche dichotomique de l’élément x dan la liste triée L est le suivant :

Comparer x avec l’élément situé au milieu M de la liste L.


• Si x = L[M], on a trouvé une solution et la recherche s’arrête
• Si x > L[M], il est possible que x se trouve avant L[M] dans la liste L et il ne reste que
traiter la moitié droite de la liste L.
• Si x < L[M], x ne peut se trouver que dans la moitié gauche de L.
On continue ainsi la recherche en diminuant de moitié le nombre d’éléments de la liste restante à
traiter après chaque comparaison, et si la liste ne contient pas x la recherche se terminera par un
échec.

44 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme rechercheDichotomique;

Const N = 100;

Var t : tableau[1 .. N] de entier;


x, debut, fin, milieu : entier;
trouve : booléen;

Début
écrire("Entrez les éléments du tableau dans l’ordre croissant");
pour i de 1 à N faire
écrire("Entrez le ", i, " ième élément");
lire(t[i]);
finpour

écrire("Entrez l’élément à rechercher");


lire(x)

debut <- 1;
fin <- N;
trouve <- faux;

tantque ((trouve <> vrai) et (debut <= N)) faire


milieu <- (debut + fin) DIV 2;

si (x = t[milieu]) alors
trouve <- vrai
sinon si (x > t[milieu]) alors
debut <- milieu + 1
sinon
fin <- milieu – 1;
finsi
finsi
fintantque

si (trouve = faux) alors


écrire("Elément inexistant")
sinon
écrire("Elément existant en position : ", milieu);
finsi
Fin.

45 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

V.2. Le tri
La spécification du tri est la suivante : La donnée est une liste à n éléments, à chaque élément est
associé une clé dont la valeur appartient à un ensemble totalement ordonné, le résultat est une liste
donc les éléments sont une permutation des éléments de la liste d’origine tel que les valeurs des clés
sont croissantes quand on parcourt la liste séquentiellement.

Considérons par exemple la liste d’entiers L suivante :

8 -3 4 10 2

Si on applique le tri sur L, on obtient la nouvelle liste L’ suivante :

-3 2 4 8 10

Où les éléments sont rangés par ordre croissant.

V.2.1. Tri par sélection


Cette méthode consiste à chercher le minimum de la liste puis le mettre en première place,
recommencer le même processus sur la fin de la liste. La figure ci-dessous présente les étapes
successives d’un tri par sélection sur une liste de 5 éléments.

Remarque :

On peut noter qu’après le kième placement, les k plus petits éléments de la liste sont à leur place
définitive.

46 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme triSelection;

Const N = 100;

Var t : tableau[1 .. N] de entier;


temp, i, j, min : entier;

Début
écrire("Entrez les éléments du tableau");
pour i de 1 à N faire
écrire("Entrez le ", i, " ième élément");
lire(t[i]);
finpour

pour i de 1 à N-1
min <- i;

pour j de i+1 à N
si (t[j] < t[min]) alors
min <- j;
finsi
finpour

si (min <> i) alors


temp <- t[i];
t[i] <- t[min];
t[min] <- temp;
finsi
finpour

écrire("Tableau trié dans l’ordre croissant");


pour i de 1 à N
écrire(t[i]);
finpour
Fin.

V.2.2. Tri à bulles ou par propagation


Ici, pendant qu’on parcourt la liste un échange est effectué chaque fois qu’on trouve deux éléments
successifs qui ne sont pas dans le bon ordre.

47 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme triBulles;

Const N = 100;

Var t : tableau[1 .. N] de entier;


temp, i, j : entier;

Début
écrire("Entrez les éléments du tableau");
pour i de 1 à N faire
écrire("Entrez le ", i, " ième élément");
lire(t[i]);
finpour

pour i de N à 2
pour j de 1 à i-1
si (t[j+1] < t[j]) alors
temp <- t[j];
t[j] <- t[j+1];
t[j+1] <- temp;
finsi
finpour
finpour

écrire("Tableau trié dans l’ordre croissant");


pour i de 1 à N
écrire(t[i]);
finpour
Fin.

V.2.3. Tri par insertion


Dans cette méthode, on tri successivement les premiers éléments de la liste. A la iième étape, on
insère le iième élément à son rang parmi les i-1 éléments précédents déjà triés.

Voici les étapes de l'exécution du tri par insertion sur le tableau T = [ 9 , 6 , 1 , 4 , 8 ]. Le tableau est
représenté au début et à la fin de chaque itération.

48 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme triInsertion;

Const N = 100;

Var t : tableau[1 .. N] de entier;


x, i, j : entier;

Début
écrire("Entrez les éléments du tableau");
pour i de 1 à N faire
écrire("Entrez le ", i, " ième élément");
lire(t[i]);
finpour

pour i de 2 à N
x <- t[i];
j <- i;

tantque ((j > 1) et (t[j-1] > x)) faire


t[j] <- t[j-1];
j <- j-1;
fintantque

t[j] <- x;
finpour

écrire("Tableau trié dans l’ordre croissant");


pour i de 1 à N
écrire(t[i]);
finpour
Fin.

VI. Tests de connaissances


1. Définir Tableau, Dimension, Type, Elément, Indice.
2. Quelle est la syntaxe de déclaration d’un tableau : dimension 1, dimension 2, dimension n ?
3. Décrire le principe de la recherche dichotomique et du tri par insertion ?

49 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE VI : LES SOUS PROGRAMMES


I. Objectifs
Les sous programmes en algorithme facilitent la visibilité du code et surtout empêche la réécriture
du même code plusieurs fois, permet de décomposer un problème P en sous problèmes P1,
P2…………Pn et surtout d’écrire plusieurs fois la même suite d’instruction. Il faut également
mentionner que les sous programmes faciliteront la mise au point et la maintenance des algorithmes
(c'est-à-dire la possibilité de faire écrire par plusieurs personnes les différentes parties d’un
algorithme). Les sous programme sont connus sur le nom de procédure et fonction.

Au terme de ce chapitre, l’apprenant sera capable de faciliter l’écriture des algorithmes à travers les
fonctions, les procédures en mettant l’accent sur la notion de :
• Structure d’un algorithme intégrant les fonctions et procédures ;
• Paramètre et de variables locales et globales ;
• Procédures sans paramètres et avec paramètres ;
• Fonctions sans paramètres et avec paramètres ;
• Appel des procures et fonctions ;
• Intégration des procédures et fonction dans l’algorithme.

II. Notion de variables globales et variables locales


Variable globale

On dit qu’une variable est globale lorsque qu’elle a été déclarée dans l’algorithme. Ainsi, elle est
connue de toutes les procédures et fonctions qui sont déclarées par la suite.

Variable locale

On dit qu’une variable est locale lorsque sa portée est limitée à la procédure ou la fonction.

50 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III. Les procédures


III.1. Définition
Une procédure est un bloc d’instructions nommé et déclaré dans l’entête de l’algorithme et
appelé dans son corps à chaque fois que le programmeur en a besoin.

III.2. Procédure sans paramètres


Une procédure est un objet qui permet aux programmeurs de traiter un problème sans s’embarrasser
du règlement dans les détails des sous problèmes le composant.

Syntaxe de déclaration d’une procédure sans paramètres

Procédure identificateur();

<déclaration de variables locales>

Début
<liste des instructions>; co corps de la procédure fco
Fin;

NB : L’identificateur représente le nom de la procédure.

Appel de la procédure sans paramètres

Elle se fait uniquement à l’aide de l’identificateur (nom de la procédure) de la procédure. La


syntaxe est la suivante :

identificateur();

Remarque : un appel de procédure est une instruction. Donc elle se termine par un « ; »

Exemple :

Ecrire un algorithme qui affiche 5 fois la phrase : « Il fait trop chaud à douala ».

Démarche à suivre : Nous allons créer une procédure chaud() et déclarer une variable globale i
comme compteur.

51 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme Temperature;

Var i : entier;

Procédure chaud();
Début
écrire("Il fait trop chaud à douala");
Fin;

Début
pour i de 1 à 5 faire
chaud();
finpour
Fin.

III.3. Procédure avec paramètres


Une procédure qui utilise des données (par exemple les résultats des calculs antérieurs) fournit par
l’algorithme principal est appelé procédure avec paramètre. Cette procédure sera écrite avec des
arguments fictifs appelés paramètres formels auquel on fera correspondre lors de l’appel des
données réels appelées paramètres effectifs.

Les différents types de paramètres

Les paramètres formels (fictifs) : qui sont figurés dans l’entête de la déclaration de la procédure et
sont utilisés dans les instructions de la procédure et la procédure seulement. Ils correspondent à des
variables locales.

Procédure identificateur(pf1 : type 1 ; pf2 : type 2 ; ………);

Les paramètres effectifs (réels) : qui sont figurés dans l’instruction d’appel de la procédure et sont
substitués aux paramètres formels au moment de l’appel de la procédure.

identificateur(pe1, pe2, …………….. );

52 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Syntaxe de déclaration d’une procédure avec paramètres

procédure identificateur(<liste des paramètres formels>);

<déclaration de variables locales> ;

Début

<liste des instructions>; co corps de la procédure fco

Fin;

Appel de la procédure d’une procédure avec paramètres

identificateur(<liste des paramètres effectifs>);

Exemple :

Ecrire un algorithme comportant une procédure qui permet de calculer la somme de n premiers
nombres entiers naturels ainsi que leur produit.

Algorithme Somme_nombre_premiers;

Var n : entier; co Le nombre d’entiers fco

Procédure somme(nb_entier : entier);

Var i : entier;
som, prod : réel;

Début
som <- 0;
prod <- 1;

pour i de 1 à nb_entier faire


som <- som+i;
prod <- prod*i;
finpour

écrire("La somme est : ", som, " et Le produit est : ", prod);
Fin;

Début
écrire("Entrez un nombre entier naturel");
lire(n);
somme(n);
Fin.

53 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

III.4. Modes de transmission des paramètres


Il existe deux modes de transmission des paramètres :

Par valeur

Le paramètre transmis n'est jamais affecté par les modifications dans la procédure ou la fonction (on
ne récupère pas les résultats !).

Le passage de paramètres par valeur permet au programme appelant de transmettre une valeur à la
procédure appelée.

Avant d’exécuter les instructions de la procédure la valeur du paramètre effectif est affectée au
paramètre formel. Dans ce cas, le paramètre formel est considéré comme une variable locale qui est
initialisée lors de l’appel.

Ainsi,
• Les paramètres effectifs et les paramètres formels doivent s’accorder du point de vue
nombre et ordre.
• Leurs types doivent être identiques selon le mode de passage des paramètres

Remarque :
• Le transfert d’information est effectué dans un seul sens, du programme principal vers la
procédure.
• Toute modification du paramètre formel est sans conséquence sur le paramètre effectif.

Par variable ou adresse ou référence

Le paramètre transmis dans ce cas peut être modifié et on récupère les résultats.

Le passage de paramètres par variable permet au programme appelant de transmettre une valeur à la
procédure appelée et vice-versa.

Pendant l’exécution des instructions de la procédure, le paramètre formel fait référence au même
contenu de la variable que celui désigné par le paramètre effectif.

Remarque :
• Le transfert d’information est effectué dans les deux sens, du programme principal vers la
procédure et vice-versa.
• Toute modification du paramètre formel entraîne automatiquement la modification de
la valeur du paramètre effectif.

54 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Illustration de la différence entre passage par valeur et passage par variable ou adresse ou
référence

IV. Les fonctions


IV.1. Définition
Une fonction est un bloc d’instructions qui retourne obligatoirement une et une seule valeur
résultat à l’algorithme appelant. Une fonction n’affiche jamais la réponse à l’écran car elle la
renvoie simplement à l’algorithme appelant.

On peut également définir une fonction comme étant une procédure avec paramètre ou sans
paramètre qui rend un résultat unique de type déterminé.

Il est obligatoire de préciser, dés le début le type de la fonction qui est en même temps le type du
résultat à retourner.

55 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV.2. Syntaxe de déclaration d’une fonction


Fonction identificateur(<liste des paramètres formels>): <type de résultat>;

<déclaration de variables locales>;

Début

<liste des instructions>; co corps de la fonction fco


identificateur <- résultat; co retourner le résultat fco

Fin;

IV.3. Appel d’une fonction


identificateur(<liste des paramètres effectifs>);

IV.4. Exemple de fonction


Ecrire algorithme comportant une fonction qui retourne le minimum entre deux (02) entiers a et b.

Algorithme Minimum_entiers;

Var a, b : entier; co Deux nombres d’entiers fco

Fonction Min(x, y : entier) : entier;

Var m : entier;

Début
si (x >= y) alors
m <- y
sinon
m <- x;
finsi

Min <- m;
Fin;

Début
écrire("Entrez deux entiers naturels");
lire(a);
lire(b);
écrire("Le minimum entre ", a, " et ", b, " est : ", Min(a, b));
Fin.

56 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV.5. Bien à savoir


Le nom de la fonction joue un double rôle, c’est à la fois l’identificateur de la fonction et une
variable locale.

Dans une fonction, le passage de tous les paramètres se fait toujours par valeur.

V. La Récursivité
La récursivité consiste à remplacer une boucle par un appel à la fonction elle-même. Elle ne
s’applique que sur les fonctions.

Une fonction récursive est une fonction qui s’appelle elle-même. Chaque appel à la fonction est
indépendant des autres, avec ses propres variables.

Exemple

Ecrire un algorithme qui permet de réaliser le factoriel d’un nombre n.

La suite factorielle est définie par :


• 0! = 1
• n! = n(n-1)!

Algorithme Factorielle;

Var nb : entier;

Fonction Facto(n : entier) : entier;

Début
si (n = 0) alors
Facto <- 1
sinon
Facto <- n * Facto(n-1);
finsi
Fin;

Début
écrire("Entrez un nombre entier");
lire(nb);

écrire("Le factorielle de ce nombre est : ", Facto(nb));


Fin.

57 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

VI. Exercices d’application


VI.1. Exercice 1
Ecrire un algorithme qui à l’aide d’une procédure permet de faire la table de multiplication d’un
nombre entier compris entre 2 et 9 fournit par l’utilisateur.

Algorithme Tableau_Multiplication;

Var nb : entier;

Procédure Multi(n : entier);

Début
écrire("Table de multiplication de ", n);
ENTER;

pour i de 1 à 10 faire
écrire(n, " x ", i, " = ", n*i);
finpour
Fin;

Début
écrire("Entrez un nombre entier");
lire(nb);

tantque ((nb < 2) ou (nb > 9)) faire


écrire("Vous devez entrer un nombre entier compris entre 2 et 9");
lire(nb);
fintantque

Multi(nb);
Fin.

VI.2. Exercice 2
Un algorithme qui calcule et affiche la valeur absolue d’un nombre en utilisant une fonction.

Algorithme Valeur_Absolue;

Var nb : réel;

Fonction abs(n : réel) : réel;


Début
si (n >= 0) alors
abs <- n
sinon
abs <- (-1*n);
finsi
Fin;

Début
écrire("Entrez un nombre");
lire(nb);
écrire("La valeur absolue de ", nb, " est : ", abs(nb));
Fin.

58 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

VI.3. Exercice 3
A l’aide de la récursivité, écrire un algorithme qui permet de faire le PGCD de deux nombres
entiers fournis par l’utilisateur.

Algorithme Calcul_PGCD;

Var a, b : entier;

Fonction PGCD(x : entier, y : entier) : entier;


Début
si ((x = 0) ou (y = 0)) alors
PGCD <- 0
sinon si (a = b) alors
PGCD <- a
sinon si (a > b) alors
PGCD <- PGCD(a-b, b)
sinon
PGCD <- PGCD(a, b-a);
finsi
finsi
finsi
Fin;

Début
écrire("Entrez deux nombres entiers");
lire(a, b);

écrire("Le PGCD de ", a, " et ", b, " est : ", PGCD(a, b));
Fin.

VII. Tests de connaissances


1. Définir Procédure, Fonction, Récursivité
2. Quelle est la différence entre une procédure et une fonction ?
3. Que signifie passage par valeur et passage par adresse ou référence ? Donnez des exemples.

59 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

CHAPITRE VII : ENREGISTREMENT ET FICHIER


I. Objectifs
Au terme de ce chapitre l’apprenant sera capable de manipuler des objets ayant des propriétés de
nature différents (types).

II. Définitions
Les ensembles d’information sont souvent organisés en des structures d’enregistrement, le tout
contenu dans un ou plusieurs fichiers.

Un enregistrement est un ensemble de données relié, chacun d’entre eux étant appelé champ ou
attribut.

Un fichier est un ensemble d’information nommé et résidant sur un support périphérique (disque
dur, bande magnétique, CD …) et référencé par un nom.

III. Enregistrement
Bien qu’un enregistrement soit un ensemble d’élément d’information, il diffère du tableau par les
points suivants :
• Un enregistrement peut être un ensemble de données hétérogène c'est-à-dire qui peut réunir
des données de types différents.
• Les éléments de données dans un enregistrement sont indexés par les noms d’attribut, il peut
ne pas exister des classements entre les champs d’un enregistrement.

Exemples

Jean
12 11 85

Paul
20
Masculin

Jean et Paul constitue la valeur d’un champ et sont des chaînes de caractères.
La valeur 20 du 2ième enregistrement désigne l’âge de Paul : c’est un entier.

60 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Syntaxe de définition d’un enregistrement

Type identificateur= enregistrement


<Liste des champs>;
fin;

• identificateur : désigne le nom de l’enregistrement


• <Liste des champs> : désigne l’ensemble des champs (dont le type peut être différent en
fonction du champ) associés à l’enregistrement

Déclaration d’un objet de type enregistrement

Var identificateur : <Type enregistrement>;

• identificateur : désigne le nom de l’objet a crée


• <Type enregistrement> : désigne le nom de l’enregistrement crée dans la section de
déclaration des structures de données

Utilisation d’un objet de type enregistrement

La manipulation d’un enregistrement se fait à travers ses champs. Comme pour les tableaux, il n’est
pas possible de manipuler un enregistrement globalement, sauf pour affecter un enregistrement à un
autre de même type (ou le passer en paramètre)

identificateur.<champ>;

• identificateur : désigne le nom de l’objet (objet de type enregistrement) crée dans la section
de déclaration des variables
• <champ> : désigne le champ de l’enregistrement que l’on souhaite attendre

61 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Exemple de déclaration et de manipulation d’un enregistrement

Algorithme Exemple_Enregistrement;

Type personne= enregistrement


nom : chaîne;
age : entier;
sexe : chaîne;
fin;

Var p : personne;

Début
p.nom <- "M. TEJIOGNI Marc";
p.age <- 19;
p.sexe <- "M"; co Masculin fco

écrire("Nom= ", p.nom, " Age= ", p.age, " Sexe= ", p.sexe);
Fin.

Exemple pratique

Ecrire un algorithme permettant d’enregistrer une liste de 100 personnes identifiées par leur nom,
âge et sexe et d’afficher le nombre d’hommes et le nombre de femmes.

Algorithme Liste_Personne;

Const N= 100;

Type personne= enregistrement


nom : chaîne;
age : entier;
sexe : chaîne;
fin;

Var tabp : tableau[1 .. N] de personne;


i, homme, femme : entier;

Début
écrire("Entrez la liste des étudiants");
pour i de 1 à N faire
écrire("Entrez les informations de l’étudiant numéro ", i);
écrire("Entrez le nom :");
lire(tabp[i].nom);
écrire("Entrez l’âge :");
lire(tabp[i].age);
écrire("Entrez le sexe (M/F) :");
lire(tabp[i].sexe);

si (tabp[i].sexe = "M") alors


homme <- homme + 1
sinon
femme <- femme + 1;
finsi
finpour

écrire("Le nombre d’hommes est : ", homme);


écrire("Le nombre de femmes est : ", femme);
Fin.

62 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Il est possible de résoudre des problèmes en utilisant un tableau d’enregistrement : ce tableau réside
en mémoire et s’il s’agit d’un fichier d’enregistrement, ce fichier réside sur un support de stockage.
Dans le cas d’un fichier, tout traitement demande que les enregistrements soient lus et envoyés en
mémoire centrale et une fois le traitement fini ou terminé, on doit procéder à une sauvegarde des
données de la mémoire pour le fichier.

IV. Fichier
Très tôt en informatique, il est apparu le besoin de conserver des informations en dehors de la
mémoire centrale de l’ordinateur c'est-à-dire sur un support permanent. Par ailleurs le volume de
certaines données ne permet pas de représenter tous les ensembles dans l’espace disponible en
mémoire centrale.

Exemple

Un programme qui calcul la paye d’une entreprise traite l’ensemble des informations relatives aux
personnels de l’entreprise. Mais à un moment donné, on n’a besoin que des données qui concernent
le bulletin de paye de l’employé courant.

La notion de fichier est conçue pour répondre aux aspects ci-dessous évoqués :
• Stockage permanent de l’information
• Rassemblement d’un gros volume d’informations pouvant être fractionné par le traitement

IV.1. Supports séquentiel et adressable


On distingue deux catégories de support :
• Supports séquentiels : sur lesquels les informations sont écrites les unes à la suite des
autres et qui sont telles que l’accès à une information I nécessite le passage sur toutes les
informations qui précède I sur le support.
• Supports adressables : qui sont structurés en surface d’enregistrement individuellement
adressable. Les informations qui y sont enregistrées peuvent être retrouvées directement
grâce à leurs adresses sans que l’on ait à passer par des enregistrements intermédiaires.

Exemple de support

La bande magnétique est le type classique de support séquentiel; les CD; mémoire centrale sont les
supports adressables.

63 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV.2. Organisation et accès


Deux techniques d’accès sont généralement utilisées :
• L’accès séquentiel où on accède au fichier dans l’ordre d’enregistrement de données.
• L’accès sélectif où on accède directement à un enregistrement sans passer par les
enregistrements intermédiaires; cet accès n’est possible qu’avec des supports adressables.

L’organisation d’un fichier définit la manière dont les enregistrements du fichier sont disposés sur
le support. On distingue trois organisations principales :
• L’organisation séquentielle qui ne permet que l’accès séquentiel
• L’organisation directe conçue pour l’accès sélectif
• L’organisation séquentielle indexée (mixte) qui permet l’accès séquentiel et l’accès
sélectif

IV.3. Association d’un fichier à un programme


Syntaxe de déclaration d’un fichier

Type identificateur= fichier de <type de structure>;

• identificateur : désigne le nom du fichier


• <type de structure> : désigne le type de structure de données

Exemple

Type fiche= fichier de personne;

Déclaration d’un objet de type fichier

Var identificateur : <type fichier>;

Exemple

Var F : fiche;

F définit un fichier d’enregistrement, où un enregistrement est une entité de type personne.

Un fichier F est identifié de manière unique par un nom externe qui lui est attaché. F ici est un
fichier logique. Dans un programme, on associera à un fichier logique un fichier physique
représenté par un nom externe.

64 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Au moment de traiter un fichier, le programme doit d’abord ouvrir le fichier à l’aide d’une primitive
d’ouverture de fichier. Une telle action permettra le positionnement initial du dispositif de
lecture/écriture sur le support du fichier.

Si F est le nom interne du fichier nous noterons « ouvrir(F) » la primitive qui permet d’ouvrir le
fichier le fichier et de débuter le traitement sur F.
En fin de traitement la primitive « fermer(F) » permettra la fermeture du fichier.

Attention : Il faut toujours veuillez à ouvrir un fichier avant traitement et à le refermer à la fin du
traitement.

Dans la suite, nous supposons que F est un fichier à organisation séquentielle.

Soit F, un fichier d’enregistrement de type personne et val une variable de lecture de même type
(personne) :
• lire(F, val) permet de lire la valeur d’un enregistrement de F et de le ranger dans la variable
val.
• écrire(F, val) permet d’écrire la valeur d’un enregistrement contenu dans la variable val à
l’intérieur du fichier.

L’exécution de lire(F, val) et écrire(F, val) suppose que la tête de lecture est placé immédiatement
avant l’enregistrement à lire pour la primitive lire et pour la primitive écrire qu’elle est correctement
positionné à l’emplacement où on désire écrire.

L’exécution de lire(F, val) à pour effet de déplacer la tête de lecture sur l’enregistrement en le
recopiant dans la variable val. Enfin d’exécution la tête de lecture se trouve immédiatement après
l’enregistrement lu.

L’exécution écrire(F, val) entraîne le déplacement de la tête d’écriture sur le support avec addition
à F d’un nouvel enregistrement dont la valeur est celle contenu dans la variable val.

65 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

IV.4. Parcours d’un fichier


Nous présenterons un algorithme général de parcours d’un fichier qui effectue sur chaque
enregistrement une opération de traitement que nous ne précisons pas.

Algorithme Parcours_Fichier;

Type personne= enregistrement


co liste des champs fco
fin;

Type fiche= fichier de personne;

Var fich : fiche;

Procédure parcours(Var F : fiche);

Var val : personne; co val est une variable de lecture fco

Début
ouvrir(F); co ouverture du fichier fco

co on fait les initialisations nécessaires ici fco

tantque non(fin(F)) faire


lire(F, val);
co on réalise le traitement de l’enregistrement lu ici fco
fintantque

fermer(F);
co autrement traitement ici fco
Fin;

Début
parcours(fiche);
Fin.

Exemple pratique

Ecrire un algorithme comportant une fonction « compteur » permettant d’afficher le nombre


d’enregistrement d’un fichier de type personne sachant qu’une personne est identifié par un nom, un
âge et un sexe.

66 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98


Algorithme et Programmation 2018 / 2019

Algorithme Nombre_Enreg_Fichier;

Type personne= enregistrement


nom : chaîne;
age : entier;
sexe : chaîne;
fin;

Type fiche= fichier de personne;

Var fich : fiche;

Fonction compteur(F : fiche) : entier;


Var p : personne;
i : entier;

Début
ouvrir(F);
i <- 0;
tantque non(fin(F)) faire
lire(F, p);
i <- i+1;
fintantque
fermer(F);
compteur <- i;
Fin;

Début
écrire("Le nombre d’enregistrements est : ", compteur(fich));
Fin.

V. Tests de connaissances
1. Définir : Enregistrement, Fichier
2. Quelle est la différence entre un tableau et un fichier en algorithmique ?
3. Citez deux catégories de support de stockage permanent des informations que vous
connaissez. Donnez quelques exemples.
4. Quelles sont les techniques d’accès à l’information dans un fichier ?
5. Que signifie organisation d’un fichier ? Citez-en quelques unes ?
6. Soit F, un fichier d’enregistrement de type personne et val une variable de lecture de même
type (personne). A quoi servent les instructions suivantes :
a. lire(F, val)
b. écrire(F, val)

67 M. Marc TEJIOGNI | mtejiogni@yahoo.fr | Tél : 693 90 91 21 – 670 10 23 98