Le document propose une série d'exercices algorithmiques sur la gestion de fichiers, comprenant des algorithmes pour compter les occurrences de caractères, créer un fichier de nombres, afficher des nombres pairs, et gérer des enregistrements d'étudiants et d'employés. Chaque exercice présente des solutions détaillées avec des procédures pour l'insertion, l'affichage et la suppression d'éléments dans des fichiers. L'objectif global est de démontrer des concepts de programmation liés aux fichiers dans un contexte éducatif.

1. Série d’exercices sur
les fichiers
Présentée par MAHSEUR Mohammed
Département MI
Université Benyoucef Benkhedda Alger 1
2019/2020
1

2. Exercice 1
Ecrire un algorithme permettant de
calculer le nombre d’occurrences d’un
caractère donné dans un fichier F de
caractères,
2

3. Solution de l’exo1
Algorithme exo1
Variable Nom_fichier: chaine[50];
c, val: caractères;
cpt: entier ;
F: fichier de caractères;
Début
Lire(Nom_fichier); Lire(c); cpt0;
FFouvrir(Nom_fichier, ‘‘modeLecture’’);
Tant que (Non FDF(F)) faire
Lire(F,val); Si (val=c) alors cptcpt+1;
Fin tant que
Ecrire(cpt); fermer(F);
Fin.
3

4. Exercice 2
4
Ecrire un algorithme qui génère un fichier intitulé
nombres.dat contenant des nombres entiers
fournis par l’utilisateur puis affiche uniquement
les nombres pairs.
En utilisant le fichier généré dans l’exercice
précédent, écrivez des actions permettant de :
1- Déterminer le nombre d’éléments du fichier
2- Supprimer les éléments du fichier se trouvant
après une position P donnée
Exercice 3

5. Solution de l’exo2 et l’exo3
5
Algorithme exo2et3
Variable F: fichier d’entier;
Choix: entier; rep: caractère;
//1) procédure qui fait la création et le remplissage
Procédure Création(var F :fichier d’entiers)
Variables cont: caractère; val: entier;
Début
Cont’O’;
FFouvrir(‘‘nombres.dat’’, ‘‘modeEcriture’’);
Tant que (Cont=‘o’ ou ‘O’) faire
Lire(val); Ecrire(F,val);
Écrire(‘voulez vous continuez’);Lire(Cont);
Fin tant que;
Fermer(F);
Fin.

6. //2) procédure qui affiche les nombres pairs
Procédure Pairs(F :fichier d’entiers)
Variables val: entier;
Début
FFouvrir(‘‘nombres.dat’’, ‘‘modeLecture’’);
Tant que (Non FDF(F)) faire
Lire(F,val);
Si( val mod2=0 )alors écrire(val);
Fin tant que;
Fermer(F);
Fin.
6

7. //3) Le nombre d’éléments du fichier
fonctionTaille(F :fichier d’entiers) :entier
Variables val,cpt: entier;
Début
cpt0
FFouvrir(‘‘nombres.dat’’, ‘‘modeLecture’’);
Tant que (Non FDF(F)) faire
Lire(F,val);
cptcpt+1;
Fin tant que;
Fermer(F);
retourner cpt;
Fin. 7

8. //4) supprimer les éléments se trouvant après une position P
8
nombres.dat
F
0
1
2
3
4
5
6
7
8
sauv.dat
Temp
P
nombres.dat

9. //4) supprimer les éléments se trouvant après une position P
Procédure Suppression(F :fichier d’entiers)
Variables val,P,i: entier;
Temp: Fichier d’entiers;
Début
Répéter Lire(P) jusqu’à (P≥0 et P<Taille(F));
FFouvrir(‘‘nombres.dat’’, ‘‘modeLecture’’);
TempFouvrir(‘‘sauv.dat’’, ‘‘modeEcriture’’);
i0;
Tant que (i ≤ P) faire
Lire(F,val); Ecrire(Temp,val); ii+1;
Fin tant que;
Fermer(F); Fermer(Temp); Supprimer(‘‘nombres,dat’’);
Renommer(‘‘sauv.dat’’,’’nombres.dat’’);
Fin.
9

10. //5) Procédure qui affiche le menu
Procédure Menu()
Début
Écrire(‘Menu principal’);
Ecrire(‘1: Création du fichier’);
Ecrire(‘2: Liste des nombres pairs’);
Ecrire(‘3: Nombre d’éléments du fichier’);
Ecrire(‘4: Supprimer des élément après une position’);
Ecrire(‘donner votre choix’);
Fin.
10

11. //6) corps de l’algorithme principal
Début
Rep’O’;
Tant que (rep=‘o’ ou rep=‘O’) faire
DébutTant que
Menu(); Lire(choix);
Cas (choix) parmi
1: Création(F);
2: Pairs(F);
3: écrire (Taille(F));
4: Suppression(F);
Sinon: écrire(‘choix incorrect’);
Fin;
Ecrire (‘voulez-vous continuez O/N:); Lire(rep);
Fin tant que;
Fin.
11

12. Exercice 4
12
Soit le type suivant :
TypeTE = enregistrement
Num_etud : entier ;
Nom : chaîne ;
Notes : tableau [5] de réels ;
Moyenne : réel ;
Fin ;
On suppose que la fonction de saisie SaisieEtud() :TE
Permettant de saisir un tableau d’enregistrementsTE qui
existe déjà. On pourra donc s’en servir.
1. Ecrire une fonction qui permet de saisir un groupe
d’étudiants dans un fichier.
2. Ecrire une fonction qui permet de calculer la moyenne
générale d’un groupe d’étudiants.

