REPUBLIQUE DU BENIN

Fraternité Justice Travail



MINISTERE DE L’ENSEIGNEMENT SUPERIEUR

ET DE LA RECHERCHE SCIENTIFIQUE


UNIVERSITE NATIONALE DES SCIENCES, TECHNOLOGIES,

INGENIERIE ET MATHEMATIQUES D’ABOMEY


ECOLE NATIONALE SUPERIEURE DES TRAVAUX PUBLICS



COURS DE PROGRAMMATION INFORMATIQUE

Algorithmique
Dr KOUBE BOCCO S. Marius

Abomey, mai 2023

Introduction
L’informatique met en jeu des ordinateurs qui fonctionnent selon des schémas préétablis. Pour
résoudre un problème donné à l’aide d’un ordinateur, il faut lui indiquer la suite d’actions à
exécuter dans son schéma de fonctionnement. Cette suite d’actions est un programme qui est
exprimé dans un langage de programmation plus ou moins évolué (code machine, C, C++, Java,
python, Fortran, Matlab,....). Et pour écrire un programme (la suite d’actions), il faut donc
d’abord savoir comment faire pour résoudre le problème.
Un algorithme est l’expression de la résolution d’un problème de sorte que le résultat soit
calculable par une machine. L’algorithme est exprimé dans un modèle théorique de machine
universelle, qui ne dépend pas de la machine réelle sur laquelle on va l’utiliser. Il peut être écrit
en langage naturel, mais pour être lisible par tous, on utilise un langage algorithmique plus
restreint qui comporte tous les concepts de base de fonctionnement d’une machine. On a
finalement l’enchaînement suivant :
Énoncé du problème ; Algorithme et Programme
Pour résoudre un problème, il faut donner la suite d’actions élémentaires à réaliser pour obtenir
le résultat. Les actions élémentaires dont on dispose sont définies par le langage algorithmique
utilisé.
Par exemple, pour « Construire une maison », il faut successivement : niveler le terrain,
placer les fondations, monter les murs, poser la toiture, installer l’électricité, installer les
canalisations, ajouter les portes et fenêtres.
L’ordre des opérations a son importance, mais dans certains cas plusieurs ordres sont possibles.
Parfois, il faut décomposer les actions trop complexes.
Le but de ce cours est donc d’apprendre à créer des algorithmes, c’est-à-dire à décomposer des
calculs compliqués en successions d’étapes simples.

1. Structure d’un algorithme

a. Variables et affectation
Un algorithme se présente comme une liste d’instructions, elles sont écrites les unes au-dessus
des autres et elles sont exécutées dans l’ordre. Lorsque l’on conçoit un algorithme, il faut
toujours avoir en tête le fait que l’ordre des instructions est très important. Le premier concept
nécessaire pour concevoir un algorithme est celui de variable. Une variable est un emplacement
dans la mémoire où est stockée une valeur. Une variable porte un nom, ce nom est laissée au
choix du concepteur de l’algorithme, il doit commencer par une lettre et ne pas comporter
d’espace. On se sert du nom d’une variable pour lire la valeur qui s’y trouve ou bien pour la

2
modifier, une variable ne peut contenir qu’une seule valeur à la fois. Une valeur est numérique
(entier, réel, complexe) s’il s’agit d’un nombre, ou bien alphanumérique s’il s’agit d’une
succession de symboles, par exemple des mots. Toute variable a un type : si une variable est de
type numérique, il n’est possible d’y mettre que des valeurs numériques, si une variable est de
type alphanumérique, il n’est possible d’y stocker que des valeurs alphanumériques.
L’affectation est une opération permettant de modifier la valeur d’une variable. La syntaxe de
l’affectation est la suivante :
Nomvariable ← valeur
<nomvariable> est le nom de la variable dont on souhaite modifier la valeur, <valeur> est la
valeur que l’on veut placer dans la variable. Notez bien que cette valeur doit être de même type
que la variable.
Par exemple, A ← 5 : place la valeur 5 dans la variable A. Si A contenait préalablement une
valeur, celle-ci est écrasée. Il est possible d’affecter à une variable le résultat d’une opération
arithmétique.
A←5+2
On peut aussi affecter à une variable la valeur d’une autre variable
A←B
A←B+2
La première instruction lit la valeur de B et la recopie dans A, la deuxième instruction, donc
exécutée après la première, lit la valeur de B, lui additionne 2, et recopie le résultat dans A. Le
fait que l’on affecte à A la valeur de B ne signifie pas que ces deux variables auront dorénavant
la même valeur. Cela signifie que la valeur contenue dans A est écrasée par la valeur que
contient B au moment de l’affectation. Si la par la suite, la valeur de A est modifiée, alors la
valeur de B restera inchangée. Il est possible de faire figurer une variable simultanément à
gauche et à droite d’une affectation :
A←A+1
Cette instruction augmente de 1 la valeur contenue dans A, cela s’appelle une incrémentation.
Exercice : Quelles sont les valeurs des variables après l’exécution des instructions suivantes ?
A←1
B←2
C←3
D←A
A←C+1
B←D+C
C←D+1

