Nombre brésilien – Bac théorique – Section informatique – 2022

Bac Info 19-01-26

23 0

Sujet (Algo et programmation - Bac 2022)

Un nombre décimal n est dit brésilien s’il possède, dans une base B (avec 2 ≤ B ≤ n – 2), une représentation qui s’écrit sous la forme de p chiffres égaux, c’est-à-dire :

Exemples :

- 7 est un nombre brésilien car 7 = (111)2

- 3124 est un nombre brésilien car 3124 = (44444)5

- 1170 est un nombre brésilien car 1170 = (2222)8

- 20 est un nombre brésilien car 20 = (22)9

- 204 est un nombre brésilien car 204 = (CC)16

- 9 n'est pas un nombre brésilien car 9 = (1001)2 = (100)3 = (21)4 = (14)5 = (13)6 = (12)7 et aucune de ces écritures n’est brésilienne.

On se propose d’écrire un algorithme d’une procédure Gen_Bres qui permet de créer et de remplir un fichier d’enregistrements nommé "F_Brésilien.dat" par les nombres brésiliens contenus dans un fichier texte existant nommé "Nombres.txt", sachant que chaque ligne du fichier texte "Nombres.txt" contient un nombre décimal et chaque enregistrement du fichier "F_Brésilien.dat" comportera les champs suivants :

- N : Le nombre décimal.

- B : Une base dans laquelle le nombre N s’écrit sous la forme de p chiffres égaux avec 2 ≤ B ≤ 16. - Rep : La représentation du nombre décimal N dans la base B.

Travail demandé :

1. Analyser le problème en le décomposant en modules.

2. Ecrire les algorithmes des modules envisagés.

Solution Algorithmique

Dans cet algorithme, On va utiliser quatre fonctions et deux procédures :

- la fonction saisie()

- la fonction conversion_base()

- la fonction test_bresilien()

- la fonction recherche_base()

- la procédure remplir_fichier_nombres()

- la procédure remplir_fichier_bresilien()

Algorithme du programme Principal

Algorithme nombres_présilien
Debut 
      n <- saisie()                     # Saisie de la borne supérieure
      remplir_fichier_nombres(n)       # Création du fichier des nombres brésiliens
      remplir_fichier_bresilien()      # Création du fichier binaire
Fin

Algorithme nombres_présilien

Debut

n <- saisie() # Saisie de la borne supérieure

remplir_fichier_nombres(n) # Création du fichier des nombres brésiliens

remplir_fichier_bresilien() # Création du fichier binaire

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction saisie()

La fonction saisie() sert à demander à l’utilisateur de saisir un entier valide n supérieur ou égal à 2, puis à vérifier cette saisie avant de la retourner.

Fonction saisie(longueur:entier):entier
     # Demande à l'utilisateur de saisir un entier n
     Ecrire('donner n >= 2 : ')
     Lire(n)
    # Vérification de la validité de la saisie
    # Tant que n est inférieur à 2, on redemande la saisie
    Tant que Non (n >= 2) faire
       Ecrire('donner n >= 2 : ') 
       Lire(n)
    Fin tant que
    # Retourne la valeur valide de n
    retourner n  
 Fin

Fonction saisie(longueur:entier):entier

# Demande à l'utilisateur de saisir un entier n

Ecrire('donner n >= 2 : ')

Lire(n)

# Vérification de la validité de la saisie

# Tant que n est inférieur à 2, on redemande la saisie

Tant que Non (n >= 2) faire

Ecrire('donner n >= 2 : ')

Lire(n)

Fin tant que

# Retourne la valeur valide de n

retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction conversion_base

La fonction conversion_base(n, b) sert à convertir un nombre décimal n en sa représentation dans une base b, avec 2 ≤ b ≤ 16, puis à retourner cette représentation sous forme de chaîne de caractères.

Fonction conversion_base(n:entier, b:entier):chaîne
    ch <- ""                               # Chaîne résultat
    chiffres <- "0123456789ABCDEF"         # Symboles des chiffres possibles

    # Conversion par divisions successives
    Tant que n > 0 faire
        reste <- n mod b                     # Calcul du reste
        ch <- chiffres[reste] + ch         # Ajout du chiffre correspondant
        n <- n div b                        # Division entière

    retourner ch

Fin

Fonction conversion_base(n:entier, b:entier):chaîne

ch <- "" # Chaîne résultat

chiffres <- "0123456789ABCDEF" # Symboles des chiffres possibles

