Problème concours – Bac théorique – Section informatique – 2008
Sujet (Algo et programmation - Bac 2008)
Les données relatives es à un concours sont enregistrées dans un fichier typé intitulé concours.dat. Il comporte n enregistrements relatifs aux n candidats.
Chaque enregistrement comporte dam.s cet ordre :
- numero (entier)
- nom (chaine de 30 caractères)
- prenom (chaine dc 30 caractères)
- matierel (Chaîe de 20 caractères)
- notel (réel)
- matiere2 (Chaîne de 20 caractères)
- note2 (réel)
- matiere3 (Chaine de 20 caractères)
- note3 (réel)
notei est la notc obtenue par un candidat dans la matière matierei.
On se propose d'écrire une application qui traite ces données pour produire deux nouveaux fichiers.
Le premier, intitulé resultat.dat contient n enregistrements comportant en plus des données précédentes, d'autres champs "moycnne" et "rang" de types respectifs réel et entier.
Les enregistrements de ce fichier sont classés par ordre de mérite c'est- à-dire suivant un tri décroissant sur tes moyennes.
La moyenne d'un candidat est calculée corn.me suit (1.note1 + 2. note2 2.note3)/ 5.
Le secord fichier intitulé delails.txt de type texte. comporte :
- dans la première ligne le nombre d'admis (moyenne >= 10)
- dans la seconde ligne : la meilleure note dans matierel suivie d'un espace puis du nombre de candidats ayant eu notel >=10,
- dans la troisième ligne : la meilleure note dans matiere2 suivie d'un espace puis du nombre de candidats ayant eu note2 >=10,
- dans la quatrième ligne la meilleure note dans niatiere3 suivie d’un espace puis du nombre de candidats ayant eu note3 >=10.
Solution Algorithmique
Dans cet algorithme, On va utiliser sept procédures :
- la fonction saisie()
- la procédure remplir_fichier_concours()
- la procédure tri_decroissant_tableau()
- la procédure remplir_fichier_resultat()
- la procédure recherche_nbr_admis()
- la procédure recherche_max_note()
- la procédure remplir_fichier_details()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 |
Algorithme concours Debut n = saisie() # Saisie du nombre de candidats remplir_fichier_concours(n) # Création concours.dat tri_decroissant_tableau(t, n) # Tri par moyenne décroissante remplir_fichier_resultat(t, n) # Création resultat.dat remplir_fichier_details(t, n) # Création details.txt Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| t | Tableau contenant 50 candidats |
La fonction saisir
Cette fonction saisit et retourne le nombre des enregistrements à insérer dans le fichier concours.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie(): entier Ecrire('donner n > 0: ') lire (n) # Tant que n n'est pas strictement positif, on redemande Tant que (n <0) faire Ecrire('donner n telque 10<n<100: ') lire (n) Fin tant que retourner n fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_fichier_concours
La procédure remplir_fichier_concours(n) sert à constituer le fichier binaire concours.dat en y enregistrant les informations des n candidats.
Pour chaque candidat, la procédure réalise les actions suivantes :
1- créer un dictionnaire contenant les champs : numéro, nom, prénom, trois matières et leurs notes.
2- demander à l’utilisateur de saisir successivement toutes ces informations.
3- calculer la moyenne du candidat selon la formule : moyenne= (note1 + 2 × note2 + 2 × note3)/ 5
4- ajouter un rang provisoire, correspondant à l’ordre d’entrée.
5- stocker le dictionnaire dans un tableau t.
6- enregistrer le dictionnaire dans le fichier binaire concours.dat à l’aide de dump().
7- finalement, la procédure ferme le fichier après avoir écrit les n enregistrements.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
Procédure remplir_fichier_councours(n:entier,t:tableau): Ouvrir("concours.dat", f_candidats , "wb") # Fichier binaire d’entrée pour i de 0 à n-1 faire # Création d'un dictionnaire pour chaque candidat candidat = Enregistrement numero : entier nom : chaine prenon : chaine matiere1 : chaine note1 : reel matiere2 : chaine note2 : reel matiere3 : chaine , note3 : float # Saisie des informations Ecrire ('donner le numero du candidat: ') Lire(candidat["numero"]) Ecrire('donner le nom du candidat: ') Lire(candidat["nom"]) Ecrire('donner le prenom du candidat: ') Lire(candidat["prenom"]) Ecrire('donner le nom de matiere1: ') Lire(candidat["matiere1"]) Ecrire('donner note1: ') Lire(candidat["note1"]) Ecrire('donner note2: ') Lire(candidat["note2"]) Ecrire('donner note3: ') Lire(candidat["note3"]) # Sauvegarde dans le tableau t[i] <- candidat # moyenne = (1*note1 + 2*note2 + 2*note3)/5 t[i]["moyenne"] <- ((candidat["note1"] + 2*candidat["note2"] + 2*candidat["note3"]) / 5) # Le rang provisoire est juste l’ordre d'apparition t[i]["rang"] <- i + 1 # Écriture du candidat dans concours.dat Ecrire(f_candidats,candidat) Fin pour Fermer(f_candidats) # Fermeture du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_candidats | fichier du concours.dat |
| i | entier |
La procédure tri_decroissant_tableau
Cete programme réalise un tri décroissant d’un tableau t contenant des enregistrements (dictionnaires). Le tri se fait selon la valeur de la clé "moyenne".
1- Pour chaque position i du tableau, on suppose que c’est la position du maximum.
2- On parcourt les éléments suivants pour trouver celui qui a la plus grande "moyenne".
3- Si on trouve un élément plus grand, on mémorise son indice.
4- À la fin, si le maximum trouvé n'est pas à sa place, on échange les deux éléments.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Procédure tri_decroissant_tableau (t:tableau,n:entier) : Pour i de 0 à n-2 faire indice_max<-i # Recherche de la plus grande moyenne dans la partie restante du tableau Pour j de i+1 à n-1 faire Si t[indice_max]["moyenne"]< t[j]["moyenne"] alors indice_max<-j Fin si Fin pour # Échange si un meilleur candidat est trouve Si (indice_max!=i) alors temp<-t[i] t[i]<-t[indice_max] t[indice_max]<-temp Fin si Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| indice_max | entier |
La procédure remplir_fichier_resultat
Ce procédure sert à enregistrer dans un fichier binaire (resultat.dat) les n premiers éléments du tableau t.
Elle :
1- ouvre un fichier binaire nommé resultat.dat en écriture ("wb").
2- parcourt les n premiers éléments du tableau t.
3- écrit chaque élément dans le fichier.
4- ferme le fichier à la fin pour sauvegarder les données.
|
1 2 3 4 5 6 7 |
Procédure remplir_fichier_resultat(t:tableau;n:entier) Ouvrir("resultat.dat", f_resultats , "wb") # Fichier binaire pour résultats triés Pour i de 0 à n-1 faire Ecrire(f_resultats,t[i]) # Sauvegarde de chaque candidat trié Fin pour Fermer(f_resultats) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_resultats | fichier du resultat.dat |
| i | entier |
La fonction recherche_nbr_admis
Cette fonction sert à compter le nombre d’admis dans un tableau t contenant des enregistrements (dictionnaires).
Un candidat est considéré "admis" lorsque la valeur du champ indiqué par champs est supérieure ou égale à 10.
|
1 2 3 4 5 6 7 8 |
Fonction recherche_nbr_admis(t:tableau,n:entier,champs:chaine) : entier nbr_admis<-0 Pour i de 0 à n-1 faire Si t[i][champs]>=10 alors nbr_admis<-nbr_admis+1 Fin si Fin pour retourner nbr_admis |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| nbr_admis | entier |
La fonction recherche_max_note
Cette fonction sert à chercher la note maximale dans un tableau t contenant des enregistrements (dictionnaires), en se basant sur un champ précis (exemple : "note1", "note2", …).
Elle :
1- suppose d’abord que le maximum est la valeur du champ champ du 1er élément → t[0][champ].
2- parcourt le tableau du 2ᵉ élément jusqu’au n-ième.
3- chaque fois qu’il trouve une valeur plus grande, il met à jour max_nombre.
4- à la fin, il retourne la plus grande valeur trouvée.
|
1 2 3 4 5 6 7 |
Procédure recherche_max_note(t:tableau, n:entier, champ:chaine):entier max_nombre <- t[0][champ] # On suppose que le premier est le maximum Pour i de 1 à n-1 faire Si max_nombre < t[i][champ] alors max_nombre <- t[i][champ] Fin si retourner max_nombre |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| max_nombre | entier |
| i | entier |
La procédure remplir_fichier_details
Le programme sert à créer un fichier texte (details.txt) contenant des statistiques calculées à partir des données des candidats.
Il extrait plusieurs informations importantes à partir du tableau t :
- max_moyenne → le nombre de candidats ayant une moyenne ≥ 10
- max_note1 → la note maximale obtenue dans la matière 1.
- nbr_note1 → le nombre de candidats ayant une note1 ≥ 10.
- max_note2 → la note maximale de la matière 2.
- nbr_note2 → le nombre de candidats ayant une note2 ≥ 10.
- max_note3 → la note maximale de la matière 3.
- nbr_note3 → le nombre de candidats ayant une note3 ≥ 10.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Procédure remplir_fichier_details(t:tableau;n:entier) Ouvrir("resultat.dat", f_details , "w") # Fichier texte pour les statistiques # Calcul des différentes statistiques max_moyenne <- recherche_nbr_admis(t, n, "moyenne") max_note1 <- recherche_max_note(t, n, "note1") nbr_note1 <- recherche_nbr_admis(t, n, "note1") max_note2 <- recherche_max_note(t, n, "note2") nbr_note2 <- recherche_nbr_admis(t, n, "note2") max_note3 <- recherche_max_note(t, n, "note3") nbr_note3 <- recherche_nbr_admis(t, n, "note3") # Écriture des résultats dans le fichier texte Ecrire(f_details , Convch(max_moyenne) + '\n') Ecrire(f_details , Convch(max_note1) + ' ' + Conch(nbr_note1) +'\n') Ecrire(f_details , Convch(max_note2) + ' ' + Conch(nbr_note2) +'\n') Ecrire(f_details , Convch(max_note3) + ' ' + Conch(nbr_note3) +'\n') Fermer(f_details) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_details | fichier du details.txt |
| max_moyenne | entier |
| max_note1 | entier |
| nbr_note1 | entier |
| max_note2 | entier |
| nbr_note2 | entier |
| max_note3 | entier |
| nbr_note3 | entier |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
import pickle from pickle import load, dump from numpy import * # Définition d'un dictionnaire modèle pour un candidat candidat = dict ( numero = int(), nom = str(), prenon = str(), matiere1 = str(), note1 = float, matiere2 = str(), note2 = float, matiere3 = str(), note3 = float ) # Tableau pouvant contenir jusqu'à 50 dictionnaires de candidats t = array([{}]*50) # Fonction pour saisir un nombre n strictement positif def saisie(): n = int(input('donner n > 0: ')) # Vérification que n est correct while (n <= 0): n = int(input('donner n > 0: ')) return n # Procedure pour remplir le fichier concours.dat avec les informations des candidats def remplir_fichier_concours(n): f_candidats = open("concours.dat", "wb") # Ouverture du fichier en mode binaire écriture for i in range(n): # Création d'un dictionnaire vide pour un candidat candidat = dict ( numero = int(), nom = str(), prenon = str(), matiere1 = str(), note1 = float, matiere2 = str(), note2 = float, matiere3 = str(), note3 = float ) # Saisie des informations du candidat candidat["numero"] = int(input('donner le numero du candidat: ')) candidat["nom"] = input('donner le nom du candidat: ') candidat["prenom"] = input('donner le prenom du candidat: ') candidat["matiere1"] = input('donner le nom de matiere1: ') candidat["note1"] = float(input('donner note1: ')) candidat["matiere2"] = input('donner le nom de matiere2: ') candidat["note2"] = float(input('donner note2: ')) candidat["matiere3"] = input('donner le nom de matiere3: ') candidat["note3"] = float(input('donner note3: ')) # Enregistrement du candidat dans le tableau local t t[i] = candidat # Calcul de la moyenne pondérée t[i]["moyenne"] = ((candidat["note1"] + 2*candidat["note2"] + 2*candidat["note1"]) / 5) # Attribution d’un rang provisoire (sera modifié après tri) t[i]["rang"] = i + 1 # Écriture du candidat dans le fichier concours.dat dump(candidat, f_candidats) f_candidats.close() # Fermeture du fichier # Procedure pour trier le tableau t selon la moyenne (ordre décroissant) def tri_decroissant_tableau(t, n): for i in range(n-1): indice_max = i # Recherche de la plus grande moyenne dans la partie restante du tableau for j in range(i+1, n): if t[indice_max]["moyenne"] < t[j]["moyenne"]: indice_max = j # Échange si un meilleur candidat est trouvé if indice_max != i: temp = t[i] t[i] = t[indice_max] t[indice_max] = temp # Procedure pour créer le fichier resultat.dat contenant les candidats triés def remplir_fichier_resultat(t, n): f_resultats = open("resultat.dat", "wb") # Fichier binaire pour résultats triés for i in range(n): dump(t[i], f_resultats) # Sauvegarde de chaque candidat trié f_resultats.close() # Fonction pour compter combien de candidats ont une note >= 10 dans un champ donné def recherche_nbr_admis(t, n, champs): nbr_admis = 0 for i in range(n): if t[i][champs] >= 10: nbr_admis += 1 return nbr_admis # Fonction pour trouver la note maximale dans un champ donné def recherche_max_note(t, n, champ): max_nombre = t[0][champ] # On suppose que le premier est le maximum for i in range(1, n): if max_nombre < t[i][champ]: max_nombre = t[i][champ] return max_nombre # Procedure qui crée un fichier texte contenant les statistiques finales def remplir_fichier_details(t, n): f_details = open("details.txt", "w") # Fichier texte pour les statistiques # Calcul des différentes statistiques max_moyenne = recherche_nbr_admis(t, n, "moyenne") max_note1 = recherche_max_note(t, n, "note1") nbr_note1 = recherche_nbr_admis(t, n, "note1") max_note2 = recherche_max_note(t, n, "note2") nbr_note2 = recherche_nbr_admis(t, n, "note2") max_note3 = recherche_max_note(t, n, "note3") nbr_note3 = recherche_nbr_admis(t, n, "note3") # Écriture des résultats dans le fichier texte f_details.write(str(max_moyenne) + '\n') f_details.write(str(max_note1) + ' ' + str(nbr_note1) + '\n') f_details.write(str(max_note2) + ' ' + str(nbr_note2) + '\n') f_details.write(str(max_note3) + ' ' + str(nbr_note3) + '\n') f_details.close() # ======================= # Programme principal # ======================= n = saisie() # Saisie du nombre de candidats remplir_fichier_concours(n) # Enregistrement des candidats dans concours.dat tri_decroissant_tableau(t, n) # Tri du tableau t par moyenne décroissante remplir_fichier_resultat(t, n) # Sauvegarde des candidats triés dans resultat.dat remplir_fichier_details(t, n) # Génération du fichier de statistiques |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
