Institut Universitaire d'Abidjan

ALGORITHME DE
BASE
K. Olivier PETEY
ALGORITHME DE BASE

K. Olivier PETEY

2
 ALGORITHME DE BASE

SYLLABUS DU COURS IUA

*INTITULE DU COURS : ALGORITHME DE BASE

Code : ………….
*Type : CM ou TD ; CM et TD (barrez la mention inutile)
*Volume horaire : 30H…………………………………………………………………….…
UE de rattachement : ………………………………………………………………………
*Niveau du cours : LICENCE 1…………………………..……………………………….
*Département : INFORMATIQUE………………………………………………………….
*Semestre : 1………………………………………………………………………………….
*Nombre de crédit : 3 ……………………………………………………………………….
*Nom de l’enseignant : PETEY KRAGBI OLIVIER……..……………………………….
*Contact téléphonique :77 77 12 75……………………………………………………….
*Email : peteykol@yahoo.fr...........................................................................................
*Statut : Enseignant à l’Université  Professionnel d’Entreprise 

*Les objectifs
Comprendre et être capable des solutions à un problème donné à partir d’un
algorithme.
*Les objectifs spécifiques
Au l’issue de la formation l’apprenant doit être capable de :
Connaitre les notions de base de l’algorithme
Utiliser des variables et des constantes,
Définir des structures alternatives, des structures itératives,
Utiliser les fonctions, les tableaux, les fichiers
Les pré-requis
Avoir le sens du raisonnement (mathématique).

*Le contenu
CHAPITRE I – NOTIONS DE BASE
I- Introduction

II-Type de données

III-Définitions de données (Variable, Constante)

IV- Les operateurs

CHAPITRE II – LES STRUCTURES ALGORITHMIQUES

I- Structure linéaire

3
II-Les structures alternatives
III-Les structures itératives

CHAPITRE III– LES TABLEAUX

I-Tableau unidimensionnel
II- Traitements de tableaux
III-Tableau multidimensionnel

CHAPITRE IV- LES SOUS-PROGRAMMES

I- Les procédures
II- Les Fonctions
III- Récursivité

CHAPITRE V : LES FICHIERS

I-Organisation des fichiers
II-Structure des enregistrements
III-Type d’accès
IV-Traitement
V-Données structurées

4
 ALGORITHME DE BASE

SOMMAIRE

CHAPITRE I : ELEMENTS DE BASE DE L’ALGORITHME ...................................................... 6

I. DEFINITIONS ................................................................................................................................. 6
II. TYPE DE DONNEES : .................................................................................................................. 8
III. DEFINITIONS DE DONNEES .................................................................................................... 8
IV. LES OPERATEURS .................................................................................................................. 11
CHAPITRE II : STRUCTURE ALGORITHMIQUES .................................................................. 12
I- Structure linéaire .......................................................................................................................... 12
II - Structures alternatives ................................................................................................................. 13
III-Structures itératives (ou répétitives)............................................................................................. 16
CHAPITRE III : LES TABLEAUX ................................................................................................. 28
I – Tableau de dimension .................................................................................................................. 28
II. Tableau multidimensionnel .......................................................................................................... 34
CHAPITRE IV: SOUS-PROGRAMMES ..................................................................................... 35
I- LES PROCEDURES ..................................................................................................................... 35
II. LES FONCTIONS ........................................................................................................................ 36
III. LES VARIABLES GLOBALES ET LES VARIABLES LOCALES ........................................ 36
IV. LES PARAMETRES .................................................................................................................. 37
V. RECURSIVITE ............................................................................................................................ 38
CHAPITRE V : TYPE DE DONNEES STRUCTUREES, LES FICHIERS ............................ 39
I. TYPE DE DONNEES STRUCTUREES ....................................................................................... 39
II. LES FICHIERS ............................................................................................................................ 40
BIBLIOGRAPHIE............................................................................................................................ 43

5
CHAPITRE I : ELEMENTS DE BASE DE L’ALGORITHME

I. DEFINITIONS

Définition : Un algorithme est suite finie d’opérations élémentaires constituant un schéma de

calcul ou de résolution d’un problème.
On peut aussi définir l’algorithme comme suit : une suite finie, séquentielle de règles que l’on
applique à un nombre fini de données, permettant de résoudre des classes de problèmes
semblables.
Algorithmique : Science qui étudie l’application des algorithmes à l’informatique.
Différences entre algorithmes et programmes
Un programme est la réalisation (l’implémentation) d’un algorithme au moyen d’un langage
donné (sur une architecture donnée). Il s’agit de la mise en œuvre du principe. Par exemple,
lors de la programmation on s’occupera parfois explicitement de la gestion de la mémoire
(allocation dynamique en C) qui est un problème d’implémentation ignoré au niveau
algorithmique.

6
 ALGORITHME DE BASE

L’algorithme d’un programme est organisé en plusieurs parties :

• déclaration des constantes
• déclaration des variables
• définition des fonctions et procédures
• définition du programme principal

7
II. TYPE DE DONNEES :

Type de données
Un programme peut-être amené à manipuler différents types de données :
- booléen : valeur pouvant être soit Vraie, soit Fausse.
- entiers : valeur numériques entières pouvant être signées ou non signées (codées sur
un ou plusieurs octets).
- réels : valeurs numériques codées avec une mantisse et un exposant.
- caractère : octet correspondant à un code ASCII.
- chaîne de caractères : ensemble de caractères.
- tableau de données : ensemble de données de même type
(exemple : tableau d’entiers, tableau de réels).
Toutes ces données sont codées sous forme d'octets en mémoire.

III. DEFINITIONS DE DONNEES

Déclaration des constantes Constante :

