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
0
6
3
4
2
5
0
6
3
4
2
0
5
6
3
4
2
0
5
6
3
4
2
0
5
3
6
4
2
0
5
3
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 = a3 + 3a²b +3ab² + b3.
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.
•
= 0.
Fonction expo qui reçoit un paramètre entier n en entrée et renvoie n! pour résultat. Prévoir le cas n
•
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
n
: x.
•
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
100
≈ 1029. Il faudra donc se limiter à des valeurs raisonnables de
50
n sous peine de dépasser les capacités des entiers.
lors que n grandit. Par exemple 10!= 3628800 et
TP5 : Pointeurs et listes chaînées
Lisez d'abord le fichier : LesPointeurs.pdf
(jusqu'au bout et surtout les listes chaînées)
Il vous est demandé dans ce TP de faire un algorithme puis un programme qui permette de créer une liste chaînée
d'entiers, de saisir N éléments, N étant lu au clavier. Le programme devra ensuite afficher la liste puis supprimer de
celle-ci tous les entiers pairs. Le programme affichera ensuite la liste résultante.
Vous serez donc amenés à faire :
•
Une procédure creer_liste
•
Une procédure ajouter_element
•
Une procédure afficher_liste
•
Une procédure supprimer_element (sans doute la plus délicate)
•
Enfin un programme principal qui, utilisant ces procédures répondra aux exigences énoncées cidessus.
Remarque : vous aurez sans doute besoin de l'opérateur déjà rencontré : % qui renvoie le reste de la division
entière. Par exemple 5%2 renvoie la valeur 1.