Faculté Electronique et Informatique USTHB 20 20/2021

Département Informatique Module PSD (ALGO2) (LMD M/I)

Série N° 1 : solution de la série sur les enregistrements

Exercice 1 :
Soit un type TEMPS contenant le résultat obtenu par un athlète dans une course de marathon.
1- Ecrire une fonction TRANSFORM qui transforme un temps T de type TEMPS en un entier S
exprimant ce temps en secondes.
2- Ecrire une procédure DECOMPOS qui décompose un temps S exprimé en secondes en un temps T de
type TEMPS.
3- Soient N participants dans cette course (N≤100). Chaque athlète est défini par un Numéro, un Nom et
un Résultat de type TEMPS. Ecrire un algorithme permettant de construire un vecteur contenant les
informations des différents athlètes, puis affiche la liste des athlètes (avec résultat) sélectionnés ayant
obtenu un résultat inférieur ou égale à la moyenne de tous les athlètes.

Solution exercice 1: ajouter l’exercice version 1 tableau resultat avec la solution

Le type TEMPS doit décrire des résultats obtenus lors d'une course ce résultat représente le temps en
heures, minutes et secondes réalisé par un athlète donc l'enregistrement est constitué de 03 champs
entiers pour représenter ce temps.
1) type
TEMPS=enregistrement
h, m, s: entier;
fin enreg ;
2) La fonction TRANSFORM a comme paramètres d'entrées le résultat exprimé en heure, minute,
seconde et comme paramètre de sortie le résultat en secondes, c'est à dire qu'il faut faire une conversion
des heures en secondes , des minutes aussi en secondes et faire la somme.
fonction TRANSFORM(E/ TR:TEMPS):entier;
var
sc:entier;
debut
sc (TR.h*3600+TR.m*60+TR.s);
TRANSFORM sc; //ou retourne(sc); retourne(TR.h*3600+TR.m*60+TR.s) ;
fin;
3) La procédure DECOMPOS a comme paramètres d'entrées le temps réalisé par l'athlète exprimé en
seconde et comme paramètre de sortie(le résultat de la procédure) c'est toujours le temps réalisé par
l'athlète mais décomposé en heures, minutes et secondes, c'est à dire il faut convertir le temps introduit en
seconde en effectuant des divisions pour avoir les heures et les minutes.

