1 ELEMENTS ELEMENTAIRES DES ALGORITHMES.

1.1. Chaînes de caractères

1.2. Procédures et variables entières
1.3. Itérations et conditions
1.4. Transmission des paramètres

2. VECTEURS
2.1. Introduction
2.2. Algorithmes traitant un seul vecteur
2.3. Tris d’un vecteur
2.4. Algorithmes de mise à jour d’un vecteur

3. FICHIERS
3.1. Définition et propriétés
3.2. Actions primitives d’accès
3.3. Algorithmes traitant un seul fichier
3.4. Algorithmes traitant plusieurs
1 fichiers 1
 1. ELEMENTS ELEMENTAIRES DES ALGORITHMES

Un algorithme est une suite d’instructions effectuée par un ordinateur

pour arriver en un temps fini, à un résultat déterminé, à partir d’une
situation donnée.

1.1. Chaînes de caractères

L’ordinateur communique une info à l’utilisateur. Soit afficher un
message à l’écran, soit imprimer un message sur papier. Cette action est
déterminée par une instruction d’écriture nommée écrire.

1.1.1. Instruction "écrire"

Nous voulons faire afficher à l’écran un message de bienvenue.
bonjour version1
Algorithme
écrire("Bonjour à tous");
2
L’instruction "écrire" est formée :
- du mot écrire,
- d’un paramètre, entre parenthèses,
et qu’elle est toujours suivie d’un point virgule.

Ce paramètre est une chaîne de caractères entre guillemets, qui sera

reproduite textuellement à l’écran ou sur l’imprimante.

Un caractère peut être une lettre majuscule ou minuscule, un chiffre, un

signe de ponctuation, ou un espace.

Une chaîne de caractères ou chaîne en abrégé, est une suite quelconque

de caractères, entourée de guillemets. Cette suite pourra être vide : "", ou
de longueur 1 (caractère), ou de longueur supérieure à 1.

3
1.1.2. Variables de type chaîne, instruction "lire"
Nous pouvons "personnaliser" le message d’accueil en affichant le nom
de l’utilisateur. Bien entendu, L’ordinateur ne connaît pas ce nom à priori
et devra donc commencer par le lui demander.
bonjour version 2
Algorithme
écrire("Comment vous appelez-vous ?"); lire(nom);
écrire("Bonjour" & nom & "!");

nom est une variable de type chaine de caractères qui contiendra la

valeur de nom. Pour cela, nous supposerons que notre ordinateur
comporte un certain nombre de "cases", dites aussi "emplacements en
mémoire", susceptibles de contenir une chaine de caractères. Chacune de
ces cases sera identifiée par une "étiquette" ou identificateur. Ici
l’identificateur employé est le mot nom.
Chaque identificateur est une suite de caractères pris parmi les lettres,
les chiffres, et le caractère "souligné", mais doit commencer par une
lettre. 4
Ainsi a, A3_b2, toto sont des identificateurs valables, alors que 35,
5A et A+b ne le sont pas.

Cette case ou mémoire, est supposée contenir initialement une valeur

quelconque. C’est l’instruction lire(nom) qui indique à l’ordinateur
qu’il doit lire la chaine de caractères que l’utilisateur a frappé au
clavier, et la ranger dans la case qui porte l’identificateur nom.

Exemple d’exécution de bonjour (version 2)

Comment vous appelez-vous ? Rakoto
Bonjour Rakoto !

Avant exécution de bonjour : nom contient par exemple "azerty"

Après exécution de bonjour : nom contient "Rakoto".
On dit alors que la variable a pour valeur : "Rakoto".
Remarque : l’instruction d’écriture contient maintenant trois parties
reliées entre elles par l’opération dite
1 de concaténation, notée &. 5
1.2. Procédures et variables entières
L’algorithme présenté jusqu’ici devrait être recopié à chaque utilisation.
Nous décidons d’en faire une procédure, c’est-à-dire une suite
d’instructions nommée, que l’on pourra appeler par ce nom chaque fois
que l’on veut l’utiliser. Une procédure doit être déclarée afin de pouvoir
ensuite l’appeler par son nom.

