Facteurs premiers – Bac pratique – Section informatique – 2012
Sujet (Algo et programmation - Bac 2012)
A partir d'un fichier nommé "Nombres.dat" contenant N entiers, formé chacun de P chiffres, on veut former un deuxième fichier nommé "Facteurs.txt" qui contiendra, des chaînes. Chaque chaîne représente la concaténation de la fréquence de chacun des facteurs premiers d'un nombre du fichier "Nombres.dat" suivi du facteur premier lui même.
Exemple :
Pour N = 3 et P = 4 :
En effet :
a) 1912 = 2 *2 *2 *239
La chaîne générée sera "321239" pour dire que 3 est la fréquence du facteur premier 2 et 1 est la fréquence du facteur premier 239.
b) 3525 = 3 * 5 * 5 * 47
La chaîne générée sera "1325147" pour dire que 1 est la fréquence du facteur premier 3, 2 est la fréquence du facteur premier 5 et 1 est la fréquence du facteur premier 47.
Travail à faire :
Ecrire un programme Pascal et l'enregistrer sous le nom FactPrem, permettant :
1- de remplir un fichier nommé "Nombres.dat" par N entiers, formés de P chiffres (avec 2 < N < 100 et 2 < P < 6),
2- de créer, pour chaque entier du fichier "Nombres.dat", une chaîne représentant la concaténation de la fréquence de chacun de ses facteurs premiers suivi du facteur premier lui-même et l'enregistrer dans une ligne d'un fichier texte nommé "Facteurs.txt",
3- d'afficher le contenu du fichier "Facteurs.txt".
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et deux procédures:
- la fonction saisie()
- la fonction saisie_nombre()
- la procédure remplir_fichier_nombres()
- la fonction facteur_premiers()
- la procédure remplir_fichier_facteurs()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 |
Algorithme facteurs Debut # Saisie du nombre de valeurs à traiter n <- saisie(2, 100) # Remplissage du fichier des nombres remplir_fichier_nombres(n) # Calcul et enregistrement des facteurs premiers remplir_fichier_facteurs(n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Cette fonction permet de saisir un entier n compris strictement entre deux bornes inf et sup.
👉 Plus précisément :
Elle demande à l’utilisateur de saisir une valeur entière n.
Elle vérifie que n appartient à l’intervalle ]inf , sup[.
Tant que la valeur saisie est inférieure ou égale à inf ou supérieure ou égale à sup, la saisie est redemandée.
Lorsque la valeur est correcte, la fonction la retourne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie(inf:entier ; sup:entier):entier # Première saisie de l'entier Ecrire('donner n tel que ' , inf , '< n < ' , sup , ': ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <= inf) ou (n >= sup) faire Ecrire('donner n tel que ' , inf , '< n < ' , sup , ': ') 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 saisie_nombre
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 |
Fonction saisie_nombre(): entier Ecrire('donner un nombre forme au maximum de 6 chiffres: ') Lire(nombre) # Vérification de la longueur de la chaîne Tant que (long(nombre) < 2) ou (long(nombre) > 6) faire Ecrire('donner un nombre forme au maximum de 6 chiffres: ') Lire(nombre) Fin tant que retourner nombre Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| nombre | 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
