Entiers ronds – Bac pratique – Section informatique- 2008
Sujet (Algo et programmation - Bac 2008)
Un entier naturel ecrit dans la base 10 est dit rand si, clans son équivalent binaire, on trouve autant de 1 que de 0.
Exemple: le nombre 611 est rand car 611=(1001100011)2 et il y a autant de 1 que de O dans cette écriture en binaire.
On dispose d'un fichier intitule naturels.dat compose d'une suite de nombres entiers naturels écrits dans la base 10. On se propose de remplir a partir de ce fichier deux autres fichiers intitules non_rond.dat et rond.dat comportant respectivement les nombres non ronds et les nombres ronds contenus dans le premier fichier naturels.dat.
Questions:
Ecrire un programme qui crée et remplit le fichier naturels.dat par n entiers naturels inferieurs à 32000 (10 < n <100}. Ensuite, il lit de ce fichier les nombres décimaux, affiche et place les nombres ronds dans le fichier rond.dat et place les autres sans les afficher dans le fichier non_rond.dat.
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
