Aller au contenu

Un mot pour Fahmio

Tu écris. Tu continues.

Un problème, une idée — assez pour qu’on comprenne, puis tu retournes à ta copie.

On lit. Tu n’as rien d’autre à faire.

Où veux-tu aller ?

↑ ↓ pour parcourir · Entrée pour ouvrir · Échap pour fermer

Fahmio
Fahmio
Bac Tunisie
FE-BFichiers, enregistrements et matrices

Fichier d'enregistrements : déclarer, ouvrir, remplir par O/N, relire pour un verdict ou un second fichier

Idée directrice

Un fichier d'enregistrements (.dat) se manipule en trois temps. On le déclare : un type Enregistrement, puis un type Fichier de cet enregistrement. On le remplit : ouverture en création "wb", boucle de saisie arrêtée par la réponse « N », un Ecrire(F, e) par tour. On le relit séquentiellement, en "rb", jusqu'à Fin_fichier, pour compter, décider d'un verdict ou écrire un second fichier du même type. Les points faciles du barème (instruction d'ouverture, déclaration, question O/N) se perdent sur des détails de mode et de primitive.

Ce qui aide à reconnaître la démarche

« Écrire une instruction d'assignation (d'ouverture) du fichier … » ; « Donner une déclaration pour le type du fichier … ainsi que pour tout nouveau type nécessaire » ; « La saisie se termine en répondant par "N" à la question … (O/N) » ; « de même structure » ; « créer et remplir un fichier d'enregistrements »

Besoin d’un point de départ ? Voir la méthode
  • Déclarer dans l'ordre : Enreg = Enregistrement … Fin, puis FEnreg = Fichier de Enreg. Ces deux lignes vont dans le tableau des nouveaux types, jamais dans celui des objets.
  • Choisir le mode d'après l'usage : "wb" pour créer (et effacer), "rb" pour relire, "ab" pour ajouter en fin ; "r", "w" et "a" pour un fichier texte.
  • Saisie O/N : une boucle Répéter extérieure qui s'arrête sur rep = "N", avec un contrôle intérieur Jusqu'à (rep = "O") Ou (rep = "N").
  • Relecture : Tant que Non (Fin_fichier (F)) → Lire (F, e) → travail sur les champs e.X. Pour relire depuis le début, fermer puis rouvrir.
  • Un pourcentage se teste sans division : 100·nb ≥ 80·total.
Les pièges à vérifier dans ta démarche

Déclarer le fichier avant l'enregistrement, ou mettre les types dans le tableau des objets. Ouvrir en "wb" un fichier qu'on veut relire ou compléter : il est effacé. Utiliser Lire_ligne ou Ecrire_nl sur un fichier d'enregistrements. Écrire un champ au lieu de l'enregistrement entier : Ecrire(F, e.Temp) au lieu de Ecrire(F, e). Poser la question O/N avant d'avoir écrit la mesure saisie. Traduire « ne dépasse pas » par < au lieu de ≤. Oublier que les rangs de Pointer commencent à 0.

Sujet principal

Exercice — fichier d'enregistrements (6 points), dans l'esprit des sessions 2018–2026

7 questionsCorrigé masqué

Pour vérifier la loi de refroidissement d'une boisson chaude, un élève relève la température T (en °C) de la boisson à différents instants t (en minutes). La loi à vérifier s'écrit :

T(t)=20+60 e−t/10T(t)=20+60\,e^{-t/10}

Les mesures sont stockées dans un fichier d'enregistrements "Mesures.dat", situé dans le dossier D:\TP. Chaque enregistrement est formé de deux champs réels : Temps (l'instant t) et Temp (la température mesurée).

L'expérience est dite réussie si l'écart entre la température mesurée et la température théorique ne dépasse pas 0,5 °C pour au moins 80 % des mesures.

