Université de Bejaia Niveau : Master 1 MI

Faculté des Sciences Exactes Module : Programmation Avancée

Département D’Informatique Année d’étude 2021/2022

Solution de la série de TD n°1

Exercice 1.
Etant donné la procédure suivante.

Procédure Produit (Var C : Matrice ; A, B : Matrice ; n, m, p : entier);

Var i, j, k: entier;

Début coût nombre de répétition

Pour i allant de 1 à n Faire c1 (n+1)
Pour j allant de 1 à m Faire c2 n*(m+1)
C[i, j] ← 0 ; c3 n*m
Pour k allant de 1 à p Faire c4 n*m*(p+1)
C[i, j] ← C[i, j] + A[i, k] × B[k, j] ; c5 n*m*p
Fin pour ;
Fin pour ;
Fin pour ;
Fin.

1. La procédure Produit calcule le produit de deux matrices A et B et le résultat est dans la

matrice C.
2. La complexité de la procédure Produit

𝑇(𝑛, 𝑚, 𝑝) = 𝑐1 ∗ (𝑛 + 1) + 𝑐2 ∗ n ∗ (m + 1) + c3 ∗ n ∗ m + c4 ∗ n ∗ m ∗ (p + 1)
+ c5 ∗ n ∗ m ∗ p

𝑆𝑖 𝑛 = 𝑚 = 𝑝

𝑇 (𝑛) = 𝑐1 ∗ (𝑛 + 1) + 𝑐2 ∗ n ∗ (n + 1) + c3 ∗ n ∗ n + c4 ∗ n ∗ n ∗ (n + 1) + c5 ∗ n ∗ n ∗ n

𝑇(𝑛) = (𝑐5 + 𝑐4) ∗ 𝑛3 + (𝑐4 + 𝑐3 + 𝑐2) ∗ 𝑛2 + (𝑐2 + 𝑐1) ∗ 𝑛 + 𝑐1

𝑇 (𝑛 ) = 𝐴 ∗ 𝑛 3 + 𝐵 ∗ 𝑛 2 + 𝐶 ∗ 𝑛 + 𝐷

La complexité est alors de l’ordre O(𝑛3 ) (Complexité polynomiale).

1
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

Exercice 2.

1. Fonction qui retourne la somme des éléments de MAT

Fonction somme (MAT : Matrice ; N : entier) : entier ;

Var : i, j : entier ;
Début
𝑠𝑜𝑚𝑚𝑒 ← 0; 1
Pour i allant de 1 a n faire n+1
𝒏+𝟑
Pour j allant de 1 a i faire ∑𝒏𝒊=𝟏(𝒊 + 𝟏) =n
𝟐
𝒏+𝟏
𝑠𝑜𝑚𝑚𝑒 ← 𝑠𝑜𝑚𝑚𝑒 + 𝑀𝐴𝑇 [𝑖, 𝑗]; ∑𝒏𝒊=𝟏 𝒊 = n
𝟐

Fin pour ;
Fin pour ;
Fin.

2. Complexité de la fonction somme

𝑛+3 𝑛+1
𝑇(𝑛) = 𝑐1 ∗ 1 + 𝑐2 ∗ (𝑛 + 1) + 𝑐3 ∗ n + c4 ∗ n
2 2
𝑇(𝑛) = ((𝑐3 + 𝑐4)⁄2) ∗ 𝑛2 + (𝑐2 + 3 ∗ 𝑐3⁄2 + 𝑐4⁄2) ∗ n + c1 + c2 + c5
𝑻(𝒏) = 𝑨𝒏𝟐 + 𝑩𝒏 + 𝑪

La complexité est alors de l’ordre O(𝑛2 ) donc de type quadratique.

3. La complexité de la fonction somme en nombre d’additions

Il y a une seule addition dans la 4ème instruction à l’intérieur des deux boucles imbriquées
𝑛+1
qui est répétée 𝑛 2 fois.
𝑛+1
D’où la complexité en nombre d’additions est : 𝑇(𝑛) = 𝑛 2
additions

2
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022
Exercice 3 :

1. Fonction itérative qui retourne la factorielle

Fonction 𝑓𝑎𝑐𝑡 (n : entier) : entier ;

Var i : entier ;

Debut

𝑓𝑎𝑐𝑡 ← 1;

Pour i allant de 2 à n faire

𝑓𝑎𝑐𝑡 ← 𝑓𝑎𝑐𝑡 ∗i ;

Fin pour

Fin.

