I.

Algorithmique
I.1. Introduction : Pour résoudre un problème sur ordinateur, on suit généralement les étapes
suivantes:
- Cerner le problème à traiter ; On doit définir toutes les données avec leur nature ainsi que les
résultats auxquels on s’attende avec les précisions souhaitées.
- Formuler la résolution du problème sous forme d’une succession logique d’instructions
pour passer des données aux résultats. (ALGORITHME).
- Pour bien schématiser le problème, on dresse un équivalent graphique de l’algorithme
(ORGANIGRAMME).
- Ensuite on réécrit l’algorithme dans un langage évolué (PROGRAMMATION).
- On compile le programme en question (COMPILATION).
- Une fois le programme est compilé, on l’exécute, puis on vérifie si les résultats correspondent
bien aux solutions du problème.
I.2 Algorithmes

I.2.1 Définition
L’algorithme est une succession de règles opératoires propres à un calcul donné. L’application de
ces règles permet de résoudre un problème particulier. L’algorithme consiste à bien analyser le
problème avant de commencer à programmer.

I.2.2 Caractéristiques d’un algorithme :

L’algorithme doit être très clair, formé d’une combinaison d’opérations élémentaires permettant de
fournir un résultat après un nombre fini d’opérations.

I.2.3 Structure générale d’un algorithme :

Elle est composée de trois parties principales : l’entête, les déclarations, les actions.
Un algorithme correctement écrit, respecte la structure générale suivante :

Algorithme… Nom de l’algorithme ………………….…. partie (1) : entête

Variables ….déclaration de toutes les variables ………..partie (2) : déclarations
Constantes …déclaration des constantes (s’il y a lieu)

Début
…………
………… insertion de toutes les instructions entre « Début » et « Fin » …… partie (3) : Actions
…………

Fin

L’entête : L’entête contient le titre qu’on souhaite donner à l’algorithme. (la partie (1) de la structure
précédente).

1
I.2.4 Les déclarations :
Dans la partie déclaration (la partie 2), on doit déclarer tous les objets que l’on souhaite utiliser
dans la partie Actions (partie 3 de l’algorithme).
L’objet : c’est un symbole ou un identificateur (variables constante…etc.) qu’on déclare avant sa manipulation.

I.2.4.1 La constante :
C’est un symbole ou un identificateur dont la valeur est introduite lors de la programmation.
Celle-ci ne peux pas changer pendant l’exécution du programme. Exemple : Pi= 3.14

I.2.4.2 Le type :

Un type est un ensemble de valeurs que peut prendre une donnée. On distingue :

- Types standards : entier, réel, booléen, caractère.

- Types non-standards :

1. Enuméré : 1. Intervalle :
Syntaxe : type identificateur = (id1, id2,…,idn) Syntaxe : type identificateur = inf….sup
Exemple : type couleur = (jaune, vert, rouge,…) Exemple : type décimal = 0 . . 9
Remarque : le mot type doit être écrit une seule fois. Remarque : pas de type intervalle issu du type réel.

I.2.4.3 La variable :
C’est un symbole ou un identificateur dont la valeur est susceptible de changer au cours de
l’exécution du programme. Le type de variable doit être choisi d’une manière très appropriée. Il y a
plusieurs types de variables numérique (entier, réel…etc.), logique, chaîne de caractères, tableau,..

I.2.5 Les actions ou instructions :

La partie instruction est la partie corps du programme ((3) dans l’exemple ci-dessus) où sont
écrites les instructions nécessaires pour arriver au résultat. Toute manipulation sur les objets est appelée
action.

I.2.5.1 Lecture :
La donnée : c’est une valeur introduite par l’utilisateur pendant l’exécution du programme. Elle
peut être lue itérativement ou issue d’un fichier.
Syntaxe : LIRE (a,b) est équivalent LIRE a, LIRE b, ça voudrait dire que l’utilisateur fait entrer à la
machine la valeur de a puis celle de b.

I.2.5.2 Ecriture :
L’instruction d’écriture est couramment utilisée dans deux situations :
- pour afficher les résultats de l’exécution,
- avant la lecture des données.
Syntaxe : ECRIRE (’la valeur de x est :’, -b/a)

