Faculté Electronique et Informatique USTHB 2020/2021

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

Série N° 1 : 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.

Type
TEMPS=Enregistrement
h, m, s : entier ;
Fin;

Fonction TRANSFORM(T :TEMPS) : entier

Var
total : entier ;
Début
total ← T.s + (T.m * 60) + (T.h *3600) ;
Retourner total ;
Fin ;

2- Ecrire une procédure DECOMPOS qui décompose un temps S exprimé en secondes en un temps T de
type TEMPS.

Procédure DECOMPOS(E : S : entier, S / T:TEMPS)

Début
T.H ← S div 3600 ;
S ← S mod 3600 ;
T.M ← S div 60 ;
T.S ← S mod 60 ;
Fin;

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.

Algorithme Sport ;
Type
TEMPS=Enregistrement
h, m, s : entier ;
fin;

TD Enregistrements Page 1
 Athlète = enregistrement
Numéro :entier ;
Nom : chaine ;
Résultat : TEMPS ;
fin ;

Var
T : tableau[1..100] de Athlète ;
N, i:entier ;
Moy: réel ;

Début
Moy ← 0 ;
Répéter
Ecrire("Donner N compris entre 2 et 100"); Lire(N);
Jusqu'à ((N >= 2) et (N <= 100));
Pour i de 1 a N Faire
Ecrire("/n Donner le", i, " ème athlète");
Lire(T[i].Numéro, T[i].Nom, T[i].Résultat.h, T[i].Résultat.m, T[i].Résultat.s);
Moy ← Moy + TRANSFORM(T[i].Résultat) ;
Fait ;
Moy ← moy / N ;

*affichage des athlètes sélectionnés*