Travail demandé :

  1. Écrire l'instruction d'ouverture du fichier "Mesures.dat" en vue de sa création, en l'associant au nom logique F.
  2. Donner le tableau de déclaration des nouveaux types : le type enregistrement Mesure et le type fichier FMesures.
  3. Écrire l'algorithme d'une procédure Remplir(F) qui remplit le fichier "Mesures.dat" par saisie, F ayant été ouvert par l'instruction de la question 1 dans le programme appelant. L'instant saisi doit être positif ou nul. La saisie s'arrête lorsque l'utilisateur répond "N" à la question « Voulez-vous saisir une autre mesure (O/N) ? », la réponse ne pouvant être que "O" ou "N".
  4. Écrire l'algorithme d'une fonction Reussie(chemin) qui retourne Vrai si l'expérience enregistrée dans le fichier dont le chemin est chemin est réussie, et Faux sinon.
  5. Écrire l'algorithme d'une procédure Retenir(ch1, ch2) qui crée le fichier d'enregistrements "Retenues.dat" (chemin ch2), de même structure que "Mesures.dat" (chemin ch1), contenant uniquement les mesures dont l'écart ne dépasse pas 0,5 °C, puis l'affiche, à raison d'une mesure par ligne sous la forme t = … min : … °C.
  6. Questions de cours.
    1. Quel est le type de la valeur retournée par Fin_fichier(F) ?
    2. Pourquoi ne peut-on pas lire le fichier "Mesures.dat" avec Lire_ligne ?
    3. Quel mode d'ouverture faut-il utiliser pour ajouter de nouvelles mesures à la fin de "Mesures.dat" sans effacer les anciennes ?
  7. Le fichier "Mesures.dat" contient les six mesures du tableau ci-dessous, où les températures théoriques sont arrondies au centième. L'expérience est-elle réussie ? Donner le nombre d'enregistrements de "Retenues.dat".
t (min)T mesurée (°C)T théorique (°C)
080,280,00
556,656,39
1041,842,07
1533,533,39
2028,928,12
3023,122,99

NB : on dispose des fonctions prédéfinies Exp(x), qui retourne eˣ, et Abs(x), qui retourne la valeur absolue de x.

Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : pour créer un fichier d'enregistrements, on l'ouvre en écriture binaire.

Ouvrir ("D:\TP\Mesures.dat", F, "wb")

2. Idée : on déclare d'abord l'enregistrement, puis le fichier dont les éléments sont de ce type.

Nouveaux types
Mesure = Enregistrement
Temps : Réel
Temp : Réel
Fin
FMesures = Fichier de Mesure

3. Idée : une boucle Répéter extérieure, une mesure par tour. Deux contrôles de saisie imbriqués : l'instant (≥ 0) et la réponse (O ou N). On écrit l'enregistrement avant de poser la question.

Procédure Remplir (@ F : FMesures)
DEBUT
    Répéter
        Répéter
            Ecrire ("Instant t (min) : ")
            Lire (e.Temps)
        Jusqu'à e.Temps ≥ 0
        Ecrire ("Température (°C) : ")
        Lire (e.Temp)
        Ecrire (F, e)
        Répéter
            Ecrire ("Voulez-vous saisir une autre mesure (O/N) ? ")
            Lire (rep)
        Jusqu'à (rep = "O") Ou (rep = "N")
    Jusqu'à rep = "N"
    Fermer (F)
FIN
ObjetType / NatureRôle
eMesureMesure en cours de saisie
repCaractèreRéponse de l'utilisateur

4. Idée : un seul parcours séquentiel suffit, en comptant à la fois toutes les mesures et les mesures conformes. On compare ensuite des entiers (100·nb ≥ 80·total), ce qui évite une division.

Fonction Reussie (chemin : Chaîne) : Booléen
DEBUT
    Ouvrir (chemin, F, "rb")
    nb ← 0
    total ← 0
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, e)
        total ← total + 1
        th ← 20 + 60 * Exp (-e.Temps / 10)
        Si Abs (e.Temp - th) ≤ 0.5 Alors
            nb ← nb + 1
        Fin Si
    Fin Tant que
    Fermer (F)
    Retourner (total > 0) Et (100 * nb ≥ 80 * total)
FIN
ObjetType / NatureRôle
FFMesuresFichier des mesures
eMesureEnregistrement lu
nb, totalEntierMesures conformes, toutes les mesures
thRéelTempérature théorique à l'instant e.Temps

« Ne dépasse pas 0,5 » se traduit par ≤, et « au moins 80 % » par ≥. Le test total > 0 empêche de déclarer réussie une expérience sans mesure.