I.2.5.3 Affectation : C’est une instruction qui consiste à attribuer une valeur à une variable pendant
l’exécution du programme. La variable peut changer de valeur dans le même programme.
Exemples :
1) A  1, B  A+1, A  3, B  A+4, après exécution A3 et B7
2) L’incrémentation : I I+1 ( I est augmenté de 1)
2
I.2.5.4 Structures conditionnelles :
Avant d’exposer les structures conditionnelles on essaye de donner les différents opérateurs de
comparaison utilisés:
- Expressions et opérateurs : un opérateur relie entre deux valeurs pour produire un résultat.
L’expression est un ensemble de valeurs reliées par des opérateurs et qui est équivalente à une
seule valeur.
a) Opérateurs numériques : +, -, *, /, div., mod. L’ordre des opérations est important, la
priorité revient aux opérateurs / , *, div, et mod.1
Exemple : 4*3+2=(4*3)+2 et non à 4*(3+2).
b) Les opérateurs alphanumériques :
Cet opérateur agglomère deux chaînes de caractère
c) Opérateurs logiques : ET, OU, NON, et XOR.
d) Opérateur de comparaison :
Egal: = , Différent: < >, Egal ou plus grand : = >, Egal ou plus petit =<,
plus grand : >, plus petit : <

- Sélection simple :
Si (condition) Alors (instruction1)
Sinon (instruction2)
Finsi
- Tests imbriqués :
Si (condition 1) Alors (instruction 1 )
Sinon Si (condition 2) Alors (instruction 2)
Sinon Si (condition 3) Alors (instruction3 )

Finsi
Finsi
Finsi

Exemple : Ecrire un algorithme qui affiche les états de l’eau en fonction de sa température T.
Algorithme Etat_eau_temp
Variable T en réel
Début
Ecrire (‘donnez la température T :’)
Lire (T)
Si T=< 0 Alors Ecrire (‘l ‘’eau est dans un état solide’)
Sinon Si T< 100 Alors Ecrire (‘l ‘’eau est dans un état liquide’)
Sinon Ecrire (‘l ‘’eau est dans un état gazeux’)

Finsi

Finsi

Fin

1
La priorité peut changer d’un langage à un autre il est fortement conseillé d’utiliser des parenthèses pour définir l’ordre
d’application des opérateurs.
3
Structures répétitives : Il existe trois types de structures répétitives :
1) Boucle Pour : Elle est souvent utilisée quand on connaît le nombre de boucles à réaliser.
Syntaxe :
Pour i  (valeur initiale) à (valeur finale) faire (ensemble d’instructions)

Fin Pour

Exemple : Effectuer la somme des n premiers entiers naturels.

Algorithme Somme
Variables s, i, n en entier
Début
Ecrire (‘donnez un nombre n :’)
Lire n
S 0
Pour i1 à n faire ss+i
FinPour
Ecrire (‘la somme est :’, s)
Fin
2) Boucle Tant que :
Syntaxe :
Tant que (condition) faire (ensemble d’instructions)

Fin Tanque
Remarques : - Pas d’augmentation automatique d’une variable.
- Faire le bloc d’instructions tant que la condition est réalisée.
Exemple (refaire l’algo précédent en utilisant Tant que) :
Algorithme Somme
Variables s, i, n en entier
Début
Ecrire (‘donnez un nombre n :’)
Lire n
s 0
i1
Tant que i<=n faire
ss+i
ii+1
FinTantque
Ecrire (‘la somme est :’, s)
Fin
3) Boucle Répéter :
Syntaxe : Répéter
Ensemble d’instructions

Jusqu’à (condition)
Fin Répéter

4
Remarques :
- Le bloc d’instructions est à faire si la condition n’est pas réalisée.
- Le bloc d’instructions est parcouru au moins une fois.
- Pas d’augmentation automatique de la variable qui apparaît dans la condition (i dans l’exemple
qui suit).

Exemple (refaire l’algo précédent en utilisant RÉPÉTER) :

Algorithme Somme
Variables s, i, n en entier
Début
Ecrire (‘donnez un nombre n :’)
Lire n
s 0
i1
Répéter
ss+i
ii+1
jusqu’à i>n
FinR
Ecrire (‘la somme est :’, s)
Fin

