Cours d’Algorithmique 2003/2004

-------------------------------------------------------------------------------------------------------------------------------1
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

I. Définitions:

Un algorithme est une suite d’actions que devra effectuer un ordinateur en un temps fini
pour arriver à un résultat à partir d’une situation donnée.

Un algorithme est une suite finie d’instructions indiquant de façon précise l’ordre dans
lequel doit être effectué un ensemble d’opérations pour obtenir la solution d’un problème.

Pour fonctionner, un algorithme doit donc contenir uniquement des instructions
compréhensibles par celui qui devra l’exécuter.

Exemple :
o Problème : À partir des notes d’un élève dans les différentes matières on veut
calculer la moyenne générale.
o Algorithme :
 Il faut avoir les notes de cette élève de chaque matière.
 Il faut avoir aussi les coefficients de chaque matière.

Matière Note Coef

Arabe 16 2
Français 12 4
…… …. ….
Math 15 6

 Il faut calculer : Note*Coef pour chaque matière.

 Il faut calculer : la somme des Notes*Coef.
 Il faut calculer : la somme des Coef.
 Et en fin il faut calculer : la moyenne=Somme des Notes*Coef/Somme des Coef
NB : Cet Algorithme doit être écrit ensuite par un Langage de Programmation que comprend
l’ordinateur, Exp. : le langage C, C++, Pascal…

II. Méthodologie de Programmation :

Le schéma suivant montre les différentes étapes du processus de programmation :

Problème Analyse
réel

Traduction
Algorithme

Programme Exécution

Résultats

Un algorithme est une suite d’instruction qui une fois exécutées correctement conduit à un résultat
donné. Si l’algorithme est juste, le résultat est le résultat voulu. Si l’algorithme est faux, le résultat est
disons aléatoire.

-------------------------------------------------------------------------------------------------------------------------------2
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

III. Les éléments de Base :

1. Déclaration :
Dans un programme informatique on va avoir en permanence besoin de stocker provisoirement
des valeurs. Ces valeurs peuvent être de différentes types : entiers, réels, caractères chaînes,…
Pour stocker une information dans un programme on utilise un Variable.
1.1. Variable :
C’est un objet dont la valeur est non fixé, il est caractérisé par :
o Sa valeur instantanée.
o Son identité.
o Son type (entier, réel, caractère,…)
Exemples : X en entier, Y en réel, C en caractère, …
1.2. Les constantes :
Une constante est une donnée dont la valeur ne change jamais durant l’exécution du programme.
Exemple : Pi=3,14, M=10, ….
2. Types des variables :
2.1. Les types Numériques :
Les types Numériques caractérisent les valeurs entières ou réels.
 Entier : De manière générale une variable est caractérisée par son nom appelé identificateur
et un contenu représentant une valeur d’un type donnée. Cette dernière peut changer durant
l’exécution du programme.
Une variable est dite entière si elle prend ses valeurs dans Z (ensemble des nombres entiers
relatifs) et qu’elle peut supporter les opérations suivantes :
Adition Notée +
Soustraction Notée -
Multiplication Notée *
Division Notée div
N div p =q : la division entière de n par p donne la partie
entière du quotient q.
Exple :
12 div 3 = 4
13 div 3 = 4
 Réel : Une variable est dite réel si elle prend ses valeurs dans R (ensemble des nombres réels).
Exemple : 2.301 854.06 -632.9
2.2. Les types Alphanumériques :
Le types alphanumérique caractérise les valeurs caractère (notées Car) ou chaîne de caractères
(notées Chaîne)
 Caractère : sa valeur est un caractère quelconque. Un caractère peut appartenir au domaine