La déclaration peut prendre la forme suivante :

procédure bonjour1
nom : chaine;
debproc
écrire("Comment vous appelez-vous ? "); lire(nom);
écrire("Bonjour" & nom & "!");
finproc;

Elle comporte le mot procédure, suivi de l’identificateur de la

procédure, ici bonjour1. 6
1.2.1. Déclarations de variables

Indiquent à l’ordinateur les identificateurs de variables utilisées dans la

procédure, ainsi que leur type.

Dans la procédure bonjour1, nous n’avons qu’une seule variable

appelée nom, de type chaîne.

Syntaxe de déclaration : identificateur : type;

Remarque : toute variable utilisée dans un algorithme doit être déclarée

au début de l’algorithme, une fois et une seule.
Le corps de la procédure est composée d’une suite d’instructions,
précédée de debproc, et suivie de finproc.
Pour utiliser ou appeler la procédure bonjour1, il suffira d’indiquer son
nom. Ce sera l’instruction très simple :
bonjour1; qui suffira d’exécuter tout le contenu de la procédure. 7
1.2.2. Variables entières et expressions arithmétiques

Notre procédure va indiquer à l’utilisateur son âge. C’est l’ordinateur qui

calculera cet âge à partir de 2 données : l’année actuelle et l’année de
naissance de l’utilisateur.

procédure bonjour2
nom : chaine;
année, naissance : entier;
debproc
écrire("A quelle année sommes-nous ?"); lire(année);
écrire("Comment vous appelez-vous ?"); lire(nom);
écrire("Votre année de naissance ?"); lire(naissance);
écrire("Bonjour " & nom & "!");
écrire("Vous êtes âgé de "  & année-naissance & "ans");
finproc;
8
Nous introduisons 2 variables : année et naissance, dont les valeurs sont
saisies au clavier. Ces variables seront des nombres entiers, nous les
déclarons donc de type entier.
Les entiers peuvent être positifs ou négatifs, et on peut leur appliquer les
opérations arithmétiques classiques : +, -, et multiplication notée *.
La division entière notée div, n div p donne la partie entière du quotient
de la division de n par p.
Le modulo noté mod, donne le reste de la division entière de n par p;
Exemples :
3 + 5 donnera 8
2 * (-6) donnera -12
12 div 3 donnera 4
14 div 3 donnera 4
12 mod 3 donnera 0
14 mod 3 donnera 2
Une expression entière est toute expression formée à partir de variables
entières, de nombres entiers, d’opérateurs, et éventuellement de
parenthèses, selon les règles habituelles
1 de l’algèbre. 9
Exemple 

Les variables abc et xy ont respectivement pour valeurs 3 et -5, alors

l’expression entière :
(abc + 25) div (4 * (7 + xy)) aura pour valeur :
(3 + 25) div (4 * (7 + -5))
soit 28 / 8 c’est-à-dire 3.

Dans la procédure bonjour2, nous avons introduit l’expression entière :

année–naissance dont la valeur est calculée par l’ordinateur.

Exemple d’exécution de bonjour2

Exercice 1. Que se passerait-il si on avait mis l’expression année – naissance entre

apostrophes : ‘année - naissance’ ?

10
1.2.3. Paramètres, instruction d’affectation

Avec la procédure bonjour2, nous demandons à l’utilisateur la valeur de

l’année en cours. On peut supposer que cette valeur est déjà connue de
l’ordinateur (par son horloge interne ou par saisie préliminaire).
On pourra alors paramétrer la procédure avec cette valeur.

procédure bonjour3(d année : entier)

