INITIATION A l’ALGORITHMIQUE ET AUX STRUCTURES DE DONNEES

ELEMENTAIRES

(E.T. : 24heures, E.D. : 24 heures, E.P. : 18 heures)

Année Universitaire 2017/2018

J. Courtin & I. Kowarski, 1994. “Initiation à l’algorithmique et aux structures de

données”. Volume 1, 2ième édition, DUNOD, Paris, p. 341.

Monsieur RAKOTOASIMBAHOAKA CYPRIEN ROBERT, Maitre de Conférences

Enseignant-chercheur à l’Ecole Nationale d’Informatique

UNIVERSITE DE FIANARANTSOA

1
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 2
 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"); 3
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.

4
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 5

commencer par une lettre.

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".
1 6
Remarque : l’instruction d’écriture contient maintenant trois
parties reliées entre elles par l’opération dite de concaténation,
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. 7
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.8
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;
9
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,
1 d’opérateurs, et 10

éventuellement de parenthèses, selon les règles habituelles de

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’ ?
11
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");
12
finproc;
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
1 13
expression entière complexe dont la valeur est un nombre entier.
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. 14
 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
19 5 7
a := a + c ;
19 19 7 15
b := a;
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 16
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; 17
 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
1 18
constructeur tantque, afin d’itérer, ou répéter, ces instructions le bon nombre
de fois.
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. 19
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 20

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.
A non A
Négation (non)
Vrai faux
faux vrai

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

Et de même (A = vrai) = A. 1 21

Remarquons aussi que (non non A) = A

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; 22
finfaire;
finproc;
 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.
Intersection (et) A B A et B
vrai vrai vrai
vrai faux faux
faux vrai faux
Dans certains cas nous serons faux
faux amener à faux
utiliser l’opération d’union.
Union (ou)
A B A ou B
vrai vrai vrai
vrai faux vrai
faux vrai vrai

Une assertion est unefaux fauxlogiquefaux

expression (booléenne) ou condition qui est toujours
23
vraie.
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;
1 24
finsi;
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 25
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. 26
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 27
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} 28
finsi;
finfonc;
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 29
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.
1 30
Exercice 6. Ecrire une fonction qui retourne le maximum de 3 nombres donnés.
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
1
le minimum de trois nombres31
donnés sous plusieurs formes.
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).
32
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 33
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; 1 34
finproc;
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 doit être définie quelconque doit être définie
initiale
Valeur finale Identique à la valeur définie (doit avoir été définie (doit avoir
initiale affectée dans l’algo.) été affectée dans
l’algo.)
Paramètre expression ou identificateur identificateur
effectif identificateur initialisé initialisé

Exercice
contrainte13. Ecrire
Ne une
doit fonction qui retourneNe
jamais être la valeur de n être
doit jamais p, où p est un nombre entier
positif, et n un entier
modifiéquelconque.
(jamais à gauche utilisé (jamais à droite 35

d’une affectation) d’une affectation)