I.3 Les tableaux

Supposons qu’on a besoin spontanément de manipuler 12 valeurs (pour calculer par exemple la
moyenne d’une classe de 12 étudiants). Il faut donc déclarer 12 variables n1, n2,…, n12. Alors là si on
se trouve à traiter 1000 ou 100000 de variables, c’est laborieux !!
La solution c’est de rassembler toutes ces variables en une seule au sein de laquelle chaque valeur sera
indexée par un numéro, cette variable est appelée tableau.

I.3.1 Les vecteurs (tableau à une dimension) :

Un vecteur est ensemble de valeurs ordonnées les unes après les autres. Il est défini par sa taille (le
plus grand indice) et le type de valeurs qu’il contient.
Exemple : Soit V(N) un vecteur qu’on représente comme suit :
12 15 2 6 14
V(1) =12, V(5)=14, N=5, ce vecteur contient des entiers.

Déclaration d’un vecteur :

On doit préciser dans la variables, le plus grand indice et le type des valeurs que le vecteur contient.

Syntaxe :
Variables V : tableau (N) en entier

Indice le plus grand

Remarque : L’avantage des tableaux c’est qu’on va pouvoir traiter des données en utilisant des boucles.

5
Exemple : calcul de la moyenne d’une section de 140 étudiants
Algorithme moyenne_section
Variables s en réel
i en entier
N : tableau (140) en réel
Début
Pour i1 à 140 faire
Lire N(i)
FP
s0
Pour i 1 à 140 faire
ss+N(i)
FP
Ecrire (‘la moyenne est:’, s/140)
Fin

I.3.2 Les matrices (tableaux à deux dimensions) :

Si on se place à deux dimensions, on aura deux indices à manipuler, soit i, j ces indices.
Déclaration des matrices :
Variables T : tableau (n,p) en entier

Nombre de
Nombre de colonnes
lignes
Exemple :
Ecrire un algorithme qui déclare et qui remplit une matrice zéro(n,n) en les mettant tous à zéro.
Algorithme matrice_zéro
Variables i, j en entier
Zero : tableau (3,3) en entier
Début
Pour i1 à 3 faire
Pour j1 à 3 faire
Zero(i,j)0
FP
FP
Fin

6
 II. Langage de programmation Pascal
II.1 Généralités :
Il existe différents logiciels prêts à l’emploi, c’est à dire déjà réalisés par d’autres programmeurs. On
cite les programmes de jeux, en bureautique (traitement de texte, tableurs...). Cependant, il arrive
fréquemment que l’on ait besoin de concevoir soi-même un logiciel particulier pour une tâche
spécifique. Il est donc indispensable de programmer. On utilise dans ce cas un langage de
programmation. De nos jours, il existe plusieurs langages spécialisés.
Exemples : C++ et le Visuel Basic : pour la programmation orientée objet.
Cobol pour les applications de gestion.
Le Pascal : traditionnellement utilisé dans l’enseignement de l’informatique pour son intérêt
pédagogique, Il permet d’apprendre les bonnes bases de la programmation, il est donc bien adapté aux
débutants. C’est un langage typé où toutes les variables sont prédéclarées et dont les types sont
explicitement définis.
Comme dans tous les langages informatiques, dans un langage Pascal on utilise des mots clés ou encore
les mots réservés tels que, Program, begin, end, if, then, else, while, do, for,...etc, et les identificateurs
ceux réservés par le programmeur pour représenter les constantes, les types, les variables et les
fonctions. Un identificateur est composé de lettres et de chiffres, et où le premier caractère est
obligatoirement une lettre.
Définition :
Un programme est un ensemble d’instructions devant être exécutées sur ordinateur.
I.2 Structure globale d’un programme Pascal :
Un programme Pascal est structuré comme suit :
3.2.1 L’en-tête : En-tête
Il s’agît de la première ligne du programme, dans l’en-tête d’un
programme pascal on inscrit le mot réservé PROGRAM suivi d’un Déclarations
identificateur et puis s’il y a, d’une liste de paramètres situés entre 1. Constantes
2. types
parenthèses.
3. variables
4. fonctions/procédures
Syntaxe : Program identificateur (id1, id2, ...idn) ;
Exemples : Program premier_degre (input, output); Bloc d’instructions

