Série d’exercices à traiter en TD

Exercices d’ordre général

Exercice 1
Ecrivez un algorithme permettant, à l’utilisateur de saisir les notes d'une classe. Une fois la
saisie terminée, l’algorithme renvoie le nombre des notes supérieures à la moyenne de la classe.

Exercice 2
Ecrire un algorithme qui calcule à une valeur approchée μ donnée la racine carrée d'un
nombre a > 0 sachant que la suite :
X1 = a
Xn = (a/Xn-1 + Xn-1 ) / 2
converge vers la racine carrée de a.

Exercice 3
Considérons un tableau T de N nombres entiers ( N > 1). On veut écrire un seul algorithme
qui répond aux questions suivantes :
- déterminer le troisième nombre premier s'il existe,
- déterminer le deuxième carré parfait s'il existe,
- déterminer le nombre de diviseurs du premier nombre pair et du dernier nombre impair.
Pour cela, créer et utiliser les fonctions suivantes :
- prem( nombre ) de type booléen qui est égal à vrai si nombre est premier, faux sinon.
- carré (nombre) de type booléen qui est égal à vrai si nombre est carré parfait, faux sinon.
- nbdiv(nombre) de type entier qui donne le nombre de diviseurs de nombre.

Exercice sur les structures et les fichiers

Exercice 1
Ecrivez un algorithme qui permet de modifier un renseignement (pour simplifier, disons
uniquement le nom de famille) d’un membre du carnet d’adresses. Il faut donc demander à
l’utilisateur quel est le nom à modifier, puis quel est le nouveau nom, et mettre à jour le fichier. Si
le nom recherché n'existe pas, le programme devra le signaler.

Exercices sur la récursivité

Exercice 1
Soit les fonctions f donnée par :
Fonction f(n: entier, Var cmpt : entier): entier
Debut
cmpt cmpt + 1
Si n < 2 Alors
Retourner n
Sinon
Retourner f(n-1, cmpt) + f(n-2, cmpt)
Fin Si
Fin
On fait appel à la fonction f avec n=3 et cmpt=0. Quelle est la valeur retournée par cet appel ?
Quelles sont les valeurs de n et de cmpt après l’exécution de cet appel ?

Exercice 2
On considère la procédure suivante :

1
Série d’exercices à traiter en TD

Procédure mystere (T: Entier[1..N])

Var i, j : entier
Debut
i 1
j N
Tant que i < j Faire
Si T[i] = 0 Alors
i i+1
Sinon
Eechanger(T[i], T[j])
j j-1
Fin Si
Fin Tant que
Fin

1. Que fait-elle en supposant que le tableau T ne contient que des 0 et des 1 ?

2. Modifier la procédure de façon à l'appliquer à des tableaux contenant au plus trois valeurs
différentes : par exemple 0, 1 et 2 (rappel : chaque élément de T doit être examiné au maximum une
fois).
3. Donner une version récursive de la procédure.

Exercice 3: Dérécursification de la fonction d’Euclide

La fonction récursive, ci-dessous, nous donne le PGCD de deux entiers n et m
FONCTION PGCD(n,m: ENTIER): ENTIER
// n>=0, m>=0
DEBUT
SI m = 0 ALORS
Retourner(n)
SINON
Retourner(PGCD(m, n MOD m))
FIN SI
FIN
Transformer cette fonction récursive en une fonction itérative

Exercice 4: Dérécursification de la fonction de Fibonacci

Considérons la suite de Fibonacci, dont voici la définition :
f ( 1 ) =1
f ( 2 ) =1
f ( n ) = f ( n-1 ) + f ( n-2 ), n >2.

La fonction récursive, ci-dessous, nous donne le nème terme de la suite de Fibonacci:

FONCTION fibo_rec(n: ENTIER): ENTIER
DEBUT
SI (n < 3 ET n> 0) ALORS Retourner 1
SINON
Retourner fibo_rec(n - 1) + fibo_rec(n - 2)
FIN SI
FIN
Transformer cette fonction récursive en une fonction itérative

2
Série d’exercices à traiter en TD

Exercices sur la complexité des algorithmes

Exercice 1
Montrer que pour toute constante réelle a et b, avec b > 0, nous avons :
(n + a)b = O(nb)
Cette relation est-elle vraie pour les notations  et  ?

Exercice 2
Trouver l’ordre de grandeur des fonctions suivantes:
1. n2 + 2n; log n2
2. log 3n; n + 1/n
3. n + log n

Exercice 3
Parmi les relations suivantes, quelles sont celles qui sont correctes.
1. O(1) = O(10); O(1) = 10; n+1 = O(n),  étant une constante
2. (n + 1)! = O(n!) ; 2n = O(n!), ; n! = O(2n); log nn = O(log n!); nn = O(n!)

Exercice 4
Quelle est la valeur de k à la sortie de la boucle de la portion d’algorithme ci-dessous:
k1
Tant que (k <= n) Faire
kk*2
Fin tant que
En déduire la complexité temporelle de cette portion d’algorithme

Exercice 5
Calculer les complexités temporelles en fonction de la variable n des portions d’algorithme
ci-dessous.

Algorithme 1
d 1
Tant que (d*d <= n) Faire
d d * 2
Fin Tant que

Algorithme 2
d1
Tant que (d*d <= n) Faire
dd*2+1
Fin tant que

Algorithme 3
Pour (i0; i<n; ii+1) Faire
Pour (j0; j<n; jj+1) Faire
ss+1
Fin Pour
Fin Pour

