Institut Supérieur d'Informatique Année Universitaire : 2019-2020

Mahdia (ISIMA)

MODULE : Algorithmique et Structure des Données II sinon

si(res='OOREDOO') alors
Auditoire : P-LCE (B/D) Enseignante : ABDELHAFIDH Maroua sol.sol_oore:= sol.sol_oore - mont
sinon
si(res='ORANGE') alors
sol_tel:=sol_eli- mont
Correction TD2 : Enregistrement else if(res='ORANGE') then
sol.sol_orang:= sol.sol_orang- mont;
finsi;
Exercice 1 fin;
1) Exercice2 :
Algorithme gestTel
1)
Type
Type DATE= Struct
Solde = struct
J,M,A :entier ;
sol_tel :entier
FinStruct
sol_oore :entier
2)
sol_orang : entier
finStruct Procedure SommeD(E/ D1,D2 :DATE ; S/ D : DATE) ;
Var
recharge= struct X :entier ;
num : chaine Debut
mont : entier X←D1.M+D2.M;
res : chaine D.J←X mod 30; D.M← X div 30;
finStruct X←D.M+D1.M+D2.M;
D.M← X mod 30;
var Fin
3)
S: Solde Fonction Convert(D :DATE) :entier ;
R: recharge Debut
Convert←D.J+30*D.M;
début Fin ;
4)
Ecrire(“Les different soldes existants sont:”) Procedure Transform(E/ J :entier ; S/ D :DATE) ;
lire(S.sol_tel) Debut
lire (S.sol_oore) D.M←J div 30 ; D.J← S mod 30 ;
lire(S.sol_orang) Fin;
Ecrire(“Le premier recharge effectué est:”) 5)
lire(R.num) Algorithme CalculD;
lire (R.mont) Type
lire(R.res) DATE=struct
H,M,S :entier ;
fin
2) Var D1,D2,D :DATE ;
Procedure maj_solde(var sol:Solde; mont:entier; res:chaine); J :entier ;
Debut
begin Ecrire(‘Donner une Date D1 : A M J’) ;
si(res='TELECOM') alors Lire(D1.Y,D1.M,D1.J) ;
sol.sol_tel:= sol.sol_tel- mont Ecrire(‘Donner une Date D2 : A M J’) ;
 Lire(D2.Y,D2.M,D2.J) ; Numéro : entier
/*transformer D1 et D2 en jours, puis additionner
Rue : chaine [50]
J← Convert (D1) + Convert (D2);
/*décomposer J en DATE D Ville : chaine [20]
Transform(J,D) ;
Gouver : chaine [20]
Ecrire(‘La somme est :’,D.M,’ :’,D.J) ;
Fin code : entier
Fin struct
Exercice 3 : TRésident= struct
Type Nom, prenom : chaine [20]
E= struct Date_naiss : date
T :Tableau[1..100] de entier
Residence : Adresse
N :entier
Procedure ABCPos( M :chaine[250] ; var Pos :E) Fin struct
Var var
I,J,T :entier
Debut T :Tableau [1..100] de TRésident
T←Taille(M) TW :Tableau[1..48] de entier
i,N,A :entier
I←1
EH :TRésident
J←1
Debut
S.N←0
Ecrire(‘Donner N’)
Tant que I<T Faire
Repeter
Si (M[I]=’a’ et M[I+1]=’b’ et M[I+2]=’c’) Alors
Lire(N)
S.T[J] ←I
Jusqu’à N>0 et N≤100
S.N←S.N+1
/*lecture du tableau des Résidents (remplir)
J←J+1
Pour i←1 à N Faire
I←I+2
Lire (T[i].Nom,EH.Prenom) ;
Sinon
Lire (T[i].Date_naiss.Jour, T[i].Date_naiss.Mois,
I←I+1
T[i].Date_naiss.Annee)
Fin si
Lire (T[i].Residence.Numero, T[i].Residence.Rue,
Fin tant que
T[i].Residence.Ville, T[i].Residence.gouver, T[i].Residence.code) ;
Fin
fin pour
fin
Exercice 4 :
/*affichage des adresses des habitants nés avant une année A
Algorithme Habitant ;
Ecrire (‘Donner une Année’) ;
Type
Lire(A) ;
TDate = struct
Pour i←1 à N Faire
Jour, mois, année : entier
Si T[i].Date_naiss.Annee=A Alors
Fin struct
Ecrire(T[i].adresse.num, T[i].adresse.rue, T[i].adresse.Ville,
TAdresse = struct
T[i].adresse.gouver, T[i].adresse.code)
 Fin si 2)
fin //Nouvelle structure après décomposition du identifiant :
/*affichage des noms et adresses des habitants de ville V Type
Pour i←1 à N Faire ID=struct
Si T[i].résidence.Ville=’V’ Alors prefixe :entier
Ecrire(T[i].Nom, T[i].Prenom, T[i]. Date_naiss.jour, T[i]. code_z :entier
Date_naiss.mois, T[i]. Date_naiss.année) code_e :entier
Fin si code_t : entier
fin chiffre : entier
/*nombre d’habitants par gouvernorat ; Fin struct
/*initialiser à 0 ; livre=struct
Pour i←1 à 24 Faire id :ID
TW[i]←0 ; titre :chaine[20]
fin auteur :chaine[10]
Pour i←1 à N Faire couleur : chaine[10]
TW[T[i].Residence.code]← TW[T[i].Residence.code]+1 Nbp, prix :entier
fin Fin struct

/*affichage 3)
Pour i←1 à 24 Faire Algorithme Bibliothèque ;
Ecrire(‘Gouvernorat ‘,i,’ Nombre ‘,TW[i]) Type
fin Type
fin ID=struct
prefixe :entier
Exercice 5 code_z :entier

1) code_e :entier

Type code_t : entier

livre=struct chiffre : entier

id :entier Fin struct

titre :chaine[20] livre=struct

auteur :chaine[10] id :ID

couleur : chaine[10] titre :chaine[20]

Nbp,prix :entier auteur :chaine[10]

Fin struct couleur : chaine[10]

Nbp, prix :entier
Fin struct
var
TP :Tableau[1..500] de livre ;
 TW :Tableau[1..48] de entier ;
l :livre ;
i,N,A :entier ;
Col :chaine[10] ;
Debut
Ecrire(‘Donner N’) ;
Repeter
Lire(N) ;
Jusqu’à N>0 et N≤500 ;
/*lecture du tableau des livre
Pour I←i à N Faire
Lire(TP[i].id.prefixe, TP[i]. id.code_z, TP[i]. id.code_e, TP[i].
id.code_t, TP[i]. id.chiffre, TP[i]. id.code)
Lire(TP[i].id, TP[i].titre, TP[i].auteur, TP[i].couleur, TP[i].prix,
TP[i].nbp)
fin pour

Ecrire(‘Donner une couleur’) ; Lire(Col) ;

Pour i←1 à N Faire
Si (TP[i].couleur=col )alors
Lire(TP[i].id.prefixe, TP[i]. id.code_z, TP[i]. id.code_e, TP[i].
id.code_t, TP[i]. id.chiffre, TP[i]. id.code)
Lire(TP[i].id, TP[i].titre, TP[i].auteur, TP[i].couleur,
TP[i].prix, TP[i].nbp)
Fin si
fin pour