TP - Campus des Sciences et Techniques d`Avignon

Travaux pratiques
Chacun de ces TP suppose que vous ayez au préalable lu et assimilé le chapitre de cours sur lequel il porte. Vous
aurez éventuellement réfléchi chez vous à l'algorithme qui vous semble le plus efficace de manière à pouvoir le taper
et le debugger pendant la séance. Vous pourrez le terminer chez vous et le rendre à la séance suivante.
TP1 : Révisions de seconde et première
Quatre exercices qui demandent peu de connaissances.
1. Faire un algorithme qui permette de saisir N nombres compris entre 0 et 100, N étant lu au clavier, et
d'afficher à l'écran le plus petit et le plus grand de ces trois nombres.
2. Faire un algorithme qui permette la saisie d'une suite de caractères dont la fin est marquée par le
caractère '.' ; le programme devra compter et afficher le nombre d'occurrence de la lettre 'e'. Le modifier
pour qu'il puisse compter le nombre d'occurrences de n'importe quel caractère saisi au clavier.
3. Recherche du PGCD de deux nombres. Vous connaissez sans doute tous l'algorithme d'Euclide qui
permet de répondre à la question (si tel n'est pas le cas, merci M. Google).
Faites un programme qui permette la saisie de deux nombres et recherche (et affiche) leur pgcd par cet
algorithme d'Euclide.
Vous aurez besoin de savoir que A, B, Q et R ayant été déclarés en entiers, A/B renvoie la division entière de
A par B et A%B renvoie le reste de la division de A par B.
4. Encore une recherche de pgcd en sachant cette fois que le pgcd de deux nombres est égal au pgcd de
plus petit et de la différence des deux. On réduit ainsi la différence des deux nombres jusqu'à ce qu'elle soit
nulle. On a alors le pgcd comme l'illustre l'exemple ci-dessous. Mettre en œuvre cet algorithme.
Par exemple, pgcd(49,14)=pgcd(14,35) =pgcd(14,21)=pgcd(14,7)=pgcd(7,7)=7

TP2 : Tableaux et structures – Le tri à bulle
Lisez d'abord le fichier : CoursLesTypesStructures.pdf
Le principe
Le tri à bulle est un algorithme de tri qui fonctionne de la manière suivante : en partant du premier élément du
tableau, on compare les éléments deux à deux et si nécessaire, on inverse ces éléments de manière à ce que le plus
petit passe avant. Un petit exemple pour illustrer cela :
Position initiale Inversion 2 et 5 Inversion 5 et 0 Pas d'inversion Inversion 6 et 3 Inversion 6 et 4
5
2
2
2
2
2
2
5
0
0
0
0
0
0
5
5
5
5
6
6
6
6
3
3
3
3
3
3
6
4
4
4
4
4
4
6
On constate qu'à la fin de cette première passe, l'élément "le plus lourd s'est retrouvé au fond". On aurait peut-être
mieux fait d'appeler ça la méthode du tri à plomb.
Toujours est-il qu'il n'y a plus qu'à recommencer autant de fois qu'il est nécessaire pour que le tableau soit trié, étant
entendu qu'à la fin de chaque passe, un élément de plus se trouve rangé, à la fin du tableau.
Travail demandé
Utilisation d'un tableau
Vous ferez un algorithme, puis un programme permettant dans un premier temps de remplir aléatoirement un
tableau de 10 valeurs comprises entre 0 et 20, puis de l'afficher. Vous trouverez ci-dessous les renseignements
concernant le générateur aléatoire.
Dans un second temps, votre programme devra le trier et afficher le tableau trié.
Vous réfléchirez enfin à l'optimisation qui permettra de ne pas faire de tests inutiles (sur de valeurs déjà triées).
Le générateur aléatoire :
La commande est rand() renvoie un nombre entier compris entre 0 et un nombre rand_max qui est supérieur à
32767. Pour obtenir un nombre compris entre 0 et 100, il vous faudra jongler avec l'opérateur % sachant que : A % B
renvoie le reste de la division entière de A par B (notion de modulo). Le reste d'une division par 10 est évidemment
un nombre compris entre 0 et 9. Qu'on se le dise !!!
Il faudra avant initialiser le générateur aléatoire avec la séquence suivante :
srand (time (NULL));
où time appartient à une librairie qui s'appelle time.h et qu'il faut inclure par : # Include <time.h>
Utilisation d'une structure
On considère un tableau de 10 clients où chaque client est caractérisé par son numéro de client (qui ne sera pas
forcément son indice mais un nombre compris entre 0 et 100 (que vous génèrerez de manière aléatoire) et son nom
(on pourrait évidemment ajouter d'autres champs).

Il vous est demandé de faire un algorithme puis un programme qui permette la saisie de chacun de ces 10 clients par
la génération aléatoire du numéro de client, puis la saisie au clavier de son nom.
Le programme devra ensuite trier ce tableau par numéro de client croissant puis de l'afficher.

TP3 : Pointeurs et tableaux dynamiques
Lisez d'abord le fichier : LesPointeurs.pdf (5 premières pages, pas les listes chaînées)
L'algorithme et le programme attendus devront créer trois tableaux dynamiques dans les conditions suivantes:
• Le tableau tab1 sera de dimension n1, n1 étant lu au clavier.
• Le tableau tab2 sera de dimension n2, n2étant lu au clavier.
• Tab1 et tab2 seront initialisés avec des entiers aléatoires appartenant à l'intervalle [0;100]
• Tab3 sera la fusion ordonnée de tab1 et tab2, les doublons étant supprimés.
Un exemple : tab1 = [1;3;12;3;65;98] et tab2 = [2;62;65;70]
Alors tab3 = [1;2;3;12;62;65;70;98]
Une contrainte importante : il n'est pas question de fusionner sans réfléchir et de trier à la fin le tableau tab3. La
règle du jeu imposée et de faire un tri par fusion, c'est-à-dire de commencer par trier tab1 et tab2 (avec un tri à bulle
par exemple), puis d'insérer les éléments dans tab3 dans l'ordre, en refusant d'insérer les doublons. Interdiction de
faire cela à la fin.

TP4 : Procédures et fonctions
Lisez d'abord le fichier : SousProgrammes.pdf
Présentation du problème
Ce TP se propose de manipuler procédures et fonctions tout en découvrant des formules mathématiques qui ont été
retirées du programme.
La factorielle : on appelle factorielle de l'entier naturel non nul le nombre noté n! tel que
n! = 1 × 2 × 3 ×…× (n-1) × n.
En d'autres termes, c'est le produit de tous les entiers naturels de l'intervalle [1;n].
Convention : par convention, pour n = 0 on a 0! = 1.
Combinaison de p parmi n : Vous connaissez tous le nombre 
 qui pour vous est un nombre donné par la
calculette dans la plus totale opacité. Il vous suffira de savoir qu'en fait 
 =
!
!×!
La formule du binôme :
Vous connaissez bien entendu (a + b)² = a² + 2ab + b² et peut être : (a + b)
3
= a
3
+ 3a²b +3ab² + b
3
.
Ce sont, vous pourrez vérifier sur d'autres exposants, des cas particuliers de la formule dite du binôme de Newton :
 + 
= 
0
+ 
1
+ 
2
+ ⋯+  .
La fonction puissance : on va même considérer que la fonction puissance n'existe pas et la réécrire avec évidemment
=  ×  × …×  (n multiplications).
Travail demandé
Il vous est demandé de faire un algorithme puis un programme qui compote quatre fonctions dont le
fonctionnement est décrit ci-dessous.
• Fonction expo qui reçoit un paramètre entier n en entrée et renvoie n! pour résultat. Prévoir le cas n
= 0.
• Fonction combi qui reçoit deux entiers n et p en paramètre d'entrée et renvoie 
 comme résultat.
• Fonction puissance qui reçoit deux paramètres d'entrée x réel et n entier et qui renvoie pour résultat
: x
n
.
• Fonction binôme qui reçoit trois paramètres en entrée : a et b réels, n entier et renvoie pour résultat
: (a + b )
n
.
Vous n'aurez plus ensuite qu'à faire le programme principal qui permettra de saisir deux réels A et B, un entier N et
de calculer puis afficher (A + B)
N
d'une part grâce à un calcul direct, et d'autre part à l'aide de la formule du binôme.
Remarque : soyez tout de même prudents, les nombres n! tout comme 
 deviennent rapidement énormes dès
lors que n grandit. Par exemple 10!= 3628800 et 100
50  ≈ 10
29
. Il faudra donc se limiter à des valeurs raisonnables de
n sous peine de dépasser les capacités des entiers.