Algorithme

 Un algorithme sert à transmettre un savoir faire. Il décrit les étapes à suivre pour
réaliser un travail. Il permet d'expliciter clairement les idées de solution d'un
problème indépendamment d'un langage de programmation. L'utilisateur d'un
algorithme n'aura qu'à suivre toutes les instructions, dans l'ordre (en séquence)
pour arriver au résultat que doit donner l'algorithme.

 Un algorithme, c’est une suite d’instructions, qui une fois exécutée correctement,
conduit à un résultat donné.

 Le "langage algorithmique" que nous utilisons est un compromis entre un

langage naturel et un langage de programmation. Nous présentons les
algorithmes comme une suite d'instructions dans l'ordre des traitements. Ils sont
toujours accompagnés d'un lexique qui indique, pour chaque variable, son type et
son rôle. Un algorithme est délimité par les mots clés début et fin.
Nous manipulerons les types couramment rencontrés dans les langages de
programmation : entier, réel, booléen, caractère, chaîne, tableau et type
composite.
 L’algorithmique exprime les instructions résolvant un problème donné
indépendamment des particularités de tel ou tel langage. Pour prendre une
image, si un programme était une dissertation, l’algorithmique serait le plan, une
fois mis de côté la rédaction et l’orthographe. Or, vous savez qu’il vaut mieux
faire d’abord le plan et rédiger ensuite que l’inverse…
 Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un
programme informatique. Cette dimension est présente quelle que soit le langage
de programmation ; mais lorsqu’on programme dans un langage (en C, en Visual
Basic, etc.) on doit en plus se colleter les problèmes de syntaxe, ou de types
d’instructions, propres à ce langage. Apprendre l’algorithmique de manière
séparée, c’est donc sérier les difficultés pour mieux les vaincre.
 A cela, il faut ajouter que des générations de programmeurs, souvent
autodidactes (mais pas toujours, hélas !), ayant directement appris à programmer
dans tel ou tel langage, ne font pas mentalement clairement la différence entre ce
qui relève de la structure logique générale de toute programmation (les règles
fondamentales de l’algorithmique) et ce qui relève du langage particulier qu’ils
ont appris. Ces programmeurs, non seulement ont beaucoup plus de mal à passer
ensuite à un langage différent, mais encore écrivent bien souvent des
programmes qui même s’ils sont justes, restent laborieux. Car on n’ignore pas
impunément les règles fondamentales de l’algorithmique… Alors, autant
l’apprendre en tant que telle !
 Un langage de programmation est «Compréhensible » par l’ordinateur. C’est à
dire qu’il existe un programme de traduction (Compilateur) qui code en langage
machines (code binaire) ce que le programme à écrit.
• Communiquer : Langage (Parlé , écrit , par signes …)

• Langage : Ensemble de caractères, de symboles et de

règles permettant de les assembler, dans le but de
communiquer.
• Algorithme : est un ensemble d ’actions faisant
évoluer un environnement d ’un état initial donné
vers un état final désiré.
• Programmer : Ecrire dans un langage de programmation
informatique une suite d’instructions, organisée en algorithme
dans un but précis, exécutable par un ordinateur.

• Langage de programmation : On distingue deux types de

langage:
- Langage Machine : Assembleur (0 et 1 bits)
- Langage Evolués : Lignes d ’instructions, ce code

Source est ensuite soit exécuté ligne à ligne par un

interpréteur soit traduit en langage machine par
un Compilateur avant l ’exécution.
• LISP : Programmation Fonctionnelle.
• PROLOG : Programmation Logique.
• PASCAL : Programmation procédurale.
• C et C++ : Programmation de logiciels.
• Visual Basic : -Programmation graphique événementielle
-Programmation Orienté Objet.
 Historiquement, plusieurs types de notations ont représenté des algorithmes.
 Il y a eu notamment une représentation graphique, avec des carrés, des losanges,
etc. qu’on appelait des organigrammes. Aujourd’hui, cette représentation est
quasiment abandonnée, pour deux raisons. D’abord, parce que dès que
l’algorithme commence à grossir un peu, ce n’est plus pratique du tout du tout.
Ensuite parce que cette représentation favorise le glissement vers un certain type
de programmation, dite non structurée (nous définirons ce terme plus tard), que
l’on tente au contraire d’éviter.
 C’est pourquoi on utilise généralement une série de conventions appelée «
pseudo-code », qui ressemble à un langage de programmation authentique dont
on aurait évacué la plupart des problèmes de syntaxe. Ce pseudo-code est
susceptible de varier légèrement d’un livre (ou d’un enseignant) à un autre. C’est
bien normal : le pseudo-code, encore une fois, est purement conventionnel ;
aucune machine n’est censée le reconnaître. Donc, chaque cuisinier peut faire sa
sauce à sa guise, avec ses petites épices bien à lui, sans que cela prête à
conséquence.
1- Pseudo-code :

La notion de base est celle d’instruction , définie comme étant la description non
ambiguë d’une ou plusieurs actions élémentaires à effectuer dans un ordre
déterminé.
Algorithme NomAlgorithme
Debut
Instructions
Fin

Selon les besoins une suite d’instructions formera un bloc délimité par
les mots Début et Fin :

Début
Instruction 1.
Instruction 2.
Instruction 3.
…
…
Instruction n.
Fin
2- Organigramme :

Les symboles utilisés dans un organigramme pour décrire un algorithme sont les
suivants :

Début

Instruction 1

Instruction 2

Instruction n

Fin

Le rectangle indique une action à exécuter.

On dispose en outre du losange :

Qui symbolise une alternative.

Le parallélogramme indique qu’on introduit des données ou qu’on fournit un

résultat.

L’organigramme donne une impression de déroulement successif des instructions plus grandes,
mais ne met pas en évidence la notion de bloc.
 Les variables et les constantes

1- A quoi servent les variables ?

Dans un programme informatique, on va avoir en permanence besoin de
stocker provisoirement des valeurs. Il peut s’agir de données issues du disque dur,
fournies par l’utilisateur (frappées au clavier), ou que sais-je encore. Il peut aussi
s’agir de résultats obtenus par le programme, intermédiaires ou définitifs. Ces
données peuvent être de plusieurs types (on en reparlera) : elles peuvent être des
nombres, du texte, etc. Toujours est-il que dès que l’on a besoin de stocker une
information au cours d’un programme, on utilise une variable.
Dans l’ordinateur, physiquement, il y a un emplacement de mémoire,
repéré par une adresse binaire.

Définition des variables

Les variables sont des données ou des valeurs qui peuvent changer à
l'intérieur d'une application. C'est pourquoi, il est fort utile de les nommer par un
nom, de déclarer quel genre de variables est-ce (nombre entier, nombre décimal,
lettres...) et leur affecter, lorsque cela est nécessaire une valeur.
La longueur maximale du nom d'une variable est de 255 caractères.
Ceux-ci peuvent être des chiffres, des lettres ou autres symboles. Notez que ce nom
doit obligatoirement commencer par une lettre.
 Les variables et les constantes

 Les variables d'un algorithme contiennent les informations nécessaires à

son déroulement. Chaque variable a un nom (identifiant) et un type. Ce
dernier correspond au genre d'information que l'on souhaite utiliser :
- Entier pour manipuler des entiers,
- Réel pour manipuler des nombres réels,
- Booléen pour manipuler des valeurs booléennes vrai ou faux,
- Caractère pour manipuler des caractères alphabétiques et
numériques,
- Chaîne pour manipuler des chaînes de caractères permettant de
représenter des mots ou des phrases.

 Il faut noter qu'à un type donné, correspond un ensemble d'opérations

définies pour ce type. Une variable est l'association d'un nom avec un type,
permettant de mémoriser une valeur de ce type.
 Les variables sont nécessaires pour stocker (conserver) une valeur
dynamique et réutilisable.
C ’est en fait une simple Zone mémoire qui porte un nom choisi par le
programmeur pour faciliter sa programmation.
Le nom de la variable est une adresse mémoire .
Si l ’on vaut une programmation cohérente il faut les déclarer avec leur type.
 Les variables et les constantes
2. Type de variables :
 Le type entier :
Les opérations utilisables sur les entiers sont :
- Les opérateurs arithmétiques classiques :
+ (addition), - (soustraction), * (produit)
- La division entière, notée / , telle que n / p donne la
partie entière du quotient de la division entière de n par p
- Le modulo, noté mod, telle que n mod p donne le
reste de la division entière de n par p
- Les opérateurs de comparaison classiques : <, >, =,
 Le type réel :
Les opérations utilisables sur les réels sont :
- Les opérations arithmétiques classiques :
+ (addition), - (soustraction), * (produit), / (division)
- Les opérateurs de comparaison classiques : <, >, =, ...
 Le type booléen :