# Conversion par divisions successives

Tant que n > 0 faire

reste <- n mod b # Calcul du reste

ch <- chiffres[reste] + ch # Ajout du chiffre correspondant

n <- n div b # Division entière

retourner ch

Fin

Déclaration des objets

Objet	Type / Nature
ch	entier
chiffres	entier
reste	entier

La fonction test_unicite_chiffres

La fonction test_unicite_chiffres(nombre) sert à vérifier si tous les chiffres d’un nombre, représenté sous forme de chaîne, sont identiques.

Fonction test_unicite_chiffres(nombre:chaine):booleen
    # Si la représentation contient plus d’un chiffre
    Si long(nombre) != 1 alors
        i <- 0
        # Vérifier l’égalité des chiffres successifs
        Tant que (i < long(nombre) - 2) et (nombre[i] = nombre[i + 1]) faire
            i <- i + 1
        Fin tant que
        retourner (nombre[i] = nombre[i + 1])
    Sinon
        retourner Faux
    Fin si
Fin

Fonction test_unicite_chiffres(nombre:chaine):booleen

# Si la représentation contient plus d’un chiffre

Si long(nombre) != 1 alors

i <- 0

# Vérifier l’égalité des chiffres successifs

Tant que (i < long(nombre) - 2) et (nombre[i] = nombre[i + 1]) faire

i <- i + 1

Fin tant que

retourner (nombre[i] = nombre[i + 1])

Sinon

retourner Faux

Fin si

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La fonction test_bresilien

La fonction test_bresilien(n) vérifie si un nombre n est brésilien, c’est-à-dire s’il existe une base entre 2 et 16 dans laquelle tous ses chiffres sont identiques.

Fonction test_bresilien(n:entier):booleen
    b <- 2                                 # Base initiale
    nombre <- conversion_base(n, b)        # Conversion du nombre

    # Recherche d’une base donnant des chiffres identiques
    Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire
        b <- b + 1
        nombre <- conversion_base(n, b)
    Fin tant que
    retourner test_unicite_chiffres(nombre)

Fin

Fonction test_bresilien(n:entier):booleen

b <- 2 # Base initiale

nombre <- conversion_base(n, b) # Conversion du nombre

# Recherche d’une base donnant des chiffres identiques

Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire

b <- b + 1

nombre <- conversion_base(n, b)

Fin tant que

retourner test_unicite_chiffres(nombre)

Fin

Déclaration des objets

Objet	Type / Nature
b	entier
nombre	chaîne

La fonction recherche_base

La fonction recherche_base(n) sert à déterminer la base (entre 2 et 16) dans laquelle un nombre décimal n devient un nombre brésilien, c’est-à-dire une base où tous ses chiffres sont identiques.

Fonction recherche_base(n:entier):entier
    b <- 2                                 # Base initiale
    nombre <- conversion_base(n, b)        # Conversion du nombre

    # Recherche d’une base donnant des chiffres identiques
    Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire
        b <- b + 1
        nombre <- conversion_base(n, b)
    Fin tant que
    retourner b

Fin

Fonction recherche_base(n:entier):entier

b <- 2 # Base initiale

nombre <- conversion_base(n, b) # Conversion du nombre

# Recherche d’une base donnant des chiffres identiques

Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire

b <- b + 1

nombre <- conversion_base(n, b)

Fin tant que

retourner b

Fin

Déclaration des objets

Objet	Type / Nature
b	entier
nombre	chaîne

La procédure remplir_fichier_nombres

La procédure remplir_fichier_nombres(n) sert à créer un fichier texte "Nombres.txt" contenant tous les nombres brésiliens compris entre 2 et n.

Procedure remplir_fichier_nombres(n:entier)
    # Ouverture du fichier en écriture texte
    Ouvrir(f , "Nombres.txt", "w")

    # Parcours des nombres
    Pour i de 2 à n faire
        Si test_bresilien(i) alors
            Ecrire(f , Convch(i) + '\n')
        Fin si
    Fin pour  
    # Fermeture du fichier
    Fermer(f)
Fin

Procedure remplir_fichier_nombres(n:entier)

# Ouverture du fichier en écriture texte

Ouvrir(f , "Nombres.txt", "w")

# Parcours des nombres

Pour i de 2 à n faire

Si test_bresilien(i) alors

Ecrire(f , Convch(i) + '\n')

Fin si

Fin pour

# Fermeture du fichier

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
i	entier

La procédure remplir_fichier_bresilien

