Vous êtes sur la page 1sur 5

Exercices :

Exercice 1 (corrig): Gestion des Rendez-vous


A laide des enregistrements et en utilisant des tableaux denregistrements on souhaite grer
une liste de rendez vous dune personne.
Soit : - le type temps _t : un enregistrement utilis pour grer le temps des rendez-vous.
- le type Rdv_t : un enregistrement utilis pour grer un rendez-vous.
- la fonction calc_ns (t : temps_t) : integer : pour calculer le nombre de secondes
correspondant une valeur de type temps_t).
On Introduit les types suivants :
TYPE
heure_t = 0..23;
minute_t = 0..59;
seconde_t = 0..59;
temps_t = Record
h : heure_t;
m : minute_t;
s : seconde_t;
End;
CONST MaxRdv = 20;
TYPE Rdv_t = Record
Titre : string [60];
debut, fin : temps _t;
End;
TabRdv_t = array [1..MaxRdv] of Rdv_t;
function calc_ns (t : temps_t) :Integer;
1) Saisie : Faire une procdure SaisieRdv (r) qui lit au clavier les champs de r:Rdv_t.
NB :
- il faut demander lutilisateur de saisir au moins 3 rendez-vous.
- Les rendez-vous sont mmoriss dans un tableau denregistrements de type Rdv_t dans
leur ordre de saisie.

2) Affichage : Faire une procdure AffiRdv (r) qui affiche l'cran les champs de r:Rdv_t.
3) Chevauchement : Faire une fonction boolenne Chevauche (r1,r2) qui renvoie TRUE si
les rendez-vous r1, r2:Rdv_t se chevauchent.
Correction :
PROGRAM RendezV;
TYPE
heure_t = 0..23;
minute_t = 0..59;
seconde_t = 0..59;
temps_t = Record
h : heure_t;
m : minute_t;
s : seconde_t;
End;

CONST MaxRdv = 20;
TYPE Rdv_t = Record
titre : string[63];
debut, fin : temps_t;
End;
TabRdv_t = array [1..MaxRdv] of Rdv_t;
function calc_ns (t : temps_t):integer;
BEGIN
calc_ns := t.h * 3600 + t.m * 60 + t.s;
END;

PROCEDURE SaisieRdv (var r : Rdv_t);
BEGIN
write ('Titre : '); readln (r.titre);
readln (r.debut.h,r.debut.m,r.debut.s);
readln (r.fin.h,r.fin.m,r.fin.s);
END;

PROCEDURE AffiRdv (r : Rdv_t);
BEGIN
writeln ('Titre : ', r.titre);
writeln (r.debut.h);
writeln (r.fin.h);
END;

FUNCTION Chevauche (r1, r2 : Rdv_t) : boolean;
VAR deb1, deb2, fin1, fin2: integer;
BEGIN
deb1 := calc_ns(r1.debut); fin1 := calc_ns(r1.fin);
deb2 := calc_ns(r2.debut); fin2 := calc_ns(r2.fin);
Chevauche := (deb1 < fin2) and (deb2 < fin1);
END;

PROCEDURE TestJournee (j : TabRdv_t; n : integer);
VAR i, k : integer;
BEGIN
for i := 1 to n-1 do
for k := i+1 to n do
if Chevauche (j[i], j[k])
then begin
writeln ('Ces RDV se chevauchent :');
AffiRdv (j[i]);
AffiRdv (j[k]);
end;
END;
VAR i, nb : integer; j : TabRdv_t;
BEGIN
write ('Nb rdv : '); readln (nb);
for i := 1 to nb do SaisieRdv (j[i]);
TestJournee (j, nb);
END.
end.
Exercice 2 : Triangle de pascal
Pour chaque question donner une fonction/procdure PASCAL qui permet de :
1. Calculer et retourner la factorielle dun nombre n
2. Calculer et retourner le rapport :
a!
b!(ab)!

3. Calculer et afficher le triangle de Pascal en prenant en paramtre le nombre de ligne afficher (et en
utilisant la dernire fonction)
Remarque : chaque lment du triangle de Pascal se calcule par
C
p
n
=
n!
p!(np)!

4. Vous pouvez remarquer que le calcul des coefficients binomiaux pour chaque lment est lent.
Simplifier le calcul des lments du triangle de Pascal et donner une nouvelle version de votre
programme.

Algorithmes de trie
Trie par insertion :
Son principe est de parcourir la liste non trie (T [1], T [2], ..., T[n]) en la dcomposant en deux
parties une partie dj trie et une partie non trie.
L'opration de base consiste a :
Prendre le 1er lment dans la partie non trie,
Insrer a sa place dans la partie trie (place que l'on recherchera Squentiellement dans la boucle
Tant Que),
Dplacer les lments que se trouve entre la position trouve et la position de llment considr
dans la partie non trie d'une position vers la droite.
Refaire ces insertions tant qu'il reste un lment a ranger dans la partie non trie.
L'insertion de l'lment est effectue par dcalages successifs d'une case.
procdure tri_insertion(tableau T, entier n)
pour i de 2 n-1
x T[i]
j i
tant que j > 0 et T[j - 1] > x
T[j] T[j - 1]
j j - 1
fin tant que
T[j] x
fin pour
fin procdure

Exemple :
Voici les tapes de l'excution du tri par insertion sur le tableau . Le tableau
est reprsent au dbut et la fin de chaque itration.


Trie bulles :
Son principe est :
De parcourir la liste (1er lment, 2eme, ..., neme ) en intervertissant toute paire d'lments
conscutifs ((i-1)eme, ieme) non ordonnes. Ainsi aprs le premier parcours, l'lment maximum se
retrouve dans la dernire position.
On recommence l'opration avec la nouvelle sous-suite (1er lment, 2eme, ..., (n-1)me) , et ainsi de
suite jusqu'a puisement de toutes les sous-suites.
Spcification :
La suite (1er lment, 2eme , ... , neme) est range dans un tableau T[...] en mmoire centrale.
Le tableau contient une partie trie et une partie non trie. On effectue plusieurs fois le parcours du
tableau a trier; le principe de base tant de rordonner les couples ((i-1)eme, ieme) non classes (en
inversion de rang) dans la partie non trie du tableau.
On arrte quand la partie a trier est rduite a un seul lment ou que le tableau est devenu trie et
dans ce cas on doit avoir un indicateur qui donne cette information.
procdure tri_bulle(tableau T, entier n)
faire
change_effectu = faux
pour j de 1 n - 1
si T[j] > T[j + 1], alors
changer T[j] et T[j + 1]
change_effectu = vrai
fin si
fin pour
tant que change_effectu = vrai
fin procdure

Exemple :
Soit la liste (6, 5, 3, 4, 8, 1), appliquons le tri a bulles sur cette liste d'entiers.
Visualisons les diffrents tats de la liste pour chaque itration :