3
 b. Littéraux
Un littéral est la représentation de la valeur d’une variable. Il s’agit de la façon dont on écrit les
valeurs des variables directement dans l’algorithme.
– numérique : 1, 2, 0, −4
– alphanumérique : ”toto”, ”toto01”, ”04”
Attention, 01 et 1 représentent les mêmes valeurs numériques, alors que ”01” et ”1” sont des va
leurs alphanumériques distinctes. Nous avons vu dans l’exemple précédent des littéraux de type
numérique, dans la section suivante il y a un exemple d’utilisation d’un variable de type
alphanumérique.

c. Convention d’écriture
Un algorithme s’écrit en trois parties :
1. Le titre, tout algorithme porte un titre. Choisissez un titre qui permet de comprendre ce que
fait l’algorithme.
2. Les déclarations de variables, vous préciserez dans cette partie quels noms vous avez décidé
de donner à vos variables et de quel type est chacune d’elle.
3. Les instructions, aussi appelé le corps de l’algorithme, cette partie contient notre succession
d’instructions.
Par exemple,
Algorithme : Mon-Algo1s
Variables :
Numériques : A, B, C
Alphanumériques : t
DEBUT
A←1
B←A+1
C←A
A←A+1
t ← ”C’est mon premier algorithme”
FIN

La lisibilité des algorithmes est un critère de qualité prépondérant. Vous devrez par conséquent
soigner particulièrement vos algorithmes, ils doivent être faciles à lire, et rédigés de sorte qu’un

4
lecteur soit non seulement capable de l’exécuter, mais aussi capable de le comprendre
rapidement.

d. Entrées-sorties
De nombreux algorithmes ont pour but de communiquer avec un utilisateur, cela se fait dans
les deux sens, les sorties sont des envois de messages à l’utilisateur, les entrées sont des
informations fournies par l’utilisateur.
Saisie
Il est possible de demander à un utilisateur du programme de saisir une valeur. La syntaxe de
la saisie est la suivante :
Saisir < nomvariable > ou lire< nomvariable >
La saisie interrompt le programme jusqu’à ce que l’utilisateur ait saisi une valeur au clavier.
Une fois cela fait, la valeur saisie est placée dans la variable nomvariable. Il est possible de
saisir plusieurs variables à la suite,
Saisir A, B, C - place trois valeurs saisies par l’utilisateur dans les variables A, B et C.
Affichage
Pour afficher un message à destination de l’utilisateur, on se sert de la commande
Afficher < message > ou écrire < message >
Cette instruction affiche le message à l’utilisateur. Par exemple,
Afficher ”Bonjour le monde” - affiche ”Bonjour le monde” (les guillemets sont très
importantes !). Il est aussi possible d’afficher le contenu d’une variable,
Afficher A - affiche à l’écran le contenu de la variable A. On peut entremêler les messages et
les valeurs des variables. Par exemple, les instructions :
Afficher ”La valeur de la variable A est” ;
Afficher A; ont le même effet que l’instruction
Afficher ”La valeur de la variable A est”, A
Lorsque l’on combine messages et variables dans les instructions d’affichage, on les sépare par
des virgules. Notez bien que ce qui est délimité par des guillemets est affiché tel quel, alors tout
ce qui n’est pas délimité par des guillemets est considéré comme des variables.
Exemple : Cet algorithme demande à l’utilisateur de saisir une valeur numérique, ensuite il
affiche la valeur saisie puis la même valeur incrémentée de 1
Algorithme : Affichage incrément
Variables :
Numériques : a, b

5
 DEBUT
