Nombre divisible par 11 – Bac pratique – Section informatique – 2011
Sujet (Algo et programmation - Bac 2011)
On se propose d'écrire un programme en Python permettant de :
1- Remplir d'un fichier texte intitulé « txt » contenant par ligne, une chaîne de caractères formée uniquement de chiffres et/ou de lettres.
Pour les chaînes ne contenant aucun chiffre, elles seront représentées dans le fichier « nombres.dat », de la manière suivante :
Nb_Dec contiendra la valeur : 1999999999
Mention contiendra le message : « Ce n'est pas un nombre décimal ».
3- Afficher le contenu du fichier « nombres.dat ».
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et une procédure:
- la fonction saisie_n()
- la fonction verif_ch()
- la fonction saisie_ch()
- la fonction extraire_chiffres()
- la fonction test_divisible11()
- la procédure remplir_fichiers()
Algorithme du programme Principal
|
1 2 3 4 5 |
Algorithme Nombres_divisible11 Debut n = saisie_n() # Saisie du nombre de chaînes à traiter remplir_fichiers(n) # Remplissage des fichiers Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Cette procédure permet de saisir un entier compris strictement entre deux bornes inf et sup, en contrôlant la validité de la saisie.
Plus précisément :
il demande à l’utilisateur d’entrer un entier n tel que 0 < n < 50. si la valeur saisie n’appartient pas à cet intervalle, le programme redemande la saisie jusqu’à obtenir une valeur correcte. une fois la saisie valide, la fonction retourne l’entier n.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie_n():entier # Première saisie de l'entier Ecrire('donner n telque 0<n<50: ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <= 0) ou (n >= 50) faire Ecrire('donner n telque 0<n<50: ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | chaîne |
La fonction verif_ch
Cette fonction verif_ch permet de vérifier si une chaîne de caractères est valide.
Une chaîne est considérée valide si :
sa longueur est comprise entre 1 et 9 caractères ;
elle est composée uniquement de lettres (A à Z, minuscules ou majuscules) et/ou de chiffres (0 à 9).
La fonction retourne Vrai si la chaîne respecte ces conditions, Faux sinon.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction verif_ch(ch:chaine): booleen Si 1 <= long(ch) <= 9 alors # Vérification de la longueur de la chaîne i <- 0 # Vérification caractère par caractère sauf le dernier Tant que (('0' <= ch[i] <= '9') ou ('A' <= Majus(ch[i]) <= 'Z')) et i < long(ch) - 1 faire i <- i + 1 Fin tant que # Vérification du dernier caractère retourner ('0' <= ch[i] <= '9') ou ('A' <= Majus(ch[i]) <= 'Z') Sinon retourner Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_ch
Cette fonction saisie_ch permet de saisir une chaîne de caractères valide composée uniquement de lettres et/ou de chiffres.
Elle demande à l’utilisateur de saisir une chaîne.
Elle vérifie la validité de la chaîne en appelant la fonction verif_ch.
Tant que la chaîne saisie est non valide, la saisie est redemandée.
Lorsque la chaîne est correcte, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_ch(): chaine Ecrire('donner une chaine formee des chiffres et/ou lettres: ') Lire(ch) # Tant que la chaîne n'est pas valide, on redemande la saisie Tant que verif_ch(ch) = Faux faire Ecrire('donner une chaine formee des chiffres et/ou lettres: ') Lire(ch) Fin tant que retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La fonction extraire_chiffres
Ce programme (fonction extraire_chiffres) permet d’extraire uniquement les chiffres d’une chaîne de caractères.
Il parcourt la chaîne caractère par caractère.
Il sélectionne seulement les caractères numériques (de 0 à 9).
Il construit une nouvelle chaîne contenant uniquement ces chiffres.
Il retourne cette chaîne représentant le nombre extrait.
|
1 2 3 4 5 6 7 8 9 |
Fonction extraire_chiffres(ch:chaine): chaine nombre <- '' Pour i de 0 à long(ch)-1 faire Si '0' <= ch[i] <= '9' alors # Si le caractère est un chiffre nombre <- nombre + ch[i] Fin si Fin pour return nombre Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction test_divisible11
Cette fonction permet de calculer et retourner la somme des chiffres d’un nombre représenté sous forme de chaîne de caractères.
Elle parcourt chaque caractère de la chaîne ch, le convertit en entier, puis l’ajoute à une variable somme.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction test_divisible11(nombre:neombre): booleen spair <- 0 # Somme des chiffres de rang pair simpair <- 0 # Somme des chiffres de rang impair Pour i de 0 à long(nombre)-1 faire Si i mod 2 = 0: spair <- spair + Valeur(nombre[i]) Sinon simpair <- simpair + Valeur(nombre[i]) Fin si Fin pour # Le nombre est divisible par 11 si la différence # des deux sommes est un multiple de 11 retourner abs(spair - simpair) % 11 = 0 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| spaire | entier |
| simpaire | entier |
La procédure remplir_fichiers
Cette procédure cherche tous les nombres « rigolos » compris entre m et n et enregistre les résultats dans un fichier texte tout en les affichant à l’écran.
Cette procédure :
1- ouvre le fichier resultat.txt en mode écriture.
2- parcourt tous les entiers entre m et n.
Pour chaque nombre i, teste s’il est rigolo avec les critères ci-dessus.
Si i est rigolo :
Affiche i et sa décomposition en facteurs premiers (avec *) à l’écran.
Écrit cette information dans le fichier.
Si aucun nombre rigolo n’est trouvé, affiche un message correspondant.
3- ferme le fichier.
|
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 |
Procédure remplir_fichier_resultat(n:entier) Ouvrir(f_chaine , "chaines.txt" , "w") # Fichier des chaînes Ouvrir(f_nombre , "nombres.dat", "w") # Fichier des résultats Pour i de 0 à n-1 faire ch <- saisie_ch() # Saisie d'une chaîne valide Ecrire(f_chaine, ch + '\n') # Écriture de la chaîne dans le fichier # Extraction des chiffres de la chaîne Si long(extraire_chiffres(ch)) > 0 alors nombre <- extraire_chiffres(ch) # Test de divisibilité par 11 Si test_divisible11(nombre) alors Ecrire(nombre + ' est divisible par 11') Ecrire(f_nombre,nombre + ' est divisible par 11\n') Sinon Ecrire(nombre + ' n est pas divisible par 11') Ecrire(f_nombre, nombre + ' n est pas divisible par 11\n') Sinon # Cas où la chaîne ne contient aucun chiffre Ecrire('1999999999 n est pas un nombre decimal') Ecrire(f_nombre,'1999999999 n est pas un nombre decimal\n') Fin si Fin pour # Fermeture des fichiers Fermer(f_chaine) Fermer(f_nombre) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_chaine | fichier |
| f_nombre | fichier |
| ch | chaîne |
| nombre | chaîne |
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 |
# -------------------------------------------------- # Fonction qui permet de saisir un entier n tel que 0 < n < 50 # -------------------------------------------------- def saisie_n(): n = int(input('donner n telque 0<n<50: ')) # Tant que n n'est pas compris dans l'intervalle demandé while (n <= 0) or (n >= 50): n = int(input('donner n telque 0<n<50: ')) return n # -------------------------------------------------- # Fonction qui vérifie si une chaîne est formée # uniquement de chiffres et/ou de lettres # et que sa longueur est comprise entre 1 et 9 # -------------------------------------------------- def verif_ch(ch): if 1 <= len(ch) <= 9: # Vérification de la longueur de la chaîne i = 0 # Vérification caractère par caractère sauf le dernier while (('0' <= ch[i] <= '9') or ('A' <= ch[i].upper() <= 'Z')) and i < len(ch) - 1: i = i + 1 # Vérification du dernier caractère return ('0' <= ch[i] <= '9') or ('A' <= ch[i].upper() <= 'Z') else: return False # -------------------------------------------------- # Fonction qui permet de saisir une chaîne valide # (lettres et/ou chiffres uniquement) # -------------------------------------------------- def saisie_ch(): ch = input('donner une chaine formee des chiffres et/ou lettres: ') # Tant que la chaîne n'est pas valide, on redemande la saisie while verif_ch(ch) == False: ch = input('donner une chaine formee des chiffres et/ou lettres: ') return ch # -------------------------------------------------- # Fonction qui extrait uniquement les chiffres # d'une chaîne de caractères # -------------------------------------------------- def extraire_chiffres(ch): nombre = '' for i in range(len(ch)): if '0' <= ch[i] <= '9': # Si le caractère est un chiffre nombre = nombre + ch[i] return nombre # -------------------------------------------------- # Fonction qui teste si un nombre est divisible par 11 # en utilisant la règle de divisibilité par 11 # -------------------------------------------------- def test_divisible11(nombre): spair = 0 # Somme des chiffres de rang pair simpair = 0 # Somme des chiffres de rang impair for i in range(len(nombre)): if i % 2 == 0: spair = spair + int(nombre[i]) else: simpair = simpair + int(nombre[i]) # Le nombre est divisible par 11 si la différence # des deux sommes est un multiple de 11 return abs(spair - simpair) % 11 == 0 # -------------------------------------------------- # Fonction qui remplit deux fichiers : # - chaines.txt : contient les chaînes saisies # - nombres.dat : contient le résultat du test de divisibilité par 11 # -------------------------------------------------- def remplir_fichiers(n): f_chaine = open("chaines.txt", "w") # Fichier des chaînes f_nombre = open("nombres.dat", "w") # Fichier des résultats for i in range(n): ch = saisie_ch() # Saisie d'une chaîne valide f_chaine.write(ch + '\n') # Écriture de la chaîne dans le fichier # Extraction des chiffres de la chaîne if len(extraire_chiffres(ch)) > 0: nombre = extraire_chiffres(ch) # Test de divisibilité par 11 if test_divisible11(nombre): print(nombre + ' est divisible par 11') f_nombre.write(nombre + ' est divisible par 11\n') else: print(nombre + ' n est pas divisible par 11') f_nombre.write(nombre + ' n est pas divisible par 11\n') else: # Cas où la chaîne ne contient aucun chiffre print('1999999999 n est pas un nombre decimal') f_nombre.write('1999999999 n est pas un nombre decimal\n') # Fermeture des fichiers f_chaine.close() f_nombre.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie_n() # Saisie du nombre de chaînes à traiter remplir_fichiers(n) # Remplissage des fichiers |
Exécution du programme
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
