ALGORITHMIQUE

Années Préparatoires Intégrés ( API )

Département Génie Informatique

Année Universitaire 2024/2025

 CHAPITRE 1
LE PSEUDO-CODE
DÉFINITIONS Analyse
Compréhension
Enoncé d'un
problème Résolution

Comment
? Algorithme
Codification Pseudo-code

ces étapes
sont liées à
l’exécution Interprétation Langage de programmation (code)
Programme

Résultat Langage machine

Exécution par
l'ordinateur

10/21/2024 3
DÉFINITIONS
Qu’est-ce qu’un Pseudo-code ?

Le pseudocode est un langage pour exprimer clairement et formellement un algorithme. Ce

langage est près d'un langage de programmation comme Java, C ou C++, sans être identique à
l'un ou à l'autre. Il exprime des idées formelles dans une langue près du langage naturel de ses
usagers (pour nous, le français) en lui imposant une forme rigoureuse

Qu’est ce que veut dire « écrire un algorithme »?

 Analyser et comprendre le problème

Etude des données fournies et des résultats attendus.
 Résoudre le problème
C’est trouver les structures de données adaptées ainsi que l’enchaînement des actions à réaliser pour passer
des données (entrées) aux résultats(sorties).
10/21/2024 4
DÉFINITIONS
Y a-t-il un langage d’algorithme universelle?

Aucune règle « officielle » ou norme n'est définie pour écrire du pseudo-code. Il n'y a donc pas de
« mauvaise » syntaxe, ni d'écriture meilleure qu'une autre (vous pouvez constater cela en cherchant
sur internet). Mais dans un soucis de compréhension et d’adaptation facile aux future langages qui
vont être étudiés, nous allons adopter les notations proposées dans ce cours.

L’analyse et l’écriture d’un algorithme dépende de quoi?

Les contraintes qui régissent une écriture algorithmique sont :

 Le niveau d’abstraction du type de langage ciblé.
 Les opérations élémentaires.
 La similarité aux langages naturels humain.
 La recherche d’universalisation.
10/21/2024 5
LES CARACTÉRISTIQUES D’UN ALGORITHME

L’organisation des données et

La modularité utilisation de ressources
et la réutilisabilité La plupart des algorithmes
une écriture modulaire par compromettent une organisation
décomposition de tâches peut optimisée des données et des
rendre des parties réutilisables ressources impliqué dans les calculs.
dans d’autres contextes. Cette organisation mène à des
structures de données qui sont
également des objets d’étude centraux
en informatique.

La clarté et la
Nombre de calculs, temps
compréhensibilité
d’exécution, complexité
de l’algorithme
Il s’agit de l’évaluation du temps
La clarté des instructions et
que peut prendre l’exécution
leur enchainement.
d’un algorithme lorsqu’il est
L’accompagnement par des
traduit en programme.
commentaire.
Le choix significatif des noms
de variables.
10/21/2024 6
MISE EN FORME D’UN ALGORITHME
Le Modèle à respecter

 Un algorithme doit porter un nom (il est

ALGORITHME <nom_algorithme>
désirable qu’il soit significatif et réduit).
<déclarations_variables>
 Juste après la déclaration de variables pour
DEBUT
stocker les données.
<instructions>
 Les mots clés doivent être écrits en majuscule.
FIN
 Entre DEBUT et FIN nous mettons l’ensemble des
instructions qui résous le problème.

10/21/2024 7
LES VARIABLES 1/3
Définition des variables

Une variables est définie par :

 Un identificateur : suite quelconque de caractères.
 Un type : Booléen, numérique (entier ou réel), caractère ou chaîne de caractères.
 Une valeur : c'est le contenu de l'objet

Déclaration

La déclaration des variables :

<id1> : TYPE
Si plusieurs variables ont le même type nous pouvons les regrouper :
<id2>,<id3>… : TYPE

10/21/2024 8
LES VARIABLES 2/3
Les types de variables Exemple de déclaration de variables

Types possibles de variables : ALGORITHME : PrixDuPain

Nom : CHAINE
 ENTIER (ex : 14, -138)
Nb : ENTIER
 REEL (ex : 3.14, 126.45)
Prx, Qt, Tot : REEL
 BOOLEEN (Vrai/Faux ou True/False)
