INTRODUCTION À L’ALGORITHME

Abdoul Aziz BADO

Manager des Systèmes d’Information
ALGORITHME : DÉFINITION

 Algorithme : procédure de calcul bien définie qui prend en

entrée une valeur, ou un ensemble de valeurs, et qui donne
en sortie une valeur, ou un ensemble de valeurs. Un
algorithme est donc une séquence d’étapes de calcul qui
transforment l’entrée en sortie.

 L’algorithmique est le permis de conduire de l’informatique

LES VARIABLES
1. A quoi servent les variables ?

Dans un programmes informatique, on a toujours 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)
• De résultats obtenus par un programme

Ces données peuvent être des nombres, du texte, des images,

etc.
LES VARIABLES
2. Déclaration des variables

La déclaration de variable se fait tout au début de

l’algorithme, avant même les instructions proprement dites.

Toutefois, une règle absolue est un nom de variable peut

comporter des lettres et des chiffres, mais qu’il exclut la
plupart des signes de ponctuation, en particulier les espaces,

Un nom de variable commence impérativement par une

lettre.

Lorsqu’on déclare une variable, on doit préciser son type.

LES VARIABLES
3.1 Type numérique classique

Si on réserve un octet, on ne pourra coder que :

 28 = 256 valeurs différentes

Cela peut signifier par exemple les nombres entiers de :

 1 à 256, ou de 0 à 255 ou de –127 à +128…

Si l’on réserve deux octets, on a droit à : 65 536 valeurs

Avec trois octets : 16 777 216, etc.

Le type de codage choisi pour un nombre va déterminer, les

valeurs minimales et maximales des nombres pouvant être
stockés dans la variable,
LES VARIABLES
LES VARIABLES
3.2 Autres Types

 Le type monétaire (avec strictement deux chiffres après la

virgule)

 Le type date (jour/mois/année).

 Le type alphanumérique également appelé type

caractère, type chaîne ou en anglais, le type string.

 ET en fin, le type booléen : on y stocke uniquement les

valeurs logiques VRAI et FAUX.
LES VARIABLES

4. Syntaxe

En pseudo-code, l'instruction d'affectation se note avec le

signe ←

Ainsi :
A ← 24 attribue la valeur 24 à la variable A .
B←A signifie que la valeur de B est maintenant celle de A
B←A+4 Si A contenait 12, B faut maintenant 16.
LES VARIABLES
4. Syntaxe
 Exemple 1 :
Début
A←B
C←D
Fin

 Exemple 1
Variable A en Numérique
Début
A ← 34
A ← 12
Fin
LES OPÉRATEURS
1. Opérateurs numériques

Ce sont les quatre opérations arithmétiques tout ce qu’il y a de

classique.

+ : addition

- : soustraction

* : multiplication

/ : division
LES OPÉRATEURS
2. 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 ← " Toto"
B ← " Tata"
C←A&B
Fin

La valeur de C à la fin de l’algorithme est « TotoTata"

LES OPÉRATEURS

3. Opérateurs logiques (ou booléens)

Il s’agit du ET, du OU, du NON

LECTURE ET ECRITURE

La lecture permet à l’utilisateur de saisir des valeurs au clavier,

tandis que l’écriture permet au programme de communiquer des
valeurs à l’utilisateur en les affichant à l’écran.

1. Les instructions de lecture et d’écriture

Dès que le programme rencontre une instruction Ecrire,
l’exécution s’interrompt, attendant la frappe d’une valeur au
clavier.

Exemple :
Ecrire "Entrez votre nom : "
Lire NomFamille
Exemple :
Ecrire un programme qui demande un nombre à l’utilisateur, puis
qui calcule et affiche le carré de ce nombre.
ALGORITHMIQUE : PREMIER PAS

 Calcul de la somme de deux entiers

variable a, b : entier
variable s : entier

Debut
afficher(" Donner le premier entier ")
saisir(a)
afficher(" Donner le deuxième entier ")
saisir(b)
s <- a+b
afficher(" La somme de a et b est : ")
afficher("s")
Fin
ALGORITHMIQUE : LES ÉTAPES

 Initialisation des variables

 Permet de donner des valeurs initiales aux variables qui
seront utilisées dans la résolution du problème posé
 Traitement
 Résolution du problème étape par étape.
 Affichage du résultat ou retour du résultat
 Affichage du résultat du problème à l’écran, dans un
fichier, ou sauvegarde du résultat du programme dans une
variable
ALGORITHMIQUE : PSEUDO CODE
 Dans ce cours les algorithmes seront exprimées
sous la forme de programmes écrits en pseudo-
code.
 Un pseudo code n’est pas un « vrai code », il
permet d’employer l’écriture qui semble être la
plus claire et la plus concise pour spécifier un
algorithme.
PSEUDO CODE : DÉCLARATION DE
VARIABLES

 Pour déclarer une variable dans notre pseudo algorithme, il faut

d’abord préciser le mot variable, suivi du nom de la variable,
suivi de deux points et le type de la variable.
 La syntaxe d’une déclaration de variable est la suivante :