Pour i de 1 à N faire
Si ( TRANSFORM(T[i].Résultat ≤ Moy) alors
Ecrire (« L’athlète »,T[i].Nom ) ;
fsi ;
fait ;
Fin.

Exercice 2 :
Considérons les types d’enregistrements suivants :
Type TPoint = Enregistrement x,y : entier ; Fin;
TSpace= Enregistrement Position : Tpoint ; Superficie, Altitude :entier ; Fin ;
TVille = Enregistrement
InfoG : TSpace;
Nom :chaine[25] ;
NBH :entier ; //nombre d’habitants
Fin;
1- Ecrire une fonction Distance qui renvoie la distance entre deux points.

Fonction Distance (p1,p2:TPoint) : réel

Début
Retourner sqrt (carré(p1.x – p2.x) + carré(p1.y – p2.y)) ;
fin ;

TD Enregistrements Page 2
2- Soit T 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.
Algorithme InfoVille ;
Type TPoint = Enregistrement x,y : entier ; Fin;
TSpace= Enregistrement Position : Tpoint ; Superficie, Altitude :entier ; Fin ;
TVille = Enregistrement
InfoG : TSpace;
Nom :chaine[25] ;
NBH :entier ; //nombre d’habitants
Fin;
Fonction Distance (p1,p2:TPoint) : réel
Début
Retourner sqrt (carré(p1.x – p2.x) + carré(p1.y – p2.y)) ;
fin ;
Var
T : tableau [1..100] de Tville ;
N, i ,j , maxAlt, maxSup: entier ;
A, B : chaine[25] ;
posA,posB: TPoint ;
Début
maxAlt ← 0 ; maxSup ← 0 ;
Répéter
Ecrire("Donner N compris entre 2 et 100"); Lire(N);
Jusqu'à ((N >= 2) et (N <= 100));
Pour i de 1 a N Faire
Ecrire("/n Donner la", i, " ème ville");
Avec T[i] faire
Lire (InfoG.position.x , InfoG.position.y , InfoG.superficie , InfoG.altitude , nom,
NBH) ;
fait ;
Si(maxAlt < T[i].infoG.altitude) alors maxAlt ← T[i].infoG.altitude ; sfi ;
Si(maxSup < T[i].infoG.superficie) alors maxSup ← T[i].infoG.superficie ; sfi ;
Fait ;
Ecrire (« Donner deux villes : ») ;
Lire (A,B) ;
Pour i de 1 à N faire
Si(T[i] . Nom = A) alors PosA ← T[i].infoG.position ; fsi ;
Si(T[i] . Nom = B) alors PosB ← T[i].infoG.position ; fsi ;
Si(T[i] . InfoG.altitude = maxAlt) alors
Ecrire(« Le nombre d’habitants de la ville la plus élevées est :», T[i].NBH) ;
fsi ;
Si(T[i] . infoG.superficie = maxSup) alors

TD Enregistrements Page 3
 Ecrire(« La position de la ville la plus vaste est : », T[i].InfoG.position) ;
fsi ;
fait ;
Ecrire(« La distance entre les deux villes », A, « et », B, « est : », Distance(PosA,PosB)) ;
Fin.

Exercice 3 :
Considérons les types enregistrement suivant :
Type
TModule = Enregitrement Nom : chaine[10] ; Note :reel ; Coef : entier ; Fin ;
TEtudiant = Enregistrement
Matricule : entier ; Nom, Prénom : 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
Type
TModule = Enregitrement Nom : chaine[10] ; Note :reel ; Coef : entier ; Fin ;
TEtudiant = Enregistrement
Matricule : entier ; Nom, Prénom : chaine [20] ;
M1, M2, M3 : TModule ; Moyenne : réel ;
Fin;
Var
T, ADMIS: tableau[1..100] de TEtudiant ;
i, N, j :entier ;
Début
Répéter
Ecrire("Donner N compris entre 2 et 100"); Lire(N);
Jusqu'à ((N >= 2) et (N <= 100));
j←1;
Pour i de 1 à N faire
Avec T[i] faire
Ecrire("/n Donner les informations du ", i, " ème étudiant");
Lire(Matricule, Nom, Prénom);
Ecrire("Donner le nom, la note et le coefficient du 1er module :");
Lire(M1.Nom, M1.Note, M1.Coef);
Ecrire("Donner le nom, la note et le coefficient du 2ème module :");
Lire(M2.Nom, M2.Note, M2.Coef);
Ecrire("Donner le nom, la note et le coefficient du 3ème module :");
Lire(M3.Nom, M3.Note, M3.Coef);

TD Enregistrements Page 4
 Moyenne ← ((M1.Note * M1.Coef) + (M2.Note * M2.Coef) + (M3.Note *
M3.Coef) ) / (M1.Coef + M2.Coef + M3.Coef) ;
fait ; * fermeture du Avec(T[i])*

Si (T[i].Moyenne ≥ 10) alors ADMIS[j] ← T[i] ; j ← j+1 ; fsi ;

* le nombre d’étudiants admis est j-1*
fait ;
Fin.

TD Enregistrements Page 5
 Série Complémentaire

Exercice 1:
Un nombre complexe Z est entièrement défini par ses parties réelle a et imaginaire b ( Z = a + bi ).
1- Donner la déclaration d’un nombre complexe,

Type
NbrComplexe = Enregistrement
a, b : réel ;
fin;

2- Ecrire les fonctions : ReelZ, ImagZ et MODule donnant les attributs d'un nombre complexe
respectivement : la partie réelle, la partie imaginaire et le module),

Fonction ReelZ(z : NbrComplexe ) : réel

Début
Retourner z.a;
Fin;

Fonction ImagZ(z : NbrComplexe) : réel

Début
Retourner z.b;
Fin;

Fonction MODule(z : NbrComplexe) : réel

Début
Retourner (sqrt(z.a * z.a + z.b * z.b));
Fin;

3- Ecrire les actions paramétrées : SommeZ, DiffZ et ProdZ nécessaires à l'arithmétique sur les
complexes, respectivement pour l’addition, la soustraction et la multiplication,

Fonction SommeZ(z1, z2 : NbrComplexe) : NbrComplexe

Var
z : NbrComplexe;
Début
z.a ← z1.a + z2.a;
z.b ← z1.b + z2.b;
Retourner z;
Fin;

TD Enregistrements Page 6
Fonction DiffZ(z1, z2 : NbrComplexe) : NbrComplexe
Var
z : NbrComplexe;
Début
z.a ← z1.a - z2.a;
z.b ← z1.b - z2.b;
Retourner z;
Fin;