DEBUT
 CARACTERE (ex : ‘1', 'H') Instruction1
 CHAINE (ex : ''Bonjour'') Instruction2
FIN

10/21/2024 9
LES VARIABLES 3/3
Les identificateurs

Un identificateur est un nom donné à une variable pour la différencier de toutes les autres. Et ce nom, c’est au
programmeur de le choisir. Cependant, il y a quelques limitations à ce choix :
1. On ne peut utiliser que les 26 lettres de l’alphabet latin, les chiffres et le caractère underscore ( _ ) : pas
d’accents, pas de ponctuation ni d’espaces.
2. Un identificateur ne peut pas commencer par un chiffre.
3. Deux variables ne peuvent avoir le même identificateur (le même nom)
4. Certains noms sont réservés pour les compilateurs des langages de programmation et ne doivent pas être
donnés à des identificateurs de variables
5. Les identificateurs peuvent être aussi longs que l’on désire, toutefois certains compilateurs ne tiendra
compte que des 32 premiers caractères.
6. Le nom d'un variable doit être significatif. On devrait savoir immédiatement, à partir de son nom, à quoi
sert la variable ou la constante, et quel sens donner à sa valeur
10/21/2024 10
AFFECTATION
Règles d’affectation ALGORITHME : Prix_du_pain
Nom : CHAINE
L'instruction d'affectation est l'opération qui consiste à
Car : CARACTERE
attribuer une valeur à une variable pendant l'exécution
Nb : ENTIER
du programme. Prx, Qt, Tot, Tot1 : REEL
DEBUT

En algorithmique on utilise un opérateur d'affectation. Nom  "Mounir"

Car  ‘g’
Nous le notons ← dans le cadre de ce cours.
Prx  10.25
Qt  6
L’affectation s’effectue de la droit vers la gauche Tot  Prx * Qt
La valeur de l’expression droite (valeur ou résultat de Tot1  Tot
calcul) sera stocké dans la variable gauche. FIN

10/21/2024 11
LECTURE / AFFICHAGE
Définition ALGORITHME : Prix_du_pain

Deux méthodes qui permettent de gérer les entrés et Nom : CHAINE

Car : CARACTERE
sorties d’un algorithme sont : LIRE et AFFICHER
Nb : ENTIER
Prx, Qt, Tot, Tot1 : REEL
La méthode LIRE permet de lire des valeurs à partir du DEBUT
clavier qui représente l’entrée d’un algorithme. Elle Nom  "Mounir"

permet de récupérer la valeur taper au clavier et la Car  ‘g’

Prx  10.25
stocker dans la variable entre les parenthèses.
Qt  6
Tot  Prx * Qt
La méthode AFFICHER permet d’afficher les messages ou Tot1  Tot
des valeurs de variables à l’écran qui représente la sortie. FIN

10/21/2024 12
LES COMMENTAIRES
Définition
ALGORITHME : Prix_du_pain
Les commentaires servent à donner des explications
Prx, Qt, Tot : REEL
à une partie de votre pseudo-code.
DEBUT
AFFICHER("donner la quantité de pains" )
Un commentaire doit être mis entre /* et */, tous ce
LIRE(Qt)
qui se trouve entre ces deux symboles est considéré Prx  10.25 /* le prix d’unité*/
comme un commentaire. Tot  Prx* Qt /* ici nous calculons le
prix totale*/
AFFICHER ("le prix total est :",Tot)
Un commentaire n’affecte pas les instructions de
FIN
votre algorithme.

Le commentaire peut s’écrire sur plusieurs lignes.

10/21/2024 13
LES OPÉRATIONS 1/5
Les opérations arithmétiques

Les opérateurs arithmétiques admis sont les suivants :

Notation en pseudocode Sens Remarques

a+b Addition
Correct Incorrect
a-b Soustraction
pi ← 3.14159 π ← 3,14159
a*b Produit y ← 2 * x y ← 2(x+y)
a./b per ← 2*r*pi vol ← 4/3π×rayon^3
Division réelle 5./3 vaut 2.5
a/b Division entière 5/3 vaut 2
a%b Modulo

L’opération modulo permet de calculer le reste de la

division de a par b, exemple :
17%5=2

10/21/2024 14
LES OPÉRATIONS 2/5
Les opérations relationnelles

 Les opérateurs relationnelles permettent d’exprimer des comparaisons entre deux variables ou expressions.

 Ils sont utilisés pour évaluer des conditions .

Notation en pseudocode Notation mathématique Sens

a<b a<b a inférieur strictement à b
a>b a>b a supérieur strictement à b
a<=b a≤b a inférieur ou égale à b
a>=b a≥b a supérieur ou égale t à b
a=b a=b a égale à b
a!=b a≠b a différent de b

10/21/2024 15
LES OPÉRATIONS 3/5
Les opérations logiques

 Les opérateurs logiques permettent d ’exprimer des conditions composées de plusieurs opérateurs relationnelles.
 Il est possible de composer plusieurs conditions avec des opérateurs logiques différents :
((x>=0)ET(x<=10))OU (x>100) 0<x ET x<10
 Les opérateurs logiques admis sont les suivants :

Notation en pseudocode Sens Exemples

c1 ET c2 Vrai seulement si c1 et c2 sont tous deux vrais (x>=0) ET (x<=10)

(prix=100) ET (qt>=3) ET (res!=0)

c1 OU c2 Faux seulement si c1 et c2 sont tous deux faux (a<b) OU (c>d)

NON c1 Vrai seulement si c1 est faux NON (a<0)

10/21/2024 16
LES OPÉRATIONS 4/5
Priorité des opérations

 Il existe une priorité à respecter entre les différents opérateurs que nous venons de voir :

Exemples
Opérations Expression Résultat
NON
Priorité croissante

a5*4+9 a29 L’operateurs * a plus de priorité que + donc

*/% l’opération 5*4 sera évaluée, le résultat 20 sera
+- ensuite additionné a 9, l’affectation est la dernière
opération effectuée car sa priorité est la plus
=≠≥≤<> faible.
ET
OU
 20+x>10 Vrai si x>-10 L’addition + est plus prioritaire que >.
10/21/2024

17
LES OPÉRATIONS 5/5
Usage de parenthèses

 Pourquoi avoir défini une règle de priorité ? C'est pour pouvoir écrire les expressions complexes de manière plus simple,
plus lisible. En effet, on peut très bien se passer de ces règles et utiliser systématiquement des parenthèses pour bien
rendre compte de l'ordre dans lequel les opérations doivent être effectuées.
 Si nous voulons forcer l'ordinateur à commencer par un opérateur avec une priorité plus faible, nous devons (comme en
mathématiques) entourer le terme en question par des parenthèses.