variable Nom_variable : types
 Exemple : variable nom : chaine de caractère
 L’opérateur d’affectation d’une variable : <-
 Exemple : a<-5
 Il est possible de déclarer plusieurs variables sur une même
ligne
 La syntaxe d’une déclaration de variable est la suivante :
variable variable1, variable2, …: type
 Déclaration d’une constante
constante Nom_constante: type
PSEUDO CODE : LES ENTRÉES-SORTIES

 La fonction afficher(<liste des noms de variables, de constantes

ou d’expression>) permet d’afficher à l’écran les informations
fournies à son entrée.

 La fonction saisir(<liste des noms de variables>) permet de

stocker dans les variables en entrées les informations fournies
par l’utilisateur.
PSEUDO CODE : EXEMPLE

 Calcul de la surface d’un cercle

variable r : réel
variable S : réel

Debut
constante PI : réel
PI<-3.14
afficher(" Donner le rayon du cercle")
saisir(r)
S<- r*r*PI
afficher(" La surface du cercle est :")
afficher(s)
Fin
PSEUDO-CODE : TRAITEMENT
CONDITIONNEL

 Un traitement conditionnel permet d’effectuer des choix

(alternative) ou de faire un choix parmi plusieurs.
 Instruction : « si-alors-sinon »
si (expression conditionnelle égale à vraie)
alors faire séquence1 d’ instructions
sinon séquence2 d’ instructions
finsi
Expression
conditionnelle

vraie fausse
Sequence2
Sequence1 d’instruction
d’instruction s
s

Suite du programme
PSEUDO CODE : MAXIMUM DE DEUX
ENTIERES

 Calcul du maximum de deux entiers

Entrée : deux entiers a et b

Sortie : un entier max

Debut
afficher(" Donner deux entiers")
saisir(a)
saisir(b)
si a > b
alors max <- a
sinon max <- b
finsi
Fin
LES DIFFÉRENTES FORMES DU SI

 si avec sinon
si E
si E vrai faux
alors A1 A1, B1,

sinon B1
finsi

si E
 si sans sinon vrai
si E A1 faux
alors A1
finsi
LES DIFFÉRENTES FORMES DU SI

 si emboités si
si E1 E
1
alors si E2 vrai
alors A1; A2, ...; An;
sinon B1; B2, ...; Bn; faux
E
finsi 2
sinon C1; C2, ...; Cn; vrai faux
finsi
A1,A2;..An; B1,B2;..Bn; C1,C2;..Cn;
EXEMPLE DE SI EMBOITÉ

 si emboités

si moyenne >=12
alors afficher("admis")
sinon si moyenne >=10
alors afficher(« admis avec crédits »)
sinon afficher(« ajourné »)
finsi
finsi
PSEUDO-CODE : TRAITEMENT
CONDITIONNEL

 Un traitement conditionnel permet d’effectuer des choix

(alternative) ou de faire un choix parmi plusieurs.
 Instruction : « selon »
selon <identificateur>
(liste de ) valeur (s) : séquence1 d’instructions
(liste de ) valeur (s) : séquence1 d’instructions
…
[autres : instructions par défaut]
TRAITEMENT RÉPÉTITIF (BOUCLE)

 Les boucles permettant d’exécuter plusieurs fois la même

série d’instructions jusqu’à ce qu’une condition ne soit plus
réalisée.
 Les variantes se différencient par la manière de caractériser
le nombre de boucles effectivement réalisées.
 pour : on exprime le décompte exact de boucles
 Tant que : on exprime la condition de continuation
 Répéter … Tant que : on exprime la condition d’arrêt
LA BOUCLE POUR

 La boucle pour permet d’exécuter plusieurs fois la même série

d’instructions. Dans sa syntaxe, il suffit de préciser :
 Le nom de la variable qui sert de compteur (et éventuellement sa valeur de
départ),
 La condition sur la variable pour laquelle la boucle s’arrête (basiquement une
condition qui teste si la valeur dépasse une limite)
 Une instruction qui incrémente (ou décrémente) le compteur.
 Elle se présente sous la forme suivante :
pour <Cpt><-CptInit à CptFin [par <pas>] faire
séquence d’ instructions;
finpour
LA BOUCLE POUR

 Exemple : exécuter l’instruction A, puis exécuter N fois l’instruction

B; puis après l’instruction C

variable i : entier;
A
A;
pour i=1 à N faire
B;
finpour Répéter N fois B
C;

C
LA BOUCLE POUR : SCHÉMA DÉTAILLÉ
DE L’EXEMPLE

variable i : entier
A; A
pour i=1 à 10 par 1 faire
B;
finpour i=1
C;

i!=10

Répéter 10 fois
B

i=i+1
C
LA BOUCLE POUR : EXEMPLE

{Saisie de n nombres et calcul de la moyenne }