La procédure remplir_fichier_nombres(n) sert à créer un fichier texte "Nombres.txt" contenant tous les nombres brésiliens compris entre 2 et n.

Procedure remplir_fichier_bresilien()
    Ecrire("*** Contenu du fichier F_Brésilien.dat ***")

    # Ouverture des fichiers
    Ouvrir(f_nombres , "Nombres.txt", "r")
    Ouvrir(f_bresilien , "F_Brésilien.dat", "wb")

    # Lecture des nombres brésiliens
    nombres <- f_nombres.readlines()

    Pour nombre_f dans nombres faire
        nombre_f <- nombre_f.strip('\n')
        n <- Valeur(nombre_f)
        b <- 2
        nombre = conversion_base(n, b)

        # Recherche de la base brésilienne
        Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire
            b <- b + 1
            nombre <- conversion_base(n, b)
        Fin tant que
        # Affichage à l’écran
        Ecrire('N =', nombre_f, ' B =', b, ' Rep =', nombre)

        # Remplissage de l’enregistrement
        enregistrement_bresilien['N'] <- n
        enregistrement_bresilien['B'] <- b
        enregistrement_bresilien['Rep'] <- nombre

        # Écriture dans le fichier binaire
        Ecrire(f_bresilien,enregistrement_bresilien)
    Fin pour
    # Fermeture des fichiers
    Fermer(f_nombres)
    Fermerf_bresilien)
Fin

Procedure remplir_fichier_bresilien()

Ecrire("*** Contenu du fichier F_Brésilien.dat ***")

# Ouverture des fichiers

Ouvrir(f_nombres , "Nombres.txt", "r")

Ouvrir(f_bresilien , "F_Brésilien.dat", "wb")

# Lecture des nombres brésiliens

nombres <- f_nombres.readlines()

Pour nombre_f dans nombres faire

nombre_f <- nombre_f.strip('\n')

n <- Valeur(nombre_f)

b <- 2

nombre = conversion_base(n, b)

# Recherche de la base brésilienne

Tant que Non(test_unicite_chiffres(nombre)) et (b < 16) faire

b <- b + 1

nombre <- conversion_base(n, b)

Fin tant que

# Affichage à l’écran

Ecrire('N =', nombre_f, ' B =', b, ' Rep =', nombre)

# Remplissage de l’enregistrement

enregistrement_bresilien['N'] <- n

enregistrement_bresilien['B'] <- b

enregistrement_bresilien['Rep'] <- nombre

# Écriture dans le fichier binaire

Ecrire(f_bresilien,enregistrement_bresilien)

Fin pour

# Fermeture des fichiers

Fermer(f_nombres)

Fermerf_bresilien)

Fin

Déclaration des objets

Objet	Type / Nature
f_nombres	fichier
f_bresilien	fichier
nombres	chaîne
nombre_f	chaîne
n	entier
b	entier
nombre	chaîne
enregistrement_bresilien	Enregistrement

Solution en Python

import pickle
from pickle import load, dump

# --------------------------------------------------
# Définition d’un enregistrement pour un nombre brésilien
# N   : le nombre décimal
# B   : la base dans laquelle le nombre est brésilien
# Rep : la représentation du nombre dans la base B
# --------------------------------------------------
enregistrement_bresilien = dict(
    N = int(),    # Nombre décimal
    B = str(),    # Base de conversion
    Rep = str()   # Représentation dans la base
)

# --------------------------------------------------
# Fonction de saisie d’un entier n (n >= 2)
# --------------------------------------------------
def saisie():
    # Demande à l'utilisateur de saisir un entier n
    n = int(input('donner n >= 2 : '))

    # Vérification de la validité de la saisie
    # Tant que n est inférieur à 2, on redemande la saisie
    while not (n >= 2):
        n = int(input('donner n >= 2 : '))

    # Retourne la valeur valide
    return n


# --------------------------------------------------
# Fonction qui convertit un nombre décimal n
# dans une base b (2 ≤ b ≤ 16)
# --------------------------------------------------
def conversion_base(n, b):
    ch = ""                               # Chaîne résultat
    chiffres = "0123456789ABCDEF"         # Symboles des chiffres possibles

    # Conversion par divisions successives
    while n > 0:
        reste = n % b                     # Calcul du reste
        ch = chiffres[reste] + ch         # Ajout du chiffre correspondant
        n = n // b                        # Division entière

    return ch