I.2.2 Partie Déclarations :

En Pascal, tout symbole utilisé dans le programme doit être explicitement déclaré. Les
déclarations doivent respecter l’ordre suivant : Constante
Types
La constante : Il est possible de déclarer dans un programme Pascal une
constante, puis à chaque fois, on peut la changer, ceci nous évite de Variables
remplacer partout une entité constante.
Syntaxe : Const identificateur=valeur;

Exemple : Constante numérique : Const Pi=3.1415926 ;

Constante booléenne : const vrai=true ; les expressions logiques ont deux valeurs vrai=true ou faux=
false

7
Constante de type caractère : const caract1=’a’ ;
Le type :
Définition : Un type est un ensemble de valeurs que peut prendre une donnée. Il existe deux catégories
de types, les types standards et les types non-standards.
 Les types standards : un type standard qu’on ne déclare pas dans un langage Pascal, on distingue
quatre types :
 Integer (les entiers) : Les entiers dans le Turbo-Pasacal sont compris entre –32768=216 et
+32767=216-1.
 Real (les réels) : En Turbo-Pascal les réels sont compris entre –1.7 e37 et 1.7 e37
 Boolean (types booléens): Ce type nous permet de manipuler avec des opérateurs logiques.
 Char (type caractère): c’est un caractère entouré d’apostrophes.
 Les types non-standards : on distingue deux catégories :
 Type Enuméré : Syntaxe : Type identificateur=(id1,…idn) ;
Remarque : On doit écrire le mot type une seule fois dans le programme.
Exemple : Type Voyelle=(A, E, I, O, U) ;
Semaine=(samedi, dimanche, lundi, mardi, mercredi, jeudi, vendredi) ;
 Type intervalle : Syntaxe : Type identificateur=inf..sup ;
Exemple :
Type Decimal=0..9;
Age=1..120;
MAJ=’A’..’Z’;
Semaine=samedi..vendredi;
REMARQUE: - La borne inf doit être placée avant la borne sup.
- Pas de type intervalles issus de types réel.
 Type tableau : Pour déclarer un type particulier de tableaux, par exemple un tableau de réels
de n lignes et de p colonnes, on utilise la syntaxe suivante :
Type table: Array [1..n,1..p] of real;
La variable :
Pour pouvoir utiliser une variable dans un programme, on doit impérativement la déclarer, en d’autres
termes, on doit définir l’ensemble de valeurs que cette variable peut prendre.
Syntaxe : VAR identificateur : type ;
Propriétés :
- Une variable est définie par un type standard ou un type non-standard.
- Plusieurs variables du même type peuvent être regroupées et séparées par des virgules.
- Le mot Var n’apparaît qu’une seule fois.
Exemple :
Var N, i : integer ;
x, y, z : real;
vivant: boolean;

I.2.3 Les instructions (les actions) :

L’instruction : une instruction dans un programme est équivalente à une phrase dans un texte, elle
représente un ou plusieurs ordres devant être exécutées par la machine.

8
L’instruction composée : L’instruction composée permet de regrouper dans un même bloc un ensemble
d’instructions exécutées au même niveau.

Caractéristiques :
- On peut écrire une instruction sur plusieurs lignes et plusieurs instructions sur la même ligne
(séparées par des point-virgule)
- Une instruction commence par un mot réservé ou un identificateur et se termine par un point-
virgule.
- On distingue les instructions simples telle que l’affectation des instructions structurées telles
que les instructions composées, itératives et conditionnelles.

Le bloc d’instructions :
Deux ou plusieurs instructions doivent être regroupées dans un même bloc entre le mot clé BEGIN
et le mot clé END suivi d’un point.
Remarque : Une instruction composée peut être imbriquée dans une autre instruction composée.

Les différentes instructions :

L’instruction d’affectation : Pour affecter une valeur à une variable en pascal on utilise la syntaxe
suivante : Variable := expression ;
L’expression peut être une constante, une variable ou des variables et des constantes reliées par des
opérateurs.
Remarque : Quand on effectue un test, on utilise l’opérateur ‘=’ et non l’opérateur ‘ :=’.
Exemple :
If (x=5) then y :=x/2 ; si la condition sur x est réalisée alors y reçoie la valeur x/2.
Les instructions d’entrée-sortie :
Les entrées-sorties se font entre la mémoire (variables et constantes) et les périphériques (clavier,
écran,…).
La lecture : Il existe deux écritures en Pascal pour la lecture
Read (a1, a2,...,an) ou Readln (a1, a2,...,an).
Le programme lit ce que l’utilisateur tape et stocke les valeurs dans les variables correspondantes
en mémoire.