des chiffre de ‘0’ à ‘9’, des lettres de ‘A’ à ‘Z’ (majuscules ou minuscules) et des caractères
spéciaux (‘+’ ‘-‘ ‘*’ ‘/’ ‘,’ ‘;’ ‘.‘ ‘(‘ ‘[‘ ‘{‘ ‘%’ ‘$’ ‘&’ ‘#’ …). Un caractère sera toujours noté entre
des apostrophes. Le caractère blanc (espace) s’écrit ‘ ’, le caractère apostrophe ‘’’.
Les opérations qu’on définit sur les données de type caractère sont :
Egal notée =
Différent notée ≠
Supérieur notée >
Supérieur ou égal notée ≥
Inférieur notée <
Inférieur ou égal notée ≤
Les quatre dernières représentent un ordre entre les caractères qui est le suivant :
‘ ‘< ‘0’<‘1’< … <‘9’<’A’<’B’< … <‘Z’<‘a’<‘b’< … <’z’ Cette ordre est déterminée par la codification ASCII
Rq : Les minuscules et les Majuscules sont considérés comme des caractères différents.

-------------------------------------------------------------------------------------------------------------------------------3
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

 Chaîne : sa valeur est une suite finie de caractères quelconques. Ce type n’est pas toujours pré
défini et doit faire l’objet d’un « paramétrage », en fonction de sa longueur (le nombre de
caractères).
Une variable chaîne peut être vide s’elle est de longueur nulle, et sera notée ‘ ‘. Si cette dernière
est = à 1 la variable est considérée aussi comme Car (caractère).
Exemple : ‘Bonjour’ ‘Ceci est un exemple’.
Les opérations définies sur les variables de type Chaîne sont celle des variables de type Car.
ChaîneA<ChaîneB si le mot contenu dans ChaîneA est inférieur à celui de ChaîneB dans le
sens du dictionnaire : (Inférieur : avant, Supérieur : Après).
Exp : ‘BAL’ < ‘BALLES’ < ‘BALLON’ < ‘Bar’ < ‘bar’
De plus, il existe une autre opération définie sur les variables chaîne : Concaténation (notée ||).
Elle crée une nouvelle chaîne en juxtaposant deux ou plusieurs chaînes.
Exp : ‘TELE’ || ‘VISION’ = ‘TELEVISION’
2.3. Les types Logiques :
Une valeur logique (ou booléenne) est l’une des deux valeurs ‘Vrai’ ou ‘Faux’. Elle intervient dans
l’évaluation d’une condition.
Les opérations définies sur les variables de type logique sont la négation, l’intersection et l’union.
• La négation (non) :

Soit A une variable booléenne :

A Non A
Vrai Faux
Faux Vrai
• L’intersection (notée et, .) :
Soit A et B deux variables booléennes :
A B A et B
Vrai Vrai Vrai
Vrai Faux Faux
Faux Vrai Faux
Faux Faux Faux
Remarque :
On peut schématiser cette opération par deux interrupteurs en séries :

L’interrupteur A est ouvert alors A est Faux

L’interrupteur B est Fermé alors B est Vrai.
Donc le courant ne va pas passer alors le résultat de A et B = Faux.
• L’union (notée ou, +) :
Soit A et B deux variables booléennes :
Remarque :
De même dans ce cas on peut schématiser cette opération par A B A ou B
deux interrupteurs en parallèle : Vrai Vrai Vrai
Vrai Faux Vrai
Faux Vrai Vrai
Faux Faux Faux

-------------------------------------------------------------------------------------------------------------------------------4
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

3. L’instruction d’affectation :
L’algorithmiques (tout comme les langages de programmation) utilisent la notion de variable. En
algorithmique, une variable est l’association d’un nom et d’un contenu(type). Ainsi, on pourra appeler
une variable MonEntier et y stocker le chiffre 4. L’action de stocker une valeur dans une variable est
appelée l’affectation. Le symbole utilisé pour l’affectation en algorithmique est l’opérateur :

« J’affecte la valeur 4 à la variable MonEntier » est traduite par : MonEntier 4.

Autre exemple : « j’affecte la valeur 4 à la variable MonPremierEntier, j’affecte la valeur 6 à la variable
MonDeuxièmeEntier et j’affecte le résultat de l’addition des deux variables à une troisième variable
MonTroisièmeEntier » est traduite en algorithmique par :

MonPremierEntier 4
MonDeuxièmeEntier 6
MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier

Après cette opération la variable MonTroisièmeEntier contient la valeur 10.

L’opération comporte trois actions, ces actions sont appelées instructions.
NB : On délimite souvent les instructions par le symbole « ; ». L’exemple précédent devient alors :

MonPremierEntier 4;
MonDeuxièmeEntier 6;
MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier ;

Rq : Dans une instruction d’affectation, on trouve :

• à gauche de la flèche, un nom de variable, et uniquement cela.

• à droite de la flèche, ce qu’on appelle une expression. C’est-à-dire un ensemble de valeurs
liées par des opérateurs, et dont le résultat final est obligatoirement du même type que la
variable située à gauche. Si l’un de ces points n’est pas respecté, la machine sera incapable
d’exécuter l’affectation, et déclenchera une erreur

4.- Les instructions de Lecture et d’Ecriture

Var X,Y,S Entier ;

Début
Lire(X) ; Signifie : Affecter à la variable X la valeur tapée au clavier.
Lire(Y) ; Signifie : Affecter à la variable Y la valeur tapée au clavier.
S X+Y ;
Ecrire(S) ; Signifie : Afficher à l’écran le paramètre S
Fin.
Rq :
Il est assez fortement recommandé d’écrire des libellés à l’écran, afin de prévenir l’utilisateur de ce
qu’il doit frapper
L’exemple précédent devient alors
Var X,Y,S Entier ;
Début
Ecrire(‘’Donnez la valeur de X :’’) ; Afficher a l’écran : Donnez la valeur de valeur de X :
Lire(X) ; X reçoit la valeur tapée au clavier.
Ecrire(‘’Donnez la valeur de Y :’’) ; Afficher a l’écran : Donnez la valeur de valeur de Y :
Lire(Y) ; Y reçoit la valeur tapée au clavier
S X+Y ;
Ecrire(‘’La somme=’’S) ; Afficher a l’écran : La somme=valeur de S
Fin.
-------------------------------------------------------------------------------------------------------------------------------5
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

5.- Les structures alternatives (le test)

Les programmeurs utilisent plus couramment les termes de « test » et de « test à choix multiples »
pour désigner les structures alternatives.
5.1.- Le test
Imaginons que nous voulions écrire l’algorithme formulé ainsi en « français » : définir lequel des
deux chiffres EntierUn et EntierDeux (tapés au clavier) est le plus grand. Nous avons à notre disposition
la notion de variable pour stocker les deux chiffres. La comparaison se traduit par la structure alternative
(le test) suivante :

Si Condition Alors Instruction1 Sinon Instruction2 FinSi ;

L’algorithme de notre problème sera alors :

Var EntierUn, EntierDeux Entier ;

Début
Ecrire(‘’Donnez la valeur de EntierUn :’’) ;
Lire(EntierUn) ;
Ecrire(‘’Donnez la valeur de EntierDeux :’’) ;
Lire(EntierDeux) ;

Si
EntierUn > EntierDeux
Alors
Ecrire(EntierUn,’’ Plus grand que ’’,EntierDeux)
Sinon
Ecrire(EntierDeux,’’ Plus grand que ’’,EntierUn)
FinSi ;
Fin.

Il n’est pas toujours nécessaire d’effectuer un traitement dans la partie Sinon du test. Dans ce cas
le test devient :
Si Condition Alors Instruction FinSi ;

Exercice d’application :
Donnez l’algorithme qui permet d’afficher la valeur absolue d’un entier donné.
Correction :

Var X Entier ;
Début
Ecrire(‘’Donnez la valeur de l’entier à traiter :’’) ;
Lire(X) ;

Si X>= 0 Alors Ecrire(‘’La valeur absolue de ’’,X , ‘’ est ‘’, X)

Sinon Ecrire(‘’La valeur absolue de ’’,X , ‘’ est ‘’, -X)

FinSi ;
Fin.

-------------------------------------------------------------------------------------------------------------------------------6
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Remarques :
Si Condition Alors Instruction1 Sinon Instruction2 FinSi ;

Rq1 (Concernant la Condition):

Exp :

R = A*B ;
Si A < 0 Et B < 0 Alors Ecrire(‘’Le Résultat est positif’’) FinSi ;
Si A = 0 Ou B = 0 Alors Ecrire(‘’Le Résultat est nul’’). FinSi ;
Si (A < 0 Et B < 0) Ou (A > 0 Et B > 0) Alors Ecrire(‘’Le Résultat est positif’’) FinSi ;

Evaluation : (donnez l’instruction afin que le résultat soit négatif)

On remarque donc que la condition pourra êtres décomposée en des sous conditions.

Rq2 (Concernant l’Instruction):

Les Instructions peuvent être simple (une seule instruction) ou composées de plusieurs instruction
dans ce cas on procède comme suit :
Si Condition Alors
Début
Instruction1 ;
Instruction2 ;
…
Instruction n
Fin ;
FinSi ;

5.2.- Le test à choix multiples

Plutôt que d’effectuer plusieurs tests les uns à la suite des autres, il est plus judicieux d’utiliser le
«test à choix multiples» qui permet d’effectuer un traitement en fonction de la valeur d’une variable. Par
exemple, les tests simples et successifs :

Si A = 1 Alors Instruction1 FinSi ;

Si A = 2 Alors Instruction2 FinSi ;
Si A = 5 Alors Instruction3 FinSi ;
Si A = 10 Alors Instruction4 FinSi ;

Peuvent être remplacés par :

Selon A
Cas 1 : Instruction1 ;
Cas 2 : Instuuction2 ;
…
Cas N : Instruction N ;
Différent : Instruction N+1 ;
FinSelon ;

La syntaxe du « test à choix multiples » est plus concise et permet d’effectuer un traitement dans le cas
où la variable à tester (ici « A ») contient tout autre valeur non traitée auparavant ( ).
Exercice d’application :
Donnez l’algorithme qui permet d’écrire en lettre un chiffre de la base 10 tapé sur le clavier. si on
tape par exemple 1 il va nous afficher un si 5 il affiche cinq …
-------------------------------------------------------------------------------------------------------------------------------7
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Correction :
Var Z Entier ;
Début
Ecrire(‘’Donnez la valeur de A :’’) ;
Lire(A) ;

Selon A
Cas 0 : Ecrire(‘’Zéro’’);
Cas 1 : Ecrire(‘’Un’’);
Cas 2 : Ecrire(‘’Deux’’);
Cas 3 : Ecrire(‘’Trois’’);
Cas 4 : Ecrire(‘’Quatre’’);
Cas 5 : Ecrire(‘’Cinq’’);
Cas 6 : Ecrire(‘’Six’’);
Cas 7 : Ecrire(‘’Sept’’);
Cas 8 : Ecrire(‘’Huit’’);
Cas 9 : Ecrire(‘’Neuf’’);
Différent :Ecrire(‘’La valeur tapée n’est pas un chiffre de la base 10’’);
FinSelon ;
Fin.

6.- Les structures répétitives (les boucles)

Les programmeurs utilisent plus couramment le terme de « boucle » pour désigner les structures
répétitives. Une boucle est un ensemble d’instructions exécutées plusieurs fois. On distingue
principalement quatre types de boucle : la boucle « Pour », la boucle « Tant que », la boucle « Jusqu’à
ce que » et la boucle « Sans fin ».
Avant de nous intéresser précisément à la notion de boucle, il est intéressant d’introduire la notion de
tableau.
Un tableau est une variable (il possède donc un nom) pouvant accueillir un nombre fini de valeurs de
même type. La représentation d’un tableau de nom « Tab » de 10 éléments dont chaque valeur est 0,
est la suivante :

Pour affecter une valeur dans un tableau il faut préciser l’emplacement exact dans ce tableau. Le rang
de cet emplacement est appelé l’indice du tableau. Exemple : j’affecte la valeur 5 dans la case d’indice
3 de mon tableau « Tab » (autrement dit au rang 3 du tableau) :

Tab[3] 5;

La représentation des cases du tableau est alors :

La déclaration d’un tableau se fais comme suit :

Tableau NomTableau[1..N] des Types ;

Avec N = Nombre d’éléments(cases) du tableau.

Types : types des valeurs a mettre dans le tableau Entier, réel, car, chaîne,…

-------------------------------------------------------------------------------------------------------------------------------8
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Rq :
La Matrice est un tableau a deux dimensions. Pour designer une case de la matrice il faux
disposer de deux indices i et j ou i désigne la ligne et j désigne la colonne.
La déclaration d’une Matrice se fais comme suit :
Matrice NomMatrice[1..N, 1..M] des Types ;

Avec N = Nombre des ligne et M = Nombre des colonnes.

Exp :
Matrice Mat[1..3,1..4] des entiers ;

14 10 11 07
05 12 08 16
02 09 17 18

La valeur 08 se trouve dans la case Mat[2,3]

La valeur 14 se trouve dans la case Mat[1,1]
La valeur 18 se trouve dans la case Mat[2,4]
6.1.- La boucle « Pour »

Exemple :
Imaginons qu’on veut remplir un tableau (Tab) de 100 cases. Si on ne connaît pas l’existence des
structures répétitives, Notre algorithme comportera 100 lignes et ressemblera à :
Ecrire(‘’ donnez la valeur de la case 1 :’’) ;
Lire(Tab[1]) ;
Ecrire(‘’ donnez la valeur de la case 2 :’’) ;
Lire(Tab[2]) ;
…………..
Ecrire(‘’ donnez la valeur de la case 99 :’’) ;
Lire(Tab[99]) ;
Ecrire(‘’ donnez la valeur de la case 100 :’’) ;
Lire(Tab[100]) ;

L’utilisation de la boucle « Pour » permet d’écrire le même algorithme en seulement une instruction !
La boucle pour utilise un compteur i qui incrémente de 1(la case 1) jusqu'à 100(la case 100) et pour
chaque valeur de i en effectue le traitement voulu « ici c’est lire la valeur de la case i du tableau Tab ».
La syntaxe est la suivante :
Var i entier ;
Tableau Tab[1..100] des entiers;

Début
Pour i=1 jusqu’à 100 faire
Début
Ecrire(‘’ donnez la valeur de la case i :’’) ;
Lire(tab[i]) ;
Fin ;
FinPour ;
Fin.

La variable i (appelée « indice de boucle ») est automatiquement incrémentée de 1 à chaque itération

(c’est le « pas » de la boucle). Les valeurs 1 et 100 sont appelées respectivement « indice de début » et
« indice de fin » de la boucle « Pour ». Comme la variable i prend successivement les valeurs
1,2,3,…,100, la variable Tab[i] prend successivement les valeurs Tab[1], Tab[2], …, Tab[99], Tab[100].

-------------------------------------------------------------------------------------------------------------------------------9
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Remarque : la boucle « Pour » est utilisée lorsque on connaît a priori le nombre de répétitions.

Exercice d’application :
Ecrire l’algorithme qui permet de calculer le factoriel d’un nombre donné : N ! = 1*2*3*…*N-1*N

Exercices à faire hors classe :

Exercice1 : Ecrire l’algorithme qui permet de calculer la somme des éléments d’un tableau, Tab
à 6 cases, des entiers.
Les étapes à suivre sont :
• Saisire les éléments d’un tableau.
• Afficher le tableau.
• Calculer la somme des éléments.
• Afficher la somme.

Exercice2 : Ecrire l’algorithme qui permet :

• De saisire les valeurs d’une matrice Mat à 3 lignes et 4 colonnes.
• D’afficher le contenu de cette matrice.

6.2.- La boucle « Tant que »

La boucle « Tant que » est utilisée quand on ne connaît pas a priori le nombre de répétitions
d’instructions à effectuer. La condition d’arrêt de la boucle est par exemple calculée au sein même de la
boucle. Exemple : on répète les instructions de la boucle tant qu’une variable n’a pas atteint une
certaine valeur.
La syntaxe de Tant que est la suivante :

Tant que (<expression logique>)

Faire <bloc d'instructions>
Ftant ;

RQ :
• Tant que l'<expression logique> fournit la valeur vrai, le <bloc d'instructions> est exécuté.
• Si l'<expression logique> fournit la valeur faux, l'exécution continue avec l'instruction qui suit ftant.
• Le <bloc d'instructions> est exécuté zéro ou plusieurs fois.

Exemple :
L’algorithme qui permet d’afficher les nombres de 0 à 9 :

Var i Entier;

Début
i 0;

Tant que (i<10) Faire

Début
Ecrire(i) ;
i i+1;
Fin ;
Ftant ;
Fin.

-------------------------------------------------------------------------------------------------------------------------------
10
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

6.3.- La boucle « Jusqu’à ce que »

Le principe est le même que celui de la boucle «Tant que» à savoir qu’on ne connaît pas le
nombre de répétitions à effectuer. La seule différence est que dans le cas de la boucle « Jusqu’à ce
que » on passe toujours au moins une fois dans la boucle quelque soit la condition d’arrêt.
La boucle « Jusqu’à ce que » à la forme générale suivante :

Répéter
Instruction1 ;
Instruction2 ;
……….
Instruction n ;
Jusqu’à « la condition d’arrêt »

L’exécution de cette boucle « jusqu’à » consiste à répéter l’exécution séquentielle de la séquence

d’instructions : instruction1, instruction2,…, instruction n ; entre Répéter et Jusqu’à, jusqu’à ce que la
condition d’arrêt se réalise.

Exemple :
Considérant l’exemple vu précédemment qui permet d’afficher les nombres de 0 à 9 dans lequel on a
utilisé la boucle tant que. Dans le même exemple on peut utiliser la boucle Jusqu’à ce que.

Var i Entier;

Début
i 0;

Répéter
Ecrire(i) ;
i i+1;
Jusqu’à ce que i=10 ;
Fin.

6.4.- La boucle « Sans fin »

Il s’agit d’une boucle dont les instructions se répètent à l’infini. On peut sortir d’une telle boucle par
une instruction de débranchement effectuée par exemple à l’issue d’un test. Attention : l’oubli d’une
instruction de débranchement dans une telle boucle génère un programme qui ne s’arrête pas !

TD Série N 1

-------------------------------------------------------------------------------------------------------------------------------
11
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

7. Les modules
7.1. Définition
Lorsqu’un certain nombre d’instructions est susceptible de se répéter dans le code source d’un programme, il
est préférable de regrouper ces instructions dans un module hors du programme principal.
Il y a trois raisons principales justifiant l’utilisation des modules :
• gain important en nombre de lignes de code ;
• les modules écrits et testés peuvent être réutilisés par la suite dans d’autres modules voire dans d’autres
programmes ;
• fiabilité accrue : en cas de modification du code d’un module, les changements ont lieu à un seul endroit ce
qui minimise les erreurs de frappe et de report.

Début du prog Début Affichage

Instruction1 ; On regroupe ces 3 instructions Instruction1 ;
Instruction2 ; dans une procédure exp : affichage Instruction2 ;
Instruction3 ; Instruction3 ;
Fin Affichage ;
Instruction4 ;
Instruction5 ; Début du Prog
Dans le nouveau programme en Affichage ;
Instruction1 ; appel la procédure affichage
Instruction2 ; Instruction4 ;
Instruction3 ; Instruction5 ;

Instruction6 ; En cas de modification de Affichage ;

Instruction7 ; l’algorithme d’affichage, on
Instruction6 ;
effectue le changement du code
Instruction1 ; Instruction7 ;
uniquement dans la procédure
Instruction2 ; Affichage et non autant de fois Affichage ;
Instruction3 ; qu’apparaissent les instructions
Fin de prog. Fin du prog
dans le programme.

Remarque : des modules peuvent appeler d’autres modules.

7.2. Procédure et fonction
7.2.1. La différence fondamentale
On distingue principalement deux types de modules : les procédures et les fonctions. La différence entre les
deux est qu’une fonction effectue un traitement et renvoie un résultat alors que la procédure effectue un traitement
mais ne renvoie aucune valeur. Le calcul de la somme d’un tableau est typiquement une fonction alors que
l’affichage des valeurs d’un tableau à l’écran est une procédure.

7.2.2. Exemple d’utilisation d’une procédure :

L’exemple suivant consiste tous simplement à réécrire l’algorithme solution de l’exercice N°2 de TD1
concernant la matrice : saisie, affichage, somme des éléments, inverser les éléments et affichage. Alors l’affichage
se répète deux fois donc on peut utiliser la procédure affichage :

« Dorénavant tout nos exemples seront implantés en Pascal »

-------------------------------------------------------------------------------------------------------------------------------
12
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Le programme qui permet de remplir une matrice de 3 lignes et de 4 colonnes, d’afficher cette matrice
de calculer la somme de ses éléments et d’inverser ses valeurs.

Program Matrice ;
Var i, j, S : Integer ;
Mat : array[1..3,1..4] of Integer ;

Procedure affichage;
Begin (* Début de la procédure*)
For i :=1 to 3 do
Begin Définition de la
For j :=1 to 4 do procédure Affichage
Write (Mat[i,j]) ;
Writeln ;
End ;

End ; (*Fin de la procédure*)

Begin (* Début du programme principale*)

For i :=1 to 3 do
For j :=1 to 4 do
Begin
Write (donnez la valeur de Mat[‘,i,’,’,j,’]’) ; Saisie
Read (Mat[i,j]) ;
End ;

Affichage ; (*appel a la procédure Affichage*)

S :=0 ; (* Initialisation de S *)
For i :=1 to 3 do
For j :=1 to 4 do
S := S+Mat[i,j] ; Somme d’éléments
Write (‘la somme =’, S) ;

For i :=1 to 3 do
For j :=1 to 4 do Inverser les éléments
Mat[i,j]:= -Mat[i,j] ;

Affichage ; (*appel a la procédure Affichage*)

End . (* Fin de programme principale*)

NB : on peut aussi refaire cette exemple en n’utilisant que les modules : procédures : saisie, affichage, inverser et
la fonction Somme_elements qui renvoi la valeur : somme des éléments de la matrice. Dans le programme
principal on a qu’à appeler ces modules :

Begin
Saisie ;
Affichage ; C’est le programme principal après la
Write (‘la somme = ‘, Somme_elements) ; déclaration de ces modules et des
Inverser ; variables utilisées dans l’algorithme
Affichage ; (Variables Globales)
End.

-------------------------------------------------------------------------------------------------------------------------------
13
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

7.2.3. Procédures :

Procédures sans paramètres :
Les déclarations de procédure figurent après les déclarations des variable globales (globale : peut être
utilisée dans tout le programme au contraire de locale qui est utilisée juste dans le module ou elle est
déclarée) Pour déclarer ces types de procédure en procède comme suit :
Procedure <Nom_de_la_procedure> ;
Var <Déclaration des variables Locales>
Begin
<Corps de la procédure : le bloc d’instruction>
End ;
On appel donc la procédure au moyen de son nom une ou plusieurs fois dans le programme pour
exécuter le groupe d’instruction regroupé dans cette procédure.
o Exemple : Considérant l’algorithme suivant qui permet du permuter les valeurs de X et Y :

Program permute ;
Var X, Y : Integer ;
Procedure Permuter ;
Var T : Integer ;
Begin
T :=X ; X :=Y ; Y :=T ;
End ;
Begin
Write (‘donnez la valeur de X : ‘) ; Read (X) ;
Write (‘donnez la valeur de Y : ‘) ; Read (Y) ;
Permuter ; (* l’appel a la procédure Permuter *)
Write (‘X= ‘, X, ‘ Y= ‘, Y) ;
End.
Rq : La variable T est déclaré comme variable locale à la procédure, on peut la déclarer comme variable
globale mais c’est une meilleure utilisation de la mémoire de l’ordinateur puisque les objets locaux à la
procédure n’existeront en mémoire que pendant l’exécution du corps de la procédure et non pendant
l’exécution de tout le programme.

Procédures avec paramètres :

L’usage de paramètres ajoute un degré de liberté supplémentaire en permettant, à chaque appel, de
faire porter l’action du corps de la procédure sur des valeurs et des variables différentes.
Par exemple l’usage de deux paramètres formels U et V dans la procédure « comparaison » suivante,
permet de comparer deux variables entières quelconques :

Procedure Comparaison (U, V : Integer) ; U et V s’appellent les paramètres

Begin formels de la procédure
If U >= V Then Write (U,’ est supérieur ou égal à ‘, V)
Comparaison.
Else Write (U,’ est Inférieur à ‘, V) ;
End ;
On peut donc appeler notre procédure par des variables entières quelconques.
Comparaison(X, Y) ;
Comparaison (T [i], T [i+1]) ;
Comparaison (A, B) ;

-------------------------------------------------------------------------------------------------------------------------------
14
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Passage de paramètres par valeur et par variables :

Nous utiliserons deux modes de passage de paramètres : passage par valeur et passage par variable.
On détermine le mode de passage d‘un paramètre effectif en consultant le paramètre formel correspondant.
Il s’agit d’un passage de paramètre par valeur si le paramètre formel n’est pas procédé par Var. Dans le cas
d’un passage par variable, le paramètre formel est procédé par Var.

NB !! :
• Dans le cas du passage de paramètre par valeur, la valeur de paramètre effectif est affectée au
paramètre formel. Toute modification du paramètre formel est sans conséquence sur le
paramètre effectif.
• Dans le cas du passage de paramètre par variable, Le paramètre formel fait référence au paramètre
effectif. Toute modification du paramètre formel est donc faite sur le paramètre effectif.
Exemple illustratif :
Considérant l’exemple suivant d’une procédure qui permet de permuter deux variables :

Passage par valeur Passage par variable

Procedure Permuter(A,B:Integer); Procedure Permuter(Var A,B:Integer);

Var T : Integer ; Var T : Integer ;
Begin Begin
T := A ; T:= A;
A := B ; A:= B;
B := T ; B:= T;
End ; End;
--------------------------------- ---------------------------------
Supposant que X=5 et Y=10 Supposant que X=5 et Y=10
Alors le résultat de : Alors le résultat de :
Permuter(X,Y) Permuter(X,Y)
Est : X=5 et Y=10 (pas de changement) Est : X=10 et Y=5 (Il y a le changement)

Exercice d’application :
Donner en pascale le programme qui permet de trier un tableau des chaînes de caractère. Utilisez les
procédures suivantes : Saisie, affichage, Triage, et sans entendu Permuter(Var A,B : String).
Solution :
Program Trie_Tableau;
Const M=5;
Var Tab: Array[1..M] of String;
{*+++++++++++++++++++++++Procédure Saisie++++++++++++++++++++*}
Procedure Saisie;
var i :integer;
begin
for i:=1 to M do
begin
write('Donnez la valeur de Tab[',i,']: ');
readln(Tab[i]);
end;
end;
{*+++++++++++++++++++++++Procédure Affichage ++++++++++++++++++++*}
Procedure Affichage;
var i :integer;
begin
for i:=1 to M do write(Tab[i],' | ');
end;

{*+++++++++++++++++++++++Procédure Permutation ++++++++++++++++++++*}

Procedure Permuter(var a,b :String);
var t: String;
-------------------------------------------------------------------------------------------------------------------------------
15
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

begin
t:=a; a:=b; b:=t;
end;
{*+++++++++++++++++++++++Procédure Triage ++++++++++++++++++++*}
Procedure Trie;
var i,j:integer;
begin
for i:=1 to M-1 do
for j:=i+1 to M do
if Tab[i]>Tab[j] then permuter(Tab[i],Tab[j]);
end;
{*+++++++++++++++++++++++Programme principal ++++++++++++++++++++*}
Begin
Saisie;
Affichage;
Trie;
writeln;
Affichage;
readln;
End.

7.2.4. Les Fonctions :

La procédure a un effet tandis que la fonction a une valeur à retourner.
Un appel de procédure peut être considéré comme une instruction alors qu’un appel d’une fonction peut être
considéré comme un facteur, cela signifie que des expressions peuvent contenir des appels des fonctions. Exp. :
Z :=3X-Somme(A,B) ; avec Somme est une fonction qui retourne la somme des deux entiers.

La syntaxe de la déclaration d’une fonction :

Function Nom_de_la_fonction(<liste des paramètres formels>) : Type de résulta;
Var <Déclaration des variables Locales>
Begin
< Corps de la fonction
Nom_de_la_fonction := La valeur retournée par la fonction >
End ;

Remarque :
Dans les fonctions on n’utilise pas le passage des valeurs par variable car l’objet d’une fonction est de
calculer une valeur et non pas de modifier la valeur des variables. Donc on n’utilise que le passage par valeur dans
des fonctions.

Exercices d’application :
Réécrivez les programmes suivant en utilisant des fonctions :
1. Programme qui permet de faire la somme des deux entiers.
2. Programme qui permet de calculer le factoriel d’un entier donné.
3. Programme qui permet de calculer le PGCD de deux entiers.

-------------------------------------------------------------------------------------------------------------------------------
16
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

8. La récursivité :
8.1. Définition :
Un objet est dit récursif s’il est défini en fonction de lui-même.
Exemple :
P ! = P * (P-1) !
Fact(P) = P * Fact(P-1)
Pour comprendre la récursivité en va traiter le problème du factoriel en utilisant les deux méthodes : (Avec et sans
utilisé la récursivité).
Programme avec la fonction Fact itérative
Program Factoriel;
Var N , X : Integer;
(* ------------------Fonction Factoriel---------------------*)
Function fact(P :integer): integer;
Var i, F : integer;
begin
F:=1;
if P=0 then fact:=1
else
for i:=1 to P do
F:=F*i;
fact:=F;
end;
(* ------------------Programme Principal--------------------*)

Begin
repeat
Write('donnez N : ');
Read (N);
Write ('le Factoriel de ',N,' = ', Fact(N)); writeln;
Write ('Voulez vous continuer O/1: ');
readln(X);
Until X=1;
End.
Pour utiliser la récursivité on va changer les instructions de la fonction fact par les instructions suivantes :
La fonction fact récursive
Function fact(P :integer): integer;
Var i : integer;
begin
if P = 0 then fact:=1
else
Fact:= P * Fact(P-1);
End;
8.2 Exercice d’application :
Utiliser la récursivité pour réaliser les programmes suivants en utilisant :
• Pg1 : le programme du PGCD
• Pg2 : le programme qui permet de chercher une valeur dans un tableau trié : il retourne l’indice de la case ou
la valeur se trouve ou 0 si la valeur n’appartient pas au tableau.
Exemple :
123 201 254 300 301

Si la valeur a chercher est 300 alors le message suivant va s’afficher lors du l’exécution du programme :
« 300 se trouve dans la case 4 »
Si la valeur est 250, ou 600 ou une autre valeur qui n’appartient pas au tableau alors le message est :
« Cette valeur se trouve dans la case 0 »
8.3 Solution Voir Annexe 1.

-------------------------------------------------------------------------------------------------------------------------------
17
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

9. Les Chaînes de caractères :

Les Chaînes de caractères peuvent être manipulées comme les tableaux de caractères de 0 à 255
éléments au maximum.
9.1. Déclaration :
Type Str20= String [20] ;

Var Ch1, Ch2, Ch3 : Str20 ;

9.2. Manipulation des chaînes :

Affectation :
Ch1 := ‘Bonjours’ ;
Ch1 := Ch2 ;

Comparaison :
Ahmed < Fatima
If (nom> ‘ Pière ’ )

Des Fonctions sur les Chaînes de caractères :
a. Concat :
Ch1 := ‘ Bonjours ’ ;
Ch2 := ‘ Tous le monde ’ ;
Ch :=Concat (Ch1, Ch2) ;
Le résulta donc dans Ch est la concaténation des deux chaînes Ch1 et Ch2 : ‘ Bonjours Tous le
monde ’
b. Copy :
Ch1 :=’ Ceci est trop long ’ ;
Ch2 := Copy (Ch,1,14) ;
Le résulta donc dans Ch2 est la copie de 14 caractères à partir de la position 1 dans la chaîne Ch1 :
‘Ceci est trop ’
c. Delet :
Ch := ‘ Voici un bon exemple ‘ ;
Delet (Ch, 10,4) ;
Cette fonction va supprimer dans la chaîne Ch, 4 caractères à partir dixième : ‘ Voici un
exemple ’
d. Insert :
Cette fonction insert Ch1 dans Ch2 à partir de la position P.
Ch1 := ‘bon ‘ ;
Ch2 :=’ Voici un exemple’ ;
Insert (Ch1, Ch2, 10) ;
Donc dans Ch2 on va trouver : ‘ Voici un bon exemple’
e. Length :
Length est une fonction qui permet de donner la longueur d’une chaîne de caractère
Ch
Ch :=’Voiture’
X :=Length
Length (Ch) ;
Write(X) ; X=7
f. Pos:
C’est une fonction qui donne la position d’une sous chaîne (Sch) dans une chaîne
(Ch).
Ch :=’Voici un bon exemple’ ;
Sch :=’bon’ ;
X :=Pos (Sch, Ch) ;
Write(X) ; X = 10
g. Str:
C’est une fonction qui permet de convertir un nombre en une chaîne de caractère
qu’elle place dans une chaîne Ch.
Nombre :=41253 ;
Str (Nombre,Ch) ;
Write (Ch) ; Ch= ‘41253’
-------------------------------------------------------------------------------------------------------------------------------
18
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

h. Val :
C’est une fonction qui permet de convertir une Chaîne de caractère on une valeur
numérique
Ch :=’111235’ ; Ch :=’11A235’ ;
Val (Ch, Nombre, Code) ; Val (Ch, Nombre, Code) ;

Nombre=111235 et Code=0 donc la Nombre=0 et Code=3 c’est la position ou un

conversion est faite caractère se trouve donc pas de conversion

Exercice d’application :
Donnez le programme pascal qui nous demande notre Nom, Prénom et CIN et qui nous affiche :

le nom complet

La longueur de notre nom complet

La chaîne résultat de la copie dans la chaîne CIN a partir de la position 4, 6 caractères et qui
convertie cette chaîne en une donnée Numérique et qui affiche ce nombre si la conversion est
faite sinon affiche un message comme quoi la conversion n’est pas faite.
Solution :
Voir Annexe 2.
10. Les enregistrements (ou Structures) :
1. Introduction:
Introduction:
Nous avons déjà vu comment le tableau permet de désigner sous un seul nom un ensemble de
valeur de même type, chacune d’entre elles est repéré par un indice.
La structure (l’enregistrement) quant à elle va permettre de désigner sous un seul nom un ensemble de
valeur pouvant être de types différents.
2. Déclaration d’un enregistrement :
Type Enreg = Record
Champ1 : Type1 ;
Chapm2 : Type2 ;
….
Champ n : Type n ;
End ;
Exemple :
Type Eleve=Record
CNE : Integer ;
Nom : String[10] ;
Prénom : String[10] ;
End ;

Matiere=record
CodeMat : Integer ;
Libelle : String[15] ;
Coef : Integer ;
End ;
3. Déclaration d’une variable :
Var El1, El2, El3 : Eleve;
Mat1, Mat2, Mat3 : Matiere;
4. Accès à un champ :

L’accès à un champ d’un enregistrement se fait par : Variable_Enregistrement.Champ

Exemple :
Pour lire les infirmations concernant l’élève El1:

-------------------------------------------------------------------------------------------------------------------------------
19
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Read ([Link]) ;
Read ([Link]) ;
Read ([Link]) ;
5. L’instruction With :
L'instruction WITH permet de simplifier les références aux champs des enregistrements.
Syntax :
WITH variable DO
Begin
Instruction1;
Instruction2;
…..... ;
Instructionn;
End;
A la suite de DO, l'instruction peut référencer les champs d'un ou plusieurs variables de type
enregistrement sans devoir mentionner l'identificateur de l'enregistrement propriétaire.
Exemple :
With El1 do
Begin
Writeln (‘donnez le CNE : ‘) ;
Readln (CNE) ;
Writeln (‘donnez le Nom : ‘) ;
Readln (Nom) ;
Writeln (‘donnez le Prénom : ‘) ;
Readln (Prenom) ;
End ;
6. Exercice d’application:
Donnez en Pascal le programme permettant de lire 3 étudiants chacun a un code, Nom, Prénom et
un tableau de 3 cases entière nommé Notes ou elles sont stockées ses notes. Le programme affichera
les informations sur tous les étudiants : Codes, Noms, Prénoms, leurs Notes et leurs Moyennes.
Exemple :
==================================================================
Code Nom Prénom Note1 Note2 Note3 Moyenne
--------------------------------------------------------------------------------------------------------------------
100 Elkhalki Souad 10 14 12 12
101 Erradi Amin 11 14 08 11
102 Fezazi Jawad 12 16 14 14
--------------------------------------------------------------------------------------------------------------------
Solution :
Voir Annexe 3

FIN

-------------------------------------------------------------------------------------------------------------------------------
20
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

-------------------------------------------------------------------------------------------------------------------------------
21
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Annexe 1

1. le programme du PGCD (Récursif)

Program plus_grand_div_com;
Var x,y : integer;
(*--------------FONCTION PGCD---------------*)
Function PGCD(u,v : integer):integer;
Begin
if u=v then pgcd:=u
else
if u>v then pgcd:=pgcd(u-v,v)
else pgcd:=pgcd(u,v-u);
End;
(*-------------PROGRAMME PRINCIPALE------------*)
BEGIN
repeat
write(' donner x: ');
read(x);
write(' donner y: ');
read(y);
until ( (x>0) and (y>0));
writeln('le PGCD = ',PGCD(x,y));
readln;
readln;
END.

2. le programme Chercher une valeur dans un tableau trié (Récursif)

Program Trie_Tableau;
const M=4;
Var Tab: Array[1..M] of integer;
X,i: integer;
label 1;
{++++++++++++++++++++++++++++Proc Saisie++++++++++++++++++++++++}
Procedure Saisie;
var i :integer;
begin
for i:=1 to M do
begin
write('Donnez la valeur de Tab[',i,']: ');
readln(Tab[i]);
end;
end;
{+++++++++++++++++++++++Proc Affichage+++++++++++++++++++++++++}
Procedure Affichage;
var i :integer;
begin
for i:=1 to M do
write(Tab[i],' | ');

-------------------------------------------------------------------------------------------------------------------------------
22
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

end;
{+++++++++++++++++++++++Proc Parmutation+++++++++++++++++++++++++}
Procedure Permuter(var a,b :integer);
var t: integer;
begin
t:=a;
a:=b;
b:=t;
end;
{+++++++++++++++++++++++Proc Triage+++++++++++++++++++++++++++++++}
Procedure Trie;
var i,j:integer;
begin
for i:=1 to M-1 do
for j:=i+1 to M do
if Tab[i]>Tab[j] then permuter(Tab[i],Tab[j]);
end;
(*++++++++++++++++++++++Fonction chercher elemt++++++++++++++++++*)
Function recherche(debut, fin, elmt :integer): integer;
Var k: integer;
Begin
if Tab[debut]=elmt then recherche:=debut;
if Tab[fin]=elmt then recherche:=fin
else
begin
k:=(debut+fin) div 2;
if debut<=fin then
if Tab[k]=elmt then recherche:=k
else
if tab[k]<elmt then
recherche:=recherche(k+1,fin,elmt)
else
recherche:=recherche(debut,k-1,elmt)
else
recherche:=0;
end;
End;
(*+++++++++++++++++++++++PROGRAMME PRINCIPAL++++++++++++++++++++*)
Begin
Saisie;
writeln;
writeln ('le tableau qui n est pas trier: ');
Affichage;
Trie;
writeln;writeln;
writeln ('le tableau tri‚: ');
Affichage;
write(' donnez la valeur a chercher: ' );read(X);
write (X,' Se trouve dans la case: ',recherche(1,M,X));
readln;readln;
End.

-------------------------------------------------------------------------------------------------------------------------------
23
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

Annexe 2

1. le programme MonNom (Manipulation des Chaînes des caractères)

Program Mon_Nom;
Type Str20=String[20];
Var Nom, Prenom, CIN, NC, Ch : Str20;
Lgnc, CCIN,c : Integer;

Begin

Write('donnez votre Nom: ' ); Readln(Nom);

Write('donnez votre Prénom: ' ); Readln(Prenom);
Write('donnez votre CIN: ' ); Readln(CIN);
NC:=Concat(Nom,Prenom); (* NC: Nom Complet *)
Lgnc:=Length(Nc); (* Lgnc : Longueur du Nom Complet)
Writeln('Nom Complet est: ', NC);
Writeln('La longueur de Nom Complet est: ',Lgnc);
Ch:=Copy(CIN,4,2);
Writeln('Résultat de la copie: ',Ch);
Val(Ch,CCIN,C);
If C=0 then Writeln('la conversion est faite:', CCIN)
else Writeln('la conversion n est pas faite car un caractère se
trouve dans la position: ',C);
Readln;
Readln;
End.

Annexe 3
1. le programme

Program Eleve_Note;
uses crt; (* Pour pouvoir utiliser la fonction Clrscr qui efface
l’écran *)
type eleve=record
code:integer;
nom: string[10];
prenom:string[10];
Note:array[1..3]of integer;
end;
var T:array[1..3] of eleve;
i,j,S : integer;
BEGIN
Clrscr; (* La fonction Clrscr qui efface l’écran *)
(*-----------------Saisie----------------*)
for i:=1 to 3 do
begin
with T[i] do
Begin
-------------------------------------------------------------------------------------------------------------------------------
24
Cours Préparé par Prof d’Info [Link] [Link]
Cours d’Algorithmique 2003/2004

write('donnez le code de l''eleve: '); readln(code);

write('donnez le nom de l''eleve: '); readln(nom);
write('donnez le prénom de l''eleve: '); readln(prenom);
for j:=1 to 3 do
begin
write('donnez la note ',j,' : ');
read(note[j]);
end;
End;
end;
(*-----------------Affichage----------------*)
Writeln('========================================================');
Writeln('Code Nom Prénom Note1 Note2 Note3 Moy');
Writeln('--------------------------------------------------------');
for i:=1 to 3 do
begin
S:=0;
with T[i] do
Begin
write(code);
write(nom:10);
write(prenom:10);
for j:=1 to 3 do
begin
S:=S+Note[j];
write(Note[j]:10);
end;
write(S div 3:10);
writeln;
End;
end;
Writeln('---------------------------------------------------------);
readln;readln;
end.

-------------------------------------------------------------------------------------------------------------------------------
25
Cours Préparé par Prof d’Info [Link] [Link]