Nombre Fort – Bac théorique – Section informatique – 2026
Sujet (Algo et programmation - Bac 2026)
Ecrire un algorithme d'un module NbreFortr(N) qui permet de créer et de remplir un fichier d'enregistrements nommé "NF.dat" par tous les nombres forts de l'intervalle [10..N] et tel que la somme de leurs facteurs premiers distincts soit inférieure ou égales à 16. Chaque enregistrement du fichier est composé des champs suivants:
Nbre: le nombre fort écrit dans la base décimale.
Base: la base b (la somme des facteurs premiers distincts de Nbre)
NB:
- On dispose d'une fonction SommeFacteurs(K) qui retourne la somme des facteurs premiers distincts d'un entier K que le candidat peuut l'utiliser sans la déveleopper.
- La création du fichier "NF.dat" dans le dossier "D:\Travail", ainsi que sa fermeture, doivent être effectuées dans le module NbreFort.
Solution Algorithmique
Dans cet algorithme, On va utiliser huit fonctions et deux procédures :
- la fonction saisie_n()
- la fonction sommefacteurs()
- la fonction somme_chiffres()
- la fonction test_nombre_fort()
- la procédure NbrFort()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 |
Algorithme nbr_fort Debut # Saisie de n n = saisie_n() # Recherche et stockage des nombres forts NbrFort(n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie_n
Cette fonction permet de saisir et retourner un entier >10 en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_n():entier Ecrire('saisir n>10: ') Lire(n) # Tant que la valeur saisie n’est pas valide, on redemande Tant que Non (n>10) faire Ecrire('saisir n>10: ') Lire(n) Fin tant que retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction sommefacteurs
La fonction sommefacteurs(k) permet de calculer la somme des facteurs premiers distincts de k.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Fonction sommefacteurs(k:entier):entier s <- 0 # somme des facteurs i <- 2 # diviseur testé j <- 0 # mémorise le dernier facteur ajouté # Parcours des diviseurs possibles Tant que i <= k div 2: Si k mod i = 0 alors # Vérifie que le facteur n'est pas déjà ajouté Si i != j alors s <- s + i j <- i Fin si # Réduction de k par division k <- k div i Sinon i <- i + 1 Fin si Fin tant que retourner s Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| s | entier |
| i | entier |
| j | entier |
La fonction somme_chiffres
La fonction somme_chiffres(ch) permet de calculer la somme des chiffres d’un nombre représenté en base 16 (hexadécimal).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction somme_chiffre(ch:chaine):entier s <- 0 # somme des valeurs des chiffres # Parcours de la chaîne Pour i de 0 à long(ch)-1 faire # Si c'est un chiffre décimal Si '0' <= ch[i] <= '9' alors s <- s + Valeur(ch[i]) # Si c'est une lettre hexadécimale (A à F) Sinon 'A' <= ch[i] <= 'F': s <- s + (ord(ch[i]) - 55) Fin si return s Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| s | entier |
| i | entier |
La fonction test_nombre_fort
La fonction test_nombre_fort(n, b) permet de vérifier si un nombre n devient un “nombre fort” dans une base b, c’est-à-dire si la somme de ses chiffres dans cette base est égale à la base elle-même.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction test_nombre_fort(n:entier, b:entier) : booléen # Ensemble des chiffres en base 16 chiffres <- "0123456789ABCDEF" resultat <- "" # Conversion de n dans la base b Tant que n > 0 faire reste <- n mod b resultat <- chiffres[reste] + resultat n <- n div b Fin tant que # Vérifie si la somme des chiffres = base b retourner somme_chiffres(resultat) = b Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| chiffres | chaîne des caractères |
| resultat | chaîne des cartactères |
La procédure NbrFort
Le rôle de la procédure NbrFort(n) est parcourir tous les entiers de 10 à n, rechercher les nombres forts, afficher chacun d'eux avec sa base associée, puis enregistrer ces informations dans un fichier binaire nommé NF.dat.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
Procédure NbrFort(n:entier) # Ouverture du fichier binaire Ouvrir("NF.dat",f, "wb") # Parcours des nombres de 10 à n Pour i de 10 à n faire # Calcul de la base associée b <- sommefacteurs(i) # Vérifie que la base est valide Si 2 <= b <= 16 alors # Test si le nombre est "fort" Si test_nombre_fort(i, b): # Affichage du résultat Ecrire(i, ' ', b) # Stockage dans le dictionnaire enregistrement['n'] <- i enregistrement['b'] <- b # Sauvegarde dans le fichier Ecrire(f , enregistrement) # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier binaire |
| i | entier |
| b | entier |
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 112 113 114 115 116 117 118 119 120 121 122 123 124 |
# Importation des fonctions load et dump du module pickle # dump : permet d'enregistrer des données dans un fichier binaire # load : permet de lire des données depuis un fichier binaire from pickle import load, dump # Création d'un dictionnaire représentant un enregistrement # contenant un nombre n et sa base b enregistrement = dict( n=int(), b=int() ) # ------------------------------------------------------- # Fonction de saisie d'un entier strictement supérieur à 10 # ------------------------------------------------------- def saisie_n(): n = int(input('saisir n > 10: ')) while n <= 10: n = int(input('saisir n > 10: ')) return n # ------------------------------------------------------- # Fonction qui calcule la somme des facteurs premiers # distincts d'un entier k # ------------------------------------------------------- def sommefacteurs(k): s = 0 # Somme des facteurs i = 2 # Premier diviseur à tester j = 0 # Dernier facteur ajouté while i <= k // 2: if k % i == 0: # Ajouter le facteur seulement s'il n'a pas été ajouté if i != j: s = s + i j = i # Supprimer ce facteur de k k = k // i else: # Passer au diviseur suivant i = i + 1 return s # ------------------------------------------------------- # Fonction qui calcule la somme des chiffres d'un nombre # représenté sous forme de chaîne en base 16 maximum # ------------------------------------------------------- def somme_chiffres(ch): s = 0 for i in range(len(ch)): # Si le caractère est un chiffre de 0 à 9 if '0' <= ch[i] <= '9': s = s + int(ch[i]) # Si le caractère est une lettre de A à F elif 'A' <= ch[i] <= 'F': s = s + (ord(ch[i]) - 55) return s # ------------------------------------------------------- # Fonction qui convertit un nombre décimal en base b # puis vérifie si la somme de ses chiffres est égale à b # ------------------------------------------------------- def test_nombre_fort(n, b): # Ensemble des symboles utilisés pour les bases jusqu'à 16 chiffres = "0123456789ABCDEF" resultat = "" # Conversion du nombre n en base b while n > 0: reste = n % b resultat = chiffres[reste] + resultat n = n // b # Vérifier si la somme des chiffres obtenus est égale à la base return somme_chiffres(resultat) == b # ------------------------------------------------------- # Recherche des nombres forts entre 10 et n # et enregistrement dans un fichier binaire # ------------------------------------------------------- def NbrFort(n): # Ouverture du fichier en écriture binaire f = open("NF.dat", "wb") # Parcours des entiers de 10 à n for i in range(10, n + 1): # Calcul de la somme des facteurs premiers distincts b = sommefacteurs(i) # La base doit être comprise entre 2 et 16 if 2 <= b <= 16: # Vérification si le nombre est un nombre fort if test_nombre_fort(i, b): # Affichage du nombre et de sa base print(i, ' ', b) # Remplissage de l'enregistrement enregistrement['n'] = i enregistrement['b'] = b # Sauvegarde dans le fichier dump(enregistrement, f) # Fermeture du fichier f.close() # ------------------------------------------------------- # Programme principal # ------------------------------------------------------- # Saisie de la borne supérieure n = saisie_n() # Recherche et enregistrement des nombres forts NbrFort(n) |
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
