Telechargé par Zey Zey

IFT1065 algo

publicité
IFT1065
IFT1065
Introduction à l’algorithmique
Chapitre 4 du livre
Ces diapositives ne contiennent pas toutes les explications détaillées. Il est recommandé d’étudier le livre de
R. Johnsonbaugh
1 / 21
IFT1065
Algorithme
I Introduction
I Pseudo-code
I Sous-problèmes
I Procédure récursive et itérative
2 / 21
IFT1065
Algorithme
Algorithme : Procédure décrivant, étape par étape, une méthode
permettant de résoudre un problème. Suite finie d’étapes
(instructions) vérifiant :
I Reçoit des données en entrée ;
I Produit des données en sortie ;
I Chaque étape est décrite de façon précise ;
I Chaque étape est déterministe : produit des résultats uniques ;
I L’algorithme s’arrête après un nb fini d’instructions ;
I L’algorithme produit des résultats corrects ;
I Généralisable : Applicable à des ensembles différents de
données d’entrée.
3 / 21
IFT1065
Différence entre problème et instance du problème
Exemple d’un problème :Tri d’un ensemble d’éléments
I Entrée : Suite de n éléts a1 , . . . , an
I Sortie : La suite ordonnée
Instances du problème :
I Suite de nombres : 475, 787, 34, 245, 56, 350
I Suite de noms : Pierre, Christine, Sylvie,
Samuel, Fabien
4 / 21
IFT1065
Exemple d’un algorithme
1. x = a ;
2. Si b > x, alors x = b ;
3. Si c > x, alors x = c ;
= Opérateur d’assignation
y = z signifie “copie la valeur de z dans y”.
Valeur de z inchangée
Paramètres d’entrée : a, b, c
Valeur de sortie : x = max(a, b, c)
5 / 21
IFT1065
Pseudo-Code
Algorithme maximum : Retourne le maximum de 3
entiers
I Entrée : Trois entiers a, b, c ;
Trace de l’algorithme pour :
a = 1; b = 5; c = 3
I Sortie : x contenant la valeur maximale parmi
a, b, c
ligne 1 : x = 1
ligne 2.1 : x = 5
Procédure max(a, b, c)
Trace de l’algorithme pour :
a = 6; b = 1; c = 9
1. x = a ;
2. Si b > x alors //
2.1
ligne 1 : x = 6
ligne 3.1 : x = 9
Si c plus grand que x, mettre x à jour
L’algorithme termine après un nombre fini
x = b;
3. Si c > x alors //
3.1
Si b plus grand que x, mettre x à jour
x = c;
4. Retourner (x)
d’étapes (trois étapes) et il est correct (il peut
trouver la plus grande valeur de trois nombres
quelconques).
Fin max
6 / 21
IFT1065
Pseudo-Code
Pseudo-Code : Notation proche du code des langages de
programmation (Python, Julia, C, Pascal). Notation standard mais
pas rigoureuse.
I Titre de l’algorithme, description brève, entrées, sorties.
I Numéroter les lignes (facultatif).
I Instructions (lignes exécutables) entre “Procédure” et “Fin”,
exécutées l’une après l’autre.
I Bloc d’instructions entre “Début” et “Fin”.
I Ligne de commentaires signalée par // (ou /* */).
I “Retourne (x)” termine une procédure et retourne la valeur
de x.
7 / 21
IFT1065
Instruction : Si-Alors-Sinon (If-Then-Else)
Si condition p vérifiée, exécuter action.
Si p alors
action
Si condition p vérifiée, exécuter action 1. Sinon, exécuter action 2.
Si p alors
action 1 ;
Sinon
action 2 ;
Bloc de conditions entre Début et Fin.
Si x ≥ 0 alors
Début
x = x − 1;
a = b + c;
Fin
8 / 21
IFT1065
Instruction : Tant que
Procédure plus-grand (S, n)
1. grand = S1 ;
Tant que p est vrai exécuter action
2. i = 2 ;
Tant que p Faire
action ;
3. Tant que i ≤ n Faire
Algorithme Plus-Grand-Element :
Retourne la plus grande valeur d’une
liste
Entrée : n entiers S1 , . . . , Sn
Sortie : grand contenant le plus grand
élément
5.
4.
Début
Si Si > grand alors //
une plus grande valeur
a été trouvée
6.
grand = Si ;
7.
i = i + 1;
8.
Fin
9. Retourne (grand)
Fin plus-grand
9 / 21
IFT1065
Instruction : Tant que
Procédure plus-grand (S, n)
1. grand = S1 ;
2. i = 2 ;
3. Tant que i ≤ n Faire
4.
5.
Si Si > grand alors //
grande valeur a été trouvée
6.
Trace de l’algorithme :
n = 4; S1 = −2; S2 = 6; S3 = 5; S4 = 6
Début
grand = Si ;
7.
i = i + 1;
8.
Fin
une plus
grand = −2
grand = 6
i=2
i=3
i=4
i=5
9. Retourne (grand)
Fin plus-grand
10 / 21
IFT1065
Instruction : Pour (For)
Algorithme Plus-Grand-Element : Réécriture de
l’algorithme précédent mais avec une boucle
“Pour”
Entrée : n entiers S1 , . . . , Sn
Sortie :grand contenant le plus grand élément
À chaque passage dans la boucle, var
est incrémenté de 1. On s’arrête dès
que var > limite.
Pour var = init à limite Faire
action ;
Procédure plus-grand (S, n)
1. grand = S1 ;
2. Pour i = 1 à n Faire
3.
Si Si > grand alors //
une plus grande valeur
a été trouvée
4.
grand = Si ;
5. Retourne(grand)
Fin plus-grand.
11 / 21
IFT1065
Subdivision d’un problème en sous-problèmes (plusieurs procédures)
Problème : Trouver le plus petit nombre premier strictement supérieur à un
entier positif donné
I Procédure pour déterminer si un entier m est un nombre premier.
m
Il suffit de tester si m est divisible par un entier entre 2 et
2
On montre pour m ≥ 0 (pour m < 0 est analogue). Par contradiction, on
suppose que m est divisible par m
+k
2
m
m= m
+
k
q,
1
≤
k
<
2
2
Si q = 0 alors m = 0 et donc 1 ≤ k < m
= 0 qui est absurde. Donc
2
q > 0.
≥m
≥1
z}|{ z}|{
m
m
Si q ≥ 2 alors 2 + k q =
q + kq et donc m = m
+ k q > m qui
2
2
est absurde. Donc q < 2.
On conclue que
0 < qm< 2 ⇒
q = 1. Alors
m= m
+
k
·
1
=
+
k
< m qui est absurde. Donc, on conclue que
2
2
m n’est pas divisible par m
+ k avec 1 ≤ k < m
.
2
2
12 / 21
IFT1065
Subdivision d’un problème en sous-problèmes (plusieurs
procédures)
Problème : Trouver le plus petit nombre premier strictement supérieur à un
entier positif donné
I Procédure pour déterminer si un entier m est un nombre premier.
m
Il suffit de tester si m est divisible par un entier entre 2 et
2
I Utiliser cette procédure pour trouver le plus petit nombre premier p
supérieur à un entier n.
13 / 21
IFT1065
Entrée : Un entier positif m
Sortie : Vrai si m est premier, Faux si
non.
Procédure est-premier (m)
1. Pour i := 2 à EN T (m/2) Faire
2.
3.
Si m mod i = 0 alors // i
divise m
Retourne (Faux)
4. Retourne (Vrai)
Fin est-premier
Entrée : Un entier positif n
Sortie : Le plus petit nb premier m > n
Procédure premier-plus-grand (n)
1. m := n + 1 ;
2. Tant que est-premier(m) est
Faux Faire
3.
m := m + 1 ;
4. Retourne (m)
Fin est-premier
Trace de est-premier pour m = 9 :
i=2
9 mod 2 = 1
i=3
Trace de premier-plus-grand pour
n=8:
m=9
m = 10
m = 11
9 mod 3 = 0
Trace de est-premier pour m = 10 :
i=2
10 mod 2 = 0
Trace de est-premier pour m = 11 :
i=2
11 mod 2 = 1
i=3
11 mod 3 = 2
i=4
11 mod 4 = 3
i=5
11 mod 5 = 1
14 / 21
IFT1065
Procédure récursive
I Procédure qui s’invoque elle-même
Exemple : n! = n(n − 1)(n − 2) · · · 2 · 1. Si n > 0
0! = 1
n! = n(n − 1)! pour n ≥ 1
5! = 5 · 4!
= 120 ←−
4! = 4 · 3!
3! = 3 · 2!
= 24 ←−
= 6 ←−
2! = 2 · 1!
1! = 1 · 0!
= 2 ←−
=1
I Toute procédure récursive doit avoir une condition d’arrêt :
cas de base qui permet de ne plus invoquer la procédure.
Ici, la condition d’arrêt est n = 0.
15 / 21
IFT1065
Trace pour n =3 :
factoriel (3) :
Retourne : 3· factoriel (2)
factoriel (2) :
Retourne : 2· factoriel (1)
factoriel (1) :
Retourne : 1· factoriel (0)
factoriel (0) :
Retourne : 1
Entrée : Entier n ≥ 0
Sortie : n!
Procédure factoriel (n)
1. Si n = 0 alors
2.
Retourne (1)
3. Retourne (n· factoriel(n − 1))
Fin factoriel
16 / 21
IFT1065
Procédure itérative pour le calcul de n!
Trace pour n = 3 :
Entrée : Entier n ≥ 0
Sortie : n!
Procédure factoriel-iteratif (n)
1. res = 1; courant = n;
res = 1
courant = 3
2. Tant que courant > 0 Faire
res = 3
courant = 2
3.
res := res · courant;
res = 6
courant = 1
4.
courant := courant − 1;
res = 6
courant = 0
5. Fin Tant que
6. Retourne (res)
Fin factoriel-itératif
17 / 21
IFT1065
Procédure récursive pour le calcul du pgcd
PGCD : Plus Grand Diviseur Commun
Trace pour a = 504 et b = 396 : Entrée : a, b deux entiers> 0
Sortie : pgcd(a, b)
pgcd − rec(504, 396)
Procédure pgcd − rec(a, b)
504 = 396 · 1 + 108
pgcd − rec(396, 108) = 36
pgcd − rec(396, 108)
1. Si b = 0 alors
2.
Retourner (a)
396 = 108 · 3 + 72
pgcd − rec(108, 72) = 36
pgcd − rec(108, 72)
108 = 72 · 1 + 36
pgcd − rec(72, 36) = 36
3. r = a mod b ;
4. Retourne (pgcd − rec(b, r))
Fin pgcd-rec
Lemma : Le pgcd(a,b) divise a − b.
pgcd − rec(72, 36)
Car pgcd(a, b) divise a − b et pgcd(a, b) divise a, alors
72 = 36 · 2 + 0
pgcd − rec(36, 0) = 36
pgcd(a, b) divise r = a mod b.
18 / 21
IFT1065
Nombres de Fibonacci
Exemple
Un robot peu avancer par des pas de 1 ou 2 mètres.
Calculer le nombre de façons différentes de parcourir une distance
de n mètres
Distance
1
2
3
4
Suite de pas
1
1, 1 ou 2
1, 1, 1 ou 1, 2 ou 2, 1
1, 1, 1, 1 ou 1, 1, 2 ou 1, 2, 1 ou 2, 1, 1 ou 2, 2
Nb de possibilités
1
2
3
5
19 / 21
IFT1065
I P as(n) Nombre de
possibilités pour parcourir n
mètres.
I P as(1) = 1, P as(2) = 2 ;
I Pour n > 2 :
I Si premier P as = 1
mètres, il reste n − 1
mètres → P as(n − 1)
I Si premier P as = 2
mètres, il reste n − 2
mètres → P as(n − 2)
Donc, P as(n) =
P as(n − 1) + P as(n − 2)
Entrée : n
Sortie : P as(n)
Procédure P as(n)
1. Si n = 1 ou n = 2 alors
2.
Retourner (n)
3. Retourne
(P as(n − 1) + P as(n − 2))
Fin Pas
Séquence de Fibonacci :

 f1 = 1
f2 = 1

fn = fn−1 + fn−2 pour n ≥ 3
20 / 21
IFT1065
Nombres de Fibonacci
http://fr.wikipedia.org/wiki/Suite_de_Fibonacci
21 / 21
Téléchargement