Exemples Expression normale Expression complètement parenthésée

X  2*(A+3)*B+4*C 7+2*3 (7 + (2 * 3))
l'ordinateur évalue d'abord l'expression entre 1-2-3 ((1 - 2) - 3)
parenthèses, ensuite les multiplications, ensuite 1+2*3/4 (1 + ((2 * 3) / 4))
l'addition et enfin l'affectation 3*5-2+1-8/2*3 ((((3 * 5) - 2) + 1) - ((8 / 2) * 3))
10/21/2024
18
EXÉCUTION CONDITIONNELLE 1/12
Qu’est-ce l’exécution conditionnelle ?

L’exécution conditionnelle permet de faire deux choses différentes selon le cas qui se produit. L’instruction ne sera exécutée
que sous certaines conditions. Plus précisément, le programme teste une condition, si la condition est satisfaite le
programme fait une chose, dans le cas contraire, le programme fait une autre chose. Une instruction conditionnelle peut
avoir plusieurs formes.

Condition si-alors

Supposons que l’on ait une condition (par exemple que l’âge du capitaine soit inférieur à 30
ans). Si la condition est vérifiée, on fait quelque chose, dans le cas contraire, on ne fait rien.
En algorithmique, cela s’écrit :
SI (condition) ALORS
Instructions 1
FINSI
19
EXÉCUTION CONDITIONNELLE 2/12
Exemple

L’algorithme ci-contre donne un exemple ALGORITHME note_valide

d’utilisation de SI en fonction d’une condition note :REEL
qui dépende de la valeur de la variable note. DEBUT
Les instructions entre SI et FINSI serons LIRE (note)
Cette instruction ne sera exécutée que si
exécutées seulement si la valeurs de note est SI (note>=12) ALORS la condition note>=12 est vrai

supérieure ou égale à 12. AFFICHER("Module valide")

les instructions qui sont à l’extérieur de ce bloc FINSI
Cette instruction sera exécutée car
serons exécutées indépendamment de cette AFFICHER("Bon courage!") elle ne dépende pas de la condition.
Elle est en d’hors de la structure SI
condition. FIN

10/21/2024
20
EXÉCUTION CONDITIONNELLE 3/12
Condition alternative : si-alors sinon

Une seconde forme plus intéressant est constituée d’un second bloc
d’instructions qui seront exécutées lorsque la condition n’est pas
vérifiée. Elle aura pour forme :
SI (condition) ALORS
Instructions 1
SINON
Instructions 2
FINSI
Instructions 3 /* suite d’instructions du
programme hors condition*/
21
EXÉCUTION CONDITIONNELLE 4/12
Exemple

L’algorithme ci-contre donne un exemple ALGORITHME note_valide

d’utilisation de SI en fonction d’une condition note :REEL
qui dépende de la valeur de la variable note. DEBUT
Les instructions entre SI et FINSI serons LIRE (note)
Cette instruction ne sera exécutée que si
exécutées que si la valeurs de note est SI (note>=12) ALORS la condition note>=12 est vrai

supérieure à 12. les instructions qui sont à AFFICHER("Module valide")

l’extérieur de ce bloc serons exécutées SINON
indépendamment de cette condition. AFFICHER("Module NON valide")
FINSI
Cette instruction ne sera
Cette instruction sera exécutée car exécutée que si la condition
elle ne dépende pas de la condition. AFFICHER("Bon courage!") note>=12 est Fausse
10/21/2024 Elle est en d’hors de la structure SI
FIN 22
EXÉCUTION CONDITIONNELLE 5/12
Conditions imbriquées

Parfois l’expression d’une structure conditionnelle peut contenir plusieurs situations.

Prenons l’exemple d’un algorithme qui donne l’état de l’eau en fonction de sa température. Il prend en entrée une variable
Temp qui représente la température de l’eau et puis il affiche des messages:
 Si la température est inférieure a 0 degrés alors il affiche que l’eau est Gelé.
 Si Temp est entre 0 et 12 degrés alors il affiche que l’eau est Froid.
 Si Temp est entre 12 et 25 degrés alors il affiche que l’eau est Confortable.
 Si Temp est entre 25 et 75 degrés alors il affiche que l’eau est Chaud.
 Si Temp est entre 75 et 100 degrés alors il affiche que l’eau est Très chaud.
 Si Temp est supérieure à 100 degrés alors il affiche que l’eau est Brûlant.

23
EXÉCUTION CONDITIONNELLE 6/12
Conditions imbriquées

Organigramme de l’algorithme

24
EXÉCUTION CONDITIONNELLE 7/12
Conditions imbriquées

L’algorithme de la structure conditionnelle non-imbriquées

ALGORITHME Temp_Eau /*suite de l’algorithme*/
Temp :REEL SI ((Temp > 75) ET (Temp <= 100)) ALORS
DEBUT AFFICHER("C'est très chaud")
AFFICHER("Donner la température") FINSI
LIRE(Temp) SI (Temp > 100) ALORS
SI (Temp <= 0) ALORS AFFICHER("C'est brulant")
AFFICHER("C'est gelé") FINSI
FINSI FIN
SI ((Temp > 0) ET (Temp <= 12)) ALORS
AFFICHER("C'est froid")
FINSI
SI ((Temp > 12) ET (Temp <= 25)) ALORS
AFFICHER("C'est confortable")
FINSI
SI ((Temp > 25) ET (Temp <= 75)) ALORS
AFFICHER("C'est chaud")
FINSI
25
EXÉCUTION CONDITIONNELLE 8/12
Conditions imbriquées