Exercice 6
Que font les fonctions récursives suivantes:

1. Fonction mystere1( n: Entier): Entier

3
Série d’exercices à traiter en TD

Début
SI (n = 0) Alors
retourner 0
Fin Si
Retourner (mystere1(n-1) + n*n)
Fin
2. Fonction mystere2(b : Reel, n: Entier): Reel
Début
SI (n = 0) Alors
retourner 1
Fin Si
retourner (1+ b*mystere1(b,n-1))
Fin

Exercice 7
Déterminer pour chacune de ces fonctions récursives leur complexité temporelle.

Exercice 8 : Puissance récursive

La fonction ci-dessous calcule récursivement nk avec n 0 et k≥ 0
FONCTION p u i s s a n c e ( n : ENTIER, k : ENTIER) : ENTIER
DEBUT
SI ( k = 0 ) ALORS
Retourner 1
SINON
SI ( k MOD 2 = 0 ) ALORS
Retourner p u i s s a n c e ( n*n , k DIV 2 )
SINON
Retourner n*p u i s s a n c e ( n*n , k DIV 2 )
FIN SI
FIN SI
FIN
Déterminer la complexité temporelle de la fonction puissance(n; k)

Exercice 9
On considère un ensemble T de n ≥ 2 entiers distincts stockés dans un tableau (T n’est pas
supposé trié). Résoudre les questions suivantes :
1 - Proposer un algorithme en O(n) pour trouver deux éléments x et y de T tels que |x − y|≥|u − v|
pour tout u, v T.
2 - Proposer un algorithme en O(n log n) pour trouver deux éléments x et y de T tels que x  y et
|x− y| |u − v| pour tout u, v  T, u  v.
3 - Soit m un entier arbitraire (pas nécessairement dans T), proposer un algorithme en O(n log n)
pour déterminer s’il existe deux éléments x et y de T tels que x + y = m.

Exercice 10 : Plus petit et plus grand

Dans cet exercice, on ne s’intéresse qu’à la complexité dans le pire des cas et en nombre de
comparaisons des algorithmes.
1- On s’intéresse maintenant au calcul (simultané) du maximum et du minimum de n entiers.
Donner un algorithme naïf et calculer sa complexité.
2 - Une idée pour améliorer l’algorithme est de regrouper par paires les éléments à comparer, de
manière à diminuer ensuite le nombre de comparaisons à effectuer. Décrire un algorithme
fonctionnant selon ce principe et analyser sa complexité.

4
Série d’exercices à traiter en TD

Exercice 11: Un nouvel algorithme de tri

Soit T un tableau contenant n entiers distincts, la procédure Nouveau_Tri est définie de la
manière suivante :
Procédure Nouveau_Tri (T : Entier[n] ; i : Entier ; j : Entier)
Var
Début
Si T[i] > T[j] Alors
Echanger les valeurs T[i] et T[j]
Fin Si
Si i <= j − 2 Alors
k  (j − i + 1)/3
Nouveau_Tri(T, i, j − k)
Nouveau_Tri(T, i + k, j)
Nouveau_Tri(T, i, j − k)
Fin Si
Fin
1 - Montrer que Nouveau_Tri(T, 1, n) trie correctement le tableau T.
2 - Donner la complexité en nombre de comparaisons de cet algorithme. Comparer avec les
complexités des algorithmes de tri vus en cours (Rappel : ln(2) ≈ 0, 7 et ln(3) ≈ 1, 1).

Exercices sur la preuve de correction des algorithmes

Exercice 1
FONCTION f1(n : Entier) : Entier
VAR R, V: Entier
DEBUT
R1
V 1
i 1
TANT QUE i < n FAIRE
V2 * V
RR+V
ii+1
FIN TANT QUE
Retourner R
FIN

1. Faites la trace de l'exécution de f1(4) en indiquant sous forme d'un tableau les valeurs des
variables R, V et i à chaque itération.
2. Montrer que R = 2i -1 et V = 2(i-1) sont 2 propriétés invariantes pour l'algorithme f1.
3. Quelle est la valeur retournée par la fonction f1 ?

Exercice 2
FONCTION g(n : Entier) : Entier
//Données : un entier n appartenant à IN
VAR m, I, R: Entier
DEBUT
R0
mn
TANT QUE m > 0 FAIRE
POUR i  1 à m FAIRE

5
Série d’exercices à traiter en TD

RR+1
FIN POUR
POUR i  m à n FAIRE
RR+1
FIN POUR
mm-1
FIN TANT QUE
Retourner R
FIN
a) Exprimez en fonction de la donnée n, le nombre de fois que la fonction g exécute les
affectations des lignes 1 et 2. Vous donnerez l'expression exacte de ce nombre ainsi que les
étapes de son calcul.
b) Donnez, en fonction de n, l'ordre de grandeur du nombre d'affectations exécutées par la
fonction g.
c) Quelle est la valeur renvoyée par g(n) ?

Exercice 3
Montrer la correction de l’algorithme de tri par insertion vu à la fin du dernier cours :
on prouvera un invariant pour chaque boucle. Donner le pire et le meilleur cas pour la complexité
et évaluer cette complexité dans les deux cas.

Exercice 4
On se donne un tableau S d’entiers triés par ordre croissant et un entier cible x. Proposer
un algorithme linéaire pour trouver s’il existe deux éléments de S dont la somme vaut x. Prouver
que la boucle termine (quelle quantité décroît à chaque itération ?) et que votre algorithme est
correct (en montrant un invariant).