5. Idée : on lit Mesures.dat et on écrit dans Retenues.dat un enregistrement du même type. Pour afficher, on ferme Retenues.dat puis on le rouvre en lecture binaire.

Procédure Retenir (ch1, ch2 : Chaîne)
DEBUT
    Ouvrir (ch1, F, "rb")
    Ouvrir (ch2, G, "wb")
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, e)
        th ← 20 + 60 * Exp (-e.Temps / 10)
        Si Abs (e.Temp - th) ≤ 0.5 Alors
            Ecrire (G, e)
        Fin Si
    Fin Tant que
    Fermer (F)
    Fermer (G)
    Ouvrir (ch2, G, "rb")
    Tant que Non (Fin_fichier (G)) Faire
        Lire (G, e)
        Ecrire ("t = ", e.Temps, " min : ", e.Temp, " °C")
    Fin Tant que
    Fermer (G)
FIN
ObjetType / NatureRôle
F, GFMesures"Mesures.dat" et "Retenues.dat"
eMesureEnregistrement lu puis écrit
thRéelTempérature théorique

6.a Fin_fichier retourne un booléen : Vrai lorsque le dernier enregistrement a été lu.

6.b Lire_ligne lit une ligne de caractères et ne s'applique qu'à un fichier texte. "Mesures.dat" est un fichier d'enregistrements : on y lit un enregistrement entier, avec Lire(F, e).

6.c Le mode "ab" (ajout en binaire) : l'écriture se fait après le dernier enregistrement. Le mode "wb" effacerait le fichier.

7. Seule la mesure de l'instant 20 min s'écarte de plus de 0,5 °C (|28,9 − 28,12| = 0,78). On a donc 5 mesures conformes sur 6, soit environ 83 % ≥ 80 % : l'expérience est réussie, et "Retenues.dat" contient 5 enregistrements.

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

Variantes rencontrées : mesures d'intensité d'un circuit RL saisies par O/N puis comparées à la loi théorique, avec un verdict « 90 % des mesures » (contrôle 2018) ; fichier Fraction.dat transformé en Irreduct.dat de même structure, puis affiché (principale 2019) ; fichier texte de nombres converti en fichier d'enregistrements des nombres brésiliens (principale 2022) ; procédure Remplir dont cinq lignes sont à corriger (principale 2026) ; ajout de notes dans un fichier existant après recherche du login (contrôle 2026) ; questions V/F sur Lire, Pointer et Fin_fichier (principale 2015, principale 2016).

Exercices d'entraînement — une nuance à la fois

1 Drill FE-B.1 — pointeur, Pointer, Taille_fichier et Fin_fichier (notation des sessions 2015–2020)
Entraînement 01 / 06

Drill FE-B.1 — pointeur, Pointer, Taille_fichier et Fin_fichier (notation des sessions 2015–2020)

6 questionsCorrigé masqué

Dans les sujets des sessions 2015 à 2020, un fichier d'enregistrements pouvait être parcouru par accès direct : Pointer(F, k) place le pointeur sur l'enregistrement de rang k, les rangs étant numérotés à partir de 0, et Taille_fichier(F) retourne le nombre d'enregistrements.

Soit un fichier d'entiers de nom logique F, déjà ouvert, contenant dans cet ordre : 27, 41, 13, 58, 36. Le pointeur est positionné sur l'entier 13.

Pour chacune des questions suivantes, mettre la lettre V devant chaque réponse correcte et la lettre F devant chaque réponse fausse. Les questions s'enchaînent : chacune part de l'état laissé par la précédente.

  1. Après l'exécution de Lire(F, X), X contient :
    1. 41
    2. 58
    3. 13
  2. Après cette lecture, le pointeur est positionné sur l'entier :
    1. 58
    2. 13
    3. 36
  3. L'instruction Pointer(F, 4) positionne le pointeur sur :
    1. 58
    2. la fin du fichier
    3. 36
  4. Taille_fichier(F) retourne :
    1. 5
    2. 4
    3. 36
  5. Après Pointer(F, 4), l'instruction Y ← Fin_fichier(F) donne à Y la valeur :
    1. Vrai
    2. Faux
    3. 36
  6. La séquence qui affiche le dernier entier du fichier, quelle que soit sa taille, est :
    1. Pointer(F, Taille_fichier(F) − 1) ; Lire(F, Z) ; Ecrire(Z)
    2. Pointer(F, Taille_fichier(F)) ; Lire(F, Z) ; Ecrire(Z)
    3. Pointer(F, 5) ; Lire(F, Z) ; Ecrire(Z)