Exemple : Lecture d’un entier

Program lecture_entier ;
Var i : integer ;
Begin
Read (i) ;
End.
Read (a1, a2,...,an) est equivalent à Read (a1), Read (a2), ..., Read (an)
La deuxième écriture (readln) signifie qu’il faut passer à ligne suivante en ignorant tout ce qui reste sur
la même ligne.

REMARQUE : pour permettre l’affichage des résultats, Readln peut être utilisé sans paramètres à la
fin du programme et ce pour laisser le temps à l’utilisateur de lire les résultats à l’écran.

L’écriture : Il existe deux façons pour l’affichage à l’écran : write et writeln

Writeln (a1, a2, …, an) est equivalent à Writeln (a1), Writeln (a2), Writeln (an).

9
Exemple:
Program entier_reel;
Var i : integer ;
r : real ;
Begin
Write (‘ donnez un entier et un réel: ’);
Read (i , r);
Writeln ( ‘ l’’entier est:’, i: 3 );
Writeln ( ‘ le réel est:’, r: 5: 3 );
End.
L’entier est affiché en trois caractères et le réel avec 5 caractères dont 2 pour la partie fractionnaire.
Les structures conditionnelles :
Avant de détailler les structures conditionnelles du Pascal, on va donner les principales opérateurs et
fonctions utilisées.

Opérateurs et expressions :
Opérateurs : + addition
- soustraction
* multiplication
/ division (dans R)
DIV division entière (3div2=1)
MOD (modulo) (3mod2=1) : reste de la division dans N.

Fonctions arithmétiques : Les principales fonctions arithmétiques sont présentées dans le tableau
suivant :
Valeur absolue de x ABS(x)
Arc tangente de x ARCTAN(x)
Cosinus de x COS (x)
Sinus de x SIN(x)
Logarithme népérien de x LN(x)
Racine carrée de x SQRT(x)
Carré de x SQR(x)
Exponentielle de x EXP(x)
Partie entière de x TRUNC(x)

Instructions de sélection :
- Selection simple : If …Then…else
Syntaxe: If (condition) then bloc1 d’instructions
Else bloc2 d’instructions;
REMARQUES:
Il n’y a pas de point virgule immédiatement avant le else.
On peut imbriquer plusieurs if.
La valeur de la condition est booléenne ; si le résultat est TRUE alors le programme effectue le bloc1,
sinon c’est le bloc2 qui est exécuté.
Si on s’intéresse au bloc1 seulement, on peut ignorer le else bloc2
Exemple :Programme qui calcule le maximum de eux nombres entiers entrés par l’utilisateurs.
10
 Program max ;
Var x, y, max : integer ;
BEGIN
Writeln (‘donnez deux nombres entiers :’) ;
Read (x, y) ;
If x>0 then max:=x
Else max:=y;
Writeln (‘le maximum est :’, max) ;
End.
- Sélection multiple (Instruction CASE):
L’instruction CASE remplace plusieurs instructions IF imbriquées, il s’agît de choisir une instruction
parmi plusieurs.
Syntaxe : CASE réponse of
1 : instruction1 ;
2 : instrcution2 ;
.
.
n : instructionn ;
end ;
REMARQUE : Au niveau du test, seule l’égalité est admise. Cependant, on peut utiliser des intervalles.
Exemple : Simulation d’une calculatrice
Program calculatrice ;
Var a, b, res : real ;
Touch: char;
begin
Write (‘ donnez un nombre, une opération puis un nombre :’);
Readln (a, touch, b) ;
CASE touch of
‘+’ : res:=a+b;
‘-‘ : res:=a-b;
‘*’ : res:=a*b;
‘/’ : res:=a/b;
end;
writeln (a, touch, b, ‘=’, res);
end.
Structures répétitives : Les boulcles
A/ Boucles à bornes définies :Boucle For
Dans le cas de la boucle FOR, on connaît le nombre d’itérations à effectuer. Un indice varie de la valeur
initiale à la valeur finale.
Syntaxe : For variable := valeur initiale to valeur finale do bloc d'instructions
REMARQUES:
La variable ne peut pas être réelle.
Si la valeur initiale est supérieures à la valeur finale la boucle est ignorée.
Il est possible d’imbriquer plusieurs boucles FOR.
Exemple : Calcul de la moyenne d’une classe de 20 étudiants :
Program Moy ;
Const n=20 ;

