Code de recharge téléphonique – Bac pratique – Section informatique – 2022
Sujet (Algo et programmation - Bac 2022)
Pour recharger une ligne téléphonique portable, un client gratte le panneau grisé de la carte de recharge pour découvrir le code de recharge à 13 chiffres, puis compose un code ayant la forme suivante :
*xxx*code de recharge#
On supposera qu'un code de recharge est valide lorsqu'il vérifie les contraintes suivantes :
1 II est composé de 13 chiffres. H-
✓ Le nombre composé des trois premiers chiffres du code de recharge, en commençant de gauche à droite, r est un nombre premier.
1 L'équivalent binaire du nombre composé des cinq chiffres suivants contient plus que huit zéros.
1 Le nombre composé des cinq chiffres restants est divisible par le nombre formé par les trois premiers ) , chiffres.
Exemple : 2114512367731 est un code de recharge valide.
Travail demandé
1) En utilisant l'éditeur de texte disponible (Bloc-notes, Notepad, Notepad+±, ...), créer un fichier texte nommé "Codes.txt" et y saisir les codes de recharge suivants :
2) Ecrire un programme Python et l'enregistrer sous le nom VerifCode qui permet :
- de saisir un code de recharge composé uniquement de 13 chiffres,
- d'afficher le message :
"Code non valide" dans le cas où le code de recharge saisi ne vérifie pas au moins une des contraintes décrites précédemment.
Ou
"Code déjà utilisé" dans le cas où le code de recharge saisi est valide et ne figure pas dans le fichier "Codes.txt", sachant que ce fichier contient les codes de recharge non encore utilisés.
Ou
"Code Valide" dans le cas où le code de recharge saisi est valide et figure dans le fichier "Codes.txt".
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et une procédure :
- la fonction verif_saisie()
- la fonction saisie_code()
- la fonction test_premier()
- la fonction convertir_binaire()
- la fonction verif_code()
- la procédure valider_code()
Algorithme du programme Principal
|
1 2 3 4 5 |
Algorithme VerifCode Debut code <- saisie_code() valider_code(code) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| code | chaîne |
La fonction verif_saisie
Le rôle de la fonction verif_saisie est de vérifier si une chaîne de caractères ch est composée exactement de 13 chiffres.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction verif_saisie(ch:chaine):booleen # Vérifier que la longueur de la chaîne est 13 Si long(ch) = 13 faire i <- 0 # Vérifier que tous les caractères sont des chiffres Tantque (i < long(ch)-1) et ('0' <= ch[i] <= '9') faire i <- i + 1 Fin tant que retourner ('0' <= ch[i] <= '9') Sinon retourner Faux Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_code
Le rôle de la fonction saisie_code est de permettre à l’utilisateur de saisir un code composé de 13 chiffres et de s’assurer que la saisie est valide.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie_code():chaîne # Saisie initiale du code Ecrire('donner un code forme de 13 chiffres : ') Lire(ch) # Répéter la saisie tant que le code n'est pas valide Tant que Non (verif_saisie(ch)) faire Ecrire('donner un code forme de 13 chiffres : ') Lire(ch) Fin tant que # Retourner le code valide retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La fonction test_premier
Cette fonction vérifie si un nombre donné est premier.
|
1 2 3 4 5 6 7 8 |
Fonction test_premier(n:entier):booleen i <- 2 # Tester la divisibilité de n par les entiers de 2 à n//2 Tant que (i < n div 2) et(n mod i != 0) faire i <- i + 1 # Retourner Vrai si n est premier retourner (n mod i != 0) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction convertir_binaire
Le rôle de la fonction convertir_binaire est convertir un nombre entier décimal n en sa représentation binaire sous forme de chaîne de caractères.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction convertir_binaire(n:entier):chaîne binaire <- '' # Conversion par divisions successives par 2 Tant que n > 0 faire reste <- n mod 2 # Calcul du reste (0 ou 1) binaire <- Convch(reste) + binaire # Ajout du bit en tête n <- n div 2 # Division entière par 2 Fin tant que return binaire Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaîne |
| reste | chaîne |
La fonction test_binaire_zeros
Le rôle de la fonction test_binaire_zeros est de vérifier si la représentation binaire d’un nombre n contient exactement 10 zéros.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction test_binaire_zeros(n:entier):booleen binaire <- convertir_binaire(n) cp <- 0 # Compteur de zéros i <- 0 # Parcours de la chaîne binaire Tant que (i < long(binaire)-1) et (cp < 10) faire Si binaire[i] = '0' alors cp <- cp + 1 Fin si i <- i + 1 Fin tant que # Retourner True si le nombre de zéros est égal à 10 retourner cp = 10 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaîne |
| cp | entier |
| i | entier |
La fonction verif_code
Cette fonction contrôle qu’un code à 13 chiffres respecte les critères de validité définis.
|
1 2 3 4 5 6 7 8 9 |
Fonction verif_code(code:chaîne):booleen # Découpage du code en trois parties partie1 <- Valeur(Sous_chaine(code, 0 , 3)) partie2 <- Valeur(Sous_chaine(code, 3 , 8)) partie3 <- Valeur(Sous_chaine(code, 8 , 3)) # Vérification des trois conditions retourner (test_premier(partie1) et test_binaire_zeros(partie2) et (partie3 div partie1 = 0)) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| partie1 | entier |
| partie2 | entier |
| partie3 | entier |
La procédure valider_code
Le rôle de la procédure valider_code est de vérifier qu’un code est valide selon les règles définies et qu’il n’a pas déjà été utilisé, puis afficher le résultat.
|
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 valider_code(code:chaîne) Si verif_code(code) alors # Ouverture du fichier Codes.txt en lecture Ouvrir (f_codes , "Codes.txt", "r") # Lecture de la première ligne code_fichier <- Lire_ligne(f_codes) code_fichier <- code_fichier.strip('\n') test <- Faux # Indicateur de présence du code # Parcours du fichier pour vérifier l'unicité du code Tant que (code_fichier != '') et (test = Faux): Si code_fichier = code: test <- Vrai code_fichier <- Lier_ligne(f_codes) code_fichier <- code_fichier.strip('\n') Fin tant que # Affichage du résultat Si test = Vrai alors Ecrire('Code valide') Sinon Ecrire('Code deja utilise') Fin si Fermer(f_codes) Sinon Ecrire('Code non valide') Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_codes | fichier |
| code_fichier | chaîne |
| test | booleen |
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 vérifie si la chaîne ch est composée # exactement de 13 chiffres # -------------------------------------------------- def verif_saisie(ch): # Vérifier que la longueur de la chaîne est 13 if len(ch) == 13: i = 0 # Vérifier que tous les caractères sont des chiffres while (i < len(ch) - 1) and ('0' <= ch[i] <= '9'): i = i + 1 return ('0' <= ch[i] <= '9') else: return False # -------------------------------------------------- # Fonction qui permet de saisir un code valide # composé de 13 chiffres # -------------------------------------------------- def saisie_code(): # Saisie initiale du code ch = input('donner un code forme de 13 chiffres : ') # Répéter la saisie tant que le code n'est pas valide while not verif_saisie(ch): ch = input('donner un code forme de 13 chiffres : ') # Retourner le code valide return ch # -------------------------------------------------- # Fonction qui teste si un nombre n est premier # -------------------------------------------------- def test_premier(n): i = 2 # Tester la divisibilité de n par les entiers de 2 à n//2 while i < n // 2 and (n % i != 0): i = i + 1 # Retourner True si n est premier return (n % i != 0) # -------------------------------------------------- # Fonction qui convertit un nombre décimal en binaire # -------------------------------------------------- def convertir_binaire(n): binaire = '' # Conversion par divisions successives par 2 while n > 0: reste = n % 2 # Calcul du reste (0 ou 1) binaire = str(reste) + binaire # Ajout du bit en tête n = n // 2 # Division entière par 2 return binaire # -------------------------------------------------- # Fonction qui vérifie si la représentation binaire # du nombre n contient exactement 10 zéros # -------------------------------------------------- def test_binaire_zeros(n): binaire = convertir_binaire(n) cp = 0 # Compteur de zéros i = 0 # Parcours de la chaîne binaire while (i < len(binaire) - 1) and (cp < 10): if binaire[i] == '0': cp = cp + 1 i = i + 1 # Retourner True si le nombre de zéros est égal à 10 return cp == 10 # -------------------------------------------------- # Fonction qui vérifie la validité du code # -------------------------------------------------- def verif_code(code): # Découpage du code en trois parties partie1 = int(code[0:3]) partie2 = int(code[3:8]) partie3 = int(code[8:13]) # Vérification des trois conditions return (test_premier(partie1) and test_binaire_zeros(partie2) and (partie3 % partie1 == 0)) # -------------------------------------------------- # Procédure qui valide le code : # - vérifie sa structure et ses conditions # - vérifie qu'il n'est pas déjà utilisé # -------------------------------------------------- def valider_code(code): if verif_code(code): # Ouverture du fichier Codes.txt en lecture f_codes = open("Codes.txt", "r") # Lecture de la première ligne code_fichier = f_codes.readline() code_fichier = code_fichier.strip('\n') test = False # Indicateur de présence du code # Parcours du fichier pour vérifier l'unicité du code while (code_fichier != '') and (test == False): if code_fichier == code: test = True code_fichier = f_codes.readline() code_fichier = code_fichier.strip('\n') # Affichage du résultat if test == True: print('Code valide') else: print('Code deja utilise') f_codes.close() else: print('Code non valide') # -------------------------------------------------- # Programme principal # -------------------------------------------------- code = saisie_code() valider_code(code) |
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