Voir la correction commentéeAprès avoir posé votre démarche

Idée : les rangs vont de 0 à Taille_fichier(F) − 1 ; Lire rend l'élément courant puis avance le pointeur d'un rang. Dans chaque question, on met la lettre V devant la seule réponse correcte et la lettre F devant les deux autres.

Question1ʳᵉ réponse2ᵉ réponse3ᵉ réponse
1FFV
2VFF
3FFV
4VFF
5FVF
6VFF

1. Lire lit l'entier sur lequel se trouve le pointeur, 13, au rang 2 ; 41 est au rang 1 et n'est pas relu.

2. Après la lecture, le pointeur avance d'un rang : il est sur 58, au rang 3.

3. Les rangs sont 0 → 27, 1 → 41, 2 → 13, 3 → 58, 4 → 36. Pointer(F, 4) vise donc 36, et non la fin du fichier.

4. Le fichier contient 5 entiers ; Taille_fichier compte des enregistrements, elle ne rend pas une valeur stockée.

5. Le pointeur est sur 36, qui n'a pas encore été lu : Fin_fichier(F) vaut Faux. Elle ne deviendrait Vrai qu'après Lire(F, Z). Fin_fichier retourne un booléen, jamais un entier.

6. Le dernier enregistrement a le rang Taille_fichier(F) − 1. Pointer(F, Taille_fichier(F)) se place après le dernier, et la lecture échoue. Pointer(F, 5) ne convient que pour un fichier de 6 entiers, et ici elle échoue aussi.

2 Drill FE-B.2 — ajouter un enregistrement à un fichier existant (mode "ab") si le login n’y figure pas encore
Entraînement 02 / 06

Drill FE-B.2 — ajouter un enregistrement à un fichier existant (mode "ab") si le login n’y figure pas encore

6 questionsCorrigé masqué

Un club organise un vote. Le fichier d'enregistrements "Votes.dat", déjà créé dans le dossier D:\Club, contient les votes déjà exprimés. Chaque enregistrement comporte deux champs : Login (chaîne de 8 chiffres) et Choix (entier de 1 à 3).

Travail demandé :

  1. Déclarer le type enregistrement Vote et le type fichier FVotes.
  2. Écrire l'algorithme d'une fonction Existe(login) qui retourne Vrai si un enregistrement de "Votes.dat" porte ce login, et Faux sinon.
  3. Écrire l'algorithme d'une procédure Voter(login) : si login a déjà voté, elle affiche « Vote déjà enregistré » ; sinon, elle saisit un choix compris entre 1 et 3 et ajoute l'enregistrement à la fin de "Votes.dat", sans effacer les votes existants. Préciser le mode d'ouverture utilisé.
  4. Écrire l'algorithme d'une procédure Resultats qui affiche le nombre de voix obtenues par chacun des trois choix.
  5. "Votes.dat" contient les cinq enregistrements (20451234, 1), (20457788, 3), (20450011, 1), (20459999, 2), (20453456, 1). On appelle Voter("20457788"), puis Voter("20452222") avec le choix saisi 3, puis Resultats. Donner ce qui est affiché.
  6. Que deviendrait "Votes.dat" si Voter l'ouvrait en mode "wb" ?
Voir la correction commentéeAprès avoir posé votre démarche

1.

Nouveaux types
Vote = Enregistrement
Login : Chaîne
Choix : Entier
Fin
FVotes = Fichier de Vote

2. Idée : un parcours séquentiel qui s'arrête dès que le login est trouvé ; le fichier est ouvert en lecture binaire, puis refermé.

Fonction Existe (login : Chaîne) : Booléen
DEBUT
    Ouvrir ("D:\Club\Votes.dat", F, "rb")
    trouve ← Faux
    Tant que Non (trouve) Et Non (Fin_fichier (F)) Faire
        Lire (F, v)
        trouve ← (v.Login = login)
    Fin Tant que
    Fermer (F)
    Retourner trouve