13. Solution de l’Exercice 4
13
Algorithme exo4;
TypeTE = enregistrement
Num_etud : entier ;
Nom : chaîne ;
Notes : tableau [5] de réels ;
Moyenne : réel ;
Fin ;
Variables F: fichier d’enregistrements;
Fonction SaisieEtud():TE
Var e:TE; i:entier
Début
Lire(e.Num_etud); Lire(e.Nom); Lire(e.Moyenne);
Pour i=1 à 5 faire Lire(e.Notes[i]);
Retourner e;
Fin;

14. 14
1. //Une fonction qui permet de saisir un groupe
d’étudiants dans un fichier.
Fonction SaisieGroupe():Fichier d’enregistrement
Var e:TE;
Cont : caractère
F: Fichier d’enregistrement;
Début
FFouvrir(‘‘groupe.dat ’’, ‘‘ModeEcriture’’);
Répéter
eSaisieEtud();
Ecrire(F,e);
Ecrire(‘voulez-vous ajouter d’autres étudiants O/N’);
Lire(Cont);
Jusqu’à (Cont≠’o’ et Cont ≠’O’);
Fermer(F);retourner F;
Fin;

15. 15
2. //Une fonction qui permet de calculer la moyenne
générale d’un groupe.
Fonction MoyGen(F:fichier d’enregistrement):réel
Var e:TE; i:entier; Som, MG: réel;
Début
FFouvrir(‘‘groupe.dat ’’, ‘‘ModeLecture’’); Som0;i0;
Tant que(Non FDF(F)) faire
Lire(F,e);SomSom+e.Moyenne; ii+1;
Fin tant que
MG Som/i;
Retourner MG;
Fin;

16. 16
//Corps de l’algorithme principal
Début
F SaisieGroupe();
Ecrire (MoyGen(F));
Fin;

17. Exercice 5
17
Ecrire un algorithme permettant de :
1) Créer et remplir un fichier "FP" qui contient les
informations sur le personnel d’une entreprise
(matricule, nom, prénom, grade, salaire).
2) Afficher la liste des employés de cette
entreprise dont le salaire est compris entre
25000 et 40000 DA.
3) Vérifier l’existence d’un employé dans FP à
partir de son matricule

18. Solution de l’Exercice 5
18
Algorithme exo5;
Type Employé = enregistrement
Matricule: entier ;
Nom, Prénom, Grade : chaîne[30] ;
Salaire : réel ;
Fin ;
Variables F: fichier d’enregistrements;
rep: caractère;
choix: entier;

19. 19
// fonction qui fait la lecture d’un employé
Fonction SaisieEmploye():Employé
Var e: Employé;
Début
Lire(e.Matricuel); Lire(e.Nom); Lire(e.Prénom);
Lire(e.Grade); Lire(e.Salaire);
Retourner e;
Fin;
// procédure qui affiche les informations d’un employé
Procédure AfficherEmploye(e:Employé)
Début
Écrire(e.Matricule); écrire(e.Nom); écrire(e.Prénom);
écrire(e.Grade); écrire(e.Salaire);
Fin;

20. 20
Procédure Création(var F: fichier)
Début
F Fouvrir(‘‘FP.dat’’, ‘‘ModeEcriture’’);
Fermer(F);
Fin;
//1). Procédure qui fait la création du fichier

21. Procédure Remplissage(var F: fichier)
Variables e: Employé; Cont: caractère;
Début
F Fouvrir(‘‘FP.dat’’, ‘‘ModeMAJ’’);
Répéter
e SaisieEmployé(); FÉcrire(F,e);
Écrire(‘Voulez-vous ajouter d’autres employés O/N’);
Lire(cont);
Jusqu’à (Cont ≠’o’ et Cont≠’O’);
Fermer(F);
Fin;
21
//1). Procédure qui fait le remplissage du fichier

22. Procédure ListeEmplyés(F: fichier)
Variables e: Employé;
Début
F Fouvrir(‘‘FP.dat’’, ‘‘ModeLecture’);
Tant que (Non FDF(f)) faire
FLire(F,e);
Si (e.Salaire≥25000 et e.Salaire≤40000) alors
AfficherEmployé(e);
Fin si
Fin tant que
Fermer(F);
Fin;
22
//2). Procédure qui affiche la liste des employés dont : 25000≤Salaire≤40000

23. Procédure Existence(F: fichier)
Variables e: Employé; Mat : entier; trouv: booléen
Début
F Fouvrir(‘‘FP.dat’’, ‘‘ModeLecture’);
Lire(Mat); trouv Faux;
Tant que (Non FDF(f) et Non trouv)
FLire(F,e);
Si (e.Matricule=Mat) alors trouv vrai;
Fin tant que
Si (Non trouv) alors écrire(‘employé inexistant’);
Sinon
écrire(‘employé existe et voici ses informations);
AfficherEmployé(e);
Fin sinon
Fermer(F);
Fin;
23
//3). Procédure qui vérifie l’existence d’un employé /Matricule

24. Procédure Menu()
Début
Écrire(‘Menu principal’);
Écrire(‘1: création du fichier’);
Écrire(‘2: insertion des employés’);
Écrire (‘3: liste des employés dont 25000≤salaire≤40000
Écrire(‘4: recherche/matricule’);
Écrire(‘donnez votre choix’);
Fin;
24
//Procédure qui affiche le menu principal

25. Début
Répéter
Menu(); Lire(choix);
Cas (choix) parmi
1: Création(F);
2: Remplissage(F);
3: ListeEmployés(F);
4: Existence(F);
Sinon: écrire(‘choix incorrect’);
Fin;
Ecrire(‘voulez-vous continuer O/N:); Lire(rep);
Jusqu’à (rep≠’o’ et rep≠’O’);
Fin . 25
//Corps de l’algorithme principal