nom : chaine;
naissance, âge : entier;
debproc
écrire("Comment vous appelez-vous ?"); lire(nom);
écrire("Votre année de naissance ?"); lire(naissance);
écrire("Bonjour " & nom & "!");
âge := année-naissance;
écrire("Vous etes âge de " & âge & "ans");
finproc; 11
Le paramètre année de type entier est appelé paramètre formel. Il
s’agit d’une donnée (lettre d). Il sera remplacé à l’appel de la procédure
par une valeur entière ou une variable de type entier ou une expression
entière.
Exemples d’instructions d’appel
• bonjour3(1993);
• Si la variable ancour contient une valeur entière :
bonjour3(ancour);
1993 ou ancour sont des paramètres effectifs, dont la valeur remplace
celle du paramètre formel lors de l’exécution.
Nous introduisons dans la procédure une instruction d’affectation
âge := année – naissance;
Elle permet de ranger une valeur dans une variable, autrement que par
une saisie directe (lire).
Elle est formée de l’identificateur de variable, puis du symbole
d’affectation (:=) puis d’une expression entière. L’expression entière
pourra être un nombre entier, une variable ou une expression entière
complexe dont la valeur est un nombre 1 entier. 12
Exemple d’instructions d’affectation correctes
a1 := 3; b := 3 * 5;
c := a1; c := (b + 6) div 4; nb := 1;
nb := nb + 1; nb := nb * (a1 + b);

nb := nb + 1 est différente d’une égalité mathématique. L’égalité est

notée nb = nb + 1 et serait évidemment toujours fausse.

Exemples d’instructions d’affectation incorrectes

a + 1 := 3;
a := 3b;

Rappel : toute variable déclarée dans un algorithme doit être déclarée au

début de l’algorithme, une fois et une seule.
Après les déclarations, les valeurs des variables sont indéfinies.
L’affectation de valeur à une variable peut être effectuée autant de fois
que l’on veut au cours d’un algorithme. La valeur de la variable sera
alors modifiée à chaque affectation. 13
 Une variable en partie droite d’une instruction d’affectation est
supposée contenir une valeur qui devra lui avoir été affectée auparavant
(initialisation), sinon l’on dira que la variable est indéfinie.
procédure corr
a, b, c : entier;
debproc
a := 12; b := 5;
c := a – b;
a := a + c;
b := a;
finproc;
Pour voir les contenus successifs des variables, nous allons en effectuer une trace ;
un tableau dans lequel pour chaque ligne de l’ algorithme, nous noterons les valeurs des
variables.
a b C
entier a, b, c ; indéfini indéfini indéfini
a := 12;b := 5 ; 12 5 Indéfini
c := a - b ; 12 5 7
a := a + c ; 19 5 7
b := a; 19 19 7 14
Exercice 2.

Donnez toutes les raisons pour lesquelles l’algorithme suivant est

incorrect :

fonction exerc
x, y : entier;
defonc
x := 7;
z := x;
x*2 := 3 + z;
y := x + 5w;
finfonc;

1 15
1.3. Itérations et conditions
Une procédure saisit le nom et l’année de naissance de toute une série de personnes et affiche
pour chaque personne son âge. Une première méthode consiste à répéter les instructions de saisie
et d’écriture un certain nombre de fois. On suppose qu’il y a 3 étudiants.
procédure etudiants1(d année:entier)
nom : chaine; naissance, âge : entier;
debproc
écrire("Nom d’un étudiant ? "); lire(nom);
écrire("Son année de naissance ? "); lire(naissance);
âge := année – naissance;
écrire(nom & "est âgé de " & âge & "ans");

écrire("Nom d’un étudiant ? "); lire(nom);

écrire("Son année de naissance ? "); lire(naissance);
âge := année – naissance;
écrire(nom & " est âgé de " & âge & "ans");

écrire("Nom d’un étudiant ? "); lire(nom);

écrire("Son année de naissance ? "); lire(naissance);
âge := année – naissance;
écrire(nom & " est âgé de " & âge & " ans");
finproc;
16
 C’est une méthode laborieuse, en raison de la répétition trois fois de la même
