Rappel Algo GE

Algorithmique
Notions et instructions de base
Mourad BOUTAHIR
2019/2020
1
Définitions
⚫ Un algorithme est une suite de raisonnements ou d'opérations qui
fournit la solution de certains problèmes.
⚫ L’algorithmique désigne la discipline qui étudie les algorithmes et

leurs applications en Informatique
⚫ Une bonne connaissance de l’algorithmique permet d’écrire des

algorithmes exacts et efficaces
2
Représentation d’un algorithme
Historiquement, deux façons pour représenter un algorithme:
• L’Organigramme: représentation graphique

avec des symboles (carrés, losanges, etc.)
• offre une vue d’ensemble de l’algorithme
• représentation quasiment abandonnée aujourd’hui
• Le pseudo-code: représentation textuelle avec

une série de conventions ressemblant à un langage
de programmation (sans les problèmes de syntaxe)
• plus pratique pour écrire un algorithme
• représentation largement utilisée
3
Représentation d’un algorithme
• Le pseudo-code:
représentation textuelle Variables N1,N2,max: réel
Avec une série de conventions DEBUT
Ecrire("Tapez le premier nombre:")
ressemblant Lire(N1)
à un langage de programmation Ecrire("Tapez le deuxième nombre:")
(sans les problèmes Lie(N2)
de syntaxe) Si(N1>N2) alors
max=N1
• plus pratique pour écrire Sinon max= N2
un algorithme fin si
• représentation Ecrire("Le plus grand nombre est: " , max)
largement utilisée FIN
4
STRUCTURE D'UN ALGORITHME
La structure d’un algorithme est composée d'une entête et d'un corps.
Nom de l’algorithme Entête

Déclarations des variables
Déclarations des constantes
Début
*commentaires*
Instruction 1 Corps
Instruction n
Délimité par
Fin
Début et Fin
Notion de variable
⚫ Une variable désigne en fait un emplacement mémoire dont le
contenu peut changer au cours d’un programme (d’où le nom
variable)
⚫ Dans les langages de programmation une variable sert à

stocker la valeur d’une donnée
⚫ Règle : Les variables doivent être déclarées avant d’être

utilisées, elles doivent être caractérisées par :
• un nom (Identificateur)
• un type (entier, réel, caractère, chaîne de caractères, …)
6
Types des variables
Le type d’une variable détermine l’ensemble des valeurs qu’elle peut
prendre, les types offerts par la plus part des langages sont:
⚫ Type numérique (entier ou réel)
⚫ Type logique ou booléen: deux valeurs VRAI ou FAUX
⚫ Type caractère: lettres majuscules, minuscules, chiffres, symboles, …

exemples: ’A’, ’a’, ’1’, ’?’, …
⚫ Type chaîne de caractère: toute suite de caractères,
exemples: " Nom, Prénom", "code postale: 1000", …
7
Déclaration des variables
Variables liste d'identificateurs : type
⚫ Exemple:
Variables i, j,k : entier
x, y : réel
OK: booléen
ch1, ch2 : chaîne de caractères
8
L’instruction d’affectation
⚫ l’affectation consiste à attribuer une valeur à une variable
(ça consiste en fait à remplir où à modifier le contenu d'une zone mémoire)
⚫En pseudo-code, l'affectation se note avec le signe ←

Var← e: attribue la valeur de e à la variable Var
- e peut être une valeur, une autre variable ou une expression

- Var et e doivent être de même type ou de types compatibles
- l’affectation ne modifie que ce qui est à gauche de la flèche
9
L’instruction d’affectation
Exemple:
Variables i, j,k : entier
x, y : réel
OK: booléen
ch1, ch2 : chaîne de caractères
⚫ Affectations valides: i ←1 j ←i k ←i+j

x ←10.3 OK ←FAUX ch1 ←"SMI"
ch2 ←ch1 x ←4 x ←j
(voir la déclaration des variables dans le transparent précédent)
⚫ Affectations non valides: i ←10.3 OK ←"SMI" j ←x
10
Quelques remarques
⚫ Beaucoup de langages de programmation (C/C++, Java, …) utilisent

le signe égal = pour l’affectation ←
⚫ l'affectation n'est pas commutative : A=B est différente de B=A
⚫ l'affectation est différente d'une équation mathématique :
• A=A+1 a un sens en langages de programmation
11
échanger deux valeurs
Variables a,b,c,z : quelconques

Debut
z  b /* on stocke la valeur de x dans z */
b  a /* on peut maintenant écrire dans x */
a  c /* on remet l’ancien contenu de x dans y */
cz
Fin
Les entrées / sorties
⚫ Les instructions de lecture et d'écriture permettent à la machine de

communiquer avec l'utilisateur
Il peut afficher Il peut saisir

une information: une information
Sous forme du texte Sous forme du texte

ou numérique
sous forme de chiffres
(contenu d’une
variable) Mémorisation dans
des variables
Les instructions d'entrées-sorties:
lecture et écriture
⚫ La lecture permet d'entrer des donnés à partir du clavier
• En pseudo-code, on note: lire (var)

la machine met la valeur entrée au clavier
dans la zone mémoire nommée var
⚫ L'écriture permet d'afficher des résultats à l'écran (ou de les écrire

dans un fichier)
• En pseudo-code, on note: écrire (var)

la machine affiche le contenu de la
zone mémoire var
14
Exemple : Instruction de lecture
Ecrire ("nombre ?")
Lire (nb)
Ecrire ("nb vaut ", nb, ".")
instruction 1 : instruction 2 : étape1 instruction 2 : instruction 3 :

affichage du attente action utilisateur étape2 texte et valeur
texte affecter la valeur
nb <- 10
Exemple : Instruction d’écriture
Ecrire ("nombre ?")

nb <- 10
Ecrire (nb)
Ecrire ("nb vaut ", nb, ".")
instruction 1 : instruction 3 : instruction 4 :

affichage du texte affichage de la valeur texte et valeur
Exercice (lecture et écriture)
Que seront les valeurs des variables a et b après l'exécution des
instructions suivantes :
Variable a, b : Entier
Début
a←3
b ← a + 15
a←1
Fin
17
Que seront les valeurs des variables a et b après l'exécution des
Variable a, b : Entier
Début
a←5
b←a+4
a←a+1
b←a-4
Fin
18
Quels seront les valeurs des variables a, b et c après l'exécution
des instructions suivantes :
Variable a, b, c : Entier
Début
a←1
b←2
c←a+b
Fin
19
Que seront les valeurs des variables a,b et c après l'exécution des
Début
a←3
b ← 10
c←a+b
b←a+b
a←c
Fin
20
Que seront les valeurs des variables a,b et c après l'exécution des
Début
a←3
b ← 10
c←a+b
b←a+b
a←c
Fin
21
Exercice
Ecrire un algorithme qui demande un nombre entier à l'utilisateur, puis
qui calcule et affiche le double de ce nombre
Algorithme Calcul_double
variables A, B : entier
Début
écrire("entrer le nombre ")
lire(A)
B ← 2*A
écrire("le double de ", A, "est :", B)
Fin
22
Ecrire un algorithme qui vous demande de saisir votre nom puis
votre prénom et qui affiche ensuite votre nom complet
Algorithme AffichageNomComplet
variables Nom, Prenom, Nom_Complet : chaîne de caractères
Début
écrire("entrez votre nom")
lire(Nom)
écrire("entrez votre prénom")
lire(Prenom)
Nom_Complet ← Nom & Prenom
écrire("Votre nom complet est : ", Nom_Complet)
Fin
23
Exercice
Écrire un algorithme permettant de permuter le contenu de deux
variables a et b, quelque soit le type.
24
25
Exercice
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. (TTC=NA*HT*(1+TVA))
Algorithme prix TTC d’un article;