Afficher ”Saisissez une valeur numérique”
Saisir a
b←a+1
Afficher ”Vous avez saisi la valeur ”, a, ”.”
Afficher a, ”+ 1 = ”, b
FIN

2. Traitements conditionnels
On appelle traitement conditionnel un bloc d’instructions dont l’exécution est soumise à la
vérification d’un test.
a. SI ... ALORS
La syntaxe d’un traitement conditionnel est la suivante :
si < condition > alors
< instructions >
Fin si
Les <instructions> ne sont exécutées que si <condition> est vérifiée. Par exemple :
si A = 0 alors
Afficher ”La valeur de la variable A est nulle.”
fin
Si la variable A, au moment du test, a une valeur nulle, alors l’instruction Afficher "La valeur
de la variable A est nulle." est exécutée, sinon, elle est ignorée.
Une < condition > peut être tout type de test. Par exemple,
A=2
A=B
B≠7
2>7
La condition A = 2 est vérifiée si la valeur contenue dans A est 2. A = B est vérifiée si les
valeurs contenues dans A et dans B sont les mêmes. B ≠ 7 est vérifié si B contient une valeur
différente de 7. 2 > 7 est vérifiée si 2 est supérieur à 7, donc jamais, cette condition est donc
fausse et ne dépend pas des valeurs des variables.
Le traitement conditionnel peut être étendu de la sorte :
si < condition > alors
< instructions >

6
 sinon
< autresinstructions >
fin
Si <condition> est vérifiée, les <instructions> sont exécutées. Dans le cas contraire, alors ce
sont les <autres instructions> qui sont exécutées. Par exemple :
Algorithme : Valeurs Distinctes
Variables :
Numériques : a, b
DEBUT
Afficher ”Saisissez deux valeurs numériques”
Saisir a, b
si a = b alors
Afficher ”Vous avez saisi deux fois la même valeur, à savoir ”, a, ”.”
sinon
Afficher ”Vous avez saisi deux valeurs différentes, ”, a, ” et ”, b, ”.”
fin
FIN
Dans l’exemple ci-dessus, la condition a = b est évaluée. Si à ce moment-là les variables a et b
contiennent la même valeur, alors la condition a = b sera vérifiée. Dans ce cas, l’instruction
Afficher "Vous avez saisi deux fois la même valeur, à savoir ", a, "." sera exécutée. Si la
condition a = b n’est pas vérifiée, c’est alors l’instruction Afficher "Vous avez saisi deux valeurs
différentes, ", a, " et ", b, "." qui sera exécutée.
Imbrication
Il est possible d’imbriquer les SI à volonté :
si a < 0 alors
si b < 0 alors
Afficher ”a et b sont négatifs”
sinon
Afficher ”a est négatif, b est positif”
fin sinon
si b < 0 alors
Afficher ”b est négatif, a est positif”
sinon
Afficher ”a et b sont positifs”

7
 finsi
fin
Si par exemple a et b sont tous deux positifs, alors aucun des deux tests ne sera vérifié, et c’est
donc le sinon du sinon qui sera exécuté, à savoir Afficher "a et b sont positifs".
Connecteurs logiques
Les connecteurs logiques permettent d’évaluer des conditions plus complexes. Deux sont
disponibles :
– et : la condition <condition1> et <condition2> est vérifiée si les deux conditions <condition1>
et <condition2> sont vérifiées simultanément.
– ou : la condition <condition1> ou <condition2> est vérifié si au moins une des deux
conditions <condition1> et <condition2> est vérifiée.
Par exemple, écrivons un algorithme qui demande à l’utilisateur de saisir deux valeurs, et qui
lui dit si le produit de ces deux valeurs est positif ou négatif sans en calculer le produit
Algorithme : Signe du produit
Variables :
Numériques : a, b
DEBUT
Afficher ”Saisissez deux valeurs numériques”
Saisir a, b
Afficher ”Le produit de ”, a, ” par ”, b, ” est ”
si (a ≤ 0 et b ≤ 0) ou (a ≥ 0 et b ≥ 0) alors
Afficher ”positif ou nul”
sinon
Afficher ”négatif”
finsi
FIN
L’instruction Afficher "positif ou nul" sera exécutée si au moins une des deux conditions
suivantes est vérifiée :
– a ≤ 0 et b ≤ 0
– a ≥ 0 et b ≥ 0

8
 b. SELON CAS
