STPI 2A (2020-2021)

Algorithmique et programmation 3
TD 2 : Correction, terminaison et complexité (1h20)

1. On rappelle que l’algorithme d’Euclide est basé sur la propriété suivante :

pgcd( a, b) = pgcd(b, a mod b).

La fonction suivante implémente cet algorithme :

Fonction pgcd(In Variable m : Entier, In Variable n : Entier) : Entier

Variables tmp,a,b : Entiers
a ← m
b ← n
Si b ≥ a Alors
tmp ← a
a ← b
b ← tmp
FinSi
Tant Que a mod b 6= 0
tmp ← a
a ← b
b ← tmp mod b
FinTantQue
Retourne b

FinFonction

(a) Démontrer que ce code est correct, c’est à dire qu’il renvoie bien pgcd(m, n).
(b) Démontrer que cet algorithme termine. Pour ce faire, on pourra démontrer au préalable
que la propriété 0 < bi+1 < bi est vérifiée pour toute itération i de la boucle while, où bi
dénote la valeur de b au début de la iième itération ou à la fin de la (i − 1)ième itération.
2. On dispose d’un programme qui peut résoudre un problème de taille maximale M en une
minute. On planifie l’achat d’un nouveau microprocesseur 100 plus rapide que le précédent.
Avec ce microprocesseur, le programme pourra résoudre en 1 minute des problèmes de taille
plus grande. Quelle sera la nouvelle taille maximale si le nombre d’opérations effectuées par
l’algorithme est n, 2n, 3n, n2 , n4 , 2n ?
3. Donner, en fonction de m et n, le nombre d’itérations de la boucle tant que dans chacun des
algorithmes suivants (on supposera que m ≥ 1 et n ≥ 1) :
(a)
Variables m, n, i, j : Entiers
saisir(m, n)
i ← 1; j ← 1;
Tant Que i ≤ m Et j ≤ n
i ← i + 1
j ← j + 1
FinTantQue
 (b)
Variables m, n, i, j : Entiers
saisir(m, n)
i ← 1; j ← 1;
Tant Que j 6= n
Si i 6= m Alors
i ← i + 1
Sinon
j ← j + 1
FinSi
FinTantQue
(c)
Variables m, n, i, j : Entiers
saisir(m, n)
i ← 1; j ← 1;
Tant Que j ≤ n
Si i ≤ m Alors
i ← i + 1
Sinon
j ← j + 1
i ← 1
FinSi
FinTantQue

4. Dans le TD précédent, on avait écrit une fonction echangerMinPartiel, que l’on avait utilisée
dans une fonction qui permettait de trier un tableau. Le pseudo-code ci-dessous est une solu-
tion possible pour cet exercice :

Fonction echangerMinPartiel(In-Out Variable t : Tableau d’Entier, In Variable i :

Entier) :
Variables indMin, tmp : Entiers
indMin ← i
Pour j allant de i+1 à taille(t) par pas de 1
Si t[j] < t[indMin] Alors
indMin ← j
FinSi
FinPour
tmp ← t[i]
t[i] ← t[indMin]
t[indMin] ← tmp

FinFonction
Fonction triSelection(In-Out Variable t : Tableau d’Entier) :
Pour i allant de 1 à taille(t)-1 par pas de 1
echangerMinPartiel(t, i)
FinPour

FinFonction

Donner la complexité en nombre d’opérations de ces deux algorithmes.

AP3 - TD1 2 /4 2020-2021

5. On considère la recherche d’un élément dans un tableau.
(a) L’algorithme rechercher_séquentiel accepte en entrée un tableau d’entier et un élément
quelconque et qui calcule l’indice de l’élément dans le tableau s’il s’y trouve, ou la taille
du tableau plus 1 sinon :

Fonction rechercher_séquentiel(In Variable t : Tableau d’Entier, In Variable n :

Entier,In Variable element : Entier) :
Variables i : Entiers
i ← 1
Tant Que t[i ] 6= element Et i ≤ n
i ← i+1
FinTantQue
Retourne i
FinFonction

Étudier la complexité de l’algorithme, dans le meilleur et le pire des cas.

(b) On suppose maintenant que le tableau est trié par ordre croissant. On considère l’algo-
rithme rechercher_dichotomie, qui est une méthode plus efficace pour retrouver un élé-
ment dans un tableau :

Fonction rechercher_séquentiel(In Variable t : Tableau d’Entier, In Variable n :

Entier,In Variable element : Entier) :
Variables i,min,mid max : Entiers
min ← 1
max ← n
Tant Que min < max
mid ← (min + max ) /2
Si t[mid] < element Alors
min ← mid + 1
Sinon
max ← mid
FinSi
FinTantQue
Si t[min] = element Alors
Retourne min
Sinon
Retourne n + 1
FinSi

FinFonction

Étudier la complexité de cet algorithme, dans le meilleur et le pire des cas.

6. Soit U (n), V (n), A(n) et B(n) des suites réelles positives définies pour n ∈ N.
(a) Montrer que les complexités peuvent s’additionner et se multiplier, c’est-à-dire :
U = O( A) et V = O( B) ⇒ U + V = O( A + B) et U · V = O( A · B).

(b) Montrer que les complexités sont transitives, c’est-à-dire :

U = O( A) et A = O( B) ⇒ U = O( B).

AP3 - TD1 3 /4 2020-2021

 (c) Montrer que les complexités peuvent se simplifier, c’est-à-dire :

U = O( A + B) et A = O( B) ⇒ U = O( B).

7. On rappelle le principe de la multiplication égyptienne. Cette méthode se base sur la propriété

suivante :  m
m∗n = 2 ∗ (2n ) si m est pair
(m − 1) ∗ n + n sinon.
Le code suivant implémente la multiplication égyptienne :

Variables n, m, res : Entiers

res ← 0
saisir(n, m)
Tant Que m 6= 0
Si m mod 2 = 0 Alors
m ← m/2
n ← n∗2
Sinon
m ← m−1
res ← res + n
FinSi
FinTantQue
afficher(res)

(a) Calculer les valeurs de la variable m ainsi que leurs écritures en base 2 au cours des
itérations, pour les entrées (4, 1), puis pour les entrées (7, 1).
(b) Si l’écriture binaire de la première entrée contient p bits, exprimer le coût temporel en
fonction de p, dans le meilleur et dans le pire des cas.
(c) Pour prouver rigoureusement le point précédent, prouver un invariant de boucle dans le
meilleur et dans le pire des cas encadrant le nombre de bits dans l’écriture binaire de la
variable m en fonction du numéro de l’itération.
(d) En déduire la complexité de l’algorithme de la multiplication égyptienne.

AP3 - TD1 4 /4 2020-2021