Corrigé Série Tableau d’enregistrement

Exercice 1 :
On considère que la fiche d’un étudiant est définie par les informations suivantes : nom,
prénom, age, cin, tel et adresse.
Ecrire un algorithme permettant de remplir un tableau de N étudiants, de rechercher un
étudiant de cin donnée et afficher son nom, prénom et adresse.
Algorithme fiche_etudiant
Constante
NMAX=100
Type

(*Déclaration enregistrement Domicile*)

Domicile= Enregistrement
Avenue,ville,pays : chaine [20]
Numero,code_postale : entier
FinEnregistrement

(*Déclaration enregistrement étudiant*)

Etudiant=Enregistrement
Nom, prénom : chaine [20]
Age : entier
Cin : entier
Tel : entier
Adresse : Domicile
finEnregistrement

Etud=tableau [1..NMAX ] d’étudiant

Variable
T : Etud
I,n :entier
Début
Répéter
Lire (n)
Jusqu'à ((n>=1) et (n ≤ NMAX))

Pour i allant de 1 à n faire

Lire (T[i].nom, T[i].prenom, T[i].age, T[i].tel)
Lire ( T[i]. Adresse.Avenue, T[i]. Adresse.ville, T[i]. Adresse.pays, T[i].
Adresse.Numero, T[i]. Adresse.code_postal)
Fin pour
Lire (cin)
i 0
Tant que ((T[i].cin) <> cin et (i≤n)) faire
i i+1
Fin Tant que
Si (T[i].cin=cin) alors
Ecrire (T[i]. Adresse.Avenue, T[i]. Adresse.ville, T[i]. Adresse.pays, T[i].
Adresse.Numero, T[i]. Adresse.code_postal)
Else
Ecrire (‘‘élément non trouvé’’)
Finsi
Fin

Exercice 2 :
Dans une banque un client est connu par :
-Nom
-Prénom
-Numéro de compte
-Solde
- Date de création du compte
- le nombre de transaction total
Historique : Tableau de transactions (type de transaction, date) (*tableau trié par ordre
croissant selon la date*).
a) Ecrire l’enregistrement client.
b) Écrire un programme permettant :
- Déclarer la variable banque comme étant un tableau de client
- D’entrer les informations de tous les clients de la banque (on considère NC : nombre de
client)
- De faire la somme d’argent totale STA et la moyenne d’argent Moy par client.
- D’afficher les clients de la banque
- De stocker dans un tableau la liste des nouveaux clients dont la date de création du compte
est supérieure à 01/07/2021. Puis, afficher le contenu du tableau.
- D’afficher le nombre total de transaction effectué par la totalité des clients à un mois donné.

Algorithme banque

Constante NMAX= 100

Type
Transaction= Enregistrement

Type_transaction : chaine [50]

Date : Date (*voir partie 1*)

Fin Enregistrement

Tab1= tableau [1 .. NMAX] de transaction

Client= Enregistrement

Nom, prénom : chaine [20]

Num_c : entier

Solde : reél

Date_creation : Date (* voir partie 1 *)

nt : entier

Historique : Tab1

Fin enregistrement

Banque = tableau [1 .. NMAX] de Client

Nouveau_client=tableau[1..NMAX] de Client

Variable

mois,TS,NC, i, j : entier

S : réel

T : Banque

Ordonne, nouv :booleen

Début
Lire (NC)

Pour i allant de 1 à NC faire

Lire (T[i]. nom, T[i].prenom, T[i].solde, T[i].num_c, T[i].nt)

lire (T[i].date_creation.jour, T[i].date_creation.mois, T[i].date_creation.année)

Lire (T[i].Historique[1].type_transaction)

Lire (T[i].Historique[1].date.jour, T[i].Historique[1].date.mois, T[i].Historique[1].date.année)

Pour j allant de 2 à (T[i].nt) faire

Lire (T[i].Historique[j].type_transaction)

Repeter

Lire (T[i]. Historique[j].date.jour, T[i].Historique[j].date.mois, T[i].Historique[j].date.année)

Ordonne ←Faux

Si (T[i].Historique[j-1].date.année < T[i].Historique[j].date.année) alors