L’imbrication des conditions consistes à utiliser la structure SI-ALORS

SINON l’une à l’intérieure d’une autre. SI (condition 1) ALORS
Instructions1
Elle permet de mieux structurer l’algorithme afin que cela soit plus SINON
SI(condition 2) ALORS
clair, mais surtout à réduire le nombre d’opérations de comparaisons Instructions2
effectuées. Cela permet de réduire la complexité de l’algorithme. SINON
SI(condition 3) ALORS
Question? Combien d’opérations de comparaison sont effectuées Instructions3
SINON
par l’algorithme précèdent? …
L’algorithme précèdent peut être conçus de manière à utiliser la FINSI
FINSI
structure de conditions imbriquées comme nous pouvons voir dans FINSI
l’organigramme de la page suivante.
26
EXÉCUTION CONDITIONNELLE 9/12
Conditions imbriquées

Organigramme de l’algorithme

27
EXÉCUTION CONDITIONNELLE 10/12
Conditions imbriquées

ALGORITHME Temp_Eau /*suite de l’algorithme*/

Temp :REEL SI (Temp <= 100) ALORS
DEBUT AFFICHER("C'est très chaud")
AFFICHER("Donner la température") SINON
LIRE(Temp) AFFICHER("C'est brûlant")
SI (Temp <= 0) ALORS FINSI
AFFICHER("C'est gelé") FINSI
SINON FINSI
SI (Temp <= 12) ALORS FINSI
AFFICHER("C'est froid") FINSI
SINON FIN
SI (Temp <= 25) ALORS
AFFICHER("C'est confortable")
SINON
SI (Temp <= 75) ALORS Étudier combien d’opérations de
AFFICHER("C'est chaud") comparaison sont effectuées ?
SINON

28
EXÉCUTION CONDITIONNELLE 11/12
L’instruction SELON - CAS

Lorsque nous somme dans une situation ou l’algorithme doit régler un SELON variable

problème ou plusieurs conditions sont liées à un ensemble de valeurs CAS valeur 1 :

Instructions 1
finis et bien déterminées, est le problème consiste plutôt à une liste de
choix. CAS valeur 2 :
Instructions 2

CAS valeur 3 :
Il est possible d’utiliser SI-ALORS plusieurs fois, mais il existe une
Instructions 3
structure qui permet de résoudre ce problème plus efficacement. …

SINON :
Instructions
Voir ci-contre la structure SELON-CAS
FINSELON

29
EXÉCUTION CONDITIONNELLE 12/12
L’instruction SELON - CAS ALGORITHME Operations
Choix : ENTIER
a,b,C : REEL
L’exemple de l’algorithme suivant DEBUT
AFFICHER("donner Deux Valeurs a et b")
présente l’utilisation de SELON-CAS LIRE(a,b)
AFFICHER("Taper 1 pour Additionner, 2 pour multiplier 3 pour le
pour présenter à l’utilisateur une liste modulo de a et b")
LIRE(Choix)
choix d’opération. SELON Choix
CAS 1 :
Il y’a 3 valeurs (1,2,3) que l’utilisateur C ← a+b
AFFICHER("le resultat de l’operation choisie =",C)
doit tapé chacun dirige l’exécution CAS 2 :
C ← a*b
vers le cas sélectionné. Noter que AFFICHER("le resultat de l’operation choisie =",C)
CAS 3 :
dans le cas ou l’utilisateur introduit C ← a%b
AFFICHER("le resultat de l’operation choisie =",C)
une valeur outre que les cas traité SINON :
AFFICHER("Vous avez tapé un mauvais choix")
l’exécution se dirige directement au
FINSELON
bloc SINON FIN

30
EXÉCUTION REPETITIVE - ITÉRATION
Boucle POUR

Si nous désirons que l’algorithme répète un bloc d’instructions un certain nombre de fois (bien déterminé). Nous utilisons la
boucle POUR. En pseudo-code cela s’exprime comme suivant :
.
instructions 1 /* début du programme */
POUR (ide initial, condition sur ide, changement de ide)
instructions 2 /* instructions répétées */
FINPOUR
instructions 3 /* suite du programme */

Lorsque le nombre de fois où un bloc d’instructions doit être exécuté est connu à l’avance, la boucle POUR est préférable.
L’usage principal de la boucle POUR est de faire la gestion d’un compteur (ide de type entier) qui évolue d’une valeur à une
autre. La variable ide est initialisé par une valeur, ensuite nous mettons une condition sur ide, le changement de ide consiste
la plupart du temps à incrémenter ou décrémenter la valeur de ide pour que la condition change au fur et à mesure de
l’avancement des calculs.
31
EXÉCUTION REPETITIVE - ITÉRATION
Boucle POUR

ALGORITHME factoriel
n,i,F :ENTIER
L’exemple ci-contre présente l’algorithme qui DEBUT
permet de calcul le factoriel de n. AFFICHER("Donner la valeur de n")
l’idée est d’effectuer des multiplications LIRE(n)
F ← 1 /* initialisation obligatoire */
successives jusqu’à ce que la variable i arrive à POUR (i ← 1, 1 i<=n , 3 i ← i+1)
la valeur de n la variable i change 2 F ← F*i
progressivement avec l’instruction i ← i+1. FINPOUR
AFFICHER("le factoriel =", F)
FIN

32
EXÉCUTION REPETITIVE - ITÉRATION
Boucle POUR : Fonctionnement

Lorsque l’ordinateur rencontre cette structure, il procède

systématiquement de la manière suivante : ALGORITHME factoriel
n,i,F :ENTIER
 La variable i, jouant le rôle de compteur, est initialisée par 1 (cet
DEBUT
initialisation s’effectue une et une seul fois). AFFICHER("Donner la valeur de n")
 L’ordinateur teste si la valeur de i est inférieure ou égale à la
LIRE(n)
F ← 1 /* initialisation obligatoire
valeur de n : */
o Si c’est le cas, l’instruction ou le bloc d’instruction est effectué, la POUR (i ← 1, i<=n ,i ← i+1)
F ← F*i
variable i jouant le rôle de compteur est augmentée de 1, et FINPOUR
répète POUR sans initialiser la valeur de la variable i. AFFICHER("le factoriel =", F)
FIN
o Si ce n’est pas le cas, l’instruction ou le bloc d’instruction n’est
pas effectuée, et l’ordinateur passe aux instructions suivantes.

33
EXÉCUTION REPETITIVE - ITÉRATION
Boucle TANT QUE

Si nous voulons répété un bloc d’instructions cette fois sans savoir explicitement le nombre de fois que cela va se répéter.
Mais plutôt nous avons une condition lorsqu’elle vrai, on répète les instructions de ce bloc.

Une autre forme de structure de contrôle itérative est proposée : C’est La boucle TANT QUE

instructions 1 /* début du programme */

TANTQUE (condition) /* Etape 1 test de condition*/
instructions 2 /* instructions répétées */
FINTQ
instructions 3 /* suite du programme */

34
EXÉCUTION REPETITIVE - ITÉRATION
Boucle TANT QUE

Lorsque l’ordinateur rencontre cette structure, il procède systématiquement de la manière suivante :

 La condition est testée (on dit aussi évaluée).
 Si la condition est vraie, l’instruction ou les instructions 2 du bloc sont exécutées, et on recommence à l’étape 1) : test