FIN

TDOL de Existe : F, FVotes ; v, Vote ; trouve, booléen.

3. Idée : on cherche d'abord, puis on ajoute. Le mode "ab" place l'écriture après le dernier enregistrement. La recherche ferme le fichier avant que Voter ne le rouvre.

Procédure Voter (login : Chaîne)
DEBUT
    Si Existe (login) Alors
        Ecrire ("Vote déjà enregistré")
    Sinon
        Répéter
            Ecrire ("Votre choix (1, 2 ou 3) : ")
            Lire (c)
        Jusqu'à (c ≥ 1) Et (c ≤ 3)
        v.Login ← login
        v.Choix ← c
        Ouvrir ("D:\Club\Votes.dat", F, "ab")
        Ecrire (F, v)
        Fermer (F)
    Fin Si
FIN

TDOL de Voter : F, FVotes ; v, Vote ; c, entier ; Existe, fonction.

4. Idée : trois compteurs remis à zéro, puis un parcours complet du fichier.

Procédure Resultats ()
DEBUT
    Ouvrir ("D:\Club\Votes.dat", F, "rb")
    n1 ← 0
    n2 ← 0
    n3 ← 0
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, v)
        Si v.Choix = 1 Alors
            n1 ← n1 + 1
        Sinon Si v.Choix = 2 Alors
            n2 ← n2 + 1
        Sinon
            n3 ← n3 + 1
        Fin Si
    Fin Tant que
    Fermer (F)
    Ecrire ("Choix 1 : ", n1, " ; choix 2 : ", n2, " ; choix 3 : ", n3)
FIN

TDOL de Resultats : F, FVotes ; v, Vote ; n1, n2, n3, entiers.

5. Le login 20457788 figure déjà dans le fichier : « Vote déjà enregistré » s'affiche, et rien n'est ajouté. Le login 20452222 est nouveau : l'enregistrement (20452222, 3) est ajouté en sixième position.

Resultats affiche alors : Choix 1 : 3 ; choix 2 : 1 ; choix 3 : 2.

6. Le mode "wb" crée un fichier vide : les cinq votes existants seraient effacés, et "Votes.dat" ne contiendrait plus que le dernier vote.

3 Drill FE-B.3 — créer un fichier d’enregistrements de même structure, transformé, puis l’afficher
Entraînement 03 / 06

Drill FE-B.3 — créer un fichier d’enregistrements de même structure, transformé, puis l’afficher

3 questionsCorrigé masqué

Un chronométreur a saisi, sans les normaliser, des durées dans le fichier d'enregistrements "Durees.dat" (racine du disque D). Chaque enregistrement comporte trois champs entiers positifs ou nuls, H, M et S (heures, minutes, secondes). Les minutes et les secondes peuvent dépasser 59.

On se propose de créer le fichier "Normal.dat" (racine du disque D), de même structure, contenant pour chaque durée de "Durees.dat" la durée équivalente dans laquelle 0 ≤ M ≤ 59 et 0 ≤ S ≤ 59. On veut ensuite l'afficher, une durée par ligne sous la forme H h M min S s, suivie de la durée totale, normalisée.

Exemple : "Durees.dat" contient les quatre enregistrements (1, 75, 30), (0, 59, 125), (2, 0, 3600) et (0, 45, 20).

Travail demandé :

  1. Donner une déclaration pour chaque nouveau type utilisé.
  2. Écrire l'algorithme d'une procédure Normaliser qui crée "Normal.dat" à partir de "Durees.dat", puis affiche son contenu et la durée totale.
  3. Donner l'affichage obtenu pour l'exemple.

NB : le candidat n'est pas appelé à remplir le fichier "Durees.dat".

Voir la correction commentéeAprès avoir posé votre démarche

1.

Nouveaux types
Duree = Enregistrement
H, M, S : Entier
Fin
FDurees = Fichier de Duree

2. Idée : on convertit chaque durée en secondes, puis on la redécompose par Div et Mod. Le même type d'enregistrement sert pour la lecture et pour l'écriture. Le total se cumule en secondes pendant la création.