Ordonne ←vrai

Sinon
Si ((T[i].Historique[j-1].date.année= T[i].Historique[j].date.année) alors
Si (T[i].Historique[j-1].date.mois < T[i].Historique[j].date.mois)) Alors

Ordonne ←vrai

Sinon
Si (T[i].Historique[j-1].date.mois = T[i].Historique[j].date.mois) alors
Si (T[i].Historique[j-1].date.jour < T[i].Historique[j].date.jour)) Alors

Ordonne ←vrai
Finsi
Finsi
Finsi
 Finsi
Finsi

Jusqu'à (Ordonne =vrai)

Fin pour

Fin pour

(***la somme d’argent totale STA et la moyenne d’argent***)

S←0

Pour i allant de 1 à NC faire

S←S+T[i]. Solde

Fin pour

Ecrire (‘‘la somme total du solde des clients est ‘‘, S, ‘‘la moyenne par client est’’, S/NC)

(***Affichage des clients de la banque ***)

Pour i allant de 1 à NC faire

Ecrire (T[i]. nom, T[i].prenom, T[i].solde, T[i].num_c)
Ecrire (T[i].date_creation.jour, T[i].date_creation.mois, T[i].date_creation.année)
pour j allant de 1 à T[i].nt faire
Ecrire (T[i].Historique[j].type_transaction)
Ecrire (T[i].Historique[j].date.jour, T[i].Historique[j].date.mois,
T[i].Historique[j].date.année)
Fin pour

Fin pour

(*** Stocker la liste des nouveaux clients ***)

J←0

Pour i allant de 1 à NC faire

nouv← faux

Si ((T[i]. date_creation.année >2021) alors

nouv ←vrai

Sinon
Si ((T[i]. date_creation.année = 2021) alors
Si (T[i]. date_creation.mois >07) Alors
nouv ←vrai
Sinon
Si (T[i]. date_creation.mois = 07) alors
Si (T[i]. date_creation.année.jour >01) Alors
nouv ←vrai

Finsi
Finsi
Finsi
Finsi
Finsi
Si ( nouv = vrai) alors
j←j+1

nouveau_client[j].nom← T[i]. nom

nouveau_client[j].prenom← T[i].prenom

nouveau_client[j].solde←T[i].solde

nouveau_client[j].num_c←T[i].num_c

Finsi

Fin pour

Pour i allant de 1 à j faire

Ecrire (nouveau_client[i].nom, nouveau_client[i].prenom, nouveau_client[i].solde,
nouveau_client[i].num_c)

Fin pour
(*** Afficher le nombre total de transaction effectué par la totalité des clients à un mois
donné ***)

Repeter

Lire (mois)

Jusqu’à ((mois>=1) ET (mois<=12))

TSß0

Pour i allant 1 a NC faire

Pour j allant de 1 a T[i].nt faire
Si (T[i]. Historique[j].date.mois =mois) alors
TS←TS+1
Fin Si

Fin pour

Fin pour

Fin

Exercice 3:

Le but de cet exercice est d’écrire un algorithme qui permet de mémoriser dans un tableau les
informations relatives aux 15 joueurs d’une équipe de rugby et de les traiter. Un joueur est
caractérisé par son numéro, nom, prénom, date de naissance, poids et rôle dans l’équipe (Le
numéro 1 est piller gauche, le numéro 2 est talonneur, etc.).

Définir les types joueur et Équipe qui représentent respectivement un joueur et un tableau de
15 joueurs.

- Saisir les informations de tous les joueurs d’une équipe.

- Afficher les informations relatives à un joueur donné.
- Rechercher et afficher le joueur le plus lourd d’une équipe.
- Trier les jours avec leur numéro.

Algorithme rugby
Constante Nmax=15
Type
Joueur= enregistrement
 Non, prenom : chaine [15]
Date_naiss : date
Poids : reél
Role : chaine [20]
Numéro : entier
Enregistrement
Équipe = tableau [1..Nmax] de joueur

Variable
T : équipe, i,j,Min : entier
Temps : joueur

Début

Pour i allant de 1 à Nmax faire

Lire (T[i].nom, T[i].prénom, T[i].role, T[i].poids, T[i].Date_naiss.jour,
T[i].Date_naiss.mois, T[i].Date_naiss.année )
Repeter
Lire ( T[i]. numéro)
Jusqu'à (( T[i]. numéro >0) et (T[i]. numéro <=Nmax))

Fin pour

Repeter
Lire ( numéro )
Jusqu'à (( numéro >0) et (numéro <=Nmax))
i 1
Tant que ((numéro <>T[i]. numéro) et (i≤Nmax)) faire
i i+1
Fin tant que
Écrire (T[i].nom, T[i].prénom, T[i].role, T[i]. numéro, T[i].poids, T[i].Date_naiss.jour,
T[i].Date_naiss.mois, T[i].Date_naiss.année )

max 1
Pour i allant de 2 à Nmax faire
Si ( T[i].poids >T[max].poids) alors
max i
FinSi
Fin pour
 Écrire (‘‘Le jours de plus lourds est, ’’, T[max].nom, T[max].prénom, T[max].role,
T[max]. Numéro, T[max]. Poids)

Pour i allant de 1 à (n-1) Faire

min i
Pour j allant de (i+1) à n Faire
Si (T[j]. Numéro <T[min]. Numéro) alors
Min j
FinSi
Fin Pour
Temp T[i]
T[i] T[min]
T[min] temp
Fin Pour

Pour i allant de 1 à Nmax faire

Écrire (T[i].nom, T[i].prénom, T[i].role, T[i]. Numéro, T[i]. Poids, T[i].Date_naiss.jour,
T[i].Date_naiss.mois, T[i].Date_naiss.année )
Fin pour
Fin
Exercice 4:
On se propose dans cet exercice de gérer le stock d’une société qui vend des articles de sport.
Sachant que la société a, à sa disposition, 10 articles et un article est défini comme suit:
Un numéro de code (entier)
Un libellé (10 caractères)
Un prix unitaire (réel)
Une quantité en stock (entier)

Définir les types article et société

Développer un menu qui permet d’:

1) Ajouter un article à une liste d’articles triés selon l’ordre croissant de leurs codes.

2) Chercher un article à travers son code.