de la condition.
 Si la condition est fausse, l’instruction ou les instructions du bloc ne sont pas exécutées et on passe aux instructions
suivantes (après la structure de contrôle).

instructions 1 /* début du programme */

TANTQUE (condition) /* Etape 1 test de condition*/
instructions 2 /* instructions répétées */
FINTQ
instructions 3 /* suite du programme */

35
EXÉCUTION REPETITIVE - ITÉRATION
Boucle TANT QUE

Prenons un exemple. Supposons ALGORITHME Puissance

que l’on veuille faire une fonction x,P :REEL
k,i :ENTIER
qui calcule et affiche 𝒙𝒙^𝒌𝒌, où x est DEBUT
un réel et k est un exposant entier AFFICHER("Donner la valeur de x est k")
LIRE(x,k)
saisi au clavier. i ← 0 /* initialisation obligatoire */
P ← 1 /*initialisation à 1 calcul du produit*/
TANTQUE (i < k)
Le résultat doit être un réel. P ← P*x
i ← i+1 /* progression obligatoire */
FINTQ
AFFICHER("x a la puissance k =", P)
FIN

36
EXÉCUTION REPETITIVE - ITÉRATION
Boucle TANT QUE

 Au départ, la variable i vaut 0 et P vaut 0 (initialisation).

ALGORITHME Puissance
 Si k est strictement positif, au départ, la condition
x,P :REEL
d’arrêt i<k est vraie, et on rentre dans TANTQUE. k,i :ENTIER
DEBUT
 À chaque exécution des instructions du TANTQUE, AFFICHER("Donner la valeur de x est k")
l’instruction i=i+1 est exécutée, ce qui augmente la LIRE(x,k)
i ← 0 /* initialisation obligatoire */
valeur de la variable i (on parle d’incrémentation P ← 1 /*initialisation à 1 calcul du produit*/
lorsqu’on augmente de 1 la valeur d’une variable). TANTQUE (i < k)
P ← P*k
 La condition d’arrêt est alors évaluée avant d’effectuer i ← i+1 /* progression obligatoire */
FINTQ
l’itération suivante. Comme la variable i augmente à AFFICHER("x a la puissance k =", P)
chaque itération, au bout d’un moment la condition FIN

d’arrêt i<k devient fausse, et la boucle se termine ; on

passe à la suite du programme
37
EXÉCUTION REPETITIVE - ITÉRATION
Boucle FAIRE - TANT QUE

 La structure TANTQUE que nous venons de

voir, commence par vérifier la condition au instructions 1 /* début du programme */
départ pour ensuite exécuter le bloc FAIRE
d’instructions inclus. instructions 2 /* instructions répétées */
TANTQUE (condition) /* vérification de la
 Parfois il est préférable de laisser la condition de répétition après l’exécution des
vérification de la condition de répétition à la instructions2 */
fin des instructions à répéter pour cela nous
avons une autre forme :
instructions 3 /* suite du programme */
La Boucle FAIRE TANT QUE