Il s'agit du domaine dont les seules valeurs sont vrai ou faux. Les opérations
utilisables sur les booléens sont réalisées à l'aide des connecteurs logiques : et
(pour le et logique), ou (pour le ou logique), non (pour le non logique).
 Les variables et les constantes
 Le type caractère :

Il s'agit du domaine constitué des caractères alphabétiques et numériques. Une

variable de ce type ne peut contenir qu'un seul et unique caractère. Les
opérations élémentaires réalisables sont les comparaisons : >, <, =, ...

 Le type chaîne :
Une chaîne est une séquence de plusieurs caractères. Les opérations
élémentaires réalisables sont les comparaisons : <, >, =, ... selon l'ordre
lexicographique.

En pseudo-code, une déclaration de variables aura ainsi cette tête :

Var G : entier
ou encore
Var PrixHT, TauxTVA, PrixTTC : Réel

Var Nom, Prenom : Chaîne

Var Trouve : Booléen
En pseudo-code, une chaîne de caractères est toujours notée entre guillemets.
Pour le type booléen : on y stocke uniquement les valeurs logiques VRAI et
FAUX.
 Les variables et les constantes

3- Instructions d'affectation et expressions :

Une instruction est la spécification d'une ou de plusieurs actions portant

sur une ou des variables. L'instruction la plus commune est l'affectation. Elle
consiste à doter une variable d'une valeur appartenant à son domaine, c'est à dire à
lui donner une première valeur ou à changer sa valeur courante. Elle se note ←.
Une expression est une suite finie bien formée d'opérateurs portant sur des
variables ou des valeurs et qui a une valeur. La valeur de l'expression doit être
conforme au domaine de la variable affectée.
En pseudo-code, l'instruction d'affectation se note avec le signe ←
Ainsi :
Toto ← 24
Attribue la valeur 24 à la variable Toto.
Exemple d'algorithme
Algorithme Exemple
Var x , y : entier
début
x ← 12
y←x+4
x←3
fin
 Les variables et les constantes
Opérateurs numériques :
Ce sont les quatre opérations arithmétiques tout ce qu’il y a de classique.
+ : addition
- : soustraction
* : multiplication
/ : division
Mentionnons également le ^ qui signifie « puissance ».
45 au carré s’écrira donc 45 ^ 2.
Enfin, on a le droit d’utiliser les parenthèses, avec les mêmes règles qu’en
mathématiques. La multiplication et la division ont « naturellement » priorité sur
l’addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour modifier
cette priorité naturelle.
Cela signifie qu’en informatique, 12 * 3 + 5 et (12 * 3) + 5 valent
strictement la même chose, à savoir 41. Pourquoi dès lors se fatiguer à mettre des
parenthèses inutiles ?
En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96. Rien de difficile là-dedans,
que du normal.
 Les variables et les constantes

Opérateur alphanumérique : &

Cet opérateur permet de concaténer, autrement dit d’agglomérer, deux

chaînes de caractères. Par exemple :
Variables A, B, C en Caractère
Début
A ← "Gloubi"
B ← "Boulga"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "GloubiBoulga"

Opérateurs logiques (ou booléens) :

Il s’agit du ET, du OU, du NON et du mystérieux (mais rarissime XOR).
C: Les variables et les constantes
4. Les constantes

Contrairement aux variables dont les valeurs diffèrent souvent, les constantes
ont des valeurs fixes. Mais tout comme les variables, on affecte aux constantes, un nom
et une valeur qui est elle, fixe. De plus, les constantes se définissent de la même façon
que les variables. Tout dépend donc de l'endroit où est défini la constante.
Le mot Const est utilisé pour la déclaration des constantes

Const TVA = 20.

TotalTTC = PrixHorsTaxe * (1 + (TVA / 100))

 Instructions de lecture et d'écriture
1- Instructions de lecture
L'instruction de prise de données sur le périphérique d'entrée (en général le
clavier) est :
Lire (Variable)

Exemple : Lire (NomFamille)

L'exécution de cette instruction consiste à affecter une valeur à la variable

en prenant cette valeur sur le périphérique d'entrée. Avant l'exécution de cette
instruction, la variable avait ou n'avait pas de valeur. Après, elle a la valeur prise sur
le périphérique d'entrée.
Dès que le programme rencontre une instruction Lire,
l’exécution s’interrompt, attendant la frappe d’une valeur au
clavier
Dès lors, aussitôt que la touche Entrée (Enter) a été frappée,
l’exécution reprend.
 Instructions de lecture et d'écriture