Une Constante est une donnée manipulée par un programme et ne pouvant être modifiée.
Exemple : Constante Pi = 3.141559
Syntaxe : Constante NomConstante : [Type] = Valeur
Exemples : Constante Pi : Reel = 3.141559
Constante NombreLettres : Entier = 10

Déclaration des variables

Une Variable est une donnée manipulée par un programme et pouvant être modifiée.
Ce peut être :
- une donnée d’entrée ;
- le résultat final d’un calcul ;
- un résultat intermédiaire de calcul.
Identificateur : nom explicite d’une constante, d’une variable ou d’une fonction.
Exemples : Conversion_BCD, Résultat, Lettre…

8
 ALGORITHME DE BASE

Remarque :
Une variable est un emplacement dans la mémoire où est stockée une valeur. Une variable
porte un nom, ce nom est laissé au choix du concepteur de l'algorithme, il doit commencer par
une lettre et ne pas comporter d'espace. On se sert du nom d'une variable pour lire la valeur
qui s'y trouve ou bien pour la modier, une variable ne peut contenir qu'une seule valeur à la
fois.
Syntaxe : Variable NomVariable : [Type]
Exemples : Variable Rayon : Reel
Variable Compteur : Entier
Variable Lettre : Caractere

Définition des fonctions et procédures

Procédures et fonctions : Une procédure ou une fonction effectuent une suite d’actions
élémentaires constituant un tout. Une fonction se différencie d’une procédure par le fait
qu’elle fournit un résultat.
Les procédures et fonctions peuvent nécessiter éventuellement un ou plusieurs paramètres
d’entrée ou de sortie. Un paramètre d’entrée est la référence à une variable manipulée par la
procédure ou la fonction. Un paramètre de sortie est une valeur renvoyée par une fonction.
Une fonction ou une procédure peut elle-même appeler une ou plusieurs fonctions et
procédures.
Syntaxe de la déclaration d’une fonction :
Fonction NomFonction (NomEntrée1 : [Type], NomEntrée2 : [Type],…) : [TypeDuRésultat]
Constante /*déclaration des constantes locales */
Variable /* déclaration des variables locales */
Début
/*description des actions effectuées par la fonction */

Fin

Syntaxe de l’appel d’une fonction :

Variable ← NomFonction (NomEntrée1, NomEntrée2…)

Exemple de déclaration de fonction :

Fonction Moyenne (Note1 : Reel, Note2 : Reel) : Reel

9
 Variable Intermediaire : Reel
Début
Intermediaire ← Note1 + Note2
Intermediaire ← Intermediaire / 2
Moyenne ← Intermediaire
Fin

Exemples d’utilisation de la fonction :

Afficher (Moyenne(10.5,15)) ou NouvelleNote ← Moyenne (10,5.5)

Nota : la déclaration et l’appel d’une procédure ne sont pas développés ici.

Définition du programme principal
Le programme principal consiste en une suite d’opérations élémentaires faisant souvent appel
à des fonctions ou procédures.
Le programme principal est délimité par les mots-clefs Début et Fin
Une affectation consiste à attribuer une valeur à une variable.
La syntaxe générale est la suivante : NomVariable ← Expression
« Expression » peut être :
-Une constante. ....................................................................Ex : surface ← 40
-Une autre variable. .................................................…........Ex : Donnee ← ValeurMemorisee
- Le résultat d’une fonction. .......................................…….Ex : resultat ← racine (nombre)
- Un calcul portant sur ces différents éléments. .…Ex : surface ← (PI * Carre (Diametre)) / 4

Nota : Un abus d’écriture nous amène parfois à voir le signe = à la place de la flèche.
C’est valable normalement pour l’écriture en langage de programmation (Basic compilé,
Pascal, …) mais pas dans un algorithme.

10
 ALGORITHME DE BASE

IV. LES OPERATEURS

1. Operateurs sur les entiers et les réels

2. Operateurs sur les entiers et les booléens

3. Operateurs sur les caractères et les chaines

4. L’affectation
Elle permet d’affecter une valeur à une variable.

L’expression est une suite d’opérations sur les constantes et les variables déjà déclaré.

11
POINTS IMPORTANTS A RETENIR
- La syntaxe générale
- Les variables
- Les constantes
- Les operateurs

CHAPITRE II : STRUCTURE ALGORITHMIQUES

Les structures algorithmiques sont réparties en 3 catégories :

- structures linéaire d'opérations;
- structures alternatives (ou conditionnelles) ou de choix : en fonction d'une condition, le
programme exécute des opérations différentes;
- structures itératives ou répétitives: sous contrôle d'une condition, une séquence d'opérations
est exécutée répétitivement.

I- Structure linéaire

Les actions successives sont mentionnées les unes après les autres.

12
 ALGORITHME DE BASE

Remarque : dans la suite, la notation « Actions » ou « ActionsN » représentera une

succession d’actions comme ci-dessus.
Exemple : Calcul d’un produit de 2 nombres
Algorithme : produit
Variable
a,b : réel /*opérandes */
p : réel /*résultat du produit * /

II - Structures alternatives

- Structure SI ... ALORS ...

Une condition est testée pour déterminer si l’action ou le groupe d’actions suivant doit être
exécuté.

13
 Exemple : Calcul d’une racine carrée
Algorithme: carre
Variable
x: réel /* opérande */
r: réel /* résultat de la racine carrée */
Début
Afficher (‘Saisir le nombre x‘)
Saisir (x)
Si x > 0 Alors
r ← racine (x)
afficher (r)
FinSi
Fin

Structure SI ... ALORS ...SINON ...

Une condition est testée pour déterminer quelle action ou quel groupe d’actions doit être
exécuté.

Exemple : Calcul d’une racine carrée

Algorithme : racinecarre