Lorsque que l’on souhaite conditionner l’exécution de plusieurs ensembles d’instructions par
la valeur que prend une variable, plutôt que de faire des imbrications de si à outrance, on
préférera la forme suivante :
Selon < variable > faire
cas < valeur-1 > < instructions1 >
cas < valeur-2 > < instructions2 >
...
cas < valeur-n >
autres cas < instructions >
finSelon
Selon la valeur que prend la variable <variable>, le bloc d’instructions à exécuter est
sélectionné. Par exemple, si la valeur de <variable> est <valeur-1>, alors le bloc
<instructions1> est exécuté. Le bloc <autres cas> est exécuté si la valeur de <variable> ne
correspond à aucune des valeurs énumérées.
Exemple : Ecrivons un algorithme demandant à l’utilisateur le jour de la semaine. Affichons
ensuite le jour correspondant au lendemain
Algorithme : Lendemain
Variables :
Numériques : erreur
Alphanumériques : jour, lendemain
DEBUT
Afficher ”Saisissez un jour de la semaine”
Saisir jour
erreur ← 0
selon jour faire
cas ”lundi” : lendemain ← ”mardi”
cas ”mardi” : lendemain ← ”mercredi”
cas ”mercredi” : lendemain ← ”jeudi”
cas ”jeudi” : lendemain ← ”vendredi”
cas ”vendredi” : lendemain ← ”samedi”
cas ”samedi” : lendemain ← ”dimanche”
cas ”dimanche” : lendemain ← ”lundi”
autres cas erreur ← 1

9
 finSelon
si erreur = 1 alors
Afficher ”Erreur de saisie”
sinon
Afficher ”Le lendemain du ”, jour, ” est ”, lendemain, ”.”
fin
FIN
Vous remarquez que si l’on avait voulu écrire le même algorithme avec des si, des imbrications
nombreuses et peu élégantes auraient été nécessaires.

3. BOUCLES
Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cet
ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une
boucle s’appelle une itération, ou encore un passage dans la boucle. Il existe trois types de
boucle :
– Tant que
– Répéter ... jusqu’à
– Pour
Chacune de ces boucles a ses avantages et ses inconvénients.
a. Tant que
La syntaxe d’une boucle Tant que est la suivante.
tant que < condition >
< instructions >
fin tant que
La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée,
on exécute les instructions de la boucle. Une fois que la condition n’est plus vérifiée, l’exécution
se poursuit après le fin tant que. Affichons par exemple tous les nombres de 1 à 5 dans l’ordre
croissant,
Algorithme : 1 à 5 Tant que
Variables :
Numérique : i
DEBUT
i←1
tant que i ≤ 5

10
 Afficher i
i←i+1
fin tant que
FIN
Cet algorithme initialise i à 1 et tant que la valeur de i n’excède pas 5, cette valeur est affichée
puis incrémentée. Les instructions se trouvant dans le corps de la boucle sont donc exécutées 5
fois de suite. La variable i s’appelle un compteur, on gère la boucle par incrémentations
successives de i et on sort de la boucle une fois que i a atteint une certaine valeur. L’initialisation
du compteur est très importante. Si vous n’initialisez pas i explicitement, alors cette variable
contiendra n’importe quelle valeur et votre algorithme ne se comportera pas du tout comme
prévu.

b. Répéter ... jusqu’à

répéter
< instructions >
jusqu’`a < condition > ;
Le fonctionnement est analogue à celui de la boucle tant que à quelques détails près : la
condition est évaluée après chaque passage dans la boucle. On exécute le corps de la boucle
jusqu’à ce que la condition soit vérifiée, donc tant que la condition est fausse.
Une boucle Répéter ... jusqu’à est donc exécutée au moins une fois. Reprenons l’exemple
précédent avec une boucle Répéter ... jusqu’à :
Algorithme : 1 à 5 Répéter . . . jusqu’à
Variables : numérique : i
DEBUT
i←1
répéter
Afficher i
i←i+1
jusqu’à i > 5
FIN
De la même façon que pour la boucle Tant que, le compteur est initialisé avant le premier
passage dans la boucle. Par contre, la condition de sortie de la boucle n’est pas la même, on ne
sort de la boucle qu’une fois que la valeur 5 a été affichée. Or, i est incrémenté après l’affichage,
par conséquent i aura la valeur 6 à la fin de l’itération pendant laquelle la valeur 5 aura été

11
affichée. C’est pour cela qu’on ne sort de la boucle qu’une fois que i a dépassé strictement la
valeur 5. Exemple : un des usages les plus courant de la boucle Répéter ... jusqu’à
Répéter
Afficher ”Saisir un nombre strictement positif”
Saisir i
si i ≤ 0 alors
Afficher ”J’ai dit STRICTEMENT POSITIF !”
fin jusqu’`a i > 0