variable n : entier
variable i : entier
variable noteCourante, somme : réel
Début
somme<- 0 {initialisation du calcul} -> commentaire
afficher("Donnez le nombre de notes que vous voulez saisir:");
saisir(n);
pour i=1 à n faire
afficher("Note",i )
afficher(" : ")
saisir(noteCourante)
somme = somme+noteCourante;
finpour
afficher("Moyenne : ",(somme)/n);
Fin
LA BOUCLE TANT QUE

 La boucle tant que permet d’exécuter plusieurs fois la même série

d’instructions. Elle se présente sous la forme suivante :
tant que (expression est vraie ) faire
séquence d’ instructions;
fintanque
 Exemple : exécuter l’instruction A, puis tant que E est vraie faire B et si
E est fausse faire C;

A; vrai
Tant que E faire E
B;
fintanque B faux
C;
C
LA BOUCLE TANT QUE

Tant que (Expression) faire

sequence d’instructions;
fintanque

 Expression constitue la condition de poursuite de la boucle. La

présence des parenthèses permet de délimiter cette condition.
 Expression est évaluée avant le premier tour de boucle. Il est donc
nécessaire que sa valeur soit définie à ce moment.
 On doit assurer la convergence (arrêt de la boucle) : la condition doit
à un moment donné s’évaluer à faux.
 Condition nécessaire : la condition doit faire intervenir une variable qui
sera modifiée dans le corps de boucle
 Dans le cas d’une conjonction de conditions (tant que ( E1 Et E2)…)
 L’arrêt est provoquée quand l’une des deux conditions s’évalue à faux
 La condition d’arrêt est alors : !E1 Ou !E2
LA BOUCLE POUR : EXEMPLE
{ Moyenne d’une série de notes saisies au clavier } -> commentaire

variable note, somme : réel

somme <- 0;
variable nbNote : entier
Debut
nbNote <- 0;
afficher(" Donnez une note >=0 ou -1 pour terminer : ");
saisir(note);
tant que note ≠-1) faire
somme <- somme + note;
nbNote <- nbNote+1;
afficher (" Donnez une note >=0 ou -1 pour terminer : ");
saisir(note)
fintanque
afficher(" Le nombre de notes saisies est :", nbNote);
afficher(" La moyenne des notes saisies est : ", (somme)/nbNote));
Fin
EQUIVALENCE D’UN TANT QUE ET D’UN
POUR

 Le pour est un cas particulier du tant que

pour i=binf à bsup faire P i<-binf
finpour tant que(i <= bsup) faire
P
i <- i+1
fintanque
 Plus généralement :
pour Cpt<-CptInit à CptMax par k faire P Cpt<-CptInit;
finpour tant que Cpt <= CptMax faire
P
Cpt = Cpt+k
fintanque
LA BOUCLE RÉPÉTER…TANT QUE

 L’a boucle répéter…tant que est un autre moyen d’exécuter

plusieurs fois la même série d’instructions. Elle est toujours
parcourue au moins une fois. La condition d’arrêt n’est
examinée qu’à la fin de chaque répétition. Elle se présente
sous la forme suivante :
répéter
séquence d’ instructions;
tant que (expression est vraie );
LA BOUCLE RÉPÉTER…TANT QUE :
EXEMPLE

variable n : entier
Début
répéter
afficher("Donnez un entier strictement supérieur a zéro :")
saisir(n)
afficher("Vous avez fourni :" ,n)
tant que (n > 0) ;

afficher("La valeur positive strictement supérieure à zéro est :");

afficher(n);
Fin
LA BOUCLE TANT QUE : EXEMPLE

{Saisie avec filtre : saisie d’une note entre 0 et 20}

variable note : réel

Début
afficher(" Donnez une note : ")
saisir(note)
tant note < 0 Ou note > 20 faire
afficher("la note saisie est incorrecte, veuillez ressaisir : ")
saisir("note)
fintanque
Fin
ALGORITHME DU PLUS GRAND COMMUN
DIVISEUR

{PGCD (plus grand commun diviseur)}

Algorithme PGCD
Entrée : deux entiers a et b
variable x, y : entier
Début
x<-a, y<-b;
si (a < 0) alors x=-a;
si (b < 0) alors y=-b;
tant que (x≠y) faire
si(x < y)
alors y<- y-x;
sinon x <- x-y;
finsi
fintanque
afficher("Le pgcd de ", a, b);
afficher("est :", x)
Fin
LA BOUCLE POUR : EXEMPLE

{ Incrément de n en n : affichage des multiples de n inférieurs à 100 }

variable n : entier
variable i : entier
variable max : entier
max <-99
afficher("Donnez un nombre inferieur à 100 :")
saisir(n);
pour i<-n à max par n faire
afficher( i);
afficher( " ");
finpour
ALGORITHME DU CALCUL DE PUISSANCE

{ calcul de x a la puissance n }

variable x , n, p, resultat : entier

resultat <- 1
afficher("Donnez la valeur de x :");
saisir(x);
afficher("Donnez la valeur de n :");
saisir(n);
pour p=1 à n faire
resultat <- resultat*x;
finpour
afficher("Resultat : ",resultat);