2- Instruction d'écriture
L'instruction de restitution de résultats sur le périphérique de sortie (en
général l'écran) est :
Ecrire (liste d'expressions)
Cette instruction réalise simplement l'affichage des valeurs des expressions
décrites dans la liste. Ces instructions peuvent être simplement des variables ayant
des valeurs ou même des nombres ou des commentaires écrits sous forme de chaînes
de caractères.
Ecrire "Entrez votre nom : "
Lire (NomFamille)
Écrire (x, y+2, "bonjour")

Lecture et Ecriture sont des instructions algorithmiques qui ne présentent

pas de difficultés particulières, une fois qu’on a bien assimilé ce problème
du sens du dialogue (homme → machine, ou machine ← homme).
 Instructions de lecture et d'écriture

Exemple d'algorithme
On désire écrire un algorithme qui lit sur l'entrée standard une valeur
représentant une somme d'argent et qui calcule et affiche le nombre de billets de 100
Euros, 50 Euros et 10 Euros, et de pièces de 2 Euros et 1 Euro qu'elle représente.

Principe :
L'algorithme commence par lire sur l'entrée standard l'entier qui représente
la somme d'argent et affecte la valeur à une variable somme. Pour obtenir la
décomposition en nombre de billets et de pièces de la somme d'argent, on procède
par des divisions successives en conservant chaque fois le reste.
 Exemple d'algorithme

Algorithme Calcul
Var somme : entier {la somme d'argent à décomposer}
b100 : entier {le nombre de billets de 100 Euros}
b50 : entier {le nombre de billets de 50 Euros}
b10 : entier {le nombre de billets de 10 Euros}
p2 : entier {le nombre de pièces de 2 Euros}
p1 : entier {le nombre de pièces de 1 Euro}
r100 : entier {reste de la division entière de somme par 100}
r50 : entier {reste de la division entière de r100 par 50}
r10 : entier {reste de la division entière de r50 par 10}
r2 : entier {reste de la division entière de r10 par 2}
Début
somme ← lire()
b100 ← somme ÷ 100
r100 ← somme mod 100
b50 ← r100 ÷ 50;
r50 ← r100 mod 50
b10 ← r50 ÷ 10
r10 ← r50 mod 10
p2 ← r10 ÷ 2
r2 ← r10 mod 2
p1 ← r2
écrire (b100, b50, b10, p2, p1)
fin
 Instructions conditionnelles

Les exemples précédents montrent des algorithmes dont les instructions

doivent s'exécuter dans l'ordre, de la première à la dernière. Nous allons introduire
une instruction précisant que le déroulement ne sera plus séquentiel. Cette instruction
est appelée une conditionnelle. Il s'agit de représenter une alternative où, selon les
cas, un bloc d'instructions est exécuté plutôt qu'un autre. La syntaxe de cette
instruction est :
Si Condition Alors
Liste d'instructions
Sinon
Liste d'instructions
Fsi
Cette instruction est composé de trois partie distinctes : la condition
introduite par si, la clause alors et la clause sinon.
La condition est une expression dont la valeur est de type booléen. Elle est
évaluée. Si elle est vraie, les instructions de la clause alors sont exécutées. Dans le
cas contraire, les instructions de la clause sinon sont exécutées.
 Une condition est une comparaison : Cette définition est essentielle, Elle signifie
qu’une condition est composée de trois éléments :
- Une valeur
- Un opérateur de comparaison
- Une autre valeur
Les valeurs peuvent être a priori de n’importe quel type (numériques, caractères…).
Mais si l’on veut que la comparaison ait un sens, il faut que les deux valeurs de la
comparaison soient du même type.
Les opérateurs de comparaison sont :
- Égal à…
- Différent de…
- Strictement plus petit que…
- Strictement plus grand que…
- Plus petit ou égal à…
- Plus grand ou égal à…
L’ensemble des trois éléments constituant la condition constitue donc, si l’on veut,
une affirmation, qui a un moment donné est VRAIE ou FAUSSE.
A noter que ces opérateurs de comparaison peuvent tout à fait s’employer avec des
caractères. Ceux-ci sont codés par la machine dans l’ordre alphabétique (rappelez vous le code
ASCII vu dans le préambule), les majuscules étant systématiquement placées avant les
minuscules. Ainsi on a :
“t” < “w” VRAI
“Maman” > “Papa“ FAUX
“maman” > “Papa” VRAI
 Instructions conditionnelles

Conditions composées
Certains problèmes exigent parfois de formuler plusieurs conditions reliées
par ce qu’on appelle un opérateur logique, l’informatique met à notre disposition
quatre opérateurs logiques : ET, OU, NON, et XOR.
On représente fréquemment tout ceci dans des tables de vérité (C1 et C2
représentent deux conditions, et on envisage à chaque fois les quatre cas possibles)

C1 et C2 C2 Vrai C2 Faux C1 Ou C2 C2 Vrai C2 Faux

C1 Vrai Vrai Faux C1 Vrai Faux Vrai
C1 Faux Faux Faux C1 Faux Vrai Faux

C1 XOr C2 C2 Vrai C2 Faux Non C1 C2 Vrai

C1 Vrai Faux Vrai C1 Vrai Faux
C1 Faux Vrai Faux C1 Faux Vrai
 Instructions conditionnelles

On peut utiliser une forme simplifiée de la conditionnelle, sans clause sinon. La

syntaxe est alors :
Si Condition Alors
Liste d'instructions
Fsi

Exemple 1
Écrire un algorithme qui permet d'imprimer le résultat d'un étudiant à un
module sachant que ce module est sanctionné par une note d'oral de coefficient 1 et
une note d'écrit de coefficient 2. La moyenne obtenue doit être supérieure ou égale à
10 pour valider le module.
 Instructions conditionnelles
Algorithme Moyenne
Var ne : réel {note d'écrit (cœfficient 2)}
no : réel {note d'oral (coefficient 1)}
moy : réel {moyenne du module}
Début
Lire(ne)
Lire(no)
moy ← (2 * ne + no)/3
Si moy < 10 alors
écrire ("reç")
sinon
écrire ("refusé")
fsi
fin
* Editer le plus grand des 2 nombres X et Y.
Algorithme SUP
Var X , Y : entier
Début
Lire (X ,Y)
Si X >Y alors
Ecrire (X)
Sinon
Ecrire (Y)
Fsi
Fin

 Ordonner 3 nombre par ordre croissant.

Soient V1,V2,V3 les variables à classer. On compare V1 à V2 et on les ordonne pour
avoir la petite valeur dans V1, puis on compare V3 à chacune des précédentes, 3 comparaisons
suffissent . Pour les permutations on a besoin d’un tampon.
Algorithme ORD
Var V1, V2, V3, T : entier
Début
Lire (V1, V2 ,V3 )
Si V1> V2 Alors
T = V1
V1 = V2
V2 = T
Fsi
Si V3< V1 Alors
T = V1
V1 = V3
V3 = V2
V2 = T
Sinon
Si V3 < V2 Alors
T = V2
V3 = T
FSi
Ecrire ‘les valeurs dans l’ordre son’ ,V1,V2,V3
Fsi
Fin
Tests imbriqués
Comme exemple, un programme devant donner l’état de l’eau selon sa température
doit pouvoir choisir entre trois réponses possibles (solide, liquide ou gazeuse).
Une première solution serait la suivante :
Algorithme Température
Var Temp : Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire (Temp)
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
FSi
Si Temp > 0 Et Temp < 100 Alors
Ecrire "C’est du liquide"
Fsi
Si Temp > 100 Alors
Ecrire "C’est de la vapeur"
Fsi
Fin
Vous constaterez que c’est un peu laborieux. Les conditions se ressemblent plus ou
moins, et surtout on oblige la machine à examiner trois tests successifs alors que tous portent sur
une même chose, la température de l'eau (la valeur de la variable Temp).
 Il serait ainsi bien plus rationnel d’imbriquer les tests de cette manière :
Algorithme Température
Var Temp : Entier
Début
Ecrire "Entrez la température de l’eau :"
Lire (Temp)
Si Temp =< 0 Alors
Ecrire "C’est de la glace"
Si Temp < 100 Alors
Ecrire "C’est du liquide"
Sinon
Ecrire "C’est de la vapeur"
Fsi
Fsi
Fin
Nous avons fait des économies : au lieu de devoir taper trois conditions, dont une
composée, nous n’avons plus que deux conditions simples
 Répétitions inconditionnelles

Les itérations

Il arrive souvent dans un algorithme que dans la même action soit répétée plusieurs fois,
avec éventuellement quelques variations dans les paramètres qui précisent le déroulement
de l'action. Il est alors fastidieux d'écrire un algorithme qui contient de nombreuses fois la
même instruction. De plus, ce nombre peut dépendre du déroulement de l'algorithme. Il est
alors impossible de savoir à l'avance combien de fois la même instruction doit être décrite.
Pour gérer ces cas, on fait appel à des instructions en boucle qui ont pour effet de répéter
plusieurs fois une même instruction.
Deux formes existent : la première, si le nombre de répétitions est connu avant l'exécution
de l'instruction de répétition, la seconde s'il n'est pas connu. On appellera itération
l'exécution de la liste des instructions.

Répétitions inconditionnelles

Il est fréquent que le nombre de répétitions soit connu à l'avance, et que l'on ait besoin
d'utiliser le numéro de l'itération afin d'effectuer des calculs ou des tests. Le mécanisme
permettant cela est la boucle Pour.
Forme de la boucle Pour :

Pour variable ← valeur initiale Jusqu’à valeur finale faire

liste d'instructions
fpour
 Répétitions inconditionnelles

La variable dont on donne le nom va prendre successivement toutes les valeurs entières entre
valeur initiale et valeur finale. Pour chaque valeur prise par la variable, la liste des
instructions est exécutée. La valeur utilisée pour énumérer les itérations est appelée valeur
d'itération, indice d'itération ou compteur. L'incrémentation par 1 de la variable est
implicite.

Autre forme de la boucle Pour :

Pour variable ← valeur initiale Jusqua’à valeur finale Pas -1 faire

liste d'instructions
fpour

La variable d'itération est décrémentée de 1 après chaque itération.

 Répétitions inconditionnelles

Exemple 1 (cas simple, compteur croisant)

Ecrire l'algorithme permettant d'afficher la table de multiplication par 9.

Un algorithme possible est le suivant :

Algorithme
Var i : Entier {indice d'itération}
début
écrire (1*9)
écrire (2*9)
écrire (3*9)
écrire (4*9)
écrire (5*9)
écrire (6*9)
écrire (7*9)
écrire (8*9)
écrire (9*9)
écrire (10*9)
fin
Il est plus simple d'utiliser une boucle avec un compteur prenant d'abord la
valeur 1, puis augmentant peu à peu jusqu'à atteindre 10.
 Répétitions inconditionnelles

Algorithme
Var i : entier {indice d'itération}
début
pour i ← 1 Jusqu’à 10 faire
écrire (i*9)
fpour
fin

Exemple 2
Compte à rebours : écrire l'algorithme de la fonction qui, à partir d'un nombre
entier positif n, affiche tous les nombres par ordre décroissant jusqu'à 0.

Exemple : pour n = 5, le résultat sera 5 4 3 2 1 0.

 Répétitions inconditionnelles

Algorithme compteARebours
Var n : entier
i : entier {indice d'itération}
début
Lire (n)
pour i décroissant de n à 0 faire
écrire (i)
fpour
fin

Exemple 3 (calcul de la récurrence : cas de la somme)

On veut éditer, pour n donné, la somme des carrés des n premiers entiers.
Cette somme, notée s, est obtenue en calculant le n-ième terme d'une suite définie
par récurrence :
sn=sn-1+i²

Algorithmiquement, le calcul d'une telle suite se fait en deux étapes :

- initialisation (ici, s0=0)
- répétition de : calcul du ième terme en fonction du terme d'indice i-1
 Répétitions inconditionnelles

Algorithme
Début
Var s : entier {somme des carré des n premiers entiers}
n : entier
i : entier {indice d'itération}

lire (n)
s← 0
pour i ← 1 à n faire
s ← s + i2
Fpour
écrire (s)
Fin
Schéma de l'évolution de l'état des variables instruction par instruction :

On suppose que la valeur introduite par l'utilisateur est 4.

Instructions n s i

1 4

2 0

3 1

4 1

3 2

4 5

3 3

4 14

3 4

4 30

3 (Fin)

5 Ecrire()
 Répétitions inconditionnelles

Exemple 4 (calcul par récurrence d'un maximum, initialisation à un terme artificiel)

Ecrire l'algorithme qui permet d’éditer le maximum de N entiers positifs donnés
au fur et à mesure.

Comment trouver ce maximum ? C'est le plus grand des 2 nombres : maximum

des N-1 premiers entiers positifs donnés, N-ème entier donné. Ceci est une définition par
récurrence :

Si nombreN > maximumN-1 alors

maximumN ← nombreN
sinon
nombreN ← maximumN-1
fsi

Comment initialiser la suite maximum ? Il faut que maximum1 prenne la valeur nombre1.
Il suffit alors de choisir une valeur de maximum0 plus petite que tout entier positif, par
exemple maximum0 = -1, de manière à assurer que maximum1 aura bien nombre1 pour
valeur. Il s'agit d'une initialisation à un terme artificiel.
 Répétitions inconditionnelles

Algorithme
Début
Var n : entier {nombre d'entiers positifs donné}
maximum : entier {maximum des i premiers entiers}
nombre : entier {ième nombre lu}
i : entier {indice d'itération}
Lire (n)
maximum ← -1
pour i de 1 à n faire
lire (nombre)
si nombre > maximum alors
maximum ← nombre
fsi
Fpour
écrire (maximum)
Fin

Schéma de l'évolution de l'état des variables instruction par instruction :

On suppose que les valeurs introduites par l'utilisateur sont : 4 (nombre d'entiers à comparer),
2, 0, 8, 7.
 Répétitions inconditionnelles

Instructions n maximum i Nombre Nombre>maximum

1 4

2 -1

3 1

4 2

5 Vrai

6 2

3 2

4 0

5 Faux

3 3

4 8

5 Vrai

6 8

3 4

4 7

5 Faux

3 (Fin)

7 Ecrire()
 Répétitions inconditionnelles

Exemple 5 (calcul par récurrence, initialisation à un terme utile)

Ecrire l'algorithme qui permet d’éditer le maximum de n entiers donnés.

L'initialisation a un terme artificiel n'est plus possible ici car les valeurs ne sont
plus bornées inférieurement. Une solution consiste alors à initialiser au premier terme et à
commencer la formule générale de récurrence à 2. Il s'agit d'une initialisation à un terme utile.
 Répétitions inconditionnelles

Algorithme
Var n : entier {nombre d'entiers positifs donné}
maximum : entier {maximum des i premiers entiers}
nombre : entier {ième entier positif donné}
i : entier {indice d'itération}
Début
lire (n)
lire (maximum)
Pour i de 2 à n faire
lire (nombre)
si nombre > maximum alors
maximum ← nombre
Fsi
Fpour
écrire (maximum)
Fin
 Répétitions inconditionnelles

Schéma de l'évolution de l'état des variables instruction par instruction :

On suppose que les valeurs introduites par l'utilisateur sont : 4 (nombre d'entiers à
comparer), 0, 2, 8, 7
Instructions n maximum i Nombre Nombre>maximum

1 4

2 2

3 2

4 0

5 Faux

3 3

4 8

5 Vrai

6 8

3 4

4 7

5 Faux

3 (Fin)

7 Ecrire()
 Répétitions conditionnelles

L'utilisation d'une boucle pour nécessite de connaître à l'avance le nombre d'itérations désiré,
c'est-à-dire la valeur finale du compteur. Dans beaucoup de cas, on souhaite répéter une
instruction tant qu'une certaine condition est remplie, alors qu'il est à priori impossible de
savoir à l'avance au bout de combien d'itérations cette condition cessera d'être satisfaite. Le
mécanisme permettant cela est la boucle Tant que.

Syntaxe de la boucle Tant que :

Tant que condition faire

liste d'instructions
Ftant

Cette instruction a une condition de poursuite dont la valeur est de type booléen et une liste
d'instructions qui est répétée si la valeur de la condition de poursuite est vraie : la liste
d'instructions est répétée autant de fois que la condition de poursuite a la valeur vraie. Le
déroulement pas à pas de cette instruction équivaut à :

Si condition alors
liste d'instructions
si condition alors
liste d'instructions
si condition alors
liste d'instructions ...
 Répétitions conditionnelles

Étant donné que la condition est évaluée avant l'exécution des instructions à
répéter, il est possible que celles-ci ne soient jamais exécutées. Il faut que la liste des
instructions ait une incidence sur la condition afin qu'elle puisse être évaluée à faux et que la
boucle se termine. Il faut toujours s'assurer que la condition devient fausse au bout d'un temps
fini.

Exemple 1
On veut laisser un utilisateur construire des rectangles de taille quelconque, à condition que
les largeurs qu'il saisit soient supérieures à 1 pixel. On peut utiliser une répétition
conditionnelle qui permet de redemander à l'utilisateur de saisir une nouvelle valeur tant que
celle-ci n'est pas valide.

Algorithme saisirLargeurRectangle
Var largeur : entier {largeur courante saisie}
Début
écrire ("indiquez la largeur du rectangle :")
Lire (largeur)
Tant que largeur < 1 faire
écrire (« Erreur : indiquez une valeur strictement positive")
écrire ("indiquez la largeur du rectangle :")
Lire (largeur)
ftant
Fin
 Répétitions conditionnelles

Étant donné que la condition est évaluée avant l'exécution des instructions à
répéter, il est possible que celles-ci ne soient jamais exécutées. Il faut que la liste des
instructions ait une incidence sur la condition afin qu'elle puisse être évaluée à faux et que la
boucle se termine. Il faut toujours s'assurer que la condition devient fausse au bout d'un temps
fini.
Exemple 2
Un poissonier sert un client qui a demandé 1Kg de poisson. Il pèse successivement différents
poissons et s'arrête dès que le poids total égale ou dépasse 1Kg. Donner le nombre de
poissons servis.
Remarque sur la terminaison :
Ce problème est typique des cas où le dernier terme (celui qui fait basculer le test)
doit être retenu.
 Répétitions conditionnelles

Algorithme
Var poids_total : réel {poids total des i premiers poissons}
poids_poisson : réel {poids du ième poisson en grammes}
nb_poisson : entier {nombre de poissons vendus après la ième itération}
Début
poids_total <- 0
nb_poisson <- 0
tant que poids_total < 1000 faire (itération i)
lire (poids_poisson)
poids_total <- poids_total + poids_poisson
nb_poisson <- nb_poisson + 1
ftant
écrire (nb_poisson)
Fin
 Répétitions conditionnelles

Schéma de l'état des variables instruction par instruction :

On suppose que les valeurs introduites par l'utilisateur sont : 350, 280, 375.

Instructions poids_total nb_poisson poids_poison poids_total < 1000

1 0

2 0

3 Vrai

4 350

5 350 Faux

6 1

3 Vrai

4 280

5 630

6 2

3 Vrai

4 375

5 1005

6 3

3 Faux

7 Ecrire()
 Boucles imbriquées

Le corps d'une boucle est une liste d'instructions. Mais cette boucle est elle-même
une instruction. Donc le corps d'une boucle peut contenir une boucle dite imbriquée, qui
utilise un compteur différent. Il faut alors faire attention à l'ordre d'exécution des
instructions : à chaque passage dans le corps de la boucle principale, la boucle imbriquée va
être exécutée totalement.

Exemple
Ecrire l'algorithme permettant d’éditer le triangle suivant, le nombre de lignes
étant donné par l'utilisateur :
1 12 123 1234 12345 ...
 Boucles imbriquées

Algorithme
Var nblignes : entier {nombre de lignes à éditer}
i : entier {indice d'itération sur les lignes}
j : entier {indice d'itération sur les éléments de la ième ligne}
Début
Lire (nblignes)
Pour i de 1 à nblignes faire
Pour j de 1 à i faire
écrire (j)
Fpour
Fpour
Fin
 Les Fonctions Prédéfinies

Tout langage de programmation propose ainsi un certain nombre de

fonctions ; certaines sont indispensables, car elles permettent
d’effectuer des traitements qui seraient sans elles impossibles.
D’autres servent à soulager le programmeur, en lui épargnant de
longs – et pénibles - algorithmes.

1. Les fonctions de texte (Chaînes de caractéres)

Une catégorie privilégiée de fonctions est celle qui nous permet de
manipuler des chaînes de caractères.
 Len(chaîne) : renvoie le nombre de caractères d’une chaîne
 Mid(chaîne,n1,n2) : renvoie un extrait de la chaîne, commençant au
caractère n1 et faisant n2 caractères de long.
exemple : Mid("informatique"", 6, 2) retourne la chaîne "ma".

Ce sont les deux seules fonctions de chaînes réellement

indispensables. Cependant, pour nous épargner des algorithmes
fastidieux, les langages proposent également :
 Left(chaîne,n) : renvoie les n caractères les plus à gauche dans
chaîne.
 Right(chaîne,n) : renvoie les n caractères les plus à droite dans
chaîne
 Trouve(chaîne1,chaîne2) : renvoie un nombre correspondant à la
position de chaîne2 dans chaîne1. Si chaîne2 n’est pas comprise
dans chaîne1, la fonction renvoie zéro.
 Les Fonctions Prédéfinies

Exemples :
Len("Bonjour, ça va ?") vaut
16
Len("")
vaut 0
Mid("Zorro is back", 4, 7) vaut
"ro is b"
Mid("Zorro is back", 12, 1) vaut
"c"
Left("Et pourtant…", 8) vaut
"Et pourt"
Right("Et pourtant…", 4) vaut
"t…"
Trouve("Un pur bonheur", "pur") vaut 4
Trouve("Un pur bonheur", "techno") vaut 0

Il existe aussi dans tous les langages une fonction

qui renvoie le caractère correspondant à un code Ascii donné (fonction
Asc), et Lycée de Versailles (fonction Chr) :
Asc("N") vaut 78
Chr(63) vaut "?"

2. Trois fonctions numériques classiques :

Partie Entière
 Les Fonctions Prédéfinies

Modulo
Cette fonction permet de récupérer le reste de la
division d’un nombre par un deuxième nombre. Par exemple :
A ← Mod(10,3) A vaut 1 car 10 = 3*3 + 1
B ← Mod(12,2) B vaut 0 car 12 = 6*2
C ← Mod(44,8) C vaut 4 car 44 = 5*8 + 4
Cette fonction peut paraître un peu bizarre, est réservée aux seuls
matheux. Mais vous aurez là aussi l’occasion de voir dans les exercices
à venir que ce n’est pas le cas.

3. Les fonctions de conversion

On trouvera une fonction destinée à convertir une chaîne en

numérique (Cnum) en pseudo-code, et une convertissant un nombre
en caractère (Ccar).
 Les tableaux

Notion de tableau
Les tableaux servent à désigner une suite finie d'éléments de même type au
moyen d'une unique variable. Ces éléments peuvent être des entiers, des chaînes, ... Ils sont
stockés dans les différentes cases du tableau, habituellement numérotées de 1 à n
n représentant la taille du tableau (le nombre de cases dans le tableau).
Le type d'un tableau précise l'intervalle de définition et le type (commun) des
éléments.
Nomtableau : tableau [borne_inférieure .. borne_supérieure] type_des_éléments

exemple : pour un tableau de 10 entiers, on pourra écrire :

t : tableau [1..10] d’ entier
Un tel tableau peut par exemple contenir les éléments suivants :
1 2 3 4 5 6 7 8 9 10

45 54 1 -56 22 134 49 12 90 -27

Pour accéder à un élément du tableau, il suffit de préciser entre crochets l'indice de la case
contenant cet élément. Par exemple, pour accéder au septième élément (49) du tableau
d'entiers ci-dessus, on écrit :
t [7].
L'instruction suivante affecte à la variable x la valeur du premier élément du tableau, c'est à
dire 45 :
x ← t [1] L'élément désigné du tableau peut être utilisé comme n'importe quelle
variable :
 Les tableaux

t [7] ← 43 Cette instruction a modifié le tableau t :

1 2 3 4 5 6 7 8 9 10

45 54 1 -56 22 134 43 12 90 -27

Parcours complet d'un tableau

La plupart des algorithmes basés sur les tableaux utilisent des itérations permettant de
faire un parcours complet ou partiel des différents éléments du tableau. De tels algorithmes
établissent le résultat recherché par récurrence en fonction des éléments successivement
rencontrés.
Les répétitions inconditionnelles sont le moyen le plus simple de parcourir
complètement un tableau.
Exemple 1
Dans l'exemple suivant, la fonction affiche un à un tous les éléments d'un tableau de n
éléments :
Algorithme écrireTableau
Var i : entier {indice d'itération}
n : entier {taille du tableau}
tab : tableau [1..n] entier
début
pour i ← 1 à n faire
Écrire (tab [i])
fpour
fin
 Les tableaux

Algorithme Remplissage_Affichage
Var n : entier {taille du tableau}
tab : tableau [1..n] entier
début
Lire (n)
Pour i ← 1 à n faire
Lire (tab[i])
fpour
pour i ← 1 à n faire
Écrire (tab[i])
fpour
fin

Exemple 2
Algorithme qui permet de multiplier par 2 tous les éléments d'un tableau.
 Les tableaux

Algorithme doublerTableau
Var n : entier {taille du tableau}
t : tableau [1..n] entier {tableau modifiable}
début
Pour i ← 1 à n faire
t[i] ← t[i]*2
fpour
fin

Parcours partiel d'un tableau

Certains algorithmes sur les tableaux se contentent de parcourir successivement les

différents éléments du tableau jusqu'à rencontrer un élément satisfaisant une certaine condition.
Un tel parcours partiel est le plus souvent basé sur une répétition conditionnelle.

Exemple : On cherche ici à savoir si un tableau saisi au clavier n'est constitué que d'entiers
positifs :
 Les tableaux

Algorithme
Var i : entier {indice d'itération} , n : entier {taille du tableau}
tab : tableau entier [1..n] , positif : booléen {vrai si aucun entier négatif n'a été détecté}
début
Pour i ← 1 à n faire
lire (tab[i])
fpour
i←0
positif ← vrai
tant que positif et (i < n) faire
si tab[i] < 0 alors
positif ← faux
fsi
i ← i+1
ftant
si positif alors
écrire ("tableau d'entiers naturels")
sinon
écrire ("tableau d'entiers relatifs")
fsi
fin
 Les tableaux

Parcours imbriqués

Certains algorithmes sur les tableaux font appel à des boucles imbriquées : la boucle
principale sert généralement à parcourir les cases une à une, tandis que le traitement de chaque
case dépend du parcours simple d'une partie du tableau (par exemple toutes les cases restantes),
ce qui correspond à la boucle interne.

Exemple
L’algorithme suivant calcule, pour chaque case d'un tableau, le nombre de cases
suivantes qui contiennent un élément strictement supérieur. Les résultats sont placés dans un
tableau.
 Les tableaux

Algorithme calculerNbSuccesseurSup
Var n : entier {taille du tableau}
t : tableau [1..n] entier
tres : tableau [1..n] entier {tableau résultat (case i contient le nombre de cases de t indice
strictement supérieur à i qui contiennent un élément supérieur à t[i] }
i : entier {indice d'itération de la boucle principale (parcours pour remplir tres)}
j : entier {indice d'itération de la boucle interne (parcours des cases restantes de t)}
début
Pour i ← 1 à n-1 faire
tres[i] ← 0
fpour
Pour i ← 1 à n-1 faire
Pour j ← i+1 à n-1 faire
si t[i] < tres[i]+1 alors
tres[i] ← tres[i]+1
fsi
fpour
fpour
tres
Fin
 Les tableaux

Tableaux multidimensionnels
Les cases d'un tableau à une dimension sont indicées de manière consécutive (cases
"alignées"). Il est possible de disposer ces cases selon des grilles (tableaux à deux dimensions),
des cubes (tableaux à trois dimensions), ...
Les algorithmes les plus simples sur ces tableaux utilisent néanmoins en général des
boucles imbriquées : chaque niveau de boucle correspond au parcours selon une dimension.
Le type d'un tableau précise l'intervalle de définition selon chaque dimension.

tableau [borne_inf_dim1 .. borne_sup_dim1, borne_inf_dim2 .. borne_sup_dim2, ...]

type_des_éléments

• Tableaux à deux dimensions

Ces tableaux sont faciles à se représenter comme une grille (ou matrice) ayant un
certain nombre de lignes (première dimension) et un certain nombre de colonnes (seconde
dimension).
tableau [1..nb_lignes, 1..nb_colonnes] type_des_éléments
Un tel tableau, avec 5 colonnes et 3 lignes, peut par exemple contenir les éléments
suivants :
1 2 3 4 5

1 45 54 1 -56 22

2 64 8 54 34 2

3 56 23 -47 0 12
 Les tableaux

Pour accéder à un élément du tableau, il suffit de préciser entre crochets l'indice de la

case contenant cet élément, et ce pour chacune des dimensions. Par exemple, pour accéder à
l'élément 23 du tableau d'entiers ci-dessus, on écrit : t[3,2].
L'instruction suivante affecte à la variable x la valeur du premier élément du tableau,
c'est à dire 45.

x ← t[1,1]

L'élément désigné du tableau peut alors être utilisé comme n'importe quelle variable :

t[3,2] ← 43

Cette instruction a modifié le tableau :

1 2 3 4 5

1 45 54 1 -56 22

2 64 8 54 34 2

3 56 43 -47 0 12
Exemple : calcul de la somme
Algorithme somme
Var li : entier {nombre de lignes du tableau}
co : entier {nombre de colonnes du tableau}
t : tableau [1..li, 1..co] entier {tableau dont on cherche l'élément maximal}
s : entier {somme des éléments déjà parcourus}
i : entier {indice d'itération sur les lignes}
j : entier {indice d'itération sur les colonnes}
début
s←0
Pour i ← 1 à li faire
Pour j ← 1 à co faire
s ← s + t[i,j]
fpour
fpour
Ecrire (s)
fin
Recherche dichotomique
La fonction rechercheDicho recherche un élément dans un tableau trié et retourne
l'indice d'une occurrence de cet élément (ou -1 en cas d'échec). Une telle recherche peut être
réalisée de manière séquentielle ou dichotomique. Nous développons ici la version
dichotomique qui est la plus efficace en temps d'exécution.

On compare l'élément cherché à celui qui se trouve au milieu du tableau. Si

l'élément cherché est plus petit, on continue la recherche dans la première moitié du tableau
sinon dans la seconde. On recommence ce processus sur la moitié. On s'arrête lorsqu'on a
trouvé ou lorsque l'intervalle de recherche est nul.

Exemples :

Exemple de recherche dans le tableau d'entiers suivant défini sur l'intervalle [3..10] :

5 13 18 23 46 53 -89 97

3 4 5 6 7 8 9 10
Recherche de 46 :
Etape 1 : comparaison de 46 avec t[6] (6=(10+3)÷2), t[6]<46 => recherche dans [7..10]
Etape 2 : comparaison de 46 avec t[8], t[8]>46 => recherche dans [7..7]
Etape 3 : comparaison de 46 avec t[7], t[7]=46 => élément cherché trouvé à l'indice 7

Recherche de 10 :
Etape 1 : comparaison de 10 avec t[6], t[6]<10 => recherche dans [3..5]
Etape 2 : comparaison de 10 avec t[4], t[4]<10 => recherche dans [3..3]
Etape 3 : comparaison de 10 avec t[3], t[3]>10 => recherche dans [4..3], Borne inférieure
supérieure à la borne supérieure donc on met fin à l'algorithme et l'élément cherché n'a pas été
trouvé !

fonction rechercheDicho(e : entier, n : entier, t : tableau entier[0..n-1]):entier

Var e : entier {élément recherché}
n : entier {taille du tableau}
t : tableau entier[0..n-1] {tableau trié par ordre croissant}
debut : entier {début de la zone de recherche}
fin : entier {fin de la zone de recherche}
trouve : booléen {faux tant que l'élément cherché n'est pas trouvé}
i : entier {indice de la case du milieu de la zone de recherche}
indice : entier {indice de l'élément recherché ou -1 s'il n'est pas trouvé}
début
debut <- 0
fin <- n-1
trouve <- faux
tant que debut <= fin et non trouve faire
i <- (debut+fin)÷2
si t[i] = e alors
trouve <- vrai
sinon
si t[i] > e alors
fin <- i-1
sinon
debut <- i+1
fsi
fsi
ftant
si trouve alors
indice <- i
sinon
indice <- -1
fsi
retourne
indice
fin
 Compléments sur les fonctions

Paramètres modifiables
L'entête d'une fonction spécifie son nom, le type de son résultat, et les paramètres
(avec leurs types). Ces paramètres sont considérés comme les données transmises à la
fonction, c'est à dire l'entrée de la fonction. Il peut arriver que la fonction modifie ces
paramètres lors de l'exécution de son algorithme. On parle alors de paramètre modifiable : il
s'agit à la fois d'une entrée et d'une sortie de l'algorithme. La déclaration d'un tel paramètre
dans la liste des paramètres se fait de la manière suivante :

Fonction nom(nom_param InOut : type_param) : type_résultat

Exemple 1
La fonction suivante prend deux paramètres réels et les modifie de manière à ce
qu'ils soient dans l'ordre croissant (N.B. : elle ne retourne pas de résultat) :

fonction ordonner2Réels (x InOut : réel, y InOut : réel)

tmp : réel {variable de stockage temporaire}

début
si x > y alors
tmp <- x
x <- y
y <- temp
fsi
fin
 Compléments sur les fonctions

Exemple 2
La fonction suivante prend trois paramètres réels : les deux premiers sont les bornes d'un
intervalle, et le troisième est (éventuellement) modifié de manière à rester dans l'intervalle
spécifié.

fonction seuillerRéel(inf : réel, sup : réel, x InOut : réel)

Var inf : réel {borne inférieure de l'intervalle}
sup : réel {borne supérieure de l'intervalle}
x : réel {valeur fournie, est modifiée (éventuellement) par seuillage}

début
si x < inf alors
x <- inf
sinon
si x > sup alors
x <- sup
fsi
fsi
fin
Enfin, une fonction qui utilise des paramètres modifiables peut également renvoyer un
résultat.
 Compléments sur les fonctions

Exemple 3
La fonction suivante est similaire à celle de l'exemple précédent. Elle renvoie en plus un
booléen égal à vrai si et seulement si le paramètre x a été effectivement modifié.

fonction modifierRéelParSeuillage(inf : réel, sup : réel, x InOut : réel):booléen

Var inf : réel {borne inférieure de l'intervalle
sup : réel {borne supérieure de l'intervalle}
x : réel {valeur fournie, est modifiée (éventuellement) par seuillage}
res : booléen {résultat vrai si x est modifié}
début
res <- faux
si x < inf alors
x <- inf
res <- vrai
sinon
si x > sup alors
x <- sup
res <- vrai
fsi
fsi
retourne res
fin
 Compléments sur les fonctions

Appels de fonction

Les fonctions ont jusqu'à présent été utilisées de façon à présenter certains algorithme de
manière autonome (données fournies, résultat calculé). Plus généralement, les fonctions sont
utilisées pour décrire les différentes étapes d'un algorithme plus complexe. On peut alors
appeler ces fonctions pour réaliser les étapes de calcul correspondantes : lors de l'appel, on
indique grâce aux paramètres les données sur lesquelles la fonction doit travailler, puis on
récupère le résultat retourné. Un appel de fonction provoque donc l'exécution complète du
corps de cette fonction.

Le passage des paramètres sera décrit ici de manière intuitive. Chaque langage de
programmation traite cet aspect d'une manière rigoureuse, ce qui nécessite d'aborder les
notions plus détaillées (paramètres formels et effectifs, passage par valeur ou par adresse,
portée des paramètres, compatibilité des types, ...).
 Compléments sur les fonctions

Exemple 1
Décrire un algorithme qui calcule le maximum de 4 réels saisis au clavier. Le
calcul du maximum de deux valeurs sera décrit par une fonction.

Fonction calculerMax2Réels(x : réel, y : réel) : réel

Var x : réel , y : réel , res : réel {maximum trouvé}
Début
si x > y alors
res <- x
sinon
res <- y
fsi
retourne
res
Fin
 Compléments sur les fonctions

Algorithme
Var maximum : réel {maximum des i premiers nombre réels}
nombre : réel {ième réel donné}
i : entier {indice d'itération}
début
lire (maximum)
pour i de 2 à 4 faire
lire (nombre)
maximum <- calculerMax2Réels(nombre, maximum)
fpour
écrire (maximum)
fin
Il est possible d'utiliser les mêmes variables dans différentes fonctions et dans
l'algorithme principal. On précise donc à chaque fois à quelle fonction correspond la
variable.
Les paramètres fournis lors de l'appel peuvent être des expressions, s'il ne s'agit
pas de paramètres modifiables.
Si une fonction a des paramètres modifiables, les paramètres fournis lors de
l'appel doivent être des variables. Les instructions d'affectation que contient la fonction
appelée peuvent alors modifier ces variables.
Une fonction peut elle-même contenir plusieurs appels de fonctions. Il est
également possible d'utiliser le résultat d'une fonction directement dans le paramètre fourni
à l'appel d'une autre fonction.
 Compléments sur les fonctions

Exemple 2
Un étudiant doit, pour obtenir son diplôme, passer un écrit et un oral dans deux
modules. le coefficient du premier module est le double de celui du second module. La
moyenne d'un module, afin de ne pas pénaliser trop les éventuels échecs accidentels,
accorde un coefficient double à la meilleure des deux notes obtenues.
On veut décrire un algorithme où, après saisie des quatre notes, la décision
finale est affichée (diplôme obtenu si la moyenne est supérieure ou égale à 10, aucun
module ne devant avoir une moyenne inférieure à 8).

fonction calculerMoyenne (n1:réel, n2:réel):réel

Var n1 : réel {note de coefficient 1}
n2 : réel {note de coefficient 2}
moy : réel {moyenne calculée}
début
moy <- (n1 + 2*n2)/3
retourne
moy
fin
 Compléments sur les fonctions

Exemple 2

fonction calculerNoteModule (n1:réel, n2:réel) : réel

Var n1 : réel {première note }
n2 : réel {deuxième note}
note : réel {note du module}
début
si n1 > n2 alors
note <- calculerMoyenne (n2, n1)
sinon
note <- calculerMoyenne (n1, n2)
fsi
retourne
note
fin
 Compléments sur les fonctions

Exemple 2
fonction accorderDiplôme (m1:réel, m2:réel) : booléen
Var m1 : réel {moyenne premier module}
m2 : réel {moyenne second module}
moy : réel {moyenne générale}
recu : booléen {à vrai si l'étudiant a obtenu son diplôme}
début
moy <- calculerMoyenne(m2, m1)
si moy < 10 alors
recu <- faux
sinon
si (m1 < 8) ou (m2 < 8) alors
recu <- faux
sinon
recu < vrai
fsi
fsi
retourne
recu
fin
 Compléments sur les fonctions

Algorithme
Var ne_m1 : réel {note d'écrit du premier module}
no_m1 : réel {note d'oral du premier module}
ne_m2 : réel {note d'écrit du second module}
no_m2 : réel {note d'oral du second module}
obtenu : booléen {vrai si le diplôme est accordé}

début
lire (ne_m1)
lire (no_m1)
lire (ne_m2)
lire (no_m2)
obtenu <- accorderDiplôme (calculerNoteModule(ne_m1, no_m1),
calculerNoteModule(ne_m2, no_m2))
si obtenu alors
écrire("diplôme obtenu")
sinon
écrire("diplôme non accordé")
fsi
fin
 Données structurées

6. Données structurées
6.1 Données structurées simples
nous pouvions réserver un emplacement pour une information
d'un certain type. Un tel emplacement s'appelle une variable.
Nous pouvions aussi réserver une série d'emplacement
numérotés pour une série d'information de même type. Un tel
emplacement s'appelle un tableau
Nous pouvons réserver une série d'emplacements pour des
données de type différents. Un tel emplacement s'appelle une
variable structurée.
Ainsi, le problème du "découpage" de chaque enregistrement en
différentes variables (le nom, le prénom, le numéro de téléphone, etc.)
sera résolu d'avance, puisqu'on aura une structure, en quelque sorte, tout
prêt d'avance pour accueillir et prédécouper nos enregistrements.
 Données structurées

Attention toutefois ; lorsque nous utilisions des variables de type

prédéfini, comme des entiers, des booléens, etc. nous n'avions qu'une
seule opération à effectuer : déclarer la variable en utilisant un des types
existants.
A présent que nous voulons créer un nouveau type de variable
(par assemblage de types existants), il va falloir faire deux choses :
d'abord, créer le type. Ensuite seulement, déclarer la (les) variable(s)
d'après ce type.
Exemple Militaire.
Nous allons donc, avant même la déclaration des variables, créer
un type, une structure, calquée sur celle de nos enregistrements, et donc
prête à les accueillir :
Exemple de Déclaration :
Structure Militaire
Nom : Chaine * 20
Prénom : Chaine * 15
Grade : Chaine * 20
Unite : Chaine * 20
Fin Structure
 Données structurées

Ici, Militaire est le nom de ma structure. Ce mot jouera par la suite dans
mon programme exactement le même rôle que les types prédéfinis
comme Numérique, Caractère ou Booléen.
Maintenant que la structure est définie, je vais pouvoir, dans la
section du programme où s'effectuent les déclarations, créer une ou des
variables correspondant à cette structure :
Var Personnel : Militaire
Et je pourrais remplir les différentes informations contenues au
sein de la variable Individu de la manière suivante :
Personnel ← “Alaoui", “Mohamed", “MG", “SIGR"

On peut aussi avoir besoin d'accéder à un seul des champs de la

variable structurée. Dans ce cas, on emploie le point :
Personnel.Nom ← "Alaoui"
Personnel.Prénom ← "Mohamed"
Personnel.Grade ← "MG"
Personnel.Unite ← "SIGR"
Ainsi, écrire correctement une information dans le fichier,
puisqu'on dispose d'une variable.
Une fois remplis les différents champs de cette variable, il n'y a
plus qu'à envoyer celle-ci directement dans le fichier.
 Données structurées

6.2 Tableaux de données structurées

Et encore plus loin, encore plus vite et encore plus fort. Si à partir
des types simples, on peut créer des variables et des tableaux de
variables, on peut créer des variables structurées... et des tableaux de
variables structurées.
En fait, dans notre tableau structuré, les champs des
emplacements du tableau correspondront aux champs du fichier texte, et
les indices des emplacements du tableaux correspondront aux différentes
lignes du fichier.
Voici, l'algorithme complet de lecture du fichier Adresses et de sa
recopie intégrale en mémoire vive, en employant un tableau structuré.
 Données structurées

Algorithme Stagiaire
Const N=30
Type Structure Stagiaire
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Adresse : Chaine * 30
Tel : Chaine * 10
Fin Structure
Var
T : Tableau [1..N] Stagiaire
i : Entier
Début
{Enregistrement des Stagiaires}
Pour i ← 1 Jusqu’à N Faire
Lire ( T[i].Matricule )
Lire ( T[i].Nom )
Lire ( T[i].Prénom )
Lire ( T[i].Adresse )
Lire ( T[i].Tel )
FPour
Fin
 Données structurées

Algorithme Stagiaire
Const N=30
Type Structure Adresse
Num : Entier
Rue : Chaine * 10
Ville : Chaine * 20
Fin Structure
Structure Stagiaire
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Adr : Adresse
Tel : Chaine * 10
Fin Structure
Var
T : Tableau [1..N] Stagiaire
i : Entier
Début
{Enregistrement des Stagiaires}
Pour i ← 1 Jusqu’à N Faire
Lire ( T[i].Matricule )
Lire ( T[i].Nom )
Lire ( T[i].Prénom )
Lire ( T[i].Adr.Num )
Lire ( T[i].Adr.Rue )
Lire ( T[i].Adr.Ville )
Lire ( T[i].Tel )
FPour
Fin
 Données structurées

Algorithme Stagiaire
Const N=30
Type Structure Adresse
Num : Entier
Rue : Chaine * 10
Ville : Chaine * 20
Fin Structure
Structure Stagiaire
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Adr : Adresse
Tel : Chaine * 10
Fin Structure
Var
T : Tableau [1..N] Stagiaire
i,j : Entier
St : Stagiaire
Début
{Enregistrement des Stagiaires}
Pour i ← 1 Jusqu’à N Faire
Lire ( T[i].Matricule )
Lire ( T[i].Nom )
Lire ( T[i].Prénom )
Lire ( T[i].Adr.Num )
Lire ( T[i].Adr.Rue )
Lire ( T[i].Adr.Ville )
Lire ( T[i].Tel )
FPour
 Données structurées

Pour i ← 1 Jusqu’à N-1 Faire

Pour j ← i+1 Jusqu’à N Faire
Si T[i].Matricule > T[j].Matricule Alors
St ← T[i]
T[i] ← T[j]
T[j] ← St
Fsi
Fpour
Fpour

Pour i ← 1 Jusqu’à N Faire

Ecrire ( T[i].Matricule )
Ecrire ( T[i].Nom )
Ecrire ( T[i].Prénom )
Ecrire ( T[i].Adr.Num )
Ecrire ( T[i].Adr.Rue )
Ecrire ( T[i].Adr.Ville )
Ecrire ( T[i].Tel )

FPour
Fin
 Les Fichiers

 Les fichiers servent à stocker des informations de manière permanente,

entre deux exécutions d’un programme. Car si les variables disparaissent
à chaque fin d’exécution, les fichiers, eux sont stockés sur des
périphériques à mémoire de masse (disquette, disque dur, CD Rom…).
1. Organisation des fichiers
- le fichier est sous forme de lignes successives
- le fichier contient le même genre d'information à chaque ligne.
Ces lignes sont alors appelées des enregistrements.
Exemple : Le cas d'un carnet d'adresses.
Le fichier est destiné à mémoriser les coordonnées d'un certain
nombre de personnes. Pour chacune, il faudra noter le nom, le prénom, le
numéro de téléphone et l'email.
Dans ce cas, il peut paraître plus simple de stocker une personne
par ligne du fichier (par enregistrement)
2. Structure des enregistrements
- Les fichiers peuvent être structurés en enregistrements
 Les Fichiers

Exemple : Carnet d’adresses

Avec le nom, le prénom, le téléphone et l'email. Les données, sur
le fichier texte, peuvent être organisées ainsi :
Structure n°1
"Fonfec";"Sophie";0142156487;"[email protected]"
"Zétofrais";"Mélanie";0456912347;"zé[email protected]"
"Herbien";"Jean-Philippe";0289765194;"[email protected]"
"Hergébel";"Octave";0149875231;"[email protected]"
ou ainsi :
Structure n°2
Fonfec Sophie 0142156487
[email protected]
Zétofrais Mélanie 0456912347
zé[email protected]
Herbien Jean-Philippe 0289765194
[email protected]
Hergébel Octave 0149875231
[email protected]
La structure n°1 est dite délimitée ; Elle utilise un caractère spécial, appelé
caractère de délimitation, qui permet de repérer quand finit un champ et
quand commence le suivant.
 Les Fichiers

La structure n°2 est dite à champs de largeur fixe. Il n’y a pas de

caractère de délimitation, mais on sait que les x premiers caractères de
chaque ligne stockent le nom, les y suivants le prénom, etc. Cela impose
bien entendu de ne pas saisir un renseignement plus long que le champ
prévu pour l’accueillir.
 L’avantage de la structure n°1 est son faible encombrement en place
mémoire ; il n’y a aucun espace perdu, et un fichier texte codé de cette
manière occupe le minimum de place possible.
Mais elle possède en revanche un inconvénient majeur, qui est la
lenteur de la lecture. En effet, chaque fois que l’on récupère une ligne
dans le fichier, il faut alors parcourir un par un tous les caractères pour
repérer chaque occurrence du caractère de séparation avant de pouvoir
découper cette ligne en différents champs.
 La structure n°2, à l’inverse, gaspille de la place mémoire.
Mais d’un autre côté, la récupération des différents champs est
très rapide. Lorsqu’on récupère une ligne, il suffit de la découper en
différentes chaînes de longueur prédéfinie.
 Les Fichiers

3. Types d’accès
Il existe une autre ligne de partage des fichiers : le type d’accès,
autrement dit la manière dont la machine va pouvoir aller rechercher les
informations contenues dans le fichier.
On distingue :
 L’accès séquentiel : Dans le cas d'un fichier texte, cela signifie qu'on lit
le fichier ligne par ligne (enregistrement par enregistrement).
 L’accès direct : on peut accéder directement à l’enregistrement de son
choix, en précisant le numéro de cet enregistrement.
 L’accès indexé : pour simplifier, il combine la rapidité de l'accès direct
et la simplicité de l'accès séquentiel (en restant toutefois plus compliqué).
Il est particulièrement adapté au traitement des gros fichiers, comme les
bases de données importantes.
En fait, tout fichier peut être utilisé avec l’un ou l’autre des trois
types d’accès. Le choix du type d’accès n’est pas un choix qui concerne le
fichier lui-même, mais uniquement la manière dont il va être traité par la
machine. C’est donc dans le programme, et seulement dans le
programme, que l’on choisit le type d’accès souhaité.
 Les Fichiers

4. Instructions (fichiers texte en accès séquentiel)

Si l’on veut travailler sur un fichier, la première chose à faire est
de l’ouvrir.
Et lorsqu’on ouvre un fichier, on stipule ce qu’on va en faire : lire
ou écrire
 Si on ouvre un fichier pour lecture, on pourra uniquement
récupérer les informations qu’il contient, sans les modifier en aucune
manière.
 Si on ouvre un fichier pour écriture, on pourra mettre dedans
toutes les informations que l’on veut. Mais les informations
précédentes, si elles existent, seront intégralement écrasées Et on
ne pourra pas accéder aux informations qui existaient
précédemment.
 Les Fichiers

Déclaration d’un fichier :

Si l’on veut travailler sur un fichier, la première
Type Structure Personne
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Fin Structure
Var
Fich : File of Personne
Individu : Personne

- La Variable Fiche est un fichier (File) dont ses composants sont du type
Personne.
- Bien entendu, le fichier qui l’on va ainsi créer contenuera à exister,
indépendament du programme lui-même, notament comme tout fichier, il possédera un nom
de la forme :
NomFichier.EXT
Ce nom est spécifié par l’instruction :
Affecter (NomFichier_Logique , NomFichier_Physique)
Exemple : Affecter ( Fich , "C:Exemple.Dat")
 Les Fichiers

- Celle-ci établit en quelque sorte une correspondance entre l’identification

‘interne’ du fichier (Fich) et son nom ‘Externe’ (Ici, C:Exemple.Dat)

Instructions de Manipulation :
- Ouverture du fichier en Lecture :

Ouvre (Fich) Lecture

Ou bien : OuvreL (Fich)
Il permet l’ouverture de fichier pour la lecture des informations

- Ouverture du fichier en écriture :

Ouvre (Fich) Ecriture

Ou bien : OuvreE (Fich)

Il permet l’ouverture de fichier pour l’écriture des informations lus au clavier dans
le fichier.
 Les Fichiers

- La lecture d’un élément dans le fichier :

Lire (Fich , Elément)

Exemple : Lire (Fich , Individu)
Il lit un élément dans le fichier à l’emplacement du fenêtre et le met dans le Buffer.
Le « Buffer » est un emplacement égale à un article dans la mémoire Tampon.

- L’écriture d’un élément dans le fichier :

Ecrire (Fich , Elément)

Exemple : Ecrire (Fich , Individu)

L’information « Buffer » doit être écrit dans le fichier.

Remarque : Après Lire (Fich , X ) ou Ecrire (Fich , X ), la fenêtre avance d’un

article dans le fichier.

- Fermeture du fichier :

Fermer (Fich)
Il permet la fermeture du fichier
 Les Fichiers

- Chercher un élément dans un fichier (Accès direct):

Cherche (Fich , N)
Il permet de déplacer la fenêtre sur le N+1 élément.
Les fonctions Standards :

- EOF ( Fich ) : Est une fonction (End Of File) qui renvoie la valeur Vrai si on a
atteint la fin du fichier

- FileSize ( Fich ) : Taille du fichier

 Les Fichiers

Algorithme Création
Type Structure Personne
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Fin Structure
Var
Fich : File of Personne
Individu : Personne
Début

Affecter ( Fich , "C:Exemple.Dat" )

OuvreE ( Fich )
Tant que Len (Individu.nom ) = 0 faire
Lire (Fich , Individu.Matricule)
Lire (Fich , Individu.Nom)
Lire (Fich , Individu.Prenom)
Si Len (Individu.Nom) <> 0 Alors
Lire (Fich , Individu )
Fsi
FTantQue
Fermer ( Fich )
Fin
 Les Fichiers

Algorithme Affichage
Type Structure Personne
Matricule : Entier
Nom : Chaine * 20
Prénom : Chaine * 15
Fin Structure
Var
Fich : File of Personne
Individu : Personne
Début

Affecter ( Fich , "C:Exemple.Dat" )

OuvreL ( Fich )
Tant que Not Eof ( Fich ) faire
Ecrire (Fich , Individu )
Ecrire (Indvidu.Matricule)
Ecrire (Indvidu.Nom)
Ecrire (Indvidu.Prénom)

FTantQue
Fermer ( Fich )
Fin
 Les Fichiers

5. Stratégies de traitement
Il existe globalement deux manières de traiter les fichiers textes :
 l’une consiste à s’en tenir au fichier proprement dit, c'est-à-dire à
modifier directement (ou presque) les informations sur le disque dur.
C’est parfois un peu acrobatique, lorsqu’on veut supprimer un
élément d’un fichier : on programme alors une boucle avec un test,
qui recopie dans un deuxième fichier tous les éléments du premier
fichier sauf un ; et il faut ensuite recopier intégralement le deuxième
fichier à la place du premier fichier.
 l’autre stratégie consiste, comme on l’a vu, à passer par un ou
plusieurs tableaux. En fait, le principe fondamental de cette
approche est de commencer, avant toute autre chose, par recopier
l’intégralité du fichier de départ en mémoire vive. Ensuite, on
ne manipule que cette mémoire vive (concrètement, un ou plusieurs
tableaux). Et lorsque le traitement est terminé, on recopie à nouveau
dans l'autre sens, depuis la mémoire vive vers le fichier d’origine.
Les avantages de la seconde technique sont nombreux, et 99 fois
sur 100, c'est ainsi qu'il faudra procéder :
 la rapidité : les accès en mémoire vive sont des milliers de fois plus
rapides que les accès aux mémoires de masse.
En basculant le fichier du départ dans un tableau, on
minimise le nombre ultérieur d'accès disque, tous les traitements
 Les Fichiers

 la facilité de programmation : bien qu’il faille écrire les instructions de

recopie du fichier dans le tableau, pour peu qu’on doive tripoter les
informations dans tous les sens, c’est largement plus facile de faire cela
avec un tableau qu’avec des fichiers.

Toutefois, lorsque le fichier contient des données de type non

homogènes (chaînes, numériques, etc.) cela risque d’être coton pour le
stocker dans un tableau unique : il va falloir déclarer plusieurs tableaux,
dont le maniement au final peut être aussi lourd que celui des fichiers de
départ.
A moins... : créer des types de variables personnalisés, composés
d’un « collage » de plusieurs types existants (10 caractères, puis un
numérique, puis 15 caractères, etc.). Ce type de variable s'appelle un type
structuré.
 Les Fichiers

7. Récapitulatif général
Lorsqu'on est amené à travailler avec des données situées dans
un fichier, plusieurs choix, en partie indépendants les uns des autres,
doivent être faits :
 sur l'organisation en enregistrements du fichier (choix entre fichier
texte ou fichier binaire)
 sur le mode d'accès aux enregistrements du fichier (direct ou
séquentiel)
 sur l'organisation des champs au sein des enregistrements (présence de
séparateurs ou champs de largeur fixe)
 sur le type de variables utilisées pour cette recopie en mémoire vive
(plusieurs tableaux de type simple, ou un seul tableau de type
structuré).
Chacune de ces options présente avantages et inconvénients, et
il est impossible de donner une règle de conduite valable en toute
circonstance. Il faut connaître ces techniques, et savoir choisir la bonne
option selon le problème à traiter.