c. POUR
pour < variable > allant de < première-valeur > à < dernière-valeur > [par pas de < pas >]
< instructions >
fin pour
La boucle Pour fait varier la valeur du compteur <variable> entre <première-valeur et
<dernière-valeur>. Le <pas> est optionnel et permet de préciser la variation du compteur entre
chaque itération, le pas par défaut est 1 et correspond donc à une incrémentation. Toute boucle
pour peut-être réécrite avec une boucle tant que. On réécrit de la façon suivante :
< variable >←< première-valeur >
tant que < variable >≠< dernière-valeur > + < pas >
< instructions >
< variable >←< variable > + < pas >
fin tant que
La boucle pour initialise le compteur <variable> à la <première-valeur>, et tant que la dernière
valeur n’a pas été atteinte, les <instructions> sont exécutées et le compteur incrémenté de <pas>
si le pas est positif, de -<pas> si le pas est négatif.
Algorithme : 1 à 5 Pour
Variables :
Numérique : i
DEBUT
pour i allant de 1 à 5
Afficher i
fin pour
FIN

12
Observez les similitudes entre cet algorithme et la version utilisant la boucle tant que. Notez
bien que l’on utilise une boucle pour quand on sait en rentrant dans la boucle combien
d’itérations devront être faites. Par exemple, n’utilisez pas une boucle pour contrôler une saisie.

4. TABLEAUX
Considérons un algorithme dont l’exécution donnerait :
Saisissez 10 valeurs : 49 0 5 -2 0 6 8 1 -7 39
Saisissez une valeur : -7
-7 est la 9-ieme valeur saisie.
Comment rédiger un tel algorithme sans utiliser dix variables pour stocker les 10 valeurs ?

a. Définition
Un tableau est un regroupement de variables de même type, il est identifié par un nom. Chacune
des variables du tableau est numérotée, ce numéro s’appelle un indice. Chaque variable du
tableau est donc caractérisée par le nom du tableau et son indice.
Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera numéroté et il sera
possible de la retrouver en utilisant simultanément le nom du tableau et l’indice de la variable.
Les différentes variables de T porteront des numéros de 1 à 10, et nous appellerons chacune de
ces variables un élément de T.
Une variable n’étant pas un tableau est appelée variable scalaire, un tableau par opposition une
variable scalaire est une variable non scalaire.

b. Déclaration
Comme les variables d’un tableau doivent être de même type, il convient de préciser ce type au
moment de la déclaration du tableau. De même, on précise lors de la déclaration du tableau le
nombre de variables qu’il contient. La syntaxe est :
< type >:< nom > [< taille >]
Par exemple :
Numérique : T [4]
déclare un tableau T contenant 4 variables de type numérique.

c. Accès aux éléments

13
Les éléments d’un tableau à n éléments sont indices de 1 à n. On note T[i] l’élément d’indice i
du tableau T. Les quatre éléments du tableau de l’exemple ci-avant sont donc notés T[1], T[2],
T[3] et T[4].

d. Exemple
Nous pouvons maintenant rédiger l’algorithme dont le comportement est décrit au début du
cours. Il est nécessaire de stocker 10 valeurs de type entier, nous allons donc déclarer un tableau
E de la sorte :
numérique : E[10]
La déclaration ci-dessus est celle d’un tableau de 10 éléments de type numérique appelé E. Il
convient ensuite d’effectuer les saisies des 10 valeurs. On peut par exemple procéder de la sorte
:
Afficher ”Saisissez dix valeurs : ”
Saisir E[1] Saisir E[2] Saisir E[3] Saisir E[4] Saisir E[5] Saisir E[6] Saisir E[7] Saisir E[8]
Saisir E[9] Saisir E[10]
La redondance des instructions de saisie de cet extrait sont d’une laideur rédhibitoire. Nous
procéderons plus élégamment en faisant une boucle :
pour i allant de 1 à 10
Saisir E[i]
fin pour
Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des boucles
pour manier les tableaux, celles-ci permettent d’effectuer un traitement sur chaque élément d’un
tableau. Ensuite, il faut saisir une valeur à rechercher dans le tableau :
Afficher ”Saisissez une valeur : ”
Saisir t
Nous allons maintenant rechercher la valeur t dans le tableau E. Considérons pour ce faire la
boucle suivante :
i←1
tant que E[i] ≠ t
i←i+1
fin tant que
Cette boucle parcourt le tableau jusqu’à trouver un élément de E qui ait la même valeur que t.
Le problème qui pourrait se poser est que si t ne se trouve pas dans le tableau E, alors la boucle
pourrait ne pas s’arrêter. Si i prend des valeurs strictement plus grandes que 10, alors il se