14
 ALGORITHME DE BASE

Variable
x: réel /* opérande*/
r: réel /*résultat de la racine carrée */
Début
Afficher (‘Saisir le nombre x‘)
Saisir (x)
Si x < 0 Alors
afficher (‘x est négatif’)
Sinon
r ← racine (x)
afficher (r)
FinSi
Fin

Structure de choix multiple

Une donnée est comparée successivement à des valeurs constantes :

15
Remarques : la partie « Actions N+1 » peut ne pas exister.
Plusieurs valeurs différentes peuvent être regroupées sur une m actions correspondantes sont
identiques.
Exemple : Affichage de la nature d’un caractère
Algorithme affichercaractere
Variable
c: caractère /* caractère saisi au clavier */
Début
Afficher (‘Taper un caractère‘)
Saisir (c)
Suivant c Faire
‘A’..’Z’ : afficher (‘Lettre majuscule’)
‘a’..’z’ : afficher (‘Lettre minuscule’)
‘0’..’9’ : afficher (‘Chiffre’)
Sinon
afficher (‘Ni Lettre Ni Chiffre’)
FinSuivant
Fin

III-Structures itératives (ou répétitives)

Structure REPETER ... JUSQUA ...

16
 ALGORITHME DE BASE

Une action ou un groupe d’actions est exécuté répétitivement jusqu'à ce qu’une condition
soit vérifiée.

Remarque : la vérification de la condition s’effectue après les actions. Celles-ci sont donc
exécutées au moins une fois.
Exemple : exécution répétitive d’un programme
Algorithme calcul_produit
Variables :
a,b : réel /*opérandes */
p : réel /*résultat du produit */
c : caractère /* réponse de l’utilisateur */
Début
Répéter
Afficher (‘Saisir le nombre a ‘)
Saisir (a)
Afficher (‘Saisir le nombre b ‘)
Saisir (b)
p←a*b
afficher (p)
afficher (‘encore un calcul ? Non touche N ; Oui autre touche’)
saisir (c)
Jusqu'à c = ‘N’
Fin

Structure TANT QUE ... FAIRE ...

Une action ou un groupe d’actions est exécuté répétitivement tout le temps où une
condition est vraie.

17
Exemple : Exécution répétitive d’une action
Algorithme : attente
Début
Tant Que Non (ToucheAppuyée)
Faire
Afficher (‘Attente’)
FinFaire
Fin

Structure POUR Indice DE ... A .... FAIRE ...

Une action ou un groupe d’actions est exécuté répétitivement un certain nombre de fois : le
nombre dépend des valeurs initiale et finale données à la variable « Indice ».

Remarque : les valeurs initiale (Val1) et finale (Val2) sont incluses dans le comptage.
Il est éventuellement possible de spécifier un autre pas d’incrémentation (+2,+10,-1....).
Exemple : Affichage d’une ligne d’étoiles
Algorithme etoilepour
Variable
i : entier /*compteur de boucles */

18
 ALGORITHME DE BASE

Début
Pour i de 1 à 80
Faire
Afficher (‘*’)
FinFaire
Fin

Remarque : cette structure algorithmique peut en fait être remplacée par une structure
TANT QUE ... FAIRE …

Algorithme etoiletq
Variable
i : entier /*compteur de boucles*/
Début
i←1
Tant Que i <= 80
Faire
Afficher (‘*’)
i ← i +1
FinFaire
Fin

Exercice 1
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche le
carré de ce nombre.
Résolution :
Algorithme carre
Variable
nb, carr : réel

19
Début
Ecrire "Entrez un nombre :"
Lire nb
carr ← nb * nb
Ecrire "Son carré est : ", carr
Fin

En fait, on pourrait tout aussi bien économiser la variable carr en remplaçant les deux
avant-dernières lignes par :
Ecrire "Son carré est : ", nb*nb

C'est une question de style ; dans un cas, on privilégie la lisibilité de l'algorithme, dans
l'autre, on privilégie l'économie d'une variable.
Exercice 2
Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le taux de
TVA, et qui fournit le prix total TTC correspondant. Faire en sorte que des libellés
apparaissent clairement.
Algorithme: calculmontant
Variable
nb, pht, ttva, pttc : réel
Début
Ecrire "Entrez le prix hors taxes :"
Lire pht
Ecrire "Entrez le nombre d’articles :"
Lire nb
Ecrire "Entrez le taux de TVA :"
Lire ttva
pttc ← nb * pht * (1 + ttva)
Ecrire "Le prix toutes taxes est : ", pttc
Fin

Là aussi, on pourrait squeezer une variable et une ligne en écrivant directement. :

Ecrire "Le prix toutes taxes est : ", nb * pht * (1 + ttva)
C'est plus rapide, plus léger en mémoire, mais un peu plus difficile à relire (et à écrire !)
Exercice 3

20
 ALGORITHME DE BASE

Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce

nombre est positif ou négatif (on laisse de côté le cas où le nombre vaut zéro).
Algorithme : signe
Variable
n : Entier
Début
Ecrire "Entrez un nombre : "
Lire n
Si n > 0 Alors
Ecrire "Ce nombre est positif”
Sinon
Ecrire "Ce nombre est négatif"
Finsi
Fin

Exercice 4
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si leur
produit est négatif ou positif (on laisse de côté le cas où le produit est nul). Attention toutefois
: on ne doit pas calculer le produit des deux nombres.
Résolution :
Algorithme : signe_p
Variables m, n : Entier
Début
Ecrire "Entrez deux nombres : "
Lire m, n
Si (m > 0 ET n > 0) OU (m < 0 ET n < 0) Alors
Ecrire "Leur produit est positif"
Sinon
Ecrire "Leur produit est négatif"
Finsi
Fin