38
EXÉCUTION REPETITIVE - ITÉRATION
Boucle FAIRE - TANT QUE

L’algorithme ci-contre calcul le PGCD de 2 nombre es introduit par l’utilisateur en utilisant la boucle FAIRE - TANT QUE

ALGORITHME PGCD
a,b,r :ENTIER
DEBUT
AFFICHER("Donner deux nombres m et n ")
LIRE(a,b)
FAIRE
r ← a%b
a ← b
b ← r
TANTQUE (b != 0)
AFFICHER("le PGCD =", a)
FIN

39
EXÉCUTION REPETITIVE - ITÉRATION
Boucle FAIRE - TANT QUE

Pour comprendre ce que fait cet

r a b États de la condition
algorithme, il est préférable de faire des
--- 260 170 Introduction de valeur
exemples d’exécution d’algorithme et de
voir le changement du contenu des 90 170 90 b!=0 est vrai
variables étape par étape. 80 90 80 b!=0 est vrai

10 80 10 b!=0 est vrai

Nous appellerons cette simulation
0 10 0 b!=0 est faux
d’algorithme dans ce cours : une preuve
d’algorithme. Vous aurez souvent à la FINTQ affichage de a
Le PGCD = 10
faire lorsque un algorithme inconnu se
présente à vous dans les Tds.

40
EXÉCUTION REPETITIVE - ITÉRATION
Boucle FAIRE - TANT QUE

Pour comprendre ce que fait cet

r a b États de la condition
algorithme, il est préférable de faire des
--- 260 170 Introduction de valeur
exemples d’exécution d’algorithme et de
voir le changement du contenu des 90 170 90 b!=0 est vrai
variables étape par étape. 80 90 80 b!=0 est vrai

10 80 10 b!=0 est vrai

Nous appellerons cette simulation
0 10 0 b!=0 est faux
d’algorithme dans ce cours : une preuve
d’algorithme. Vous aurez souvent à la FINTQ affichage de a
Le PGCD = 10
faire lorsque un algorithme inconnu se
présente à vous dans les Tds.

41
Les tableaux ALGORITHME Moy_note_1

DEBUT
N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,Moy: REEL

AFFICHER(“donner Les 10 notes”)

Problème AFFICHER(“note1”)
LIRE(N1)
AFFICHER(“note2”)
• Manipulation de nombreuses variables représentant LIRE(N2)
des valeurs distinctes mais de même nature. AFFICHER(“note3”)
LIRE(N3)
AFFICHER(“note4”)
LIRE(N4)
AFFICHER(“note5”)
Exemple, si nous avons besoin de traiter simultanément LIRE(N5)
de 10 valeurs (par exemple, des notes pour calculer une AFFICHER(“note6”)
moyenne). Evidemment, la seule solution dont nous LIRE(N6)
disposons à l’heure actuelle consiste à déclarer dix AFFICHER(“note7”)
LIRE(N7)
variables, appelées par exemple Notea, Noteb, Notec, etc.
AFFICHER(“note8”)
Bien sûr, on peut opter pour une notation un peu LIRE(N8)
simplifiée, par exemple N1, N2, N3, etc. AFFICHER(“note9”)
LIRE(N9)
AFFICHER(“note10”)
LIRE(N10)

Moy ← (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10)/10

AFFICHER(“la moyenne est =”,Moy)

FIN 42
Les tableaux
ALGORITHME Moy_note_2
Solution i,n : ENTIER
N[40] : REEL /*déclaration d’un
• Les tableaux permettent de rassembler tableaux de 40 valeurs réels*/
toutes ces variables en une seule, au sein Moy : REEL
de laquelle chaque valeur sera désignée par DEBUT
un numéro. AFFICHER(“Donner le nombre de notes <40”)
• Un tableau est un ensemble de valeurs LIRE(n)
portant le même nom de variable et AFFICHER(“donner Les notes”)
repérées par un nombre (indice). POUR(i ← 0, i<n, i ← i+1)
• La déclaration d’un tableau de variables AFFICHER(“note”,i+1)
s’effectue par N[10] : REEL (10 le nombre LIRE(N[i])
d’éléments est obligatoire dans la FINPOUR
déclaration) Moy ← 0
• L’accès au contenus des éléments du POUR(i ← 0,i<n,i ← i+1)
tableau s’effectue par in indice entre les Moy ← Moy+N[i]
crochets [ ]. FINPOUR
Moy ← Moy/n
AFFICHER(“la moyenne est =”,Moy)
FIN 43
Les tableaux
Consignes

• La déclaration d’un tableau de variables s’effectue par N[10] : REEL (10 le nombre d’éléments est
obligatoire dans la déclaration).
• L’accès au contenus des éléments du tableau s’effectue par l’indice (un nombre entier) entre les crochets
[ ].
• Les indices des éléments d’un tableau commence toujours par 0 et le dernier élément dans cet
algorithme est N[9] (puisque nous avons déclaré exactement 10 éléments).
• Il ne faut pas confondre la valeur notée entre crochets lors de la déclaration du tableau (la taille
maximale) et la valeur notée entre crochets lors des instructions (l’indice).

Indice 0 1 2 3 4 5 6 7 8 9
14 12.5 8.5 5 16 18 10.5 11 17 12
N
N[0] N[1] N[2] N[3] N[4] N[5] N[6] N[7] N[8] N[9]