séquence d’instructions.
Pour résoudre ces problèmes, on utilise l’instruction d’itération.

1.3.1. Instruction d’itération

procédure etudiants2(d année:entier)
nom : chaine; naissance, âge, nbetudiants, i : entier;
debproc
écrire("Combien d’etudiants avez-vous ?") ; lire(nbetudiants);
i := 1;
tantque i ≤ nbetudiants faire
écrire("Nom d’’un étudiant ? "); lire(nom);
écrire("Son année de naissance ?"); lire(naissance);
âge := année – naissance;
écrire(nom & "est âge de" & âgé & "ans");
i := i + 1;
finfaire;
finproc;
Dans cette fonction, nous demandons à l’utilisateur combien de fois il faudra répéter
les instructions de saisie et d’affichage. Puis nous utilisons le constructeur tantque,
afin d’itérer, ou répéter, ces instructions le bon
1 nombre de fois. 17
Exemple d’exécution de etudiants2
Nous avons introduit une opération de comparaison ≤ entre deux
valeurs i et nbetudiants. Nous pourrons aussi employer toutes les
autres opérations de comparaison sont  : <, =, >, ≥ et ≠.

Les instructions sur lesquelles agit le constructeur tantque sont

comprises entre faire et finfaire.
La forme générale d’une instruction tantque est :
tantque condition faire
instruction1;
instruction2;
…
finfaire;
La suite d’instructions est effectuée aussi longtemps que la condition
demeure vraie.
tantque est elle-même une instruction, dite instruction d’itération.
18
1.3.2. Variables booléennes, instruction conditionnelle
On peut faire arrêter l’itération par l’utilisateur, lorsqu’il le juge utile.
procédure etudiants3(d année : entier)
nom : chaine; naissance, âge : entier; stop : booléen;
debproc
stop := faux ;
tantque non stop faire
écrire(‘Nom d’’un étudiant ?’); lire(nom);
si nom ≠ ‘*’ alors
écrire("Son année de naissance ?"); lire(naissance);
âge := année–naissance;
écritexte(nom & "est âgé de" & âge & "ans");
sinon stop := vrai;
finsi;
finfaire;
finproc;
Nous avons employé une instruction conditionnelle dont la forme est :
si condition alors
suite d’instructions 1
sinon
suite d’instructions 2
19
finsi;
 Si la condition est vraie, la suite d’instructions 1 est effectuée; si elle est fausse,
on effectue la suite d’instruction 2.
Les 2 suites d’instructions peuvent comporter à leur tour des instructions d’
itérations ou encore d’autres instructions conditionnelles.
Dans certains cas, on peut vouloir ne rien faire si la condition est fausse. On pourra
se passer de la partie sinon, et la forme se réduit à :
si condition alors
suite d’instructions
finsi;
Pour arrêter l’itération, nous avons introduit une variable de type booléen, ou
variable booléenne, stop. Ce type signifie que la variable ne peut prendre que l’une
de deux valeurs suivantes : vrai ou faux.
La première opération que nous pouvons introduire sur cette variable est la
négation.
Négation (non) A non A
Vrai faux
faux vrai

Notons que A = faux est toujours équivalent à non A.

Et de même (A = vrai) = A.
Remarquons aussi que (non non A) = A 1 20
Exercice 3. Faire afficher le mot ‘an’ au singulier si l’étudiant est âgé de moins de deux ans, et
au pluriel s’il est âgé au moins de deux ans.

Nous pouvons imaginer que des utilisateurs s’amusent à faire tourner indéfiniment l’itération
de la procédure etudiants3, en refusant de frapper un nom égal à ‘*’. Nous allons forcer la
procédure à s’arrêter au bout de 20 itérations au maximum, en ajoutant un second test
d’arrêt, contrôlé par un compteur.
procédure etudiants4(d année : entier)
nom : chaine; naissance, âge, i : entier;
stop : booléen;
debproc
stop := faux;
i := 0;
tantque non stop et (i < 20) faire
écrire("Nom d’un étudiant ? ") ; lire(nom);
si nom ≠ "*" alors
écrire("Son année de naissance ? ") ; lire(naissance);
âge := année – naissance;
écrire(nom & "est âgé de " & âge & "ans"); i := i+1;
sinon stop := vrai;
finsi;
finfaire;
finproc;
21
 Nous avons introduit la variable i, destinée à compter le nombre d’itérations. Ce compteur est