14
produira ce que l’on appelle un débordement d’indice. Vous devez toujours veiller à ce qu’il ne
se produise pas de débordement d’indice. Nous allons donc faire en sorte que la boucle s’arrête
si i prend des valeurs strictement supérieures à 10.
i←1
tant que i <= 10 et E[i] ≠ t
i←i+1
fin tant que
Il existe donc deux façons de sortir de la boucle :
– En cas de débordement d’indice, la condition i <= 10 ne sera pas vérifiée. Une fois sorti de la
boucle, i aura la valeur 11
– Dans le cas où t se trouve dans le tableau à l’indice i, alors la condition E[i] ≠ t ne sera pas
vérifiée et on sortira de la boucle. Un fois sorti de la boucle, i aura comme valeur l’indice de
l’élément de E qui est égal à t, donc une valeur comprise entre 1 et 10.
On identifie donc la façon dont on est sorti de la boucle en testant la valeur de i :
si i = 11 alors
Afficher t, ” ne fait pas partie des valeurs saisies.”
sinon
Afficher t, ” est la ”, i, ”-ème valeur saisie.”
fin
Si (i = 11), alors nous sommes sorti de la boucle parce que l’élément saisi par l’utilisateur ne
trouve pas dans le tableau. Dans le cas contraire, t est la i-eme valeur saisie par l’utilisateur.
Récapitulons :
Algorithme : Exemple tableau
Variables :
numériques : E[10], i, t
DEBUT
Afficher ”Saisissez dix valeurs : ”
pour i allant de 1 à 10
Saisir E[i]
fin pour
Afficher ”Saisissez une valeur : ”
Saisir t
i←1
tant que i <= 10 et E[i] ≠ t

15
 i←i+1