# --------------------------------------------------
# Fonction qui teste si tous les chiffres d’un nombre
# sont identiques (exemple : 111 ou AAA)
# --------------------------------------------------
def test_unicite_chiffres(nombre):
    # Si la représentation contient plus d’un chiffre
    if len(nombre) != 1:
        i = 0

        # Vérifier l’égalité des chiffres successifs
        while (i < len(nombre) - 2) and (nombre[i] == nombre[i + 1]):
            i = i + 1

        return (nombre[i] == nombre[i + 1])
    else:
        return False


# --------------------------------------------------
# Fonction qui teste si un nombre n est brésilien
# --------------------------------------------------
def test_bresilien(n):
    b = 2                                 # Base initiale
    nombre = conversion_base(n, b)        # Conversion du nombre

    # Recherche d’une base donnant des chiffres identiques
    while not(test_unicite_chiffres(nombre)) and (b < 16):
        b = b + 1
        nombre = conversion_base(n, b)

    return test_unicite_chiffres(nombre)


# --------------------------------------------------
# Fonction qui retourne la base dans laquelle
# le nombre n est brésilien
# --------------------------------------------------
def recherche_base(n):
    b = 2
    nombre = conversion_base(n, b)

    while not(test_unicite_chiffres(nombre)) and (b < 16):
        b = b + 1
        nombre = conversion_base(n, b)

    return b


# --------------------------------------------------
# Procédure qui écrit dans le fichier "Nombres.txt"
# tous les nombres brésiliens compris entre 2 et n-1
# --------------------------------------------------
def remplir_fichier_nombres(n):
    # Ouverture du fichier en écriture texte
    f = open("Nombres.txt", "w")

    # Parcours des nombres
    for i in range(2, n+1):
        if test_bresilien(i):
            f.write(str(i) + '\n')

    # Fermeture du fichier
    f.close()


# --------------------------------------------------
# Procédure qui crée le fichier binaire
# "F_Brésilien.dat" contenant les informations
# des nombres brésiliens
# --------------------------------------------------
def remplir_fichier_bresilien():
    print("*** Contenu du fichier F_Brésilien.dat ***")

    # Ouverture des fichiers
    f_nombres = open("Nombres.txt", "r")
    f_bresilien = open("F_Brésilien.dat", "wb")

    # Lecture des nombres brésiliens
    nombres = f_nombres.readlines()

    for nombre_f in nombres:
        nombre_f = nombre_f.strip('\n')
        n = int(nombre_f)
        b = 2
        nombre = conversion_base(n, b)

        # Recherche de la base brésilienne
        while not(test_unicite_chiffres(nombre)) and (b < 16):
            b = b + 1
            nombre = conversion_base(n, b)

            # Affichage à l’écran
        print('N =', nombre_f, ' B =', b, ' Rep =', nombre)

        # Remplissage de l’enregistrement
        enregistrement_bresilien['N'] = n
        enregistrement_bresilien['B'] = b
        enregistrement_bresilien['Rep'] = nombre

        # Écriture dans le fichier binaire
        dump(enregistrement_bresilien, f_bresilien)

    # Fermeture des fichiers
    f_nombres.close()
    f_bresilien.close()


# --------------------------------------------------
# Programme principal
# --------------------------------------------------
n = saisie()                     # Saisie de la borne supérieure
remplir_fichier_nombres(n)       # Création du fichier des nombres brésiliens
remplir_fichier_bresilien()      # Création du fichier binaire

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

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

import pickle

from pickle import load, dump

# --------------------------------------------------

# Définition d’un enregistrement pour un nombre brésilien

# N : le nombre décimal

# B : la base dans laquelle le nombre est brésilien

# Rep : la représentation du nombre dans la base B

# --------------------------------------------------

enregistrement_bresilien = dict(

N = int(), # Nombre décimal

B = str(), # Base de conversion

Rep = str() # Représentation dans la base

)

# --------------------------------------------------

# Fonction de saisie d’un entier n (n >= 2)

# --------------------------------------------------

def saisie():

# Demande à l'utilisateur de saisir un entier n

n = int(input('donner n >= 2 : '))

# Vérification de la validité de la saisie

# Tant que n est inférieur à 2, on redemande la saisie

while not (n >= 2):

n = int(input('donner n >= 2 : '))

# Retourne la valeur valide

return n

# --------------------------------------------------

# Fonction qui convertit un nombre décimal n

# dans une base b (2 ≤ b ≤ 16)

# --------------------------------------------------

def conversion_base(n, b):