3) Diminuer ou augmenter la quantité en stock d’un article donné par une quantité
quelconque.

Algorithme gestion_stock

Constante Nmax=100
Type
Produit= enregistrement
code : entier
Nom : chaine[10]
Prix : réel
Quantité : entier
Fin produit
Société= tableau [1..Nmax] de produit

Variable
S : société
I, choix : entier
X : produit
N : entier
Début
N=10
(*saisir les informations de N articles *)
(*trier les articles selon l’ordre croissant de leurs codes *)
Écrire (‘‘menu’’)

Répéter

Répéter

Lire (choix)

Jusqu'à (choix >0 et choix <5)

Si (choix =1) alors
Lire (X)
N N+1
I=N
Tant que ( S.code > X.code et i>0) faire
I i-1
Fin tant

Pour j allant de N à I faire

S[j] S[j-1]
Fin pour
S[i] X

Sinon
Si (choix =2) alors
1=1
 Tant que ( S.code <>X.code et (i≤n)) faire
I i+1
Fin tant
Si ( S.code =X.code) alors
Ecrire (‘‘article existant’’)
Sinon
Ecrire (‘‘article inexistant ’’)
Finsi
Sinon
Si (choix = 3) alors
Lire (code)
i=1
Tant que ( S[i].code= code et i≤N)
I i+1
Fin tant que
Si (S[i]. code =code) alors
Repeter
Lire (action)
Jusqu'à (action=’O’ ou action=’D’)
Si (action =’O’) alors (*augmenter*)
Repeter
Lire (Q)
Jusqu'à (Q>0)
Sinon
Repeter
Lire (Q)
Jusqu'à ( S[i].code-D≥0) ( *diminution*)
Sinon
Écrire ( ‘‘ code introuvable’’)
Finsi

Finsi
Finsi
Finsi
Jusqu'à (choix =4)

FIN

(* De même, vous pouvez utiliser le selon au niveau du menu*)