2. La complexité de la fonction 𝑓𝑎𝑐𝑡 en nombre de multiplication est :

T(n)= n-1 multiplications. Son ordre de grandeur est O(n) linéaire. On ne peut pas faire
mieux car pour calculer la factorielle de n, il nous faut au minimum (n-1)
multiplications.
3. Fonction itérative qui retourne 𝐶𝑁𝑃 : On a :

𝑁! 𝑁 ∗ (𝑁 − 1) ∗ (𝑁 − 2) ∗ … ∗ (𝑁 − 𝑃 + 1) ∗ (𝑁 − 𝑃) ∗ … ∗ 2 ∗ 1
𝐶𝑁𝑃 = =
𝑃! ∗ (𝑁 − 𝑃)! 𝑃! ∗ (𝑁 − 𝑃)!
𝑁 ∗ (𝑁 − 1) ∗ (𝑁 − 2) ∗ … ∗ (𝑁 − 𝑃 + 1)
=
𝑃!

Nous avons alors simplifié par le facteur (𝑁 − 𝑃 ) !; cela qui nous fait gagner 2*(N-P-1)
multiplications. Ce qui n’est pas négligeable.

Fonction combin (N, P : entier) : réel ;

Var i : entier ; comb: réel;

Debut

𝑐𝑜𝑚𝑏 ← 𝑁 − 𝑃 + 1 ;

Pour i allant de 𝑁 − 𝑃 + 2 à N faire

𝑐𝑜𝑚𝑏 ← 𝑐𝑜𝑚𝑏 ∗i ;

Fin pour

𝑐𝑜𝑚𝑏 ← 𝑐𝑜𝑚𝑏/𝑓𝑎𝑐𝑡(𝑃);

Retourner (comb) ;

Fin.

3
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

4. La complexité de la fonction comb en nombre de multiplications et son ordre de

grandeur.
• Il y a une multiplication dans la 3 ème instruction qui se répète

N-(N-P+2) + 1= P-1 fois.

• L’appel à fact(P) nécessite P-1 multiplications.

D’où le nombre de multiplications nécessaires pour l’exécution de cette fonction est :

T (n, p) = T(p)= P-1+P-1=2*P-2 multiplications.

Sa complexité est de l’ordre O(P), donc linéaire.

Exercice 4.

1. Une fonction efficace qui calcule 𝑠𝑜𝑚 = 1 + 2𝑥 2 + 3𝑥 3 + ⋯ + 𝑛𝑥 𝑛

Fonction 𝑠𝑜𝑚𝑚𝑒 (x : réel, n : entier): reel ;

Var i: entier; y: reel;

Debut

𝑠𝑜𝑚𝑚𝑒 ← 1;

𝑦 ← 𝑥;

Pour i allant de 1 a n faire

𝑠𝑜𝑚𝑚𝑒 ← 𝑠𝑜𝑚𝑚𝑒 + 𝑖 ∗ 𝑦;

𝑦 ←𝑦∗𝑥;

Fin pour ;

Fin.

2. Complexité en nombre de multiplications

On a 2 multiplications à l’intérieur de la boucle Pour répétées n fois. D’où la

complexité en nombre de multiplications est :

T(n) = 2*n multiplications. Son ordre de grandeur est O(n).

3. On ne peut pas faire mieux puisque on a effectué le minimum de multiplications. En

effet, pour chaque terme i, on doit effectuer au moins 2 multiplications, une pour
multiplier le terme par i et l’autre pour obtenir 𝑥 𝑖 en fonction de 𝑥 𝑖−1 (terme précédent).
La fonction est alors optimale.

4
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

Exercice 5.

1. Algorithme de recherche du maximum dans un tableau à n éléments

Algorithme max ;

Var t : tableau [1..100] de entier ; i, max,n : entier ;

Debut

Lire (n) ;

𝑚𝑎𝑥 ← 𝑇[1];

Pour i allant de 2 a n faire

Si 𝑇[𝑖]>max alors

𝑚𝑎𝑥 ← 𝑇[𝑖];

Fin pour

Ecrire (max) ;

Fin.

2. La complexité de l’algorithme max en nombre de comparaisons est :

Seules les comparaisons entre éléments sont comptées d’où :

T(n)= n-1 comparaisons

3. L’algorithme est optimal car tout élément excepté le max doit avoir perdu une
comparaison, sinon on ne peut pas savoir qu’il n’est pas le max. Ce qui donne lieu à n-1
comparaisons.

5
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

Exercice 6.

1. Algorithme de recherche d’un élément dans un tableau de taille n