variables nb, pht, ttva, pttc :réels
Début
Ecrire ("Entrez le prix hors taxes : ");
Lire (pht);
Ecrire( "Entrez le nombre d’articles :" );
Lire (nb);
Ecrire ("Entrez le taux de TVA :");
Lire (ttva);
pttc ← nb * pht * (1 + ttva);
Ecrire ("Le prix toutes taxes est : ", pttc);
fin
Tests: instructions conditionnelles (1)
⚫ Les instructions conditionnelles servent à n'exécuter une instruction

ou une séquence d'instructions que si une condition est vérifiée
⚫ On utilisera la forme suivante: Si condition alors
instruction ou suite d'instructions1
Sinon
Finsi
• la condition ne peut être que vraie ou fausse
• si la condition est vraie, se sont les instructions1 qui seront exécutées
• si la condition est fausse, se sont les instructions2 qui seront exécutées

• la condition peut être une condition simple ou une condition composée de
plusieurs conditions
27
Tests: instructions conditionnelles (2)
⚫ La partie Sinon n'est pas obligatoire, quand elle n'existe pas et que
la condition est fausse, aucun traitement n'est réalisé
• On utilisera dans ce cas la forme simplifiée suivante:
Si condition alors
Finsi
28
Exemple (Si…Alors…Sinon)
Algorithme AffichageValeurAbsolue (version1)
Variable x : réel
Début
Ecrire (" Entrez un réel : “)
Lire (x)
Si (x < 0) alors
Ecrire ("la valeur absolue de ", x, "est:",-x)
Sinon
Ecrire ("la valeur absolue de ", x, "est:",x)
Finsi
Fin
29
Exemple (Si…Alors)
Algorithme AffichageValeurAbsolue (version2)
Variable x,y : réel
Début
Ecrire (" Entrez un réel : “)
Lire (x)
y← x
Si (x < 0) alors
y ← -x
Finsi
Ecrire ("la valeur absolue de ", x, "est:",y)
Fin
30
Exercice (tests)
Ecrire un algorithme qui demande un nombre entier à l'utilisateur,
puis qui teste et affiche s'il est divisible par 3
Algorithme Divsible_par3
Variable n : entier
Début
Ecrire " Entrez un entier : "
Lire (n)
Si (n%3=0) alors
Ecrire (n," est divisible par 3")
Sinon
Ecrire (n," n'est pas divisible par 3")
Finsi
Fin
31
Tests imbriqués
⚫ Les tests peuvent avoir un degré quelconque d'imbrications
Si condition1 alors
Si condition2 alors
instructionsA
Sinon
instructionsB
Finsi
Sinon
Si condition3 alors
instructionsC
Finsi
Finsi
32
Tests imbriqués: exemple (version 1)
Variable n : entier
Début
Ecrire ("entrez un nombre : ")
Lire (n)
Si (n < 0) alors
Ecrire ("Ce nombre est négatif")
Sinon
Si (n = 0) alors
Ecrire ("Ce nombre est nul")
Sinon
Ecrire ("Ce nombre est positif")
Finsi
Finsi
Fin
33
Tests imbriqués: exemple (version 2)
Variable n : entier
Début
Ecrire ("entrez un nombre : ")
Lire (n)
Si (n < 0) alors Ecrire ("Ce nombre est négatif")
Finsi
Si (n = 0) alors Ecrire ("Ce nombre est nul")
Finsi
Si (n > 0) alors Ecrire ("Ce nombre est positif")
Finsi
Fin
Remarque : dans la version 2 on fait trois tests systématiquement alors que
dans la version 1, si le nombre est négatif on ne fait qu'un seul test
Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
d'abord les conditions les plus probables
34
Tests imbriqués: exercice
Le prix de photocopies dans une reprographie varie selon le
nombre demandé: 0,5 DH la copie pour un nombre de copies
inférieur à 10, 0,4DH pour un nombre compris entre 10 et 20 et
0,3DH au-delà.
Ecrivez un algorithme qui demande à l’utilisateur le nombre de

photocopies effectuées, qui calcule et affiche le prix à payer
35
Tests imbriqués: corrigé de l'exercice
Variables copies : entier
prix : réel
Début
Ecrire ("Nombre de photocopies : ")
Lire (copies)
Si (copies < 10) Alors
prix ← copies*0.5
Sinon Si (copies< 20)
prix ← copies*0.4
Sinon
prix ← copies*0.3
Finsi
Finsi
Ecrire (“Le prix à payer est : ”, prix)
Fin
36
Conditions composées
⚫ Une condition composée est une condition formée de plusieurs
conditions simples reliées par des opérateurs logiques:
ET, OU, OU exclusif (XOR) et NON
⚫ Exemples :
• x compris entre 2 et 6 : (x > 2) ET (x < 6)
• n divisible par 3 ou par 2 : (n%3=0) OU (n%2=0)
• deux valeurs et deux seulement sont identiques parmi a, b et c :

(a=b) XOR (a=c) XOR (b=c)
⚫ L'évaluation d'une condition composée se fait selon des règles

présentées généralement dans ce qu'on appelle tables de vérité
37
Tables de vérité
C1 C2 C1 ET C2 C1 C2 C1 OU C2
VRAI VRAI VRAI VRAI VRAI VRAI
VRAI FAUX FAUX VRAI FAUX VRAI
FAUX VRAI FAUX FAUX VRAI VRAI
FAUX FAUX FAUX FAUX FAUX FAUX
C1 C2 C1 XOR C2 C1 NON C1
VRAI VRAI FAUX VRAI FAUX
VRAI FAUX VRAI FAUX VRAI
FAUX VRAI VRAI
FAUX FAUX FAUX
38
Tests: L’instruction cas
Lorsque l’on doit comparer une même variable avec plusieurs
valeurs, comme par exemple :
si (a=1) alors
faire une chose
Sinon si a=2 alors
faire une autre chose
Sinon si a=4 alors
faire une autre chose
sinon
...
Finsi
On peut remplacer cette suite de si par l’instruction cas

Tests: L’instruction cas
Syntaxe :
selonque
v1 : action1
v2 : action2
...
vn : actionn
autre : action autre
finselonque
v1, . . . , vn sont des constantes de type scalaire (entier, caractère … )
Action i est exécutée si v = vi (on quitte ensuite l’instruction cas)
Action autre est exécutée si quelque soit i, v ≠ vi

Algorithme jours de la semaine
Exemple Variables Njour: Entier
Début
Ecrire(“Entrer un numéro de jour:”);
Lire(Njour);
selonque
1 : écrire (“C’est un lundi”);
2 : écrire (“C’est un mardi”);
3 : écrire (“C’est un mercredi”);
4 : écrire (“C’est un jeudi”);
5 : écrire (“C’est un vendredi”);
6 : écrire (“C’est un samedi”);
7 : écrire (“C’est un dimanche”);
défaut : écrire (“valeur invalide:”,val);
Finselonque
Fin
41
Exercice1-1
Écrire un algorithme qui demande de saisir trois notes et calcule leur
moyenne,
Exercice
Algorithme Moyenne
Variable N1,N2,N3,Moy: Réels
Début
Ecrire ("Entrez la note N1 :")
Lire (N1)
Ecrire ("Entrez la note N2 : " )
Lire (N2)
Ecrire ("Entrez la note N3 : " )
Lire (N3)
Moy (N1+N2+N3)/3
Ecrire (" La moyenne est:”,Moy)
Fin
Exercice1-2
Algorithme Moyenne
Variables N1,N2,N3,Moy: Réels
Variables C,Coef1,Coef2,Coef3: Entiers
Début
Ecrire ("Entrez la note N1 et coefficient : ")
Lire (N1,Coef1)
Lire (N2,Coef2)
Lire (N3,Coef3)
C Coef1+Coef2+Coef3
Moy (N1*Coef1+N2*Coef2+N3*Coef3)/C
Ecrire (" La moyenne est:”,Moy)
Fin
Exercice2-a
Ecrire un algorithme qui demande un nombre à l’utilisateur,et l’informe ensuite si ce
nombre est positif ou négatif (onlaisse de côté le cas où le nombre vaut zéro).
Exercice2-a
Algorithme Nombre_Pos_Nég
Variable n : Entier
Début
Ecrire ("Entrez un nombre : ")
Lire(n)
Si (n > 0) Alors
Ecrire ("Ce nombre est positif”)
Sinon
Finsi
Fin
Exercice2-b
Modifier l'algorithme précédent pour qu'il affiche si le nombre est positif, négatif, ou
nul
Exercice2-b
Algorithme Nombre_Pos_Nég
Variable n :Entier
Début
Ecrire ("Entrez un nombre :")
Lire(n)
Si (n > 0) Alors
Ecrire ("Ce nombre est positif”)
Sinon
Si (n = 0) Alors
Ecrire ("Ce nombre est nul")
Sinon
Finsi
Finsi
Fin
Exercice2-c
Écrire un algorithme qui demande de saisir un nombre et dit s'il est pair ou impair
Exercice2-c
Algorithme Nombre_Pair_Impair
Variable n,r: Entiers
Début
Ecrire ("Entrez un nombre : ")
Lire(n)
r n%2
Si (r = 0) Alors
Ecrire ("Ce nombre est pair”)
Sinon
Ecrire ("Ce nombre est impair")
Finsi
Fin
Exercice2-d
Écrire un algorithme qui lit deux nombres et dit s'ils sont compris entre 25 et 75.
Exercice2-d
Algorithme Deux_Nombres_Etre_25_75
Variable A,B: Entiers
Début
Ecrire ("Entrez deux nombres A et B:")
Lire(A,B)
Si (A < 75 ET A > 25) ET (B < 75 ET B > 25) Alors
Ecrire (" Ces deux nombres compris entre 25 et 75”)
Finsi
Fin
Exercice2-e
Écrire un algorithme qui lit trois nombres et dit s'ils sont dans l'ordre croissant.
Exercice2-e
Algorithme Ordre_Croissant
Variable A,B,C: Entiers
Début
Ecrire ("Entrez 3 nombres A, B et C:")
Lire(A,B,C)
Si (A < B ET B < C) Alors
Ecrire(" Ces nombres sont dans l’ordre croissant”)
Sinon
Ecrire("Ces nombres ne sont pas dans l’ordre croissant”)
Finsi
Fin
Exercice2-f
Modifier l'algorithme de la question 1-2 pour qu'il affiche l'une des mentions
suivantes en
fonction de la moyenne :
entre 0 et 9 : Insuffisant entre 13 et 16 : Bien
entre 10 et 12 : Passable entre 17 et 20 : Très Bien

Exercice2-f
Algorithme Moyenne
Variables N1,N2,N3,Moy: Réels
Variables C,Coef1,Coef2,Coef3: Entiers
Début
Lire (N1,Coef1)
Lire (N2,Coef2)
Lire (N3,Coef3)
C Coef1+Coef2+Coef3
Exercice2-f
Selonque
(Moy>0 ET Moy<10): Ecrire("Insufisant")
(Moy>=10 ET Moy<12): Ecrire("Passable")
(Moy>=12 ET Moy<16): Ecrire(« Bien")
(Moy>=16 ET Moy=<20): Ecrire(« T,Bien")
Finselonque
Fin
Exercice3-1
Ecrire un algorithme permettant de lire au clavier l’heure et les minutes, et
il affichera l’heure
qu’il sera une minute plus tard. Par exemple, si l'utilisateur tape 21 puis 32,
l'algorithme doit
répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de
la vérifier.
Exercice3-1
Algorithme Heure
Variables h, m : Entiers
Début
Ecrire( "Entrez les heures, puis les minutes : ")
Lire (h, m)
m←m+1
Si m = 60 Alors
m←0
h←h+1
FinSi
Si h = 24 Alors
h←0
FinSi
Ecrire ("Dans une minute il sera ", h, "heure(s) ", m, "minute(s) ")
Fin
Exercice3-2
De même que le précédent, cet algorithme doit demander une heure et en
afficher une autre.
Mais cette fois, il doit gérer également les secondes, et afficher l'heure qu'il
sera une seconde
plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit
répondre : "Dans une
seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : On suppose que l'utilisateur entre une date valide.

Exercice3-2
Algorithme Heure
Variables h, m, s : Entiers
Début
Ecrire( "Entrez les heures, les minutes , puis les secondes : ")
Lire (h, m,s)
s←s+1
Si (s = 60) Alors
s←0
m← m+ 1
FinSi
Si (m = 60) Alors
m← 0
h← h+ 1
FinSi
Exercice3-2
Si h = 24 Alors
h←0
FinSi
Ecrire ("Dans une seconde il sera ", h, "heure(s) ", m, "minute(s) ", s,
"seconde(s) ")
Fin
Instructions itératives: les boucles
⚫ Les boucles servent à répéter l'exécution d'un groupe d'instructions
un certain nombre de fois
⚫ On distingue trois sortes de boucles en langages de programmation :

• Les boucles tant que : on y répète des instructions tant qu'une certaine
condition est réalisée
• Les boucles jusqu'à : on y répète des instructions jusqu'à ce qu'une

certaine condition soit réalisée
• Les boucles pour ou avec compteur : on y répète des instructions en

faisant évoluer un compteur (variable particulière) entre une valeur initiale
et une valeur finale
63
Les boucles Tant que
TantQue (condition)
instructions condition Vrai instructions
FinTantQue Faux
⚫ la condition (dite condition de contrôle de la boucle) est évaluée avant chaque

itération
⚫ si la condition est vraie, on exécute instructions (corps de la boucle), puis, on

retourne tester la condition. Si elle est encore vraie, on répète l'exécution, …
⚫ si la condition est fausse, on sort de la boucle et on exécute l'instruction qui

est après FinTantQue
64
Les boucles Tant que : remarques
Attention aux boucles infinies
⚫Exemple de boucle infinie :

i←2
TantQue (i > 0)
i ← i+1 (attention aux erreurs de frappe : + au lieu de -)
FinTantQue
65
Boucle Tant que : exemple
Un algorithme qui détermine le premier nombre entier N tel que la
somme de 1 à N dépasse strictement 100
version 1
Variables som, i : entier
Debut
i←0
som← 0
TantQue (som <=100)
i ← i+1
som ← som+i
FinTantQue
Ecrire (" La valeur cherchée est N= ", i)
Fin
66
Boucle Tant que : exemple (version2)
Un algorithme qui détermine le premier nombre entier N tel que la
somme de 1 à N dépasse strictement 100
version 2: attention à l'ordre des instructions et aux valeurs initiales

Debut
som ← 0
i←1
TantQue (som <=100)
som ← som + i
i ← i+1
FinTantQue
Ecrire (" La valeur cherchée est N= ", i-1)
Fin
67
Les boucles Répéter … jusqu’à …
Répéter
instructions instructions
Jusqu'à condition
Faux
condition
Vrai
⚫ Condition est évaluée après chaque itération
⚫ les instructions entre Répéter et jusqu’à sont exécutées au moins une

fois et leur exécution est répétée jusqu’à ce que condition soit vrai (tant
qu'elle est fausse)
68
Boucle Répéter jusqu’à : exemple
Un algorithme qui détermine le premier nombre entier N tel que la somme de 1
à N dépasse strictement 100 (version avec répéter jusqu'à)

Debut
som ← 0
i←0
Répéter
i ← i+1
som ← som+i
Jusqu'à ( som > 100)
Ecrire (" La valeur cherchée est N= ", i)
Fin
69
Les boucles Pour
Pour compteur allant de initiale à finale par pas valeur du pas
instructions
FinPour
i ←initiale
Vrai
i n'a pas atteint finale instructions i ← i + pas
Faux
70
Les boucles Pour
⚫ Remarque : le nombre d'itérations dans une boucle Pour est connu
avant le début de la boucle
⚫ Compteur est une variable de type entier (ou caractère). Elle doit
être déclarée
⚫ Pas est un entier qui peut être positif ou négatif. Pas peut ne pas
être mentionné, car par défaut sa valeur est égal à 1. Dans ce cas, le
nombre d'itérations est égal à finale - initiale+ 1
⚫ Initiale et finale peuvent être des valeurs, des variables définies

avant le début de la boucle ou des expressions de même type que
compteur
71
Boucle Pour : exemple1
Calcul de x à la puissance n où x est un réel non nul et n un
entier positif ou nul
Variables x, puiss : réel
n, i : entier
Debut
Ecrire (" Entrez la valeur de x ")
Lire (x)
Ecrire (" Entrez la valeur de n ")
Lire (n)
puiss ← 1
Pour i allant de 1 à n
puiss← puiss*x
FinPour
Ecrire (x, " à la puissance ", n, " est égal à ", puiss)
Fin
72
Boucle Pour : exemple1 (version 2)
Calcul de x à la puissance n où x est un réel non nul et n un entier
positif ou nul (version 2 avec un pas négatif)

n, i : entier
Debut
Ecrire (" Entrez respectivement les valeurs de x et n ")
Lire (x, n)
puiss ← 1
Pour i allant de n à 1 par pas -1
puiss← puiss*x
FinPour
Fin
73
Lien entre Pour et TantQue
La boucle Pour est un cas particulier de Tant Que (cas où le nombre d'itérations est
connu et fixé) . Tout ce qu'on peut écrire avec Pour peut être remplacé avec
TantQue (la réciproque est fausse)
Pour compteur allant de initiale à finale par pas valeur du pas

instructions
FinPour
peut être remplacé par : compteur ← initiale

(cas d'un pas positif) TantQue compteur <= finale
instructions
compteur ← compteur+pas
FinTantQue
74
Lien entre Pour et TantQue: exemple
Calcul de x à la puissance n où x est un réel non nul et n un entier positif ou
nul (version avec TantQue)
n, i : entier
Debut
Ecrire (" Entrez la valeur de x ")
Lire (x)
Ecrire (" Entrez la valeur de n ")
Lire (n)
puiss ← 1
i←1
TantQue (i<=n)
puiss← puiss*x
i ← i+1
FinTantQue
Fin
75
Boucles imbriquées
⚫ Les instructions d'une boucle peuvent être des instructions
itératives. Dans ce cas, on aboutit à des boucles imbriquées
⚫ Exemple: Exécution
Pour i allant de 1 à 5 OX
Pour j allant de 1 à i OOX
écrire("O") OOOX
FinPour OOOOX
écrire("X") OOOOOX
FinPour
76
Choix d'un type de boucle
⚫ Si on peut déterminer le nombre d'itérations avant l'exécution de la boucle,
il est plus naturel d'utiliser la boucle Pour
⚫ S'il n'est pas possible de connaître le nombre d'itérations avant l'exécution

de la boucle, on fera appel à l'une des boucles TantQue ou répéter jusqu'à
⚫ Pour le choix entre TantQue et jusqu'à :
• Si on doit tester la condition de contrôle avant de commencer les instructions

de la boucle, on utilisera TantQue
• Si la valeur de la condition de contrôle dépend d'une première exécution des

instructions de la boucle, on utilisera répéter jusqu'à
77
Exercice4-1
Ecrire un algorithme qui détermine si un entier N est parfait ou non Un
entier est dit
parfait s’il est égal à la somme de ces diviseurs Exemple 6=1+2+3

Exercice4-1
Algorithme Nombre_Parfait
Variables N,div,Som : Entiers
Début
Ecrire( "Entrez un nombre N: ")
Lire (N)
Si (N=0) Alors
Ecrire( « Le nombre 0 n’est pas parfait ")
Sinon
Som ← 1
Pour div de 2 à N/2 faire
Si (N%div=0) alors
Som ← Som +div
FinSi
FinPour
Exercice4-1
Si (N=Som) alors
Ecrire( "Le nombre " ,N, " est parfait ")
Sinon
Ecrire( "Le nombre " ,N, " n’est pas parfait ")
Ecrire( « La somme vaut " ,Som)
FinSi
FinSi
Fin
Exercice4-2
Ecrire un algorithme qui détermine si un entier est premier
Exercice4-2
Algorithme Nombre_Premier
Variables N,div : Entiers
R : réel
Début
Ecrire( "Entrez un nombre N: ")
Lire (N)
R ← RacineCarrée(N)
div ← 2
Tantque ((N%div diff 0) ET (div<=R)) faire
div ← div+1
FinTantque
Si (div>R) Alors
Ecrire( « Le nombre est premier ")
Sinon
Ecrire( « Le nombre n’est pas premier ")
FinSi
Fin
Exercice4-3
Ecrire un algorithme qui détermine le PGDC de deux entiers a et b
Exercice4-3
Algorithme PGCD
Variables a,b : Entiers
q,r,pgcd,a1,a2 : Entiers
Début
Ecrire( "Entrez deux nombres a et b : ")
Lire (a,b)
Si (a<b) Alors
b1 ← b
a1← a
Sinon
b1 ← a
a1← b
FinSi
Exercice4-3
Repeter
q ← b1/a1
r← b1%a1
b1 ← a1
a1← r
Jusqu’à r=0
pgcd ← b1
Ecrire( "Le PGCD de " ,a, " et " ,b, " est ",pgcd)
Fin
Exercice5
Les habitants paient l’impôt selon les règles suivantes :
les hommes de plus de 20 ans paient l’impôt
les femmes paient l’impôt si elles ont entre 18 et 35 ans
les autres ne paient pas d’impôt
L’algorithme demandera donc l’âge et le sexe de chaque habitant, et se
prononcera donc ensuite
sur le fait que l’habitant est imposable.

Exercice5
Algorithme Impôt
Variable sex : Caractère
age : entier
C1, C2 : booléen
Début
Ecrire ("Entrez le sexe M/F: ")
Lire (sex)
Ecrire ("Entrez l’âge: ")
Lire (age)
C1 ← sex = "M" ET age > 20
C2 ← sex = "F" ET (age > 18 ET age < 35)
Si (C1 ou C2) Alors
Ecrire ("Imposable")
Sinon
Ecrire ("Non Imposable ")
FinSi
Fin
Exercice6-a
Écrivez un algorithme qui calcule la somme des n premiers nombres entiers
positifs.
L’algorithme demandera à l’utilisateur d’entrer la valeur de n.

Exercice6-a
Algorithme Somme
Variables N,i,Som : Entiers
Début
Ecrire("Entrez un nombre:")
Lire(N)
Som ← 0;
Pour i de 1 à N faire
Som ← Som+i;
Finpour
Ecrire("La somme est:",Som);
Fin
Exercice6-b
Écrivez un algorithme qui calcule la somme des n premiers nombres entiers
positifs paires.
L’algorithme demandera à l’utilisateur d’entrer la valeur de n.

Exercice6-b
Algorithme Somme
Variables N,i,Som : Entiers
Début
Ecrire("Entrez un nombre:")
Lire(N)
Som ← 0;
Pour i de 1 à N faire
Si (i%2=0) Alors
Som ← Som+i;
FinSi
Finpour
Ecrire("La somme est:",Som);
Fin
Exercice7
Les élections législatives, en Guignolerie Septentrionale, obéissent à la règle
suivante :
lorsque l'un des candidats obtient plus de 50% des suffrages, il est élu dès le
premier tour.
en cas de deuxième tour, peuvent participer uniquement les candidats ayant
obtenu au moins 12,5% des voix au premier tour.
Vous devez écrire un algorithme qui permette la saisie des scores de quatre
candidats au premier tour. Cet algorithme traitera ensuite le candidat numéro 1
(et uniquement lui) : il dira s'il est élu, battu, s'il se trouve en ballottage
favorable (il participe au second tour en étant arrivé en tête à l'issue du premier
tour) ou défavorable (il participe au second tour sans avoir été en tête au
premier tour).
Exercice7
Algorithme Elections
Variables A, B, C, D : Réels
Variables C1, C2, C3, C4 : Booléen
Début
Ecrire( "Entrez les scores des quatre prétendants : " )
Lire (A, B, C, D)
C1 ← A > 50
C2 ← B > 50 ou C > 50 ou D > 50
C3 ← A >= B et A >= C et A >= D
C4 ← A >= 12,5
Si (C1) Alors
Ecrire (“Elu au premier tour ")
Sinonsi (C2 ou Non(C4) ) Alors
Ecrire (“Battu, éliminé, sorti !!!”)
Exercice7
SinonSi (C3) Alors
Ecrire ("Ballotage favorable ")
Sinon
Ecrire ("Ballotage défavorable ")
FinSi
Fin
Serie 3 Exercice1-a
Ecrire l'algorithme qui permet de calculer le produit de deux entiers en
utilisant des additions successives.
Serie 3 Exercice1-a
Algorithme Multiplier (a, b)
Variables produit,i,a,b : Entiers
Debut
Ecrire ("Entrez deux nombres a et b")
Lire(a,b)
produit <- 0
Pour i de 1 A a Faire
produit <- produit + b
Finpour
Ecrire ("le produit de a et b est" ,produit)
Fin
Serie 3 Exercice1-b
Ecrire l'algorithme qui permet de calculer la division de deux entiers en
utilisant des soustractions successives
Serie 3 Exercice1-b
Algorithme Soustration(a, b)
Variables quotient,a,b : Entiers
Debut
quotient<-0
Tantque (a >= b) Faire
a <- a - b
quotient <- quotient + 1
Ftque
Ecrire ( " la division de a sur b est" ,quotient)
Fin
Serie 3 Exercice1-c
Ecrire l'algorithme qui permet de saisir un entier N et d'afficher s'il est
premier ou non. Un
nombre est dit premier s'il est divisible uniquement par 1 et par lui-même.
Serie 3 Exercice2-a
Ecrire l'algorithme qui détermine le 20ième terme d'une suite définie
par : S0 = 2, S1 = 3 et Sn = Sn-2 + (-1)n * Sn-1
Serie 3 Exercice2-a
Algorithme 2-a
Variables i,u,v,w : Entiers
Debut
u <- 2
v <- 3
Pour i de 2 A 20 Faire
w <- u + (-1)î*v
u v
v w
Finpour
Ecrire ("le 20eme terme est" ,w)
Fin
Serie 3 Exercice2-b
Ecrire l'algorithme qui détermine le Nième terme d'une suite définie
par : S0 = 2, S1 = 3, S2 = -2 et Sn = Sn-3 + (-1)n * Sn-1
Serie 3 Exercice2-b
Algorithme 2-a
Variables i,u,v,w,z : Entiers
Debut
Ecrire (" donnez un nombre N")
Lire(N)
u <- 2
v <- 3
w <- -2
Pour i de 3 A N Faire
z <- u + (-1)î*w
u v
v w
w z
Finpour
Ecrire ("le Neme terme est" ,z)
Fin
Serie 3 Exercice2-d
Ecrire l'algorithme qui permet d'évaluer le cosinus d'une valeur x donnée.
Serie 3 Exercice2-d
Algorithme 2-d
Variables i,N : Entiers
X,som,prod: Reél
Debut
Lire(N)
Ecrire (" donnez un nombre X")
Lire(X)
som <- 0
prod 1
som <- som + (-1)î*(X^(2*i))/( prod*2*i)
Finpour
Ecrire (" le resultat est" ,som)
Fin
Serie 3 Exercice3-1
Ecrire un algorithme qui demande à l’utilisateur de saisir une série de
nombres et
calculant leurs somme et produit en utilisant les structures :
- Pour .......... ....Faire
- Tant que ..........Faire.
Serie 3 Exercice3-1
Algorithme 2-d
X,som,prod : Reél
Debut
Lire(N)
som <- 1
prod 1
Lire(X)
Serie 3 Exercice3-1
som <- som + x
prod prod*x
Finpour
Ecrire (" la somme de ces nombes est" ,som)
Ecrire (" le produit de ces nombes est" ,prod)
Fin
Serie 3 Exercice3-1
Algorithme 2-d
X,som,prod: Reéls
Debut
Lire(N)
som <- 1
prod 1
i1
Tantque (i<N)
Lire(X)
Serie 3 Exercice3-1
som <- som + x
prod prod*x
Ii+1
FinTantQue
Ecrire (" la somme de ces nombes est" ,som)
Ecrire (" le produit de ces nombes est" ,prod)
Fin
Serie 3 Exercice3-2
Ecrire un algorithme déterminant le Maximum et le minimum de cette
série de nombres
Serie 3 Exercice3-2
Algorithme 2-d
Variables i,N,som,prod : Réels
X,Y,Max,Min: Reél
Debut
Ecrire (" donnez un nombre N et X")
Lire(N,X)
YX
Lire(X)
Serie 3 Exercice3-2
Si (X<Y) Alors
MinX
MaxY
FinSi
Finpour
Ecrire (" Le maximum de ces nombes est" ,Max)
Ecrire (" le minimum de ces nombes est" ,Min)
Fin
Serie 3 Exercice4-1
Ecrire un algorithme qui demande un nombre 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
Serie 3 Exercice4-1
Algorithme 4-1
Variables i,N,som : Entiers
Debut
Lire(N)
som0
somsom+i
FinPour
Ecrire (" La somme est" ,som)
Fin
Serie 3 Exercice4-2
Ecrire un algorithme calculant la somme de la série suivante :
Déduire la valeur de e à partir du calcul de la somme de S

Serie 3 Exercice4-2
Algorithme 4-2
som,prod,prodx,X : Entiers
Debut
Lire(N)
Lire(X)
som0
prod1
prodx1
prodprod*i
prodx prodx*X
somsom+(prodx/prod)
FinPour
Ecrire (" La somme est" ,som)
Fin
Serie 3 Exercice5
Ecrire un algorithme calculant le n-ième terme Un de la suite de
FIBONACCI qui est donnée
par la relation de récurrence:
U1=1 U2=1 Un=Un-1+ UN-2 (pour n>2)
Serie 3 Exercice5
Algorithme 2-a
Variables i,u,v,w : Entiers
Debut
Lire(N)
u <- 1
v <- 1
w <- u + v
u v
v w
Finpour
Ecrire ("le Neme terme est" ,w)
Fin
Serie 3 Exercice6
Calculez la racine carrée d'un nombre réel positif A par approximations
successives en utilisant la relation de récurrence suivante:
XJ+1 = 0.5*(XJ + A/XJ) et 2 X1= A
Serie 3 Exercice6
Algorithme 2-a
Variables i,u,v,A : Entiers
Debut
Ecrire (" donnez un nombre N et A")
Lire(N,A)
u <- A/2
v <- 0,5*(u+A/u)
u v
Finpour
Ecrire ("le Neme terme est" ,v)
Fin
Tableaux
⚫ Un tableau est un ensemble d'éléments de même type désignés
par un identificateur unique
⚫ Une variable entière nommée indice permet d'indiquer la position

d'un élément donné au sein du tableau et de déterminer sa valeur
⚫ La déclaration d'un tableau s'effectue en précisant le type de ses

éléments et sa dimension (le nombre de ses éléments)
• En pseudo code :
variable tableau identificateur[dimension] : type
• Exemple :
variable tableau notes[30] : réel
⚫ On peut définir des tableaux de tous types : tableaux d'entiers, de
réels, de caractères, de booléens, de chaînes de caractères, …
2007/2008 Module I2, 1ère année 122
Tableaux : remarques
⚫ L'accès à un élément du tableau se fait au moyen de l'indice. Par exemple,
notes[i] donne la valeur de l'élément i du tableau notes
⚫ Selon les langages, le premier indice du tableau est soit 0, soit 1. Le plus
souvent c'est 0 (c'est ce qu'on va adopter en pseudo-code). Dans ce cas,
notes[i] désigne l'élément i+1 du tableau notes
⚫ Il est possible de déclarer un tableau sans préciser au départ sa dimension.
Cette précision est faite ultérieurement .
• Par exemple, quand on déclare un tableau comme paramètre d'une procédure,

on peut ne préciser sa dimension qu'au moment de l'appel
• En tous cas, un tableau est inutilisable tant qu’on n’a pas précisé le nombre de
ses éléments
⚫ Un grand avantage des tableaux est qu'on peut traiter les données qui y
sont stockées de façon simple en utilisant des boucles

Tableaux : exemples (1)
⚫ Pour le calcul du nombre d'étudiants ayant une note supérieure à
10 avec les tableaux, on peut écrire :
Variables i ,nbre : entier

tableau notes[30] : réel
Début
nbre ← 0
Pour i allant de 0 à 29
Si (notes[i] >10) alors
nbre ←nbre+1
FinSi
FinPour
écrire ("le nombre de notes supérieures à 10 est : ", nbre)
Fin
Tableaux : saisie et affichage
⚫ Procédures qui permettent de saisir et d'afficher les éléments d'un tableau :
Procédure SaisieTab(n : entier par valeur, tableau T : réel par référence )
variable i: entier
Pour i allant de 0 à n-1
écrire ("Saisie de l'élément ", i + 1)
lire (T[i] )
FinPour
Fin Procédure
Procédure AfficheTab(n : entier par valeur, tableau T : réel par valeur )
variable i: entier
écrire ("T[",i, "] =", T[i])
FinPour
Fin Procédure
Tableaux : exemples d'appel
⚫ Algorithme principale où on fait l'appel des procédures SaisieTab et
AfficheTab :
Algorithme Tableaux
variable p : entier
tableau A[10] : réel
Début
p ← 10
SaisieTab(p, A)
AfficheTab(10,A)
Fin

Tableaux : fonction longueur
La plus part des langages offrent une fonction longueur qui donne la dimension
du tableau. Les procédures Saisie et Affiche peuvent être réécrites comme suit :
Procédure SaisieTab( tableau T : réel par référence )
variable i: entier
Pour i allant de 0 à longueur(T)-1
écrire ("Saisie de l'élément ", i + 1)
lire (T[i] )
FinPour
Fin Procédure
Procédure AfficheTab(tableau T : réel par valeur )
variable i: entier
Pour i allant de 0 à longueur(T)-1
écrire ("T[",i, "] =", T[i])
FinPour
Fin Procédure
Tableaux : syntaxe Maple
⚫ En Maple, un tableau se définit en utilisant le type array comme suit :
identificateur:= array (a..b)
• Identificateur est le nom du tableau
• a et b sont les bornes de l'indice du tableau
⚫ Il est possible d'entrer directement toutes les valeurs d'un tableau.
Exemple: > A:=array(1..4,[5,8,1,7]);
⚫ Il est également possible de les entrer un par un comme suit :
Exemple : > T:=array(1..3);

> T[1]:=1: T[2]:=3: T[3]:=5:
⚫ Pour afficher tous les éléments d'un tableau, il suffit d'utiliser la commande
print > print(T); [1, 3, 5]

Tableaux en malpe : exemple
⚫ Une procédure qui calcule la moyenne des éléments d'un tableau :
> moyenne:=proc(n,T)
> local i,s;
> s:=0;
> for i from 1 to n do
> s:=s+T[i];
> od;
> s/n;
> end;
> A:=array(1..4,[5,8,1,7]);
> moyenne(4,A); résultat : 21/4

Tableaux à deux dimensions
⚫ Les langages de programmation permettent de déclarer des
tableaux dans lesquels les valeurs sont repérées par deux indices.
Ceci est utile par exemple pour représenter des matrices
⚫ En pseudo code, un tableau à deux dimensions se déclare ainsi :
variable tableau identificateur[dimension1] [dimension2] : type
• Exemple : une matrice A de 3 lignes et 4 colonnes dont les éléments

sont réels
variable tableau A[3][4] : réel
⚫ A[i][j] permet d'accéder à l’élément de la matrice qui se trouve à

l’intersection de la ligne i et de la colonne j
Exemples : lecture d'une matrice
⚫ Procédure qui permet de saisir les éléments d'une matrice :
Procédure SaisieMatrice(n : entier par valeur, m : entier par valeur

, tableau A : réel par
référence )
Début
variables i,j : entier
écrire ("saisie de la ligne ", i + 1)
Pour j allant de 0 à m-1
écrire ("Entrez l'élément de la ligne ", i + 1, " et de la colonne ", j+1)
lire (A[i][j])
FinPour
FinPour
Fin Procédure
Exemples : affichage d'une matrice
⚫ Procédure qui permet d'afficher les éléments d'une matrice :
Procédure AfficheMatrice(n : entier par valeur, m : entier par valeur

,tableau A : réel par
valeur )
Début
écrire ("A[",i, "] [",j,"]=", A[i][j])
FinPour
FinPour
Fin Procédure

Exemples : somme de deux matrices
⚫ Procédure qui calcule la somme de deux matrices :
Procédure SommeMatrices(n, m : entier par valeur,

tableau A, B : réel par valeur , tableau C : réel par référence )
Début
C[i][j] ← A[i][j]+B[i][j]
FinPour
FinPour
Fin Procédure

Appel des procédures définies sur les matrices
Exemple d'algorithme principale où on fait l'appel des procédures définies
précédemment pour la saisie, l'affichage et la somme des matrices :
Algorithme Matrices
variables tableau M1[3][4],M2 [3][4],M3 [3][4] : réel
Début
SaisieMatrice(3, 4, M1)
SaisieMatrice(3, 4, M2)
AfficheMatrice(3,4, M1)
SommeMatrice(3, 4, M1,M2,M3)
Fin
Matrices : syntaxe Maple
⚫ Pour définir une matrice en Maple, on peut utiliser le type array ou le type
matrix comme suit :
identificateur:= array (a1..b1, a2..b2)

identificateur:= matrix(n, m)
• a1 et b1 sont les bornes du premier indice du tableau

• a2 et b2 sont les bornes du deuxième indice du tableau
• n est le nombre de lignes et m le nombre de colonnes
⚫ Il est possible d'entrer directement toutes les valeurs d'une matrice

Exemple: > A:=matrix(2, 3, [ [7,0,1], [2,4,3]] );
⚫ Le type matrix est disponible dans le package linalg. Il faut donc charger ce
package avec la commande with(linalg) avant d'utiliser ce type
Tableaux : 2 problèmes classiques
⚫ Recherche d’un élément dans un tableau
• Recherche séquentielle
• Recherche dichotomique
⚫ Tri d'un tableau
• Tri par sélection

• Tri rapide

Tri d'un tableau
⚫ Le tri consiste à ordonner les éléments du tableau dans l’ordre
croissant ou décroissant
⚫ Il existe plusieurs algorithmes connus pour trier les éléments d’un

tableau :
• Le tri par sélection

• Le tri par insertion
• Le tri rapide
• …
⚫ Nous verrons dans la suite l'algorithme de tri par sélection et

l'algorithme de tri rapide. Le tri sera effectué dans l'ordre croissant

Tri par sélection
⚫ Principe : à l'étape i, on sélectionne le plus petit élément parmi les
(n - i +1) éléments du tableau les plus à droite. On l'échange ensuite avec
l'élément i du tableau
⚫ Exemple : 9 4 1 7 3
• Étape 1: on cherche le plus petit parmi les 5 éléments du tableau. On
l’identifie en troisième position, et on l’échange alors avec l’élément 1 :
1 4 9 7 3
• Étape 2: on cherche le plus petit élément, mais cette fois à partir du

deuxième élément. On le trouve en dernière position, on l'échange avec
le deuxième: 1 3 9 7 4
• Étape 3:
1 3 4 7 9

Tri par sélection : algorithme
⚫ Supposons que le tableau est noté T et sa taille N
Pour i allant de 0 à N-2

indice_ppe ← i
Pour j allant de i + 1 à N-1
Si T[j] <T[indice_ppe] alors
indice_ppe ← j
Finsi
FinPour
temp ← T[indice_ppe]
T[indice_ppe] ← T[i]
T[i] ← temp
FinPour
Tri par sélection : complexité
⚫ Quel que soit l'ordre du tableau initial, le nombre de tests et d'échanges
reste le même
⚫ On effectue N-1 tests pour trouver le premier élément du tableau trié, N-2
tests pour le deuxième, et ainsi de suite. Soit : (N-1)+(N-2)+…+1 = N(N-1)/2
On effectue en plus (N-1) échanges.
⚫ La complexité du tri par sélection est d'ordre N² à la fois dans le meilleur

des cas, en moyenne et dans le pire des cas
⚫ Pour un ordinateur qui effectue 106 tests par seconde on a :
N 103 106 109

temps 1s 11,5 jours 32000 ans

Tri rapide
⚫ Le tri rapide est un tri récursif basé sur l'approche "diviser pour régner"
(consiste à décomposer un problème d'une taille donnée à des sous
problèmes similaires mais de taille inférieure faciles à résoudre)
⚫ Description du tri rapide :
• 1) on considère un élément du tableau qu'on appelle pivot
• 2) on partitionne le tableau en 2 sous tableaux : les éléments inférieurs

ou égaux à pivot et les éléments supérieurs à pivot. on peut placer ainsi
la valeur du pivot à sa place définitive entre les deux sous tableaux
• 3) on répète récursivement ce partitionnement sur chacun des sous

tableaux crées jusqu'à ce qu'ils soient réduits à un à un seul élément

Procédure Tri rapide
Procédure TriRapide(tableau T : réel par adresse, p,r: entier par valeur)
variable q: entier
Si p <r alors
Partition(T,p,r,q)
TriRapide(T,p,q-1)
TriRapide(T,q+1,r)
FinSi
Fin Procédure
A chaque étape de récursivité on partitionne un tableau T[p..r] en deux sous

tableaux T[p..q-1] et T[q+1..r] tel que chaque élément de T[p..q-1] soit
inférieur ou égal à chaque élément de A[q+1..r] . L'indice q est calculé
pendant la procédure de partitionnement

Procédure de partition
Procédure Partition(tableau T : réel par adresse, p,r: entier par valeur,
q: entier par adresse )
Variables i, j: entier
pivot: réel
pivot← T[p], i←p+1, j ← r
TantQue (i<=j)
TantQue (i<=r et T[i] <=pivot) i ← i+1 FinTantQue
TantQue (j>=p et T[j] >pivot ) j ← j-1 FinTantQue
Si i <j alors
Echanger(T[i], T[j]), i ← i+1, j ← j-1
FinSi
FinTantQue
Echanger(T[j], T[p])
q←j
2007/2008
Fin Procédure Module I2, 1ère année 143
Tri rapide : complexité et remarques
⚫ La complexité du tri rapide dans le pire des cas est en O(N²)
⚫ La complexité du tri rapide en moyenne est en O(N log N)
⚫ Le choix du pivot influence largement les performances du tri rapide
⚫ Le pire des cas correspond au cas où le pivot est à chaque choix le plus petit
élément du tableau (tableau déjà trié)
⚫ différentes versions du tri rapide sont proposés dans la littérature pour rendre
le pire des cas le plus improbable possible, ce qui rend cette méthode la plus
rapide en moyenne parmi toutes celles utilisées

Rappel Algo GE

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rappel Algo GE

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique

Notions et instructions de base

⚫ L’algorithmique désigne la discipline qui étudie les algorithmes et

⚫ Une bonne connaissance de l’algorithmique permet d’écrire des

• L’Organigramme: représentation graphique

• Le pseudo-code: représentation textuelle avec

Nom de l’algorithme Entête

⚫ Dans les langages de programmation une variable sert à

⚫ Règle : Les variables doivent être déclarées avant d’être

⚫ Type numérique (entier ou réel)

⚫ Type logique ou booléen: deux valeurs VRAI ou FAUX

⚫ Type caractère: lettres majuscules, minuscules, chiffres, symboles, …

Variables liste d'identificateurs : type

⚫En pseudo-code, l'affectation se note avec le signe ←

- e peut être une valeur, une autre variable ou une expression

⚫ Affectations valides: i ←1 j ←i k ←i+j

⚫ Beaucoup de langages de programmation (C/C++, Java, …) utilisent

⚫ l'affectation n'est pas commutative : A=B est différente de B=A

⚫ l'affectation est différente d'une équation mathématique :

• A=A+1 a un sens en langages de programmation

Variables a,b,c,z : quelconques

⚫ Les instructions de lecture et d'écriture permettent à la machine de

Il peut afficher Il peut saisir

Sous forme du texte Sous forme du texte

⚫ La lecture permet d'entrer des donnés à partir du clavier

• En pseudo-code, on note: lire (var)

⚫ L'écriture permet d'afficher des résultats à l'écran (ou de les écrire

• En pseudo-code, on note: écrire (var)

instruction 1 : instruction 2 : étape1 instruction 2 : instruction 3 :

Ecrire ("nombre ?")

instruction 1 : instruction 3 : instruction 4 :

Algorithme prix TTC d’un article;

⚫ Les instructions conditionnelles servent à n'exécuter une instruction

• si la condition est fausse, se sont les instructions2 qui seront exécutées

• On utilisera dans ce cas la forme simplifiée suivante:

Ecrivez un algorithme qui demande à l’utilisateur le nombre de

• deux valeurs et deux seulement sont identiques parmi a, b et c :

⚫ L'évaluation d'une condition composée se fait selon des règles

On peut remplacer cette suite de si par l’instruction cas

Action autre est exécutée si quelque soit i, v ≠ vi

entre 10 et 12 : Passable entre 17 et 20 : Très Bien

NB : On suppose que l'utilisateur entre une date valide.

⚫ On distingue trois sortes de boucles en langages de programmation :

• Les boucles jusqu'à : on y répète des instructions jusqu'à ce qu'une

• Les boucles pour ou avec compteur : on y répète des instructions en

⚫ la condition (dite condition de contrôle de la boucle) est évaluée avant chaque

⚫ si la condition est vraie, on exécute instructions (corps de la boucle), puis, on

⚫ si la condition est fausse, on sort de la boucle et on exécute l'instruction qui

Attention aux boucles infinies

⚫Exemple de boucle infinie :

version 2: attention à l'ordre des instructions et aux valeurs initiales

⚫ les instructions entre Répéter et jusqu’à sont exécutées au moins une

Variables som, i : entier

⚫ Initiale et finale peuvent être des valeurs, des variables définies

Variables x, puiss : réel

Pour compteur allant de initiale à finale par pas valeur du pas

peut être remplacé par : compteur ← initiale

⚫ S'il n'est pas possible de connaître le nombre d'itérations avant l'exécution

⚫ Pour le choix entre TantQue et jusqu'à :

• Si on doit tester la condition de contrôle avant de commencer les instructions

• Si la valeur de la condition de contrôle dépend d'une première exécution des

parfait s’il est égal à la somme de ces diviseurs Exemple 6=1+2+3

sur le fait que l’habitant est imposable.

L’algorithme demandera à l’utilisateur d’entrer la valeur de n.