Exercice 5 :
On s’intéresse à la gestion des véhicules d’un parc auto. Chaque véhicule est caractérisé par
un matricule, une marque, un modèle, une couleur, le nombre de places, une puissance fiscale
et l’état du véhicule, smart ou non, âge. Si le véhicule est smart on rajoute les caractéristiques
suivantes : nombre totale de capteur, nombre de Caméra et de Lidars. Si le véhicule n’est pas
smart, on rajoute le Nombre de Kilomètre Parcouru.
Donner l’enregistrement permettant de décrire un véhicule.
1) Ecrire un algorithme qui permet de :
a) Stocker les informations d’un parc auto regroupent au max 50 véhicules en utilisant les
structures adéquates ;
b) Établir la liste (matricule, marque, modèle, puissance) des véhicules d’une couleur
donnée ;
c) Rechercher le véhicule smart ayant le nombre maximal de capteurs dont au moins 4
Caméras et deux Lidars.
d) Établir l’âge moyen du parc auto des voitures.

Algorithme parc_auto

Constante

Nmax=50

Véhicule= enregistrement

Matricule, Marque, Modèle, Couleur, Etat : Chaine [20]

Nb_place, Age : entier

Puissance : réel

Type : chaine[9] (*smart ou non smart*)

Selon (type) faire

‘Smart’ : Capteurs, Caméra, Lidars : entier

‘Non smart’ : NKP : réel

Finselon

FinEnregistrement

Tab= tableau [1..Nmax] de véhicule

Variable
T : tab

N ,i : entier

Couleur : chaine [20]

SV : véhicule

Début

Repeter

Lire (n)

Jusqu'à (n>1 et n≤Nmax)

Pour i allant de 1 à N faire

Lire (T[i]. Matricule, T[i]. Marque, T[i]. Modèle, T[i]. Couleur, T[i]. Etat, T[i].
Nb_place, T[i]. Age, T[i]. Puissance)

Repeter

Lire(T[i].Type)

Jusqu’à(T[i].Type=’smart’) OU (T[i].Type=’Non smart’)

Si(T[i]. Type =’smart’) alors

Lire (T[i]. Capteurs, T[i].Caméra, T[i].Lidars)

Sinon

Lire (T[i]. NKP)

Finsi

Finpour

Lire (couleur)

Ageß0

Pour i allant de 1 à N faire

Si ( T[i].couleur=couleur )

Écrire (T[i].Matricule, T[i]. Marque, T[i]. Modèle, T[i]. Puissance)

 Finsi

Age ß Age + T[i]. age

Finpour

Ecrire (‘‘l’âge moyenne du parc auto est :’’, Age/N)

(*Chercher d'abord le premier vehicule smart qui a les caractéristiques demandé,

l'initialisation n’est pas automatique *)

i<-1

Trouve<-faux

TantQue(Trouve=faux) et (i<=N) faire

Si (T[i].type=’’smart’’) alors

Si ((T[i].Caméra≥ 4) et (T[i].Lidars≥2)) alors

Ind_Cmax<-i

Trouve<-vrai

Finsi

Sinon i<-i+1

Finsi

FinTantQue

(*Chercher et comparer avec le premier s'il existe*)

Si(Trouve = faux) alors

ecrire(‘Pas de vehicule avec ces caractéristiques')

sinon

Pour i allant de (Ind_Cmax+1) à N faire

Si (T[i].type=’’smart’’) alors

Si ( (T[Ind_Cmax]. Capteurs < T[i].Capteurs) et (T[i].Caméra≥

4) et (T[i].Lidars≥2)) alors

Ind_Cmax<-i
 Finsi

Finsi

FinPour

Ecrire (‘‘le véhicule le plus smart est : ‘‘, T[Ind_Cmax]. Matricule, T[Ind_Cmax].
Marque, T[Ind_Cmax]. Modèle, T[Ind_Cmax]. Puissance, T[Ind_Cmax]. Age,
T[Ind_Cmax]. Capteurs, T[Ind_Cmax]. Caméra, T[Ind_Cmax]. Lidars)

FinSi

Fin