Procédure Normaliser ()
DEBUT
    Ouvrir ("D:\Durees.dat", F, "rb")
    Ouvrir ("D:\Normal.dat", G, "wb")
    tot ← 0
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, d)
        s ← d.H * 3600 + d.M * 60 + d.S
        tot ← tot + s
        d.H ← s Div 3600
        d.M ← (s Mod 3600) Div 60
        d.S ← s Mod 60
        Ecrire (G, d)
    Fin Tant que
    Fermer (F)
    Fermer (G)
    Ouvrir ("D:\Normal.dat", G, "rb")
    Tant que Non (Fin_fichier (G)) Faire
        Lire (G, d)
        Ecrire (d.H, " h ", d.M, " min ", d.S, " s")
    Fin Tant que
    Fermer (G)
    Ecrire ("Total : ", tot Div 3600, " h ", (tot Mod 3600) Div 60, " min ", tot Mod 60, " s")
FIN
ObjetType / NatureRôle
F, GFDurees"Durees.dat" et "Normal.dat"
dDureeDurée lue, puis normalisée
sEntierDurée en secondes
totEntierTotal en secondes

3. (1, 75, 30) vaut 8130 s ; (0, 59, 125) vaut 3665 s ; (2, 0, 3600) vaut 10800 s ; (0, 45, 20) vaut 2720 s. Le total est de 25315 s.

2 h 15 min 30 s
1 h 1 min 5 s
3 h 0 min 0 s
0 h 45 min 20 s
Total : 7 h 1 min 55 s
4 Drill FE-B.4 — fichier texte vers fichier d’enregistrements : ne garder que les lignes qui vérifient une propriété
Entraînement 04 / 06

Drill FE-B.4 — fichier texte vers fichier d’enregistrements : ne garder que les lignes qui vérifient une propriété

5 questionsCorrigé masqué

Un entier n ≥ 2 est dit abondant si la somme de ses diviseurs stricts (tous ses diviseurs positifs sauf n lui-même) est strictement supérieure à n. Par exemple, 12 est abondant : 1 + 2 + 3 + 4 + 6 = 16 > 12.

Le fichier texte "Nombres.txt", situé à la racine du disque D, contient un entier n ≥ 2 par ligne. On se propose de créer et de remplir le fichier d'enregistrements "Abondants.dat" (racine du disque D) par les nombres abondants de "Nombres.txt". Chaque enregistrement comporte deux champs : N, le nombre, et SD, la somme de ses diviseurs stricts.

Exemple de contenu du fichier "Nombres.txt" : 12, 15, 18, 28, 20, 945, 21, à raison d'un nombre par ligne.

Travail demandé :

  1. Donner une déclaration du type du fichier "Abondants.dat", ainsi que des types nécessaires à sa déclaration.
  2. Donner en algorithmique les instructions d'ouverture des deux fichiers, de noms logiques Ft et Fb.
  3. Écrire l'algorithme d'une fonction SommeDiv(n) qui retourne la somme des diviseurs stricts de n.
  4. Écrire l'algorithme d'une procédure Generer(Ft, Fb), sachant que les deux fichiers sont ouverts dans le programme appelant.
  5. Donner le contenu du fichier "Abondants.dat" pour l'exemple.

NB : le candidat n'est pas appelé à remplir le fichier "Nombres.txt".

Voir la correction commentéeAprès avoir posé votre démarche

1.

Nouveaux types
Abondant = Enregistrement
N, SD : Entier
Fin
FAbondants = Fichier de Abondant

2. Idée : la source est un fichier texte, lu en "r" ; le fichier d'enregistrements est créé en "wb".

Ouvrir ("D:\Nombres.txt", Ft, "r")
Ouvrir ("D:\Abondants.dat", Fb, "wb")

3. Idée : les diviseurs vont par paires (d, n Div d) ; on les ajoute tant que d² ≤ n, sans ajouter deux fois une racine carrée exacte. Le diviseur 1 est compté d'office, et n n'est jamais ajouté.

Fonction SommeDiv (n : Entier) : Entier
DEBUT
    s ← 1
    d ← 2
    Tant que d * d ≤ n Faire
        Si n Mod d = 0 Alors
            s ← s + d
            Si d ≠ n Div d Alors
                s ← s + n Div d
            Fin Si
        Fin Si
        d ← d + 1
    Fin Tant que
    Retourner s
FIN

TDOL de SommeDiv : s et d, entiers. Une boucle simple de 1 à n − 1 est aussi acceptée.

4. Idée : chaque ligne lue est une chaîne ; Valeur la convertit en entier. On remplit les champs de l'enregistrement, puis on écrit l'enregistrement entier avec Ecrire, pas avec Ecrire_nl.

Procédure Generer (@ Ft : Fichier texte ; @ Fb : FAbondants)
DEBUT
    Tant que Non (Fin_fichier (Ft)) Faire
        Lire_ligne (Ft, ch)
        n ← Valeur (ch)
        s ← SommeDiv (n)
        Si s > n Alors
            e.N ← n
            e.SD ← s
            Ecrire (Fb, e)
        Fin Si
    Fin Tant que
    Fermer (Ft)
    Fermer (Fb)
FIN

TDOL de Generer : ch, chaîne ; n et s, entiers ; e, Abondant ; SommeDiv, fonction.

5. 15 donne 9, 28 donne 28 (il est parfait, pas abondant) et 21 donne 11 : ces trois nombres ne sont pas retenus. Pour les autres, la somme dépasse le nombre ; 945 est le plus petit nombre impair abondant.

NSD
1216
1821
2022
945975
5 Drill FE-B.5 — corriger les cinq lignes erronées d’une procédure qui remplit un fichier d’enregistrements
Entraînement 05 / 06

Drill FE-B.5 — corriger les cinq lignes erronées d’une procédure qui remplit un fichier d’enregistrements

3 questionsCorrigé masqué

Le fichier texte Ft contient dans chaque ligne le nom d'un élève, un point-virgule, puis sa moyenne (un réel écrit avec un point). À partir de Ft, on veut créer et remplir un fichier d'enregistrements Fb, dont chaque enregistrement comporte les champs Nom (chaîne), Moy (réel) et Mention ("Admis" si Moy ≥ 10, "Ajourné" sinon).

La procédure Convertir ci-dessous devrait réaliser ce traitement, mais cinq lignes comportent des erreurs de logique ou de syntaxe. ch1 et ch2 contiennent les chemins d'accès et les noms physiques des fichiers Ft et Fb.

Procédure Convertir (ch1, ch2 : Chaîne)
DEBUT
    Ouvrir (ch1, Ft, "w")
    Ouvrir (ch2, Fb, "wb")
    Tant que Non (Fin_fichier (Fb)) Faire
        Lire_ligne (ch, Ft)
        p ← Pos (";", ch)
        e.Nom ← Sous_chaine (ch, 0, p)
        e.Moy ← Sous_chaine (ch, p + 1, Long (ch))
        Si e.Moy ≥ 10 Alors
            e.Mention ← "Admis"
        Sinon
            e.Mention ← "Ajourné"
        Fin Si
        Ecrire_nl (Fb, e)
    Fin Tant que
    Fermer (Ft)
    Fermer (Fb)
FIN

Travail demandé :

  1. Reproduire le tableau ci-dessous et, pour chaque ligne erronée, inscrire la ligne telle qu'elle apparaît puis sa correction.
  2. Dresser le tableau des nouveaux types et celui des objets locaux de Convertir, en tenant compte des corrections.
  3. Ft contient les trois lignes Amine;12.5, Rym;9.25 et Sami;10. Donner les enregistrements de Fb.
Ligne erronéeCorrection
Voir la correction commentéeAprès avoir posé votre démarche

1. Idée : vérifier, ligne par ligne, le mode de chaque fichier, le fichier testé par la boucle, l'ordre des paramètres des primitives, le type des valeurs affectées aux champs, et la primitive d'écriture adaptée à la nature du fichier.

Ligne erronéeCorrection
Ouvrir (ch1, Ft, "w")Ouvrir (ch1, Ft, "r")
Tant que Non (Fin_fichier (Fb)) FaireTant que Non (Fin_fichier (Ft)) Faire
Lire_ligne (ch, Ft)Lire_ligne (Ft, ch)
e.Moy ← Sous_chaine (ch, p + 1, Long (ch))e.Moy ← Valeur (Sous_chaine (ch, p + 1, Long (ch)))
Ecrire_nl (Fb, e)Ecrire (Fb, e)

