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
Ce programme demande un nombre n (entre 10 et 100), saisit n nombres naturels (< 3200), puis sépare ces nombres en deux fichiers selon qu’ils possèdent ou non un nombre égal de zéros et de uns dans leur écriture binaire.
En résumé ce programme :
1- saisit contrôlée d'un nombre n
2- saisit de n entiers naturels (< 3200) et les écrit dans un fichier
3- fait la conversion en binaire
4- teste : autant de ‘0’ que de ‘1’ ?
5- Classifit dans deux fichiers : rond.dat et non_rond.dat
Dans cet algorithme, On va utiliser trois fonctions et deux procédures :
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme conversion_nombres Debut n <- saisie() # Saisie d'un nombre n (10 < n < 100) remplir_fichier_nombres(n) # Remplir le fichier "naturels.dat" avec n valeurs < 3200 remplir_fichiers_ronds() # Classer les nombres dans rond.dat et non_rond.dat Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisir
Cette fonction saisit et retourne un entier entre 10 et 100.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie(): entier Ecrire('donner n telque 10<n<100: ') lire (n) # Tant que n n'est pas dans l'intervalle demandé, on redemande Tant que (n <= 10) ou (n >= 100) 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 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