fin tant que
si i = 11 alors
Afficher t, ” ne fait pas partie des valeurs saisies.”
sinon
Afficher t, ” est la ”, i, ”-`eme valeur saisie.”
fin
FIN

5. SOUS-PROGRAMMES
Il est souvent nécessaire, pour éviter d’écrire plusieurs fois le même code, de préparer des blocs
de code prêts à l’emploi. Une procédure est un ensemble d’instructions. Chaque procédure a un
nom, on se sert de ce nom pour exécuter les instructions contenues dans la procédure.

a. Principe
procedure nomprocedure()
variables :
déclaration de variables
DEBUT
corps de la procedure
FIN
Par exemple,
procédure afficheBonjour()
DEBUT
Afficher "bonjour !"
FIN
On invoque une procédure en utilisant son nom. Par exemple,
afficheBonjour()
exécute la procédure afficheBonjour, on dit aussi qu’on appelle la procédure afficheBonjour.

b. Passage de paramètres
Les variables du programme appelant ne sont pas lisibles depuis un sous-programme. Mais si
une procédure, pour s’exécuter, a besoin de la valeur d’une variable définie dans le programme
appelant, on utilise pour la lui communiquer un mécanisme dit ”passage de paramètres”.

16
 procedure afficheVariable(donnée numérique : monEntier)
DEBUT
Afficher "La valeur de l’entier placé en paramètre est ", monEntier
FIN
La valeur contenue dans la variable monEntier est communiquée au sous-programme lors de
l’appel de la procédure. Par exemple, afficheVariabler(3) va placer la valeur 3 dans la variable
monEntier. Il est aussi possible de passer en paramètre une valeur contenue dans une variable.
Par exemple, celle d’une variable A :
afficheVariable(A)
La procédure suivante permute les valeurs des deux variables passées en paramètres :
procedure echange (données numériques : x, y)
Variable :
Numérique : temp
DEBUT
temp <- x
x <- y
y <- temp
FIN
On peut appeler cette procédure de la façon suivante :
echange (A, B)
Cependant, l’exécution de ce sous-programme laisse les valeurs de A et B inchangées, car x et
y sont des copies de A et B. Les valeurs des copies sont échangées, mais les originaux ne sont
pas affectés par cette modification. Si l’on veut passer en paramètres non pas les valeurs des
variables, mais les variables elles-mêmes, il faut quelque peu modifier la syntaxe de la
procédure :
procédure echange(donnees/resultats numeriques : x, y)
Variable :
Numérique : temp
DEBUT
temp <- x
x <- y
y <- temp
FIN

17
 c. Fonctions
Une fonction est un sous-programme quelque peu particulier, dans le sens mathématique du
terme, il sert à calculer une valeur. Définissons une fonction simple :
fonction successeur(donnée numérique : x)
DEBUT
retourner (x + 1);
FIN
Cette fonction ”fabrique” le x + 1. On dit que cette fonction renvoie (ou retourne) x + 1. On
peut appeler cette fonction ainsi :
Afficher x, " + 1 = ", successeur(x)
Une fois la fonction appelée, on remplace successeur(x) par le résultat retourné par la fonction.

6. ORGANIGRAMME
Il donne une description schématique de l’algorithme. On dessine un schéma indiquant l’ordre
d’exécution des opérations traitées par l’algorithme. Les variables utilisées dans le programme
doivent être déclarées au départ. Voici les principaux symboles utilisés :

Exemple 1 : l’organigramme correspondant à : S’il pleut, je prends mon parapluie et je mets

mes bottes, sinon je mets mes sandales est le suivant

18
 7. PROGRAMMES
Après avoir trouvé le bon algorithme pour résoudre numériquement un problème et après avoir
donné son exécution sous forme schématique (organigramme), on choisit ensuite un langage de
programmation afin de le faire exécuter par un ordinateur. Le programme transmet étape par
étape les instructions décrites dans l’organigramme. C’est le messager de l’ordinateur. Les
instructions décrites dans le programme doivent respecter des codes et des ordres d’écriture
spécifique à celui-ci. C’est les syntaxes du programme. L’exécution du programme doit se faire
via le compilateur (le noyau du programme). Il existe plusieurs programmes (aujourd’hui sous
forme de logiciels scientifiques). Dans le cadre de ce cours, nous utiliserons le logiciel
MATLAB.

19
 Exercices Algorithmiques
Exercice 0
Ecrire un programme qui échange la valeur de deux variables. Exemple, si a = 2 et b = 5, le
programme donnera a = 5 et b = 2.
Exercice 1
Ecrire un programme qui demande un nombre à l’utilisateur, puis qui calcule et affiche le
carré de ce nombre.
Exercice 2
Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le taux de TVA,
et qui fournit le prix total TTC correspondant. Faire en sorte que des libellés apparaissent
clairement.
Exercice 3
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si leur
produit est négatif ou positif (on laisse de côté le cas où le produit est nul). Attention
toutefois : on ne doit pas calculer le produit des deux nombres.
Exercice 4
Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il l’informe de
sa catégorie :
”Poussin” de 6 à 7 ans
”Pupille” de 8 à 9 ans
”Minime” de 10 à 11 ans
”Cadet” après 12 ans
Exercice 5
Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la
réponse convienne. En cas de réponse supérieure à 20, on fera apparaitre un message :
Plus petit ! , et inversement, Plus grand !, si le nombre est inférieur à 10.
Exercice 6
Ecrire un algorithme qui demande un nombre entier de départ, et qui calcule la somme des
entiers jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer : 1 + 2
+ 3 + 4 + 5 = 15
NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.
Exercice 7
Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 !, vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8

20
 Exercice 8
Que produit l’algorithme suivant ?
Tableau Nb(5) en Entier
Variable i en Entier
Début
Pour i ← 0 à 5
Nb(i) ← i * i
Fin pour
Pour i ← 0 à 5
Ecrire Nb(i)
Fin pour
Fin
Peut-on simplifier cet algorithme avec le même résultat ?

Exercice 9
Ecrivez un algorithme permettant, à l’utilisateur de saisir les notes d’une classe. Le
programme, une fois la saisie terminée, renvoie le nombre de ces notes supérieures à la
moyenne de la classe.

21