ch = "" # Chaîne résultat

chiffres = "0123456789ABCDEF" # Symboles des chiffres possibles

# Conversion par divisions successives

while n > 0:

reste = n % b # Calcul du reste

ch = chiffres[reste] + ch # Ajout du chiffre correspondant

n = n // b # Division entière

return ch

# --------------------------------------------------

# Fonction qui teste si tous les chiffres d’un nombre

# sont identiques (exemple : 111 ou AAA)

# --------------------------------------------------

def test_unicite_chiffres(nombre):

# Si la représentation contient plus d’un chiffre

if len(nombre) != 1:

i = 0

# Vérifier l’égalité des chiffres successifs

while (i < len(nombre) - 2) and (nombre[i] == nombre[i + 1]):

i = i + 1

return (nombre[i] == nombre[i + 1])

else:

return False

# --------------------------------------------------

# Fonction qui teste si un nombre n est brésilien

# --------------------------------------------------

def test_bresilien(n):

b = 2 # Base initiale

nombre = conversion_base(n, b) # Conversion du nombre

# Recherche d’une base donnant des chiffres identiques

while not(test_unicite_chiffres(nombre)) and (b < 16):

b = b + 1

nombre = conversion_base(n, b)

return test_unicite_chiffres(nombre)

# --------------------------------------------------

# Fonction qui retourne la base dans laquelle

# le nombre n est brésilien

# --------------------------------------------------

def recherche_base(n):

b = 2

nombre = conversion_base(n, b)

while not(test_unicite_chiffres(nombre)) and (b < 16):

b = b + 1

nombre = conversion_base(n, b)

return b

# --------------------------------------------------

# Procédure qui écrit dans le fichier "Nombres.txt"

# tous les nombres brésiliens compris entre 2 et n-1

# --------------------------------------------------

def remplir_fichier_nombres(n):

# Ouverture du fichier en écriture texte

f = open("Nombres.txt", "w")

# Parcours des nombres

for i in range(2, n+1):

if test_bresilien(i):

f.write(str(i) + '\n')

# Fermeture du fichier

f.close()

# --------------------------------------------------

# Procédure qui crée le fichier binaire

# "F_Brésilien.dat" contenant les informations

# des nombres brésiliens

# --------------------------------------------------

def remplir_fichier_bresilien():

print("*** Contenu du fichier F_Brésilien.dat ***")

# Ouverture des fichiers

f_nombres = open("Nombres.txt", "r")

f_bresilien = open("F_Brésilien.dat", "wb")

# Lecture des nombres brésiliens

nombres = f_nombres.readlines()

for nombre_f in nombres:

nombre_f = nombre_f.strip('\n')

n = int(nombre_f)

b = 2

nombre = conversion_base(n, b)

# Recherche de la base brésilienne

while not(test_unicite_chiffres(nombre)) and (b < 16):

b = b + 1

nombre = conversion_base(n, b)

# Affichage à l’écran

print('N =', nombre_f, ' B =', b, ' Rep =', nombre)

# Remplissage de l’enregistrement

enregistrement_bresilien['N'] = n

enregistrement_bresilien['B'] = b

enregistrement_bresilien['Rep'] = nombre

# Écriture dans le fichier binaire

dump(enregistrement_bresilien, f_bresilien)

# Fermeture des fichiers

f_nombres.close()

f_bresilien.close()

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

n = saisie() # Saisie de la borne supérieure

remplir_fichier_nombres(n) # Création du fichier des nombres brésiliens

remplir_fichier_bresilien() # Création du fichier binaire

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Nombre brésilien – Bac théorique – Section informatique – 2022

Bac Info 19-01-26

Problème matrice – Bac théorique – Section informatique – 2022

Bac Info 19-01-26

Clients gagnants – Bac pratique – Section informatique – 2022

Bac Info 16-01-26

Code de recharge téléphonique – Bac pratique – Section informatique – 2022

Bac Info 16-01-26

Jeu Dominos – Bac théorique – Section informatique – 2021

Bac Info 16-01-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 10982vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 10541vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9321vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 8919vues

Allumer une LED par la carte ESP32

ESP32 8913vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 23 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Nombre brésilien – Bac théorique – Section informatique – 2022

Sujet (Algo et programmation - Bac 2022)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisie()

La fonction conversion_base

La fonction test_unicite_chiffres

La fonction test_bresilien

La fonction recherche_base

La procédure remplir_fichier_nombres

La procédure remplir_fichier_bresilien

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles