Pistolet de FURY – Bac théorique – Section informatique – 2025
Sujet (Algo et programmation - Bac 2025)
Le pistolet de FUR Y génère des impulsions successives dont l'intensité, exprimée en valeurs entières, varie selon une loi mathématique. Pour calculer le cycle de l'intensité de l'impulsion, il suffit de suivre le procédé suivant :
Etape 1 : Convertir en binaire l'intensité de l'impulsion émise (l'entier de départ).
Etape 2 : Inverser les chiffres de ce nombre binaire (miroir du nombre binaire).
Etape 3 : Convertir en base 10 le nombre binaire obtenu à l'étape 2, puis lui ajouter
Répéter les trois étapes précédentes jusqu'à ce que l'intensité de l'impulsion émise devienne périodique c'est-à-dire que le résultat retourné par l'étape 3 soit l'entier de départ.
Exemple :
Si le pistolet est réglé sur 39 (intensité de l'impulsion initiale) alors, lors d'un tir, les impulsions émises auront pour intensité :
D'où, on constate que pour le réglage 39, les intensités sont périodiques et les valeurs 39, 59, 57, 41 se répètent indéfiniment 
. Pour le réglage 39, la période est donc 4.
Pour certaines valeurs, l'intensité n'est jamais périodique. Le comportement du pistolet devient alors imprévisible et peut s'exploser après un changement d'intensité de plus de 1024 fois.
Afin d'améliorer le pistolet de FURY, il convient de ne permettre que les réglages des valeurs de départ qui donnent lieu à un comportement périodique.
On se propose de simuler le fonctionnement du pistolet de FURY afin de générer, sur la racine du disque C, un fichier d'enregistrement "Amplitude.dat" contenant les cycles périodiques associés à des valeurs de départ de l'intensité de l'impulsion. Ces valeurs de départ sont préalablement stockées dans un fichier texte "Depart.txt", déjà rempli et enregistré sous la racine du disque C à raison d'un entier par ligne.
Chaque enregistrement du fichier "Amplitucle.dat" est formé par les champs suivants :
Cycle : une chaîne de caractères qui contient les intensités des impulsions ayant abouti à un
cycle périodique, où chaque paire d'intensités est séparée par le caractère "e.
Periode : un entier naturel qui représente le nombre d'impulsions du cycle périodique.
MB : Si l'entier de départ n'aboutit pas à un cycle périodique après 1024 changements d'intensité, on arrête la vérification pour cet entier.
Exemple :
Pour le réglage de départ 39 :
- le champ Cycle = "39#59#57#41"
- le champ Periode = 4
Travail demandé :
1- Ecrire les instructions d'ouverture des deux fichiers "Depart.txt" et "Amplitude.dat" sachant que les noms logiques des deux fichiers sont respectivement Fd et
2- Ecrire un algorithme d'une procédure FURY(Fd, Fa) qui permet de générer le fichier d'enregistrements Fa à partir des valeurs de départ de l'intensité de l'impulsion stockées dans le fichier texte Fd en respectant le procédé décrit précédemment.
NB : Le candidat est appelé à déclarer les nouveaux types nécessaires pour le fichier Fa.
Solution Algorithmique
Dans cet algorithme, On va utiliser quatre fonctions et deux procédures :
- la fonction saisie()
- la fonction decimal_vers_binaire()
- la fonction inverser_binaire()
- la fonction binaire_vers_decimal()
- la procédure remplir_fichier_depart()
- la procédure fury()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 |
Algorithme pistolet_fury Debut n <- saisie() # Saisie du nombre d'entiers à générer remplir_fichier_depart(n) # Création du fichier "Depart.txt" Ecrire('*** Contenu du fichier Amplitude.dat ***') fury("Depart.txt", "Amplitude.dat") # Calcul et enregistrement des cycles Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Cette fonction permet de saisir et retourner un entier > 0 en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie():entier # Demande à l'utilisateur de saisir un entier n > 0 Ecrire('donner un entier > 0: ')) Lire(n) # Vérification de la validité de la saisie Tant que Non (n > 0) faire Ecrire('donner un entier > 0: ')) Lire(n) Fin tant que # Retourne la valeur valide saisie par l'utilisateur retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction decimal_vers_binaire
Le rôle de la fonction decimal_vers_binaire est de convertir un entier décimal en sa représentation binaire sous forme de chaîne de caractères.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction decimal_vers_binaire(n:entier):chaine binaire <- "" # Tant que n > 0, on calcule le reste de la division par 2 # et on le concatène à gauche de la chaîne binaire Tant que n > 0 faire binaire <- Convch(n mod 2) + binaire n <- n div 2 Fin tant que retourner binaire Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaîne |
La fonction inverser_binaire
Le rôle de la fonction inverser_binaire est de renverser une chaîne de caractères représentant un nombre binaire, c’est-à-dire que le premier bit devient le dernier et le dernier devient le premier.
|
1 2 3 4 5 6 7 8 |
Fonction inverser_binaire(binaire:chaine):chaine binaire_inverse <- '' # Parcours de la chaîne de droite à gauche Pour i de long(binaire)-1 à 0 (pas=-1) faire binaire_inverse <- binaire_inverse + binaire[i] Fin pour retourner binaire_inverse Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire_inverse | chaîne |
| i | entier |
La fonction binaire_vers_decimal
Le rôle de la fonction binaire_vers_decimal est de convertir une chaîne représentant un nombre binaire en son équivalent entier décimal.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction binaire_vers_decimal(binaire:chaine):entier decimal <- 0 puissance <- 0 # Parcours du binaire de droite à gauche Pour i de long(binaire)-1 à 0 (pas=-1) faire decimal = decimal + Valeur(binaire[i]) * (2 ** puissance) puissance = puissance + 1 Fin pour retourner decimal Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| decimal | entier |
| puissance | entier |
| i | entier |
La procédure remplir_fichier_depart
Le rôle de la procédure remplir_fichier_depart est de créer et remplir un fichier texte nommé "Depart.txt" avec les nombres entiers de 0 à n‑1, un nombre par ligne.
|
1 2 3 4 5 6 7 |
Procédure remplir_fichier_depart(n:entier) Ouvrir(f , "Depart.txt", "w") # Ouverture du fichier en écriture Pout i de 0 à n-1 faire Ecrire(f , Convch(i)+'\n') # Écriture de chaque entier sur une ligne Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
La procédure fury
Le rôle de la procédure fury est de calculer pour chaque entier d’un fichier de départ un “cycle” de transformations binaires et sa période, puis de sauvegarder ces résultats dans un fichier binaire.
|
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 |
Procédure fury(fd:chaine, fa:chaine) Ouvrir(f_depart , fd, "r") # Ouvre le fichier des nombres de départ Ouvrir(f_amplitude , fa, "wb") # Ouvre le fichier pour enregistrer les résultats en binaire nombres <- Lire_lignes(f_depart) # Lecture de toutes les lignes Pour nombre dans nombres faire n <- Valeur(nombre.strip('\n')) # Conversion de la ligne en entier # Première transformation : décimal -> binaire -> inversé -> décimal binaire <- decimal_vers_binaire(n) binaire_inverse <- inverser_binaire(binaire) n2 <- binaire_vers_decimal(binaire_inverse) n2 <- n2 + 2 # Ajustement selon l'algorithme cycle <- Convch(n) # Initialisation du cycle avec le nombre de départ periode <- 0 # Initialisation de la période # Boucle pour calculer le cycle jusqu'à ce que le nombre se stabilise Tant que n!=n2 et periode<1024 faire cycle <- cycle + '#' + Convch(n2) # Ajout du nouveau nombre au cycle periode <- periode + 1 # Incrémentation de la période binaire <- decimal_vers_binaire(n2) binaire_inverse <- inverser_binaire(binaire) n2 <- binaire_vers_decimal(binaire_inverse) n2 <- n2 + 2 Fin tant que # Si le cycle est terminé (stabilisé) Si n = n2 alors amplitude['cycle'] <- cycle # Stockage du cycle complet amplitude['periode'] <- periode # Stockage de la période Ecrire(f_amplitude, amplitude) # Écriture de l'objet dans le fichier binaire Ecrire(amplitude) Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_depart | fichier |
| f_amplitude | fichier |
| nombres | chaîne |
| nombre | chaîne |
| n | entier |
| binaire | chaîne |
| binaire_inverse | chaîne |
| n1 | entier |
| n2 | entier |
| cycle | chaîne |
| periode | entier |
| amplitude | enregistrement |
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 |
from pickle import load, dump # Import des fonctions pour sérialiser (dump) et désérialiser (load) des objets Python # -------------------------------------------------- # Enregistrement pour stocker les informations # d'un cycle : la suite des nombres (cycle) et sa période # -------------------------------------------------- amplitude = dict( cycle=str(), # Chaîne représentant le cycle des nombres periode=int() # Nombre entier représentant la période ) # -------------------------------------------------- # Fonction pour saisir un entier positif # -------------------------------------------------- def saisie(): # Première saisie de l'utilisateur n = int(input('donner un entier > 0: ')) # Vérification que l'entier est strictement positif while not (n > 0): n = int(input('donner un entier > 0: ')) # Retourne la valeur valide return n # -------------------------------------------------- # Fonction qui convertit un entier décimal en binaire # -------------------------------------------------- def decimal_vers_binaire(n): binaire = "" # Tant que n > 0, on calcule le reste de la division par 2 # et on le concatène à gauche de la chaîne binaire while n > 0: binaire = str(n % 2) + binaire n = n // 2 return binaire # -------------------------------------------------- # Fonction qui inverse une chaîne binaire # -------------------------------------------------- def inverser_binaire(binaire): binaire_inverse = '' # Parcours de la chaîne de droite à gauche for i in range(len(binaire) - 1, -1, -1): binaire_inverse = binaire_inverse + binaire[i] return binaire_inverse # -------------------------------------------------- # Fonction qui convertit une chaîne binaire en entier décimal # -------------------------------------------------- def binaire_vers_decimal(binaire): decimal = 0 puissance = 0 # Parcours du binaire de droite à gauche for i in range(len(binaire) - 1, -1, -1): decimal += int(binaire[i]) * (2 ** puissance) puissance += 1 return decimal # -------------------------------------------------- # Procédure qui remplit un fichier texte "Depart.txt" # avec les entiers de 0 à n-1 # -------------------------------------------------- def remplir_fichier_depart(n): f = open("Depart.txt", "w") # Ouverture du fichier en écriture for i in range(n): f.write(str(i) + '\n') # Écriture de chaque entier sur une ligne f.close() # Fermeture du fichier # -------------------------------------------------- # Procédure principale "fury" qui calcule les cycles et périodes # -------------------------------------------------- def fury(fd, fa): f_depart = open(fd, "r") # Ouvre le fichier des nombres de départ f_amplitude = open(fa, "wb") # Ouvre le fichier pour enregistrer les résultats en binaire nombres = f_depart.readlines() # Lecture de toutes les lignes for nombre in nombres: n = int(nombre.strip('\n')) # Conversion de la ligne en entier # Première transformation : décimal -> binaire -> inversé -> décimal binaire = decimal_vers_binaire(n) binaire_inverse = inverser_binaire(binaire) n2 = binaire_vers_decimal(binaire_inverse) n2 = n2 + 2 # Ajustement selon l'algorithme cycle = str(n) # Initialisation du cycle avec le nombre de départ periode = 0 # Initialisation de la période # Boucle pour calculer le cycle jusqu'à ce que le nombre se stabilise while n != n2 and periode < 1024: cycle = cycle + '#' + str(n2) # Ajout du nouveau nombre au cycle periode = periode + 1 # Incrémentation de la période binaire = decimal_vers_binaire(n2) binaire_inverse = inverser_binaire(binaire) n2 = binaire_vers_decimal(binaire_inverse) n2 = n2 + 2 # Si le cycle est terminé (stabilisé) if n == n2: amplitude['cycle'] = cycle # Stockage du cycle complet amplitude['periode'] = periode # Stockage de la période dump(amplitude, f_amplitude) # Écriture de l'objet dans le fichier binaire print(amplitude) # Affichage à l'écran pour vérification # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie() # Saisie du nombre d'entiers à générer remplir_fichier_depart(n) # Création du fichier "Depart.txt" print('*** Contenu du fichier Amplitude.dat ***') fury("Depart.txt", "Amplitude.dat") # Calcul et enregistrement des cycles |
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