Exercice 6
Ecrire un algorithme qui demande trois noms à l’utilisateur et l’informe ensuite s’ils sont

21
rangés ou non dans l’ordre alphabétique.
Résolution :
Algorithme classer
Variables a, b, c : Caractère
Début
Ecrire "Entrez successivement trois noms : "
Lire a, b, c
Si a < b ET b < c Alors
Ecrire "Ces noms sont classés alphabétiquement"
Sinon
Ecrire "Ces noms ne sont pas classés"
Finsi
Fin

Exercice 7
Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce
nombre est positif ou négatif (on inclut cette fois le traitement du cas où le nombre
vaut zéro).
Algorithme : signepnn
Variable n : Entier
Début
Ecrire "Entrez un nombre : "
Lire n
Si n < 0 Alors
Ecrire "Ce nombre est négatif"
SinonSi n = 0 Alors
Ecrire "Ce nombre est nul"
Sinon
Ecrire "Ce nombre est positif"
Finsi
Fin

Exercice 8

22
 ALGORITHME DE BASE

Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si le

produit est négatif ou positif (on inclut cette fois le traitement du cas où le produit peut être
nul). Attention toutefois, on ne doit pas calculer le produit !
Résolution :
Algorithme signesp

Variables m, n : Entier
Début
Ecrire "Entrez deux nombres : "
Lire m, n
Si m = 0 OU n = 0 Alors
Ecrire "Le produit est nul"
SinonSi (m < 0 ET n < 0) OU (m > 0 ET n > 0) Alors
Ecrire "Le produit est positif"
Sinon
Ecrire "Le produit est négatif"
Finsi
Fin

Si on souhaite simplifier l’écriture de la condition lourde du SinonSi, on peut toujours passer

par des variables booléennes intermédiaires. Une astuce de sioux consiste également à
employer un Xor (c'est l'un des rares cas dans lesquels il est pertinent).

Exercice 9
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il l’informe de
sa catégorie :
• "Poussin" de 6 à 7 ans
• "Pupille" de 8 à 9 ans
• "Minime" de 10 à 11 ans
• "Cadet" après 12 ans
Peut-on concevoir plusieurs algorithmes équivalents menant à ce résultat ?
Résolution :
Algorithme : categorie

23
Variable age : Entier
Début
Ecrire "Entrez l’âge de l’enfant : "
Lire age
Si age >= 12 Alors
Ecrire "Catégorie Cadet"
SinonSi age >= 10 Alors
Ecrire "Catégorie Minime"
SinonSi age >= 8 Alors
Ecrire "Catégorie Pupille"
SinonSi age >= 6 Alors
Ecrire "Catégorie Poussin"
Finsi
Fin

On peut évidemment écrire cet algorithme de différentes façons, ne serait-ce qu’en

commençant par la catégorie la plus jeune.
Exercice 10
Formulez un algorithme équivalent à l’algorithme suivant :
Si Tutu > Toto + 4 OU Tata = "OK" Alors
Tutu ← Tutu + 1
Sinon
Tutu ← Tutu – 1
Finsi
Exercice 11
Cet algorithme est destiné à prédire l'avenir, et il doit être infaillible !
Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une minute plus tard.
Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit répondre : "Dans une minute, il
sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la vérifier.
Exercice 12
De même que le précédent, cet algorithme doit demander une heure et en afficher une autre.
Mais cette fois, il doit gérer également les secondes, et afficher l'heure qu'il sera une seconde

24
 ALGORITHME DE BASE

plus tard. Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit répondre :
"Dans une seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : là encore, on suppose que l'utilisateur entre une date valide.
Exercice 13
Un magasin de reprographie facture 0,10 E les dix premières photocopies, 0,09 E les vingt
suivantes et 0,08 E au-delà. Ecrivez un algorithme qui demande à l’utilisateur le nombre de
photocopies effectuées et qui affiche la facture correspondante.
Exercice 14
Les habitants de Zorglub paient l’impôt selon les règles suivantes :
• les hommes de plus de 20 ans paient l’impôt
• les femmes paient l’impôt si elles ont entre 18 et 35 ans
• les autres ne paient pas d’impôt
Le programme demandera donc l’âge et le sexe du Zorglubien, et se prononcera donc ensuite
sur le fait que l’habitant est imposable.

Corrigés des Exercices (10, 11, 12, 13,14)

Exercice 10
Aucune difficulté, il suffit d’appliquer la règle de la transformation du OU en ET vue en cours
(loi de Morgan). Attention toutefois à la rigueur dans la transformation des conditions en leur
contraire...
Si Tutu <= Toto + 4 ET Tata <> "OK" Alors
Tutu ← Tutu – 1
Sinon
Tutu ← Tutu + 1
Finsi

Exercice 11
Algorithme predireavenir
Variable
h, m : entier
Début
Ecrire "Entrez les heures, puis les minutes : "
Lire h, m
m←m+1
Si m = 60 Alors

25
 m←0
h←h+1
FinSi
Si h = 24 Alors
h←0
FinSi
Ecrire "Dans une minute il sera ", h, "heure(s) ", m, "minute(s)"
Fin

Exercice 12
Algorithme predireav
Variables h, m, s : Numérique
Début
Ecrire "Entrez les heures, puis les minutes, puis les secondes : "
Lire h, m, s
s←s+1
Si s = 60 Alors
s←0
m←m+1
FinSi
Si m = 60 Alors
m←0
h←h+1
FinSi
Si h = 24 Alors
h←0
FinSi
Ecrire "Dans une seconde il sera ", h, "h", m, "m et ", s, "s"
Fin

Exercice 13
Algorithme calcul
Variables n, p : Numérique
Début

26
 ALGORITHME DE BASE

