Problème concours – Bac théorique – Section informatique – 2008
Sujet (Algo et programmation - Bac 2008)
Les données relatives es à un concours sont eliregisti éCS 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 quai traite ces données pour produire dieux 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 fonction convertir_binaire
L’objectif de cette fonction est de convertir un nombre décimal (base 10) en binaire (base 2) sans utiliser de fonction Python prête à l’emploi.
Cette fonction permet de :
1) prendre un nombre décimal.
2) lire son dernier bit (reste de la division par 2).
3) ajouter ce bit au début de la chaîne binaire.
4) diviser le nombre par 2.
5) répéter jusqu’à ce que le nombre soit nul.
|
1 2 3 4 5 6 7 8 9 |
fonction convertir_binaire(n:entier):chaine binaire <- '' # Tant qu'il reste une valeur à convertir Tant que n > 0: reste <- n Mod 2 # On récupère le bit (0 ou 1) binaire <- Convch(reste) + binaire # On l’ajoute au début de la chaîne n <- n div 2 # Division entière par 2 Fin tant que retourner binaire |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaine |
| reste | entier |
La fonction compter
Cette fonction compte combien de fois le caractère c (par exemple '0' ou '1') apparaît dans la chaîne binaire.
Plus précisément :
1- Elle parcourt toute la chaîne binaire caractère par caractère.
2- Chaque fois qu’elle trouve le caractère recherché c, elle incrémente un compteur.
3- À la fin, elle retourne le nombre total d'occurrences du caractère.
|
1 2 3 4 5 6 7 8 9 |
Fonction compter(binaire: chaine, c: caratctere) : entier cp <- 0 Pour i de 0 à long(binaire)-1 faire Si binaire[i] = c alors # Si le caractère correspond cp <- cp + 1 # On incrémente le compteur fin si fin pour retourner cp Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| cp | entier |
| i | entier |
La procédure remplir_fichier_nombres
Cette procédure Cette fonction sert à créer un fichier contenant n nombres naturels, chacun strictement inférieur à 3200.
1- Elle ouvre le fichier naturels.dat en écriture, ce qui crée le fichier s'il n'existe pas et efface son contenu s'il existait déjà.
2- Elle demande à l'utilisateur de saisir n entiers naturels.
Pour chaque nombre saisi :
a) la fonction vérifie qu’il est < 3200 b) si ce n’est pas le cas, elle redemande un nombre valide. c) Chaque nombre accepté est écrit dans le fichier, un par ligne. Une fois la saisie terminée, le fichier est fermé correctement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Procédure remplir_fichier_nombres(n:entier): Ouvrir("naturels.dat", f , "w") # Ouverture du fichier en écriture pour i de 0 à n-1 faire écrire('donner un entier naturel<3200') lire(nombre) Tant que nombre >= 3200 faire écrire('donner un entier naturel<3200') lire(nombre) Fin tant que Ecrire(f , nombre + '\n') # Écriture du nombre dans le fichier fin pour fermer(f) fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier du nombre.dat |
| i | entier |
| nombre | chaine |
La procédure remplir_fichiers_ronds
Cette procédure sert à lire tous les nombres enregistrés dans le fichier naturels.dat, puis à les classer dans deux fichiers distincts selon une propriété liée à leur écriture binaire.
1- Cette procédure ouvre naturels.dat et lit tous les nombres qui y sont enregistrés.
2- Pour chaque nombre, elle calcule son écriture binaire grâce à la fonction convertir_binaire().
3- Analyse de la chaîne binaire : Elle compte le nombre de '0' et le nombre de '1'dans la chaîne binaire, .
4- Test du "nombre rond" :
Si le nombre est rond, il est écrit dans : rond.dat
Sinon, il est écrit dans non_rond.dat
5- Tous les fichiers ouverts sont fermés correctement à la fin.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Procédure remplir_fichier_conv():: Ouvrir("naturels.dat", f_nombre , "r") # Fichier contenant les nombres Ouvrir("rond.dat", f_rond , "w") # Fichier qui va contenir les nombres ronds Ouvrir("non_rond.dat", f_non_rond , "w") # Fichier qui va contenir les nombres non ronds Lire ( f_nombre , ch ) # Lecture de toutes les lignes Pour nombre dans ch faire # Parcourir les lignes du fichier nombre.dat # Retirer le caractère '\n' en fin de ligne et convertir en entier binaire <- convertir_binaire(int(nombre.rstrip('\n'))) # Vérifier si le nombre a autant de zéros que de uns en binaire Si compter(binaire, '0') = compter(binaire, '1') alors Ecrire(f_rond,nombre + '\n') # Écriture dans rond.dat Sinon Ecrire(f_non_rond,nombre + '\n') + '\n') # Écriture dans non_rond.dat finsi fin pour fermer(f_nombre) fermer(f_rond) fermer(f_non_rond) fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_nombre | fichier du naturels.dat |
| f_rond | fichier du rond.dat |
| f_non_rond | fichier du non_rond.dat |
| binaire | chaine |
| i | entier |
| nombre | chaine |
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 |
# Fonction pour saisir un nombre n compris entre 10 et 100 def saisie(): n = int(input('donner n telque 10<n<100: ')) # Tant que n n'est pas dans l'intervalle demandé, on redemande la saisie while (n <= 10) or (n >= 100): n = int(input('donner n telque 10<n<100: ')) return n # Fonction pour convertir un nombre décimal en binaire def convertir_binaire(n): binaire = '' # Tant qu'il reste des bits à déterminer while n > 0: reste = n % 2 # Reste de la division → bit (0 ou 1) binaire = str(reste) + binaire # On ajoute le bit au début de la chaîne n = n // 2 # Division entière par 2 return binaire # Fonction qui compte combien de fois un caractère c apparaît dans la chaîne binaire def compter(binaire, c): cp = 0 for i in range(len(binaire)): if binaire[i] == c: # Si le caractère correspond cp = cp + 1 # On incrémente le compteur return cp # Procédure pour remplir un fichier avec n nombres naturels < 3200 def remplir_fichier_nombres(n): f = open("naturels.dat", "w") # Ouverture du fichier en écriture for i in range(n): nombre = input('donner un entier naturel: ') # Vérifier que le nombre est bien < 3200 while int(nombre) >= 3200: nombre = input('donner un entier naturel: ') f.write(nombre + '\n') # Écriture du nombre dans le fichier f.close() # Fermeture du fichier # Procédure pour répartir les nombres en deux fichiers : "rond" et "non_rond" # Un nombre est "rond" si en binaire il possède autant de 0 que de 1 def remplir_fichiers_ronds(): f_nombre = open("naturels.dat", "r") # Fichier des nombres saisis f_rond = open("rond.dat", "w") # Fichier pour les nombres "ronds" f_non_rond = open("non_rond.dat", "w") # Fichier pour les nombres non ronds ch = f_nombre.readlines() # Lecture de tous les nombres for nombre in ch: # Retirer le caractère '\n' en fin de ligne et convertir en entier binaire = convertir_binaire(int(nombre.rstrip('\n'))) # Vérifier si le nombre a autant de zéros que de uns en binaire if compter(binaire, '0') == compter(binaire, '1'): f_rond.write(nombre.rstrip('\n') + '\n') # Écriture dans rond.dat else: f_non_rond.write(nombre.rstrip('\n') + '\n') # Écriture dans non_rond.dat # Fermeture des fichiers f_nombre.close() f_rond.close() f_non_rond.close() # Programme principal n = saisie() # Saisie d'un nombre n (10 < n < 100) remplir_fichier_nombres(n) # Remplir "naturels.dat" avec n valeurs < 3200 remplir_fichiers_ronds() # Classer les nombres dans rond.dat et non_rond.dat |
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