initialisé à 0, puisqu’au départ nous avons effectué zéro fois, l’itération. Chaque fois que nous
traitons un nom différente de ‘*’, nous incrémentons i. Avant d’entrer de nouveau dans
l’itération, nous testons i. Si cette valeur n’est pas inférieure à 20, nous n’autorisons pas l’entrée
dans l’itération, et l’algorithme s’arrête.
Dans l’expression de test (non stop) et (i<20), nous utilisons une nouvelle opération,
l’intersection. Le résultat de L’intersection n’est vrai que si les deux opérandes ont la valeur
vrai. A B A et B
Intersection (et) vrai vrai vrai
vrai faux faux
faux vrai faux
faux faux faux

Dans certains cas nous serons amener à utiliser l’opération d’union.

Union (ou) A B A ou B
vrai vrai vrai
vrai faux vrai
faux vrai vrai
faux faux faux

Une assertion est une expression logique (booléenne) ou condition qui est toujours vraie.
22
1.3.3. Type caractère et instructions conditionnelles imbriquées
Nous améliorons la procédure bonjour en affichant Monsieur, Madame,
Mademoiselle devant le nom de l’utilisateur.
Pour cela, nous devons connaître son sexe, codé par la lettre ‘M’ ou ‘F’. Si le sexe est
féminin, nous devons de plus demander si la personne est mariée (réponse codée par
‘O’ ou ‘N’).
procédure bonjour4
nom : chaine; sexe, marié : char;
debproc
écrire("Comment vous appelez-vous ? "); lire(nom);
écrire("Quel est votre sexe (M ou F) ? "); lire(sexe);
si sexe = ‘M’ alors
écrire("Bonjour, Monsieur" & nom & "! ");
sinon
écrire("êtes-vous mariée (O ou N) ? ") ; lire(marié);
si marie = ‘O’ alors
écrire("Bonjour, Madame" & nom & "! ");
sinon
écrire("Bonjour, Mademoiselle" & nom & "! ");
finsi;
finsi; 1 23
finproc;
Nous avons utilisé deux instructions de la forme si-sinon-finsi, la seconde étant
incluse, ou imbriquée, dans la première.
Le résultat équivalent serait obtenu par la procédure suivante qui utilise la forme
sinonsi de l’instruction conditionnelle.

procédure bonjour5
nom : chaine; sexe, marié : char;
debproc
écrire("Comment vous appelez-vous ? "); litexte(nom);
écrire("Quel est votre sexe (M ou F) ? "); litexte(sexe);
écritexte("êtes-vous mariée (O ou N) ? ") ; litexte(marié);
si sexe = ‘M’ alors
écritexte("Bonjour, Monsieur" & nom & "! ");
sinonsi marié = ‘O’ alors
écritexte("Bonjour, Madame" & nom & "! ");
sinon
écritexte("Bonjour, Mademoiselle" & nom & "! ");
finsi;
finproc;
1 24
La forme la plus générale de l’instruction conditionnelle est :
si condition1 alors
(suite d’instructions)1
sinonsi condition2 alors
(suite d’instruction)2
…
sinonsi conditionn alors
(suite d’instructions)n
sinon
(suite d’instruction)n+1
finsi;

Les parties sinonsi sont facultatives.

La partie sinon est facultative, mais si elle est présente, elle sera toujours
la dernière.
25
1.4. Fonction
Simplifions la procédure bonjour5 en regroupant les instructions de calcul du titre
Monsieur, Madame, Mademoiselle, dans une fonction qui délivre (retourne) une
valeur d’un type déterminé que nous nommerons résultat.

