Conversion nombres – Bac pratique – Section informatique- 2008
Sujet (Algo et programmation - Bac 2008)
On dispose d'un fichier intitulé nombres.dat composé d'une suite de nombres entiers naturels écrits dans la base 10.
On se propose de remplir un deuxième fichier intitulé nbr_conv.dat comportant autant d'enregistrements que de nombres dans le fichier nombres.dat.
Chaque enregistrement est composé de quatre données successives : le nombre décimal pris du premier fichier, son équivalent binaire, son équivalent octal puis son équivalent hexadécimal.
Questions :
Ecrire un programme qui crée et remplit le fichier nombres.dat par n entiers naturels inférieurs à 32000 (5 < n <100).
Ensuite, il lit de ce fichier les nombres décimaux, les convertit dans les bases indiquées ci haut, affiche les résultats de ces conversions puis les met dans le fichier nbr_conv.dat sous forme d'enregistrements.
Solution Algorithmique
Ce programme réalise un mini-système de traitement et conversion de nombres, avec :
✔ Saisie contrôlée
✔ Stockage des valeurs dans un fichier
✔ Conversion en plusieurs bases
✔ Génération d’un second fichier regroupant toutes les conversions
Dans cet algorithme, On va utiliser quatre fonctions et deux procédures :
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme conversion_nombres Debut n <- saisie() # Saisie du nombre n remplir_fichier_nombres(n) # Remplir le fichier avec n valeurs remplir_fichier_conv() # Générer le fichier avec les conversions Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisir
Cette fonction saisit et retourne un entier entre 5 et 100.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie(): entier Ecrire('donner n telque 5<n<100: ') lire (n) # Tant que n n'est pas dans l'intervalle demandé, on redemande Tant que (n <= 5) ou (n >= 100) faire Ecrire('donner n telque 5<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 convertir_octal
Cette fonction a pour rôle de convertir un nombre décimal (base 10) en un nombre octal (base 8) sans utiliser de fonctions Python toutes faites.
Elle applique la méthode mathématique classique de conversion :
1- On divise le nombre par 8 (puisque l’octal est en base 8),
2- On récupère à chaque étape le reste (un chiffre entre 0 et 7),
3- On construit le nombre octal en plaçant chaque nouveau chiffre à gauche,
4- On recommence jusqu’à ce que le nombre devienne 0.
|
1 2 3 4 5 6 7 8 9 |
fonction convertir_octal(n:entier):chaine octal <- '' # Tant qu'il reste une valeur à convertir Tant que n > 0: reste <- n Mod 8 # Calcul du reste en base 8 octal <- Convch(reste) + octal # Ajout du chiffre à gauche n <- n div 8 # Division entière par 8 Fin tant que retourner octal |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| octal | chaine |
| reste | entier |
La fonction convertir_hexadecimal
Cette fonction a pour rôle de convertir un nombre décimal (base 10) en un nombre hexadécimal (base 16) en utilisant la méthode de conversion manuelle.
Comment elle fonctionne ?
1- Elle divise successivement le nombre par 16.
2- À chaque étape, elle récupère le reste, qui correspond à un chiffre hexadécimal.
3- Comme l’hexadécimal utilise 16 symboles (0–9 et A–F), la fonction récupère le bon caractère dans la chaîne :"0123456789ABCDEF"
4- Chaque caractère obtenu est ajouté à gauche pour construire correctement le nombre hexadécimal.
5- La conversion s’arrête lorsque le nombre devient 0.
|
1 2 3 4 5 6 7 8 |
fonction convertir_hexadecimal(n:entier):chaine hexa <- "" caracteres <- "0123456789ABCDEF" # Table des symboles hexadécimaux Tant que n > 0 faire reste <- n lod 16 # Reste en base 16 hexa <- caracteres[reste] + hexa # Ajout du caractère correspondant n <- n div 16 # Division entière par 16 retourner hexa |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| hexa | chaine |
| caracteres | chaine |
| reste | entier |
La procédure remplir_fichier_nombres
Cette procédure sert à saisir plusieurs nombres entiers depuis le clavier et à les enregistrer dans un fichier texte nommé nombre.dat.
Plus précisément, elle réalise les actions suivantes :
- Ouvrir le fichier nombre.dat en mode écriture. Cela crée le fichier ou écrase son contenu s’il existe déjà.
- Demander à l’utilisateur d’entrer n nombres entiers
- Écrire chaque nombre dans le fichier. Chaque nombre est enregistré sur une ligne du fichier.
- Fermer le fichier à la fin
|
1 2 3 4 5 6 7 8 9 |
Procédure remplir_fichier_nombres(n): Ouvrir("nombre.dat", f , "w") # Ouverture du fichier en écriture pour i de 0 à n-1 faire écrire('donner un entier naturel:') lire(nombre) 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_fichier_conv
Cette procédure lit tous les nombres enregistrés dans le fichier nombre.dat, puis pour chaque nombre :
1- Elle convertit le nombre : en binaire, en octal et en hexadécimal.
2- Elle écrit dans un nouveau fichier nbr_conv.dat, sur une même ligne : le nombre en décimal, son équivalent en binaire, son équivalent en octal et son équivalent en hexadécimal
Le tout séparé par des espaces.
3- Elle ferme les deux fichiers à la fin du traitement.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Procédure remplir_fichier_conv():: Ouvrir("nombre.dat", f_nombre , "r") # Fichier contenant les nombres Ouvrir("nbr_conv.dat", f_convnombre , "w") # Nouveau fichier qui va contenir les conversions des nombres Lire ( f_nombre , ch ) # Lecture de toutes les lignes Pour nombre dans ch faire # Parcourir les lignes du fichier nombre.dat # Conversion du nombre et écriture dans le fichier Ecrire(f_convnombre, Convch(Valeur(nombre)) + ' ' + convertir_binaire(Valeur(nombre)) + ' ' + convertir_octal(Valeur(nombre)) + ' ' + convertir_hexadecimal(Valeur(nombre)) + '\n' fin pour fermer(f_nombre) fermer(f_convnombre) fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_nombre | fichier du nombre.dat |
| f_convnombre | fichier du nbr_conv.dat |
| 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 60 61 62 63 64 65 66 67 68 |
# Fonction pour saisir un nombre n compris entre 5 et 100 def saisie(): n = int(input('donner n telque 5<n<100: ')) # Tant que n n'est pas dans l'intervalle demandé, on redemande while (n <= 5) or (n >= 100): n = int(input('donner n telque 5<n<100: ')) return n # Fonction pour convertir un nombre décimal en binaire def convertir_binaire(n): binaire = '' # Tant qu'il reste une valeur à convertir while n > 0: reste = n % 2 # On récupère le bit (0 ou 1) binaire = str(reste) + binaire # On l’ajoute au début de la chaîne n = n // 2 # Division entière par 2 return binaire # Fonction pour convertir un nombre décimal en octal def convertir_octal(n): octal = '' while n > 0: reste = n % 8 # Calcul du reste en base 8 octal = str(reste) + octal # Ajout du chiffre à gauche n = n // 8 # Division entière par 8 return octal # Fonction pour convertir un nombre décimal en hexadécimal def convertir_hexadecimal(n): hexa = "" caracteres = "0123456789ABCDEF" # Table des symboles hexadécimaux while n > 0: reste = n % 16 # Reste en base 16 hexa = caracteres[reste] + hexa # Ajout du caractère correspondant n = n // 16 # Division entière par 16 return hexa # Fonction pour remplir un fichier avec n nombres donnés par l'utilisateur def remplir_fichier_nombres(n): f = open("nombre.dat", "w") # Ouverture du fichier en écriture for i in range(n): nombre = input('donner un entier naturel: ') f.write(nombre + '\n') # Écriture du nombre dans le fichier f.close() # Fermeture du fichier # Fonction pour créer un fichier contenant les conversions def remplir_fichier_conv(): f_nombre = open("nombre.dat", "r") # Fichier contenant les nombres f_convnombre = open("nbr_conv.dat", "w") # Nouveau fichier avec conversions ch = f_nombre.readlines() # Lecture de toutes les lignes for nombre in ch: # Conversion du nombre et écriture dans le fichier f_convnombre.write( str(int(nombre)) + ' ' + convertir_binaire(int(nombre)) + ' ' + convertir_octal(int(nombre)) + ' ' + convertir_hexadecimal(int(nombre)) + '\n' ) f_nombre.close() f_convnombre.close() # Programme principal n = saisie() # Saisie du nombre n remplir_fichier_nombres(n) # Remplir le fichier avec n valeurs remplir_fichier_conv() # Générer le fichier avec les conversions |
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