Ecrire "Nombre de photocopies : "

Lire n
Si n <= 10 Alors
p ← n * 0,1
SinonSi n <= 30 Alors
p ← 10 * 0,1 + (n – 10) * 0,09
Sinon
p ← 10 * 0,1 + 20 * 0,09 + (n – 30) * 0,08
FinSi
Ecrire "Le prix total est: ", p
Fin

Exercice 14
Algorithme impot
Variable
sex : Caractère
age : Numérique
C1, C2 : Booléen
Début
Ecrire "Entrez le sexe (M/F) : "
Lire sex
Ecrire "Entrez l’âge: "
Lire age
C1 ← sex = "M" ET age > 20
C2 ← sex = "F" ET (age > 18 ET age < 35)
Si C1 ou C2 Alors
Ecrire "Imposable"
Sinon
Ecrire "Non Imposable"
FinSi
Fin

POINTS IMPORTANTS A RETENIR

- Les structures alternatives

27
 - Les structures itératives

CHAPITRE III : LES TABLEAUX

I – Tableau de dimension

Un tableau est un regroupement de variables de même type, il est identique par un nom.
Chacune des variables du tableau est numerotique, ce numéro s'appelle un indice. Chaque
variable du tableau est donc caractérisée par le nom du tableau et son indice.
Si par exemple, T est un tableau de10 variables, alors chacune d'elles sera numérotée et il sera
possible de la retrouver en utilisant simultanément le nom du tableau et l'indice de la variable.
Les différentes variables de T porteront des numéros de 1 à10, et nous appellerons chacune de
ces variables un élément de T.
Une variable n'étant pas un tableau est appelée variable scalaire, un tableau par opposition à
une variable scalaire est une variable non scalaire.
Un tableau est une structure qui rassemble, sous un même nom, un multi-ensemble de do
nnées. Dans la suite, nous supposons que toutes les données enregistrées dans un tableau so
nt homogènes, c’est­à­dire toutes de même type.

Déclaration
Comme les variables d'un tableau doivent être de même type, il convient de préciser ce type
au moment de la déclaration du tableau. De même, on précise lors de la déclaration du tableau
le nombre de variables qu'il contient. La syntaxe est:
<type>: <nom> [<taille>]
Par exemple,
numérique : T[4] déclaré un tableau T contenant 4 variables de type numérique.
On peut aussi le déclarer comme suit :
Tableau <nom> [<taille>]:<type>
Un tableau est défini par sa déclaration.
Cette déclaration précise le nom du tableau, le numéro de la première et de la dernière case
ainsi que le type de données qu’il contiendra.

Autres syntaxes:
Ainsi, pour le tableau de la figure ci-dessus, la déclaration est, par exemple :

variable
v : TABLEAU[ENTIER][1,30]

28
 ALGORITHME DE BASE

Cependant, cette forme n’est pas obligatoire. Ainsi, par exemple, on trouve souvent, c
hez différents auteurs, la notation suivante :

variable
v : TABLEAU[1 .. 30] d’ENTIER
Cette notation imite les déclarations définies en langage PASCAL, par exemple. L’important
est encore que la notation utilisée précise bien les différents éléments de la définition du table
au. D’ailleurs, si ce n’était pas si verbeux, il serait tout aussi légitime d’écrire :

variable
v : tableau de 30 cases numérotées de 1 à 30 et recevant des entiers.
La déclaration précise le nombre de cases en donnant les numéros de la première et
de la dernière case. On peut aussi, par exemple, accepter la convention selon laquelle
le numéro de la première case est toujours 1.

Alors, le nombre de cases du tableau est le numéro de la dernière case et une déclaration de ta
bleau avec ces conventions se simplifie en :

variable
v : tableau[entier][30]
Certaines conventions donnent à la première case du tableau le numéro 0. Dans ce cas, la décl
aration qui précède ne donne plus le numéro de la dernière case, mais le nombre de cases.
Nous admettons qu’un tableau est une structure de données statique
: après déclaration, le tableau ne peut plus être redimensionné pendant « l’exécution
» de l’algorithme. Il est possible, là encore, de faire d’autres conventions et d’admettr
e que le nombre de cases d’un tableau peut évoluer, mais cela semble compliquer un premier
apprentissage.
Comme pour les chaînes de caractères, il est possible de donner à la première case un numéro
entier quelconque. La seule contrainte est que le numéro de la dernière case doit lui être supéri
eur.

Accès aux éléments

Les éléments d'un tableau en éléments sont indices de 1 à n. On note T[i] l'élément d'indice i
du tableau T. Les quatre éléments du tableau de l'exemple ci-avant sont donc notes T[1],
T[2], T[3]et T[4].
Exercice 15
Ecrire un algorithme qui déclare et remplit un tableau de 7 valeurs numériques en les mettant
toutes à zéro.
Exercice 16
Ecrire un algorithme qui déclare et remplit un tableau contenant les six voyelles de l’alphabet
latin.
Exercice 17
Ecrire un algorithme qui déclare un tableau de 9 notes, dont on fait ensuite saisir les valeurs
par l’utilisateur.

29
Exercice 18
Que produit l’algorithme suivant ?
Variable
i : Entier
Tableau Nb[6] : Entier

Début
Pour i ← 0 à 5
Nb[i]← i * i
FinPour
Pour i ← 0 à 5
Ecrire Nb[i]
FinPour
Fin

Peut-on simplifier cet algorithme avec le même résultat ?

Exercice 19
Que produit l’algorithme suivant ?

Variables
i, k : Entier
Tableau N[7] : Entier
Début
N[0] ← 1
Pour k ← 1 à 6
N[k]← N[k-1]+ 2
FinPour
Pour i ← 0 à 6
Ecrire N[i]
FinPour
Fin