Fonction ProdZ(z1, z2 : NbrComplexe) : NbrComplexe ;

Var
z : NbrComplexe;
Début
z.a ← z1.a * z2.a - z1.b * z2.b;
z.b ← z1.a * z2.b + z1.b * z2.a;
Retourner z;
Fin;

4- Ecrire une procédure ConjZ qui calcule le conjugué d’un nombre complexe.

Procédure ConjZ(E/ z : NbrComplexe ; S/ conj: NbrComplexe) ;

Début
conj.a ← z.a;
conj.b ← -z.b;
Fin;

5- Ecrire une fonction EgaleZ qui teste l'égalité de deux nombres complexes.

Fonction EgaleZ(z1, z2 : NbrComplexe) : Booleen

Début
Si (( z1.a = z2.a) ET (z1.b = z2.b)) alors
Retourner Vrai;
Sinon
Retourner Faux;
fsi ;
Fin;

6- Ecrire une procédure EcrireZ qui permet d’afficher un nombre complexe.

Procédure EcrireZ(E/ z : NbrComplexe)

Début
si (z.a = 0) alors écrire(z.b, ' i');
sinon
si (z.b = 0) alors écrire(z.a)
Sinon
si (z.b > 0) alors écrire(z.a, ' +', z.b, ' i');
TD Enregistrements Page 7
 sinon écrire(z.a, z.b, ' i');
fsi ;
fsi ;
fsi ;
Fin;

Soit TC un tableau de N nombres complexes (N≤100). En utilisant les actions paramétrés précédentes,
écrire un algorithme qui :
- Affiche l’élément de TC ayant le plus petit module. Puis vérifie l’existence de son conjugué dans TC.
- Calcule la somme Zs et le produit Zp des éléments non nuls du tableau TC.
- Calcule et affiche le nombre Zs-Zp et son module.

Algorithme NombresComplexes;
Type
NbrComplexe = Enregistrement
a, b : réel ;
fin;
* Fonctions et procédures *

Var
TC : tableau [1..100] de NbrComplexe ;
N, i : entier ;
Zs, Zp, Zmin : NbrComplexe ;
minMod : réel ;
existe : booléen ;
Début
Répéter
Ecrire("Donner N Compris entre 1 et 100");
Lire(N);
Jusqu'a ((N>=1) ET (N<=100));

Pour i de 1 à N faire
Lire(TC[i].a, TC[i].b);
Fait;

* recherche du nombre complexe Zmin qui a le plus petit module*

minMod ← MODule(TC[1]) ;
Zmin ← TC[1];
Pour i de 2 à N faire
Si (minMod > MODule(TC[i]) alors
minMod ← MODule(TC[i]) ;
Zmin ← TC[i] ;
fsi ;
fait ;

TD Enregistrements Page 8
* recherche du conjugué de Zmin*
i ← 1 ; existe ← faux
Tant que ((i ≤ N) ET (existe = faux)) faire
si( EgaleZ( ConjZ(Zmin), TC[i]) = vrai ) alors existe ← vrai ;
sinon i ← i+1 ;
fsi ;
fait ;
Si ( existe = vrai) alors écrire(« le conjugué du nombre qui a le plus petit module : »,Zmin,
« existe. ») ;
sinon
écrire(« le conjugué du nombre qui a le plus petit module : »,Zmin, « n’existe pas. ») ;
fsi ;

* somme et produit des éléments non nuls du tableau*

Zs.a←0 ; Zs.b ← 0 ; Zp.a ← 1 ; Zp.b ← 0 ; Znul ← Zs ;
Pour i de 1 à N faire
si( EgaleZ(Znul, TC[i]) = faux ) alors
Zs ← SommeZ(Zs, TC[i]) ;
Zp ← ProdZ(Zp, TC[i]) ;
fsi ;
fait ;

* calcul et affichage de la différence entre Zs et Zp et son module*

Ecrire(« la différence entre la somme et le produit des nombres du tableau est : ») ;

EcrireZ(DiffZ(Zs,Zp)) ;
Ecrire(« son module : », MODule(DiffZ(Zs,Zp))) ;
Fin.

TD Enregistrements Page 9