TD Enregistrements Page 1
Procedure DECOMPOS(E/ SR:entier; E-S/TR:TEMPS);
debut
TR.h<--SR div 3600;
TR.m<--(SR mod 3600) div 60;
TR.s<--(SR mod 3600) mod 60;
fin;
4)
Solution proposée (elle n'est pas unique)
Algorithme exo1;
type
TEMPS=enregistrement
h, m, s: entier;
fin enreg ;
AT=enregistrement
numero :entier ;
nom :chaine ;
resultat :TEMPS ;
Fin enreg ;
var
athlete: tableau[1..100] de AT;
i,N:entier ; moy:reel ; som: TEMPS;
fonction TRANSFORM(…….
…Q2
Procedure DECOMPOS(…
…Q3
debut
repeter
lire(N);
jusqu'à (N>0 et N<=100);
//remplir le tableau
pour i<--1 à N faire
lire(athlete[i].numero, athlete[i].nom);
repeter lire(athlete[i].resultat.h); jusqu'a (athlete[i].resultat.h >=0);

TD Enregistrements Page 2
repeter lire(athlete[i].resultat.m); jusqu'a (athlete[i].resultat.m>=0 et athlete[i].resultat.m<60);
repeter lire(athlete[i].resultat.s); jusqu'a (athlete[i].resultat.s>=0 et athlete[i].resultat.s<60) ;
fait ;
//calculer la moyenne des temps de tous les athlètes
som.h<--0; som.m<--0; som.s<--0;
pour i<--1 à N faire
som.h<-- som.h+ athlete[i].resultat.h;
som.m<-- som.m+ athlete[i].resultat.m;
som.s<-- som.s+ athlete[i].resultat.s;
fait;
moy<--TRANSFORM(som)/N;
//afficher les athlètes dont le temps est inférieure à la moyenne
pour i<--1 à N faire
Si TRANSFORM(athlete[i].resultat)<moy alors ecrire(athlete[i].nom, athlete[i].resultat.h,
athlete[i].resultat.m, athlete[i].resultat.s); fsi;
fait;
FIN.

Exercice 2 :
Considérons les types d’enregistrements suivants :
Type TPoint = Enregistrement
x,y : entier ;
Fin enreg;
TSpace= Enregistrement
Poistion : Tpoint ;
Superficie, Altitude :entier ;
Fin enreg;
TVille = Enregistrement
InfoG : TSpace;
Nom :chaine[25] ;
NBH :entier ; //nombre d’habitants
Fin enreg;

1- Ecrire une fonction Distance qui renvoie la distance entre deux points.
2- Soit un tableau T de N Villes (N≤100). Ecrire un algorithme permettant de :
a- Remplir le tableau T.
b- Afficher la distance entre deux villes A et B.
c- Afficher le nombre d’habitants de la ville la plus élevée.
d- Afficher la position géographique de la ville la plus vaste.

TD Enregistrements Page 3
Solution
Fonction Distance (p1,p2 :Tpoint) :reel ;
Var
D :reel ;
debut
Dsqrt((p1.x-p2.x)^2+(p1.y-p2.y)^2) ;
DistanceD ;
Fin ;
Algorithme dist_ville ;
Type TPoint = Enregistrement
x,y : entier ;
Fin enreg;
TSpace= Enregistrement
Poistion : Tpoint ;
Superficie, Altitude :entier ;
Fin enreg;
TVille = Enregistrement
InfoG : TSpace;
Nom :chaine[25] ;
NBH :entier ; //nombre d’habitants
Fin enreg;

Var
T :tableau[1..100]de TVille ;
A,B :chaine[25] ;
i,j,k,N, max :entier ;
Fonction Distance(p1,p2 :Tpoint) :reel ;
…
Fin ;
debut
repeter lire(N) ; jusqu’à N>0 et N<=100 ;
pour i1 à N faire

TD Enregistrements Page 4
ecrire(‘Donner le nom de la ville’) ;
repeter lire(T[i].Nom) ; jusqu’à longueur(T[i].Nom)>0 ;
ecrire(‘Donner l’’info G :la position , la superficie , l’’altitude et le nombre d’’habitant ’) ;
lire(T[i].InfoG.Position.x, T[i].InfoG.Position.y,T[i].InfoG.Supererficie, T[i].InfoG.Altitude,T[i].NBH ) ;
fait ;
repeter lire(A,B) ; jusqu’à longueur(A)>0 et longueur(B)>0 ;
/*chercher les deux villes dans le tableau*/
i1 ;r0 ;
Tantque i<=N et r<2 faire
Si T[i].nom=A alor ki ; rr+1 ;fsi ;
Si T[i].nom=B alor ji ; rr+1 ;fsi ;
ii+1 ;
fait ;
si r<2 alors ecrire(‘une ou les deux villes n’’existent pas’)
sinon ecrire (‘la distance entre les deux villes=’,Distance (T[k].InfoG.Position, T[j].InfoG.Position) ;
fsi ;
maxT[1].InfoG.Altitude ;k1 ;
pour i2 à N faire
si T[i].InfoG.Altitude>max alors max T[i].InfoG.Altitude ;ki ;fsi ;
fait ;
ecrire(T[k].NBH) ;
maxT[1].InfoG.superficie ;k1 ;
pour i2 à N faire
si T[i].InfoG.superficie>max alors max T[i].InfoG.superficie ;ki ;fsi ;
fait ;
ecrire(T[k].InfoG.Position.x, T[K].InfoG.Position.y) ;
fin.

Exercice 3 :
Considérons les types enregistrement suivant :
Type
TModule = Enregitrement
Nom : chaine[10] ; Note :reel ; Coef : entier ;
Fin enreg ;

TD Enregistrements Page 5
TEtudiant = Enregistrement
Matricule : entier ; Nom, Prenom : chaine [20] ;
M1, M2, M3 : TModule ; Moyenne : réel ;
Fin;

Soit T un tableau d’au plus 100 étudiants.

Ecrire un algorithme permettant de remplir le tableau T, calculer la moyenne de chaque étudiant puis
recopier tous les étudiants admis dans un tableau ADMIS de type TEtudiant. Un étudiant est admis si sa
moyenne est supérieure ou égale 10.

Algorithme Tab_Etudiants;

Type

TModule = Enregitrement

Nom : chaine[10] ;

Note :reel ;

Coef : entier ;

Fin enreg ;

TEtudiant = Enregistrement

Matricule : entier ;

Nom, Prenom : chaine [20] ;

M1, M2, M3 : TModule ;

Moyenne : réel ;

Fin enreg;

Var

T, ADMIS: Tableau[1..100] de TEtudiant;

i, J, N: entier;

debut

repeter

Ecrire("Donner N entre 1 et 100");

Lire(N);

Jusqu'a ((N>0) et (N<=100));

TD Enregistrements Page 6
 // Remplir le tableau T de N étudiants.

pour i  1 à N faire

Ecrire(‘Donner Matricule, Nom et Prenom de Etudiant ...’);

Lire(T[i].Matricule,T[i.] Nom,T[i] Prenom);

Ecrire (‘Donner le Nom, Note et Coefficient de Module 1’);

Lire(T[i].M1.Nom, T[i].M1.Note, T[i]. M1.Coef);

Ecrire (‘Donner le Nom , Note et Coefficient de Module 2’);

Lire(T[i].M2.Nom, T[i]. M2.Note, T[i].M2.Coef);

Ecrire (‘Donner le Nom, Note et Coefficient de Module 3’);

Lire(T[i].M3.Nom, T[i].M3.Note, T[i].M3.Coef);

Fait ;

/* Calcul de la moyenne de chaque étudiant */

Pour i 1 à N faire

T[i].Moyenne  ((T[i].M1.Note * T[i].M1.Coef) + (T[i].M2.Note *

T[i].M2.Coef) + (T[i].M3.Note*T[i].M3.Coef) ) /

(T[i].M1.Coef + T[i].M2.Coef + T[i].M3.Coef);

Fait ;

// Mettre les étudiants admis dans ADMIS

J  0;

Pour i 1 à N faire

Si(T[i].Moyenne >= 10) alors

J  J + 1;

ADMIS[J]  T[i];

Fsi ;

Fait ;

Ecrire(‘Liste des étudiants admis:’);

Pour i  1 à J faire

TD Enregistrements Page 7
 Ecrire(ADMIS[i] .Matricule, ADMIS[i] .Nom, ADMIS[i] .Prenom, ADMIS[i] .moyenne );

Fait ;

Fin.

TD Enregistrements Page 8