Peut-on simplifier cet algorithme avec le même résultat ?

30
 ALGORITHME DE BASE

Exercice 20
Que produit l’algorithme suivant ?
Variable
i :Entier
Tableau Suite[8] :Entier

Début
Suite[0]← 1
Suite[1]← 1
Pour i ← 2 à 7
Suite[i]← Suite[i-1]+ Suite[i-2]
FinPour
Pour i ← 0 à 7
Ecrire Suite[i]
FinPour
Fin

Exercice 21
Ecrivez la fin de l’algorithme 17 afin que le calcul de la moyenne des notes soit effectué
et affiché à l’écran.
Corrigés d’exercices
Exercice 15
Algorithme : initialisation
Variable
i : entier
Tableau Truc[7] : entier

Debut
Pour i ← 0 à 6
Truc[i]← 0
FinPour
Fin

Exercice 16

31
Algorithme : tableau_voyelle
variable
Tableau Truc[6] : Caractère
Debut
Truc[0]← "a"
Truc[1]← "e"
Truc[2]← "i"
Truc[3]← "o"
Truc[4]← "u"
Truc[5]← "y"
Fin

Exercice 17
Algorithme : note
Variable
i : Numérique
Tableau Notes[9] : Numérique
Pour i ← 0 à 8
Ecrire "Entrez la note numéro ", i + 1
Lire Notes[i]
FinPour
Fin

Exercice 18
Cet algorithme remplit un tableau avec six valeurs : 0, 1, 4, 9, 16, 25.
Il les écrit ensuite à l’écran. Simplification :
Algorithme : initialisation
Tableau Nb[6] : Numérique
Variable i : Numérique
Début
Pour i ← 0 à 5
Nb[i] ← i * i
Ecrire Nb[i]
FinPour

32
 ALGORITHME DE BASE

Fin

Exercice 19
Cet algorithme remplit un tableau avec les sept valeurs : 1, 3, 5, 7, 9, 11, 13.
Il les écrit ensuite à l’écran. Simplification :
Variables
i, k : Numérique
Tableau N[7] : Numérique
Début
N[0] ← 1
Ecrire N[0]
Pour k ← 1 à 6
N[k] ← N[k-1] + 2
Ecrire N[k]
FinPour
Fin

Exercice 20
Cet algorithme remplit un tableau de 8 valeurs : 1, 1, 2, 3, 5, 8, 13, 21
Exercice 21
Algorithme : moyenne
Variable
S : Numérique
Tableau Notes [9] :Numérique
Debut
s←0
Pour i ← 0 à 8
Ecrire "Entrez la note n° ", i + 1
Lire Notes[i]
s ← s + Notes[i]
FinPour
Ecrire "Moyenne :", s/9
Fin

33
II. Tableau multidimensionnel

I.1 Déclaration
variable
Tableau <nom> [<taille>] [<taille>]:<type>

I.2 Autres syntaxes

Pour déclarer un tableau composé, on déclare un tableau en précisant d’abord les n
uméros de la première et de la dernière ligne, puis les numéros de la première et de
la dernière colonne. Ainsi, la matrice m ci-dessus est déclarée par :

variable
m : TABLEAU[ENTIER][1,3][1,5]
ou encore :
variable
m : MATRICE[ENTIER][1,3][1,5]
ce qui définit une matrice composée de 3 tableaux simples de 5 composantes chacun, soit une
matrice de 3 lignes et de 5 colonnes. Il est possible de déclarer de même un tableau de matrice
s, une matrice de matrices…

POINTS IMPORTANTS A RETENIR

- Déclaration de tableau à une dimension
- Utilisation de tableau à une dimension
- Déclaration de tableau à plusieurs dimensions
- Utilisation de tableau à plusieurs dimensions

34
 ALGORITHME DE BASE

CHAPITRE IV: SOUS-PROGRAMMES

I- LES PROCEDURES

Il est souvent nécessaire, pour éviter d'écrire plusieurs fois le même code, de préparer des
blocs de code prêts à l'emploi. Une procédure est un ensemble d'instructions. Chaque
procédure à un nom, On se sert de ce nom pour exécuter les instructions contenues dans la
procédure.
Une procédure est donc un sous-programme constitué d’un ensemble d’instruction référencé
par un nom, et donc l’exécution est provoquée par le simple énoncé du nom.
Passage de paramètres
Les variables du programme appelant ne sont pas lisibles depuis un sous-programme. Mais si
une procédure, pour s'exécuter, a besoin de la valeur d'une variable définie dans le programme
appelant, on utilise pour la lui communiquer un mécanisme dit "passage de paramètres".
Procedure afficheVariable (monEntier : entier )
DEBUT
Afficher "La valeur de l'entier passé en paramètre est", monEntier
FIN

La valeur contenue dans la variable monEntier est communiquée au sous-programme lors de

l'appel de la procedure. Par exemple,
AfficheEntier(3) va placer la valeur 3 dans la variable monEntier. Il et aussi possible de passer
en paramètre une valeur contenue dans une variable. Par exemple, celle d'une variable A :
Affiche Entier(A)

La procedure suivante permute les valeurs des deux variables passées en paramètres:
Procedure echange( x,y : entier)
Variable:
numérique: temp
DEBUT
temp<-x
x<-y
y<-temp

35
FIN

On peut appeler cette procédure de la façon suivante:

echange(A,B)

Cependant, l'exécution de ce sous-programme laisse les valeurs de A et B inchangées, car x et

y sont des copies de A et B. Les valeurs des copies sont échangées, mais les originaux ne sont
pas affectés par cette modification. Si l'on veut passer en paramètres non pas les valeurs des
variables, mais les variables elles-mêmes, il faut quelque peu modifier la syntaxe de la
procédure:
procedure echange (x,y : entier )
Variable:
temp: numérique
DEBUT
temp <-x
x<-y
y<-temp
FIN