Les éléments du tableau

44
Les tableaux
Relation entre tableaux et boucles

ALGORITHME recherche_max
maxi :ENTIER /* stocke la valeur du maximum*/
Les boucles sont extrêmement tablval[50] :ENTIER /* un tableau stockant des valeurs*/
utiles pour les algorithmes Nb,i,j: ENTIER /* la taille utile du tableau et les indices de
parcourt*/
associés aux tableaux. En effet, de DEBUT
nombreux algorithmes relatifs au AFFICHER("entrez le nombre d’elements du tableau ( taille max 50) ")
tableau nécessitent de parcourir LIRE(Nb)
les éléments du tableau dans un POUR (i ← 0 , i< Nb , i ← i+1) FAIRE
certain ordre, le plus souvent dans AFFICHER("entrez une valeur dans le tableau : ")
le sens des indices croissant. Le LIRE(tablval[i])
FINPOUR
traitement de chacun des maxi ← tablval[0] /* pour l’instant, le plus grand est dans la case 0
éléments étant souvent le même, cherchons case par case (de l’indice 1 à Nb)*/
seule la valeur de l’indice est POUR (j ← 1 , j< Nb , j ← j+1) FAIRE
amenée à changer. Une boucle est SI (tablval[j] > maxi) ALORS
donc parfaitement adaptée à ce maxi ← tablval[j] /* la valeur est mémorisée dans maxi*/
genre de traitements. FINSI
FINPOUR
AFFICHER("la valeur maximal de ce tableau: ", maxi)
FIN
45
 Les tableaux
Multi-dimension
Tableau à deux dimensions
Déclaration du tableau
Il est possible de définir des tableaux à de taille 5x5
plusieurs dimensions en les indiquant
dans des crochets successifs lors de la
définition du tableau. Pour des propos
d’illustration l’exemple se limitera à deux
dimensions, la généralisation à N
dimensions est immédiate. Certains
problèmes (notamment le calcul
matriciel) ont une représentation
naturelle en deux dimensions avec un
repérage en lignes/colonnes ou L’élément tab[3][2]
abscisse/ordonnée.

46
 Les tableaux
Multi-dimension

ALGORITHME Moy_note_2
L’exemple ci-contre, montre tab[10][10],S : REEL /*déclaration d’un tableaux 2 dimensions de 10x10 valeurs réels*/
comment manipuler les élément d’in i,j,N,M : ENTIER
DEBUT
tableau dans le but de remplir un AFFICHER("entrez le nombre de lignes et le nombre de colonnes ")
tableau de 2 dimensions, puis de LIRE(N,M)
l’afficher et ensuite calculer la POUR(i ← 0, i<N, i ← i+1) /* Double boucle 1 :parcourt des éléments pour
POUR(j ← 0, j<M, j ← j+1) remplir le tableau tab*/
somme de ses éléments. LIRE(tab[i][j])
FINPOUR
• Note que Pour parcourir les FINPOUR
éléments du tableau tab nous
avons besoin de deux boucles POUR(i ← 0, i<N, i ← i+1) /* Double boucle 2 : parcourt des éléments pour
POUR(j ← 0, j<M, j ← j+1) afficher le tableau tab*/
imbriquées, chacune a son propre AFFICHER(tab[i][j])
indice de parcourt (i et j), il faut FINPOUR
faire attention au sens des indices FINPOUR
S ← 0
pour ils ne soient pas mélangés POUR(i ← 0, i<N, i ← i+1) /* Double boucle 3 : parcourt des éléments pour
dans les boucles imbriquées. POUR(j ← 0, j<M, j ← j+1) calculer la somme des éléments du tableau tab*/
S ← S+tab[i][j])
• Noter aussi que nous pourront FINPOUR
FINPOUR
réutiliser les indices dans les AFFICHER(“la somme des elements = ”,S)
autres Double boucles, car ils sont FIN
indépendantes cette fois-ci. 47
 Les tableaux
Multi-dimension

ALGORITHME Moy_note_2
L’exemple ci-contre, montre tab[10][10],S : REEL /*déclaration d’un tableaux 2 dimensions de 10x10 valeurs réels*/
comment manipuler les élément d’in i,j,N,M : ENTIER
DEBUT
tableau dans le but de remplir un AFFICHER("entrez le nombre de lignes et le nombre de colonnes ")
tableau de 2 dimensions, puis de LIRE(N,M)
l’afficher et ensuite calculer la POUR(i ← 0, i<N, i ← i+1) /* Double boucle 1 :parcourt des éléments pour
POUR(j ← 0, j<M, j ← j+1) remplir le tableau tab*/
somme de ses éléments. LIRE(tab[i][j])
FINPOUR
• Note que Pour parcourir les FINPOUR
éléments du tableau tab nous
avons besoin de deux boucles POUR(i ← 0, i<N, i ← i+1) /* Double boucle 2 : parcourt des éléments pour
POUR(j ← 0, j<M, j ← j+1) afficher le tableau tab*/
imbriquées, chacune a son propre AFFICHER(tab[i][j])
indice de parcourt (i et j), il faut FINPOUR
faire attention au sens des indices FINPOUR
S ← 0
pour ils ne soient pas mélangés POUR(i ← 0, i<N, i ← i+1) /* Double boucle 3 : parcourt des éléments pour
dans les boucles imbriquées. POUR(j ← 0, j<M, j ← j+1) calculer la somme des éléments du tableau tab*/
S ← S+tab[i][j])
• Noter aussi que nous pourront FINPOUR
FINPOUR
réutiliser les indices dans les AFFICHER(“la somme des elements = ”,S)
autres Double boucles, car ils sont FIN
indépendantes cette fois-ci. 48
LES SOUS-PROGRAMMES OU FONCTIONS
Définition