11
Var V: array [1..n] of real;
i: integer;
moy: real;
begin
moy:=0;
For i:=1 to 20 do
begin
write (‘donnez l”élément V[‘,i,’] :’) ;
readln (V[i]);
moy:=moy+V[i];
end;
Writeln (‘la moyenne de la classe est:’,moy/n);
End.

b/Boucles à bornes non-définies :

Il existe deux types de boucles aux bornes inconnues, soient boucles while et repeat.
La boucle While : Il s’agît de la boucle tant que en algorithmique.
Syntaxe :
While expression do bloc d’instructions
Caractéristiques:
Le traitement du bloc d’instruction est effectué tant que la condition est réalisée, et il s’arrête dès que
l’expression est fausse.
L’incrémentation n’est pas automatique contrairement à la boucle FOR.
Exemple :
Program Moy ;
Const n=20 ;
Var V: array [1..n] of real;
i: integer;
moy: real;
begin
moy:=0; i:=1;
while i:<= 20 do
begin
write (‘donnez l”élément V[‘,i,’] :’) ;
readln (V[i]);
moy:=moy+V[i];
i:=i+1;
end;
Writeln (‘la moyenne de la classe est:’,moy/n);
End.

La boucle repeat :
Syntaxe : Repeat
Bloc d’instructions
Until expression ;

Caractéristiques :

12
Contrairement à la boucle while, le traitement est effectué tant que l’expression est fausse, l’arrêt
correspond au résultat TRUE de l’expression.
L’incrémentation est nécessaire comme la boucle while.
Etant donné que la condition vient après le bloc d‘instructions, le traitement est effectué au moins une
fois.
Program Moy ;
Const n=20 ;
Var V: array [1..n] of real;
i: integer;
moy: real;
begin
moy:=0;i:=1;
repeat
write (‘donnez l”élément V[‘,i,’] :’) ;
readln (V[i]);
moy:=moy+V[i];
i:=i+1;
until i>20 ;
Writeln (‘la moyenne de la classe est:’,moy/n);
End.

3.3 Enoncés des exercices

Exercice 1 :
Ecrire un programme Pascal qui résout et qui affiche les solutions de l’équation de 1er degré
ax+b=0.

Exercice 2 :
Soit l’équation de second degré ax2+bx+c, avec a, b, c des réels.
Ecrire un algorithme qui résout et qui affiche les solutions de cette équation. (considérez les solutions
complexes).
Donnez le programme Pascal correspondant.

Exercice 3 :
Ecrire un programme Pascal qui demande un nombre de départ, et qui calcule sa factorielle.

13
Exercice 4:
Ecrire un programme Pascal qui simule la remise de monnaie après la lecture des achats et du
montant à payer par un client. Ne considérez que des pièces de 10Da et de 5Da , et de 1Da.

Exercice 5 :

1) Traduire l’algorithme suivant en langage pascal :

Algorithme ……….
Constante n=10
Variable mat : tableau (n,n) en entier
i,j en entier
début
pour i1 à n faire
pour j1 à n faire
si j=i alors mat(i,j)1
sinon mat(i,j)0
écrire (‘mat[‘,i,j,’]=’,mat(i,j) )

fp
fp
end.

2) Que produit le programme ainsi écrit ? Améliorer-le pour pouvoir calculer et afficher la trace
de la matrice mat.

Exercice 6 :