fonction titre(d sexe, marié : car) : chaine

debfonc
si sexe =’M’ alors retour  " Monsieur";
sinon
écrire(" Etes-vous mariée ? "; lire(marié);
si(marie =’O’)retour "Madame";
sinon retour "Mademoiselle";
finsi;
finsi;
finfonc;

Le type de la valeur de retour de la fonction est chaine.

La valeur que retourne la fonction (résultat) est déterminée par une ou plusieurs
instructions retour.

1 26
1.4.1. Résultat d’une fonction, prédicat
Une fonction qui retourne une valeur booléenne (vrai ou faux) est appelée prédicat.
Note : il est obligatoire que la fonction retourne une valeur. Dans tous les cas, sinon le
résultat n’aurait pas de valeur dans les cas non prévus. La fonction suivante est
interdite car elle ne retourne pas de valeur si l’âge est supérieur ou égal à 18.
fonction majeur( d âge : entier) : booléen
debfonc
si âge < 18 alors
retour faux ; {écriture incorrecte}
finsi;
finfonc;
L’ exécution de l’instruction retour interrompt l’exécution de la fonction, ainsi la
fonction suivante, bien que syntaxiquement correcte, retournera toujours la valeur vrai.
fonction majeur( d âge : entier) : booléen
debfonc
retour vrai;
si âge < 18 alors
retour faux ; {écriture incorrecte}
finsi;
finfonc;
27
Les solutions correctes seraient les suivantes.

fonction majeur1( d âge : entier) : booléen

debfonc
si âge < 18 alors
retour faux ;
finsi;
retour vrai;
finfonc;

fonction majeur2( d âge : entier) : booléen

debfonc
si âge < 18 alors
retour faux;
sinon
retour vrai;
finsi;
finfonc;

1 28
fonction majeur3( d âge : entier) : booléen
debfonc
si âge ≥ 18 alors
retour vrai;
sinon
retour faux;
finsi;
finfonc;

La solution la plus simple et aussi correcte serait :

fonction majeur4( d âge : entier) : booléen
debfonc
retour âge ≥ 18;
finfonc;

En effet, l’expression âge ≥ 18 prend la valeur vrai ou faux selon la valeur de âge, l’instruction
conditionnelle est inutile. C’est cette forme qu’un utilise le plus souvent.

Exercice 4. le prédicat appelé triangleRectangle retourne la valeur vrai si et seulement si a, b

et c (des données) peuvent être les mesures des cotés d’un triangle rectangle.
Exercice 5. Ecrire une fonction qui retourne le maximum de 2 nombres donnés.
Exercice 6. Ecrire une fonction qui retourne le maximum de 3 nombres donnés.
1 29
Appel de fonction
Si nous voulons utiliser la fonction titre, il suffit d’indiquer son nom et les paramètres
effectifs ; l’appel de la fonction correspond à une valeur, et non à une instruction
comme l’appel de la procédure. Nous pouvons effectuer cet appel, directement au
niveau de l’écriture du message d’accueil.
Comme dans l’appel de la procédure, les paramètres effectifs (valeurs données à
l’appel) peuvent avoir des indicateurs différents des paramètres formels (définis à
l’appel de la fonction). Ainsi, les paramètres effectifs s et m remplacent les paramètres
formels sexe et marié.
procédure bonjour6
nom : chaine; s, m : car;
debproc
écrire("Comment vous appelez-vous ? "); lire(nom);
écrire("Quel est votre sexe (M ou F) ? "); lire(s);
écrire("êtes-vous mariée (O ou N) ? ") ; lire(m);
écrire("Bonjour, " & titre(s, m) & nom & "! ");
finproc;
Exercice 7. Ecrire une fonction qui retourne le maximum de trois nombres donnés, en
utilisant la fonction qui donne le maximum de deux nombres.
Exercice 8. Ecrire la fonction min3 qui calcule le minimum de trois nombres donnés
sous plusieurs formes.
1 30
Exercice 9. Les tarifs d’affranchissements d’une lettre sont les suivantes :
En-dessous de 20g : 6 000ar
À partir de 20g, mais en-dessous de 50g : 13 000ar
À partir de 50g : 20 000ar
Ecrire la fonction qui retourne le tarif pour un poids donné.

1.4.2. Paramètre donnée et résultat

Nous définissons en-dessous les paramètres résultat et donnée-résultat.

Paramètres résultat
Pour simplifier la procédure d’accueil, nous pouvons regrouper les
questions posées à l’utilisateur dans une procédure qui devra donc
fournir trois résultats : le nom, le sexe, et l’état-civil. On ne pourra pas
utiliser une fonction car celle-ci ne peut retourner qu’une seule valeur.
Les résultats fournis seront dans des paramètres formels précédés de la
lettre r (résultat), au lieu de d (donnée).

31
procédure interrogatoire (r nom : chaine, r sexe, marié : car)
debproc
écrire("Comment vous appelez-vous ? "); lire(nom);
écrire("Quel est votre sexe (M ou F) ? "); lire(sexe);
écrire("Etes-vous marié ? "); lire(marié);
finproc;
La procédure d’accueil se réduit alors à :
procédure bonjour7
n : chaine;
s, m : car;
debproc
interrogatoire(n, s, m);
écritexte("Bonjour, "& titre(s, m) & n & "! ");
finproc;

Remarques
-Toute procédure qui possède un paramètre résultat et un seul peut être remplacée par
une fonction.
- Un paramètre résultat doit recevoir une valeur dans tous les cas de figure.
- Il est interdit d’utiliser un paramètre résultat en partie droite d’une affectation ou dans
un test.
1 32
Exercice 10. Ecrire une procédure qui teste si un nombre n, non négatif, est un carré
parfait. Cette procédure fournit deux résultats : un booléen qui est vrai si et seulement
si n est un carré parfait, et un entier égal à la partie entière de la racine carrée de n.
Exercice 11. Utiliser la procédure définie ci-dessus dans une autre procédure, qui, pour
tout entier n, imprime la valeur de sa racine carrée ou de la partie entière de celle-ci, ou
bien un message d’erreur.

La modification des paramètres

Il arrive quelquefois que le but d’un programme soit de modifier la valeur d’un
paramètre : celui-ci est donc à la fois une donnée, par sa valeur à l’entrée de
l’algorithme, et un résultat, par sa valeur à la sortie de l’algorithme. C’est ce que nous
exprimerons en la faisant précéder de dr (donnée-résultat).
Exemple. Un algorithme qui permet de permuter les valeurs de deux variables a et b. Si
les valeurs initiales respectives de a et b sont de x et y, leurs valeurs finales respectives
sont y et x.
procédure permut (dr a, b : entier)
c : entier;
debproc
c := a; a := b; b := c;
finproc; 1 33
Appel de permut :
n1 := 25; n2 := 17;
permut(n1, n2);
Exercice 12. Ecrire une procédure qui permute les valeurs de trois nombres donnés a, b et c afin
d’obtenir : a ≤ b ≤ c.
Les différents paramètres de procédure et fonction
Une fonction ne doit normalement posséder que des paramètres ”données”.
d r dr
« donnée » « résultat » «  donnée- résultat »
Valeur initiale doit être définie quelconque doit être définie
Valeur finale Identique à la valeur initiale définie (doit avoir été définie (doit avoir été
affectée dans l’algo.) affectée dans l’algo.)
Paramètre expression ou identificateur identificateur identificateur
effectif initialisé initialisé
contrainte Ne doit jamais être modifié Ne doit jamais être
(jamais à gauche d’une utilisé (jamais à droite
affectation) d’une affectation)

Exercice 13. Ecrire une fonction qui retourne la valeur de n^p, où p est un nombre entier positif,
et n un entier quelconque. 34