Algorithme recherche ;

Var t : tableau [1..100] de entier ; i, x, n : entier ;

trouve : booleen ;

Debut

Lire (n, x) ;

𝑡𝑟𝑜𝑢𝑣𝑒 ← 𝑓𝑎𝑢𝑥;

𝑖 ← 1;

Tant que ((i<=n) et (trouve=faux)) faire

Si (𝑡[𝑖]=x) alors n comparaisons

𝑡𝑟𝑜𝑢𝑣𝑒 ← 𝑣𝑟𝑎𝑖;

Fin si ;

𝑖 ← 𝑖 + 1;

Fin tant que ;

Si (trouve= vrai) alors 1 comparaison

Ecrire ("l’élément", x, "existe") ;

Sinon

Ecrire ("l’élément", x, "n’existe pas") ;

Fin Si ;

Fin.

2. La complexité de cet algorithme en fonction du nombre de comparaisons

• Dans le pire (tableau trié ou tableau non trié) : le pire des cas de cet algorithme
est que l’élément x n’existe pas ou il existe à la dernière position du tableau d’où la
complexité en nombre de comparaison est T(n) = n+1 comparaisons. Son ordre de
grandeur est O(n).

6
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

• Dans le meilleur des cas : le meilleur des cas de cet algorithme est que l’élément x
se trouve dans la case T[1] donc on a deux comparaisons T(n)=2 comparaisons. Son
ordre de grandeur est O(1).

3. Le principe de la recherche dichotomique sur un exemple n=8

L’algorithme de la recherche dichotomique s’applique uniquement sur un tableau trié.

Le principe est : on accède à la valeur centrale du tableau qu’on compare à l’élément recherché.
Il y a trois cas de figure :

- Si la valeur centrale = élément recherché → La recherche est terminée.

- Si la valeur centrale < élément recherché → L’élément, s’il existe dans le tableau, il est
dans la partie gauche du tableau.
- Si la valeur centrale > élément recherché → L’élément, s’il existe dans le tableau, il est
dans la partie droite du tableau.

On recommence la recherche avec un tableau dont la taille est divisée par deux. On arrête la
recherche lorsqu’on tombe sur la valeur recherchée ou lorsqu’on se retrouve avec un tableau
contenant un seul élément.

Exemple avec n = 8

Niveau 1

Niveau 2

Niveau 3

Sachant qu'à chaque comparaison de l’élément recherché avec l’élément central, si ce dernier
n’est pas égal à l’élément recherché, une division du tableau en deux est effectuée. Donc, le
nombre de comparaisons est égale au nombre de divisions (nombre de niveaux) +1 (1 s’agit de
la dernière comparaison).

Pour n= 8, dans le pire des cas, on a 3 niveaux et 4 comparaisons.

4. La complexité de la recherche dichotomique en nombre de comparaisons

Au pire des cas : l’élément recherché n’existe pas dans le tableau ou il est retrouvé à la dernière
itération (dernière comparaison).

Dans le pire cas, le nombre de comparaisons revient à chercher le nombre de divisions du

tableau en deux pour obtenir, à la fin, un tableau comportant un seul élément ? Autrement dit,
le nombre de divisions de n par 2 pour obtenir 1 ?

7
Université de Bejaia Niveau : Master 1 MI
Faculté des Sciences Exactes Module : Programmation Avancée
Département D’Informatique Année d’étude 2021/2022

𝑛
Mathématiquement cela se traduit par l'équation 2𝑘 = 1 avec k le nombre de fois qu'il faut
diviser n par 2 pour obtenir 1 (nombre de niveaux).
𝑛
= 1 donc 𝑛 = 2𝑘
2𝑘

Nombre de comparaisons = nombre de niveaux + 1= k+1 on a :

𝑛 = 2𝑘 donc 𝑙𝑜𝑔2 𝑛 = 𝑙𝑜𝑔2 (2𝑘 ) = 𝑘 donc 𝑘 = 𝑙𝑜𝑔2 𝑛 Donc :

Le nombre de comparaisons est 𝑇(𝑛) = 𝑙𝑜𝑔2 𝑛 + 1

Dans le cas général, pour n non nécessairement égal à une puissance de 2, le nombre de
comparaisons est dans l’intervalle :

1+⌊𝑙𝑜𝑔2 𝑛 ⌋≤T(n)≤1+⌈𝑙𝑜𝑔2 𝑛⌉

Au meilleur des cas : l’élément recherché est retrouvé à la première itération donc t(n)=1
comparaison.