Lorsque l'on progresse dans la conception d'un

algorithme, ce dernier peut prendre une taille et Le sous-algorithme est écrit séparément du
une complexité croissante. De même des séquences corps de l'algorithme principal et sera appelé
par celui-ci quand ceci sera nécessaire.
d'instructions peuvent se répéter à plusieurs Le sous-algorithme est une partie de
endroits. l’algorithme presque indépendante qui a un
Un algorithme écrit d'un seul tenant devient difficile nom et peut être appelée d’un autre sous-
algorithme ou de l’algorithme principal.
à comprendre et à gérer dès qu'il dépasse deux
pages. La solution consiste alors à découper
l'algorithme en plusieurs parties plus petites. Ces
parties sont appelées des sous-algorithmes.

49
LES SOUS-PROGRAMMES OU FONCTIONS
Intérêt des sous-algorithmes

Factorisation du code
Les sous-algorithmes permettent de réutiliser des parties d'un algorithme. Par exemple, pour calculer le
factoriel de plusieurs nombres, on peut écrire une fonction pour ce calcul. Cela rend le code plus simple et
évite la répétition.
Mise au point
Une fois qu'un sous-algorithme est écrit, il doit être testé. Cela permet de vérifier chaque partie séparément,
facilitant l'identification des erreurs et de leur origine, contrairement à un test de l'algorithme entier d'un
seul coup.
Amélioration de la maintenance
Comme la compréhension d’un algorithme, la maintenance est automatiquement améliorée, car il sera plus
facile d’identifier les parties de l’algorithme à modifier et d’en évaluer l’impact. L’idéal est bien entendu que
la modification puisse être limitée à un petit nombre de sous-algorithmes.

50
LES SOUS-PROGRAMMES OU FONCTIONS
Définir une fonction

Une fonction doit être définie avant d’être utilisée, c’est-à-dire que l’on doit indiquer quelles sont les
instructions qui la composent : il s’agit de la définition de la fonction, où l’on associe les instructions à
l’identification de la fonction.
La fonction doit être définie et comporter : un en-tête, pour l’identifier et un corps contenant ses
instructions, pour la définir.

FONCTION nom_de_fonction(«liste entrées avec leurs types»):type de la sortie

« Déclarations des variables »
DEBUT
« instructions »
RETOURNER (« la valeurs ou la variable à retourner »)
FINFCT

51
LES SOUS-PROGRAMMES OU FONCTIONS
Définir une fonction

Une fonction doit être définie avant d’être utilisée, c’est-à-dire que l’on doit indiquer quelles sont les
instructions qui la composent : il s’agit de la définition de la fonction, où l’on associe les instructions à
l’identification de la fonction.
La fonction doit être définie et comporter : un en-tête, pour l’identifier et un corps contenant ses
instructions, pour la définir.

FONCTION nom_de_fonction(«liste entrées avec leurs types»):type de la sortie

« Déclarations des variables »
DEBUT
« instructions »
RETOURNER (« la valeurs ou la variable à retourner »)
FINFCT

52
LES SOUS-PROGRAMMES OU FONCTIONS
L’entête d’une fonction et la valeur retourner

 L’entête de la fonction : comporte le nom de la fonction qui doit être significatif en vérifiant les mêmes règles de
nomination des variables.
 Entre les parenthèses : nous mettons la liste des variables requises pour que la fonction réalise les tâches désirées.
Pour chaque variable de cette liste on doit écrire sont type. (NB : une fonction peut avoir plusieurs variables dans ses
arguments, il se peut aussi que la fonction n’ai aucun paramètre, dans se cas on écrit VIDE pour signaler qu’elle ne
récupère aucune valeur de l’extérieur. )
 Après les parenthèses : on écrit le type de la valeur que la fonction doit retourner avec l’instruction RETOURNER()
(NB : Une fonction ne peut retourner qu’une seule valeur, ou dans certain cas elle ne retourne rien, dans ce cas on ne
met pas le type de retour et on ne met pas l’instruction RETOURNER. )

FONCTION nom_de_fonction(«liste entrées avec leurs types»):type de la sortie

« Déclarations des variables »
DEBUT
« instructions »
RETOURNER (« la valeurs ou la variable à retourner »)
FINFCT
53
LES SOUS-PROGRAMMES OU FONCTIONS
L’appel de la fonction

une fonction nommée « factoriel » qui prend un entier n en paramètre et retourne son factoriel

La fonction L’appel de la fonction

FONCTION factoriel(n : ENTIER) :ENTIER

ALGORITHME combinaison /*L’algorithme principale*/
i,F : ENTIER
DEBUT n,f : ENTIER
F ← 1 DEBUT
SI(n!=0) ALORS AFFICHER("donner un entier : ")
POUR(i ← 1, i<=n, i ←i+1)FAIRE LIRE(n)
F ← F*i f ← factoriel(n)
FINPOUR
AFFICHER("le focatoriel de votre entier est :",f)
FINSI
RETOURNER (F) FIN
FINFCT

54