II. LES FONCTIONS

Une fonction est un sous-programme quelque peu particulier, dans le sens mathématique du
terme, il sert à calculer une valeur (ie. image). Définissons une fonction simple:
Fonction successeur(x: entier) : entier
DEBUT
retourner(x+1);
FIN

Cette fonction "fabrique" le x +1. On dit que cette fonction renvoie(ou retourne) x +1. On
peut appeler cette fonction ainsi:
Afficher x,"+1=", successeur(x)

Une fois la fonction appelée, on remplace successeur(x) par le résultat retournée par la
fonction.

III. LES VARIABLES GLOBALES ET LES VARIABLES LOCALES

1. Variable globale

36
 ALGORITHME DE BASE

Une variable globale est une variable déclarée dans la partie déclarative du programme
principale. Elle peut être utilisée aussi bien dans le corps du programme principal que dans le
corps des sous-programmes.
Sa portée s’étend au programme principal. Cette variable est valable dans tout le programme
principal.
2. Variable locale

Une variable locale est une variable déclarée dans la partie déclarative d’un sous-programme.
Elle est utilisée uniquement dans le sous-programme ou elle a été déclarée et dans d’autres
sous-programme de celle-ci.
Sa portée est limitée au périmètre du sous-programme. Cette variable n’est valable que dans le
sous-programme.

IV. LES PARAMETRES

1. Paramètre effectif

Un paramètre effectif est une variable globale dont la valeur sera effectivement utilisée dans
le sous-programme. Cette valeur est généralement le contenu d’une variable globale ou d’une
variable d’un sous-programme qui appelle un autre sous-programme. Cette valeur est
transmise à un paramètre du sous-programme appelé.
2. Paramètre formel

C’est un paramètre se trouvant entre les parenthèses en face du nom du sous-programme lors
de sa déclaration. Il est muet tout simplement parce qu’il reçoit son contenu d’un paramètre
effectif.
3. Passage de paramètre

3.1.Passage par valeur

Ici c’est la valeur du paramètre effectif qui est affecté directement au paramètre formel (aussi
appelé paramètre muet).
Syntaxe :
 Lors de la déclaration des sous-programmes :

Nom_du_sous-programme( paramètre1 : type, paramètre2 : type,…..paramètren :type) :

type_de_valeur_retournée
NB : Le type de la valeur retournée est précisé uniquement dans le cas des fonctions et
non celui des procédures.
 Lors de l’appel :

Nom_variable<- nom_fonction(argument1,argument2,…….,argumentn)
Ou

37
 nom_procedure(argument1,argument2,…….,argumentn)

3.2.Passage par adresse

Ici, c’est l’adresse du paramètre effectif qui est passée au formel.

Syntaxe :
 Lors de la déclaration des sous-programmes :

Nom_du_sous-programme (paramètre1^ : type, paramètre2^ : type,…..

paramètren^ :type) : type_de_valeur_retournée
NB : Le type de la valeur retournée est précisé uniquement dans le cas des fonctions et
non celui des procédures.
 Lors de l’appel :

Nom_variable<- nom_fonction(@argument1, @argument2,……., @argumentn)

Ou
nom_procedure(@argument1, @argument2,……., @argumentn)

V. RECURSIVITE
La récursivité donne la possibilité de faire figurer dans la d’un objet une référence à ce même
objet. Par exemple, la somme des n premiers entiers peut faire référence à la somme des (n-1)
premiers entiers, en écrivant :
Som(n) = n + Som(n-1) avec Som (1) = 1
Une procédure ou une fonction récursive est un sous-programme qui s’appelle lui-même, et
qui intègre une variable de contrôle permettant d’arrêter le processus d’appel.

POINTS IMPORTANTS A RETENIR

- Déclaration et utilisation de procédure
- Déclaration et utilisation de fonction
- variable globale, variable locale
- Paramètre par valeur, paramètre par adresse
- Récursivité

38
 ALGORITHME DE BASE

CHAPITRE V : TYPE DE DONNEES STRUCTUREES, LES FICHIERS

I. TYPE DE DONNEES STRUCTUREES

I.1 Vecteur ou tableau à une dimension

Un tableau est un ensemble de zones contigües contenant des valeurs de mêmes types.
Chaque zone est repérée et identifiée par un ou plusieurs indices.
I.2 Tableau à plusieurs dimensions
Un tableau à N dimensions est une structure contenant des éléments de mêmes type, dans
laquelle chaque élément est repéré par N indices.
Exemple :
Note[1..30,1..8] : Réel
I.3 Ensembles
Une variable de type ensemble peut prendre pour valeur une , plusieurs ou toutes les valeurs de son
type.
Exemples :
Type
chiffre, pair, impair =Ensemble de 1..9
Acier = Ensemble de (Fer, Chrome, Nickel, Etain)

I.4 Type énuméré

C’est un ensemble de données ordonnées.
C’est un ensemble dans lequel on énumère tous ces éléments dans un ordre donné.
Ce n’est pas véritablement une structure de donnée.
Exmple :
Type
Day=(Lundi, mardi,mercredi,jeudi,vendredi,samedi,dimanche)

I.5 Enregistrement
Une variable de type enregistrement contient plusieurs CHAMPS, de différents types.
Exemple :
Type cuve =Enregistrement

39
numero : Entier
volume : Réel
vide: booléen
Fin enregistrement

II. LES FICHIERS