1) En utilisant la boucle for, écrire un Programme Pascal qui calcule et qui affiche :
la valeur de pi en utilisant l’expression de la série suivante: (considérez les dix premiers termes)
p i = 4 (1 / 1 − 1 / 3 + 1 / 5 − 1 / 7 + ⋅ ⋅ )
Le périmètre et la surface d’un cercle de rayon r.
2) Refaire l’algorithme précédent en utilisant la boucle while, le processus d’itération s’arrête
quand l’erreur sur pi est inférieur à 10-8 ? affichez le nombre d’itérations effectuées ?

Exercice 7 :
Ecrire un programme Pascal qui demande successivement 20 nombres à l’utilisateur, qui lui
dise ensuite quel était le plus grand parmi ces 20, et qui affiche en quelle position avait été saisie ce
nombre.

Exercice 8:
Complétez ce qui manque à l’algorithme suivant :
Algorithme ……..
……………
début
…………..
Ecrire (‘ introduire une suite de nombres entiers terminée par 0 :’ )
Répéter
14
 ……….
Si Nombre > 0 Alors
S1S1+Nombre
pp+1
Finsi
Si Nombre < 0 Alors
S2S2+Nombre
nn+1
Finsi
Jusqu’à ………
Ecrire (‘………………..’, S1)
Ecrire (‘………………..’, S2)
Fin
Donnez le programme Pascal correspondant ?
Exercice 9:
1/ Ecrire un programme Pascal qui calcule et qui affiche le maximum de trois nombre entrés au
clavier.
2/ On suppose maintenant qu’on a N nombres et que l’on range dans un tableau. Ecrire le
programme Pascal qui calcule et qui affiche le maximum de ses éléments.
3/ Ecrire le programme qui calcule et qui affiche la moyenne des éléments du tableau.

Exercice 10 :
Que produit le programme suivant? (Après avoir compléter)
program …………………….. ;
const n=5 ;
var…………………;
begin
for i:=1 to n do
begin
writeln (‘introduire l”elément A[‘,i,’]:’ );
………..;
end;
for i:=1 to n do
begin
writeln (‘introduire l”elément B[‘,i,’]:’ );
………..;
end;
s:=0;
for i:=1 to n do s=s+ A[i]*B[i];
writeln (‘……………..:’, s);
end.
2) Réduire ce programme en utilisant une seule boucle for?

Exercice 11 :

Soit A[1..N] un tableau à N éléments. Ecrire un programme Pascal permettant de remplir ce

tableau d’entiers et de classer ces éléments par ordre décroissant.

15
Exercice 12 :
1) Ecrire un programme algorithme qui rempli un tableau T de 20 nombres entiers, et qui calcule :
- Le plus petit élément.
- Le nombres d’éléments nuls.
- La somme des éléments de rang pair.
- Le produit des éléments de rang impair.
- Donner le programme Pascal correspondant ?

Exercice 13 :
Soit deux matrices carrées A et B. Ecrire un programme Pascal qui calcule :
1/ La matrice somme.
2/ La matrice produit.

16
 Annexe : Procédures et Fonctions
Les procédures :

Définition : Une procédure est un sous programme. Son utilisation nous permet de découper un
programme en plusieurs parties, chacune d’entre elles effectue une tâche particulière. Définir une
procédure revient à donner un nom à un groupe d’instructions qu’on peut appeler en tout endroit du
programme. Les procédures sont déclarées dans la partie déclaration juste avant le begin du programme
principal.
Procédures sans paramètres :
Il s’agit simplement de donner un nom à un ensemble d’instructions, chaque fois qu’on introduit ce
nom dans le programme, les instructions sont exécutées.
Syntaxe :
Procedure nom-procedure;
begin
{ensemble d’instructions de la procédure}
end ;

Exemple : Procédure qui permute entre entiers entrés au clavier.

Program exemp1 ;
Var x, y, c : integer ;
{ déclaration de la procédure permutation}
procedure perm_xy ;
begin
c:=x; x:=y; y:=c;
end ;
begin
x :=5 ; y :=10 ;
write (x, ‘ ‘, y) ;
perm_xy ;
write (x,’ ‘, y) ;
end.
Ce programme affiche 5 10
10 5
Remarque : On peut appeler une procédure depuis une autre, seulement il faudrait que celle qu’on
appelle soit déclarée la première.

Variables locales et globales : Si on reprend l ‘exemple précédent, on remarque que la variable