Ft existe déjà : le mode "w" l'effacerait. C'est la fin de la source qui arrête la boucle, et non celle du fichier en cours de création. Lire_ligne reçoit d'abord le fichier, puis la variable. Le champ Moy est un réel, et Sous_chaine rend une chaîne : il faut Valeur. Enfin, Ecrire_nl écrit une ligne de texte, alors que Fb reçoit un enregistrement.

2.

Nouveaux types
Eleve = Enregistrement
Nom : Chaîne
Moy : Réel
Mention : Chaîne
Fin
FEleves = Fichier de Eleve
ObjetType / NatureRôle
FtFichier texteFichier source
FbFElevesFichier d'enregistrements créé
chChaîneLigne lue
pEntierPosition du point-virgule
eEleveEnregistrement à écrire

3. 10 donne la mention Admis, car la condition est Moy ≥ 10.

NomMoyMention
Amine12,5Admis
Rym9,25Ajourné
Sami10Admis
6 Drill FE-B.6 — parcourir deux fois un fichier d’enregistrements : la moyenne d’abord, la liste ensuite
Entraînement 06 / 06

Drill FE-B.6 — parcourir deux fois un fichier d’enregistrements : la moyenne d’abord, la liste ensuite

3 questionsCorrigé masqué

Le fichier d'enregistrements "Ventes.dat", situé à la racine du disque D, contient au moins un enregistrement. Chaque enregistrement comporte deux champs : Vendeur (chaîne) et Montant (entier, chiffre d'affaires du mois en dinars).

On se propose d'afficher la moyenne des montants, puis de créer le fichier texte "Meilleurs.txt" (racine du disque D), qui contient, à raison d'un vendeur par ligne et dans l'ordre du fichier, le nom et le montant (séparés par un espace) de chaque vendeur dont le montant est strictement supérieur à la moyenne.

Exemple : "Ventes.dat" contient (Hela, 1250), (Omar, 980), (Sonia, 1500), (Fares, 720) et (Lina, 1100).

Travail demandé :

  1. Expliquer pourquoi un seul parcours du fichier "Ventes.dat" ne suffit pas.
  2. Écrire l'algorithme d'une procédure Meilleurs qui réalise ce traitement, avec son tableau de déclaration des objets locaux (le type fichier FVentes et le type enregistrement Vente sont supposés déclarés).
  3. Donner la moyenne affichée et le contenu du fichier "Meilleurs.txt" pour l'exemple.
Voir la correction commentéeAprès avoir posé votre démarche

1. On ne sait si un vendeur dépasse la moyenne qu'une fois la moyenne connue, c'est-à-dire après avoir lu tous les montants. Un premier parcours calcule la somme et l'effectif ; un second relit les enregistrements depuis le début pour les comparer à la moyenne.

2. Idée : pour revenir au début d'un fichier d'enregistrements, on le ferme puis on le rouvre en lecture.

Procédure Meilleurs ()
DEBUT
    Ouvrir ("D:\Ventes.dat", F, "rb")
    s ← 0
    n ← 0
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, v)
        s ← s + v.Montant
        n ← n + 1
    Fin Tant que
    Fermer (F)
    moy ← s / n
    Ecrire ("Moyenne : ", moy)
    Ouvrir ("D:\Ventes.dat", F, "rb")
    Ouvrir ("D:\Meilleurs.txt", G, "w")
    Tant que Non (Fin_fichier (F)) Faire
        Lire (F, v)
        Si v.Montant > moy Alors
            Ecrire_nl (G, v.Vendeur + " " + Convch (v.Montant))
        Fin Si
    Fin Tant que
    Fermer (F)
    Fermer (G)
FIN
ObjetType / NatureRôle
FFVentesFichier des ventes
GFichier texteFichier "Meilleurs.txt"
vVenteEnregistrement lu
s, nEntierSomme des montants, nombre de vendeurs
moyRéelMoyenne des montants

La division s / n est sûre, car le fichier contient au moins un enregistrement.

3. La somme vaut 5550 pour 5 vendeurs, et la moyenne affichée est 1110. Lina (1100) reste en dessous. "Meilleurs.txt" contient :

Hela 1250
Sonia 1500

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.