Un fichier est un ensemble de données. Il peut servir soit à la lecture, pour rentrer des informations
dans un programme, soit à l’écriture pour sauvegarder les résultats obtenus.
Les fichiers sont caractérisés par deux notions :
• le mode d’organisation : comment sont organisées les données dans le fichier (séquentiel, indexé,..) ;
• le mode d’accès : comment sont accédées les données dans le fichier (séquentiel, direct...).
Ces caractéristiques sont étroitement liées aux langages de programmation utilisés. Chacun de ces
derniers offre différents types de fichiers.
En algorithmique, nous nous limiterons par souci de facilité aux fichiers texte et aux fichiers
d’enregistrements.
L’utilisation d’un fichier se fait selon les phases suivantes :
♦ Ouverture du fichier.
♦ Traitement du fichier.
♦ Fermeture du fichier.
II.1 Les fichiers texte
Les fichiers de type Texte sont des fichiers séquentiels (mode d’organisation séquentielle). Les
informations sont disposées de façon séquentielle, les unes à la suite des autres. Elles ne sont ni en
ligne ni en colonne. Elles sont repérées par un pointeur. Leur organisation est séquentielle et leur
accès ne peut être que séquentiel.
Trois opérations sont définies sur ce type de fichiers :
• La lecture : Lors de l’ouverture du fichier, le pointeur pointe sur la 1° information, quel que soit son
type. A chaque accès (Lire), le pointeur se déplace sur l’information suivante, (mode d’accès
séquentiel). Si on veut lire une information en amont du pointeur, il faut fermer le fichier, le rouvrir et
lire jusqu’à l’information désirée.
• L’écriture : un fichier non vide ouvert en écriture perd tout ce qu’il possède. En effet, dès son
ouverture le pointeur est positionné sur la première ligne. Seules les opérations d’écriture sont
autorisées.
• L’ajout : cette opération permet de rajouter de nouvelles données à la fin du fichier sans détruire ce
qu’il y avait auparavant. Le pointeur est positionné sur la marque de fin de fichier qui est décalée
d’une position après chaque rajout.
Exemple :
Variable

40
 ALGORITHME DE BASE

Fich1 : FICHIER texte

Pour i <- 1 à 100 faire
Lire (Fich1, Tab(i))
fin Pour
Les données du fichier Fich1 sont lues et stockées dans la tableau Tab.
Ecrire (Fich1, ‘’Le salaire annuel est de : ‘‘, Sal_Annuel) ;
Ces informations sont stockées dans Fich1 à l’endroit où se trouve le pointeur lors de cette action.
Ajout (Fich1, ‘‘Le salaire annuel est de : ‘‘, Sal_Annuel) ;
Ces informations sont rajoutées à la fin de Fich1 et le pointeur reste sur la marque de fin de fichier.
Il n’y a que la fin du fichier qui est marquée par un symbole repéré par la fonction EOF(Nomfichier),
qui rend la valeur vraie si elle le rencontre, la valeur faux sinon.
Un fichier séquentiel ne peut être ouvert qu’on lecture ou en écriture. Après l’ouverture d’un fichier, la
première opération (Lire, Ecrire ou Ajout) indique si le fichier est accessible en lecture ou en écriture.
Ecrire et Ajout sont des opérations d’écriture, leur seule différence et due au fait que pour Ecrire, le
pointeur se place en début du fichier, alors que pour Ajout, il se place en fin du fichier.
Toute manipulation d’un fichier nécessite 3 phases :
" Ouverture du fichier :
OUVRIR (Nomfichier)
" Traitement du fichier : Lecture ou Ecriture :
LIRE(Nomfichier, ........) ;
ECRIRE(Nomfichier, ........) ;
AJOUT(Nomfichier, ........) ;
" Fermeture du fichier :
FERMER(Nomfichier)
Remarques :
• La fonction EOF(Fich1) permet de tester si le pointeur est sur la fin du fichier Fich1.
• L’utilité des fichiers est la sauvegarde les données.
• Il est préférable d’utiliser Ecrire à la place d’Afficher, quand on utilise les fichiers.

II.2 Les fichiers d’enregistrements

C’est un ensemble d’enregistrements (ou d’articles) de type structuré que l’on déjà défini.
Exemple :

41
Type Etudiant = Enregistrement
Numéro : entier ;
NomPrénom : Chaîne[30]
Discipline : Chaîne[25]
Année_Inscrip : 1950..2000
fin ;
Variable
E1 : Etudiant
Fich_Etudiant : FICHIER de Etudiant ;
E1.Numéro <- 134561 ;
E1.NomPrénom <- ‘’Dupont Lionel’’ ;
E1.Discipline <- ‘’Sciences économiques’’ ;
E1.Année_Inscrip <- 1996
Afficher(Fich_Etudiant, E1) ;
On peut traiter un fichier d’enregistrements de manière séquentielle, mais son intérêt et de permettre
un accès direct aux données.
Lors de l’ouverture d’un tel fichier, le pointeur est positionné sur le premier enregistrement. On peut
se déplacer directement sur n’importe quel enregistrement avant une opération de lecture ou d’écriture
à l’aide de l’action :
Positionner(Fichier, N°enregistrement)
Remarques :
• Contrairement aux fichiers séquentiels, un fichier d’enregistrements peut être ouvert en lecture et en
écriture.
• La taille d’un fichier de ce type est le nombre de ses enregistrements.

POINTS IMPORTANTS A RETENIR

- Type de données structurées
- Les fichiers

42
 ALGORITHME DE BASE

BIBLIOGRAPHIE

 Christophe HARO, Algorithme, raisonner pour concevoir .

 Christophe Darmangeat , Université Paris 7, Algorithme pour les non-matheux ,2008.
 Alexandre Meslé, Algorithmique pour le BTS, 2009.
 Christophe Dabancourt, apprendre à programmer, Edition Eyrolles, 2008.

43