temporaire c n’est utile que dans la procédure. On peut la déclarer localement dans la procédure et non
dans les déclarations globales. La variable c est appelée variable locale. Les variables globales sont
toutes des variables qu’on déclare dans la partie var du programme principal.
Exemple : procédure permutation
Program exemp2 ;
Var x, y : integer ;
Procedure perm_xy ;
Var c: integer; { déclaration de la variable locale}
Begin
17
c:=x ; x := y ; y :=c ;
end ;
begin
x :=5 ; y :=10 ;
write (x, ‘ ‘, y) ;
perm_xy ;
write (x,’ ‘, y) ;
end.
Remarques :
On ne peut avoir accès à une variable locale à une procédure ni par le programme principal ni par
d’autres procédures.
Il faut éviter de donner à une variable locale le même nom qu’une variable globale.

Procédures avec paramètres :

Pour éclaircir l’utilité d’utiliser des paramètres regardons de près le programme qui utilise une
procédure produit pour calculer les produits c=a*b et (a+1)*(b+1)
Exemple :
Program exemp3 ;
Var x, y, z, a, b, c, d : real ;
Procedure produit ;
z :=x*y ;
end;
Begin
Write(‘donnez a et b ?’) ;
Readln (a,b) ;
x:= a; y:=b;
produit ;
c :=z ;
x :=a+1 ; y :=b+1 ;
produit ;
d :=z ;
writeln (‘c=’, c, ‘d=’ d) ;
end.
Remarques :
On remarque à premier abord que l’écriture est lourde.
On ne doit se servir des variables x, y, z que pour communiquer avec la procédure. On risque de changer
les valeurs de x, y, et de z.
On distingue entre deux sortes de paramètres, les données d’une part (a, b) et les résultats d’autres part
(c, d).
Une solution plus élégante consiste en l’utilisation de paramètres pour la procédures. L’exemple
précédent devient :
Program prod_para ;
Var a, b, c, d: real;
Procedure produit (x, y: real; var z: real);
Begin
z:=x*y;
End ;

18
Begin
Write (‘donnez a et b : ’) ;
Readln (a, b) ;
Produit (a, b, c);
Produit (a+1, b+1, d) ;
Writeln (‘c=’, c, ‘d=’, d) ;
End.
La procédure reçoit des paramètres et les identifie dans le même ordre aux variables x, y puis z, soit
ax, by, cz.

Passage de paramètres : Il y a deux sortes de passages de paramètres, par la valeur ou par la référence.
Par la valeur :
A l’appel, le paramètre peut être une valeur ou une expression, mais c’est la valeur qui est transmise.
Elle sert à initialiser la variable en question. Dans l’exemple précédent x à a et y à b.
Par la référence :
A l’appel, le paramètre ne peut être qu’une variable. En fait, c’est l’adresse de la variable qui est
transmise, et non sa valeur. La variable qu’on utilise dans la procédure est la même utilisée dans le
programme principal mais sous un nom différent.

Syntaxe : Pour distinguer entre les deux cas, on utilise le mot réservé var dans la déclaration de la
procédure dans le cas du passage par l’adresse. Si par hasard, on oublie de mettre le mot var dans la
procédure, la valeur calculée par la procédure ne peut pas sortir de celle-ci.

Les fonctions :
Définition : Une fonction est une procédure qui renvoie un résultat, le résultat sort de la fonction en
faisant une affectation sur son nom.
Fonctions sans paramètres :
Déclaration :
Syntaxe :
Déclaration :
Function nom : type-résultat ;
Begin
Nom :=expression ;
End;
Appel :
Program fonction ;
Var result : type-résultat ;
{déclaration de la fonction plus haut}
begin
result :=Nom ;
End.

Remarques:
Nom n’est pas une variable, et il ne faut pas l’utiliser dans une expression à l’intérieur de la fonction,
cela provoquerait un appel recursif.
Une fonction doit toujours avoir un résultat (une valeur).

19
Fonction avec paramètres :

Syntaxe :
Function Nom (paramètre : types-paramètres) : type-résultat ;
Var variables locales : leurs types ;
Result : type ;
Begin
Result:=expression;
Nom(paramètres) :=result ;
End;
Remarque :
Tout ce que l’on a dit sur le paramétrage des procédures reste valable pour les fonctions.

20