Clients gagnants – Bac pratique – Section informatique – 2022
Sujet (Algo et programmation - Bac 2022)
Soient "Clients.dat" et "Chance.txt" deux fichiers contenant respectivement les informations de p clients et n chiffres.
Chaque enregistrement du fichier "Clients.dat" se compose de deux champs :
- Identifiant : une chaîne de 10 chiffres qui désigne l'identifiant d'un client.
- NTel : une chaîne de 8 chiffres qui désigne le numéro de téléphone d'un client.
On se propose de déterminer le(s) client(s) gagnant(s), sachant qu'un client est déclaré gagnant si le chiffre de chance CC de son numéro de téléphone existe dans le fichier "Chance.txt".
Un chiffre de chance CC relative â un numéro de téléphone est calculé en additionnant de façon répétitive
tous les chiffres du numéro de téléphone jusqu'à obtenir un seul chiffre.
Exemple
Pour p = 4, n = 6 et les fichiers "Clients.dat" et "Chance.txt" suivants :
Les clients gagnants sont :
Identifiant : 0001998810 — N° Téléphone : 65405003
Identifiant 0001466877 N° Téléphone : 80617081
En effet,
- Le CC du client ayant l'identifiant 0001998810 a été obtenu en additionnat les chiffres de son numéro de télephione jusqu'à obtenir un seul chiffre c'est à dire 6+5+4+0+5+0+0+3 = 23 4 2+3 =5. Le chiffre 5 figure dans le fichier "Chance.txt", donc c'est un client gagnant.
- Le CC du client ayant l'identifiant 0005432179 est 4+9+4+5+6+2+4+1=35 4 34-5=8. Le chiffre 8 ne figure pas dans le fichier "Chance.txt".
- Le CC du client ayant l'identifiant 0001466877 est 8+0+6+1+7+0+8+1=31 4 3+1=4. Le chiffre 4 figure dans le fichier "Chance.txt", donc c'est un client gagnant.
- Le CC du client ayant l'identifiant 0000247855 est 0+9+5+6+2+4+4+4=34 4 3+4=7. Le chiffre 7 ne figure pas dans le fichier "Chance.txtu.
Travail demandé :
1- En utilisant l'éditeur de texte disponible (Bloc-notes, Notepad, Notepad-H-, ...), créer un fichier texte nommé "Chance.txt" et y saisir les chiffres du fichier mentionnés dans l'exemple précédent.
2- Ecrire un programme en Python intitulé Jeu qui permet de remplir un fichier "Clients.dat" par l'identifiant et le numéro de téléphone de p
NB :
L'identifiant d'un client est une chaîne de 10 Le numéro de téléphone d'un client est une chaîne de 8 chiffres.
p est un entier de l'intervalle [14,101] choisi aléatoirement. - Le candidat n'est pas appelé à tester l'unicité de l'identifiant.
3- d'afficher l'identifiant et le numéro de téléphone de chaque client gagnant.
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_code
Le rôle de la fonction verif_code est de vérifier si une chaîne de caractères ch est composée exactement de longueur chiffres.
|
1 2 3 4 5 6 7 8 9 10 11 |
Fonction verif_code(ch:chaine;longueur:entier):booleen Si long(ch) = longueur alors i <- 0 # Vérifier que tous les caractères sont des chiffres Tant que (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()
Le rôle de la fonction saisie est de permettre à l’utilisateur de saisir une chaîne de chiffres d’une longueur spécifiée 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(longueur:entier):entier # Saisie initiale du code Ecrire('donner un code forme de ',longueur,' chiffres : ') Lire(ch) # Répéter tant que la saisie est invalide Tant que Non(verif_code(ch, longueur)) faire Ecrire('donner un code forme de ',longueur,' chiffres : ') Lire(ch) Fin tant que # Retourner la valeur valide retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichier_client
Cette procédure saisit les informations de plusieurs clients et les enregistre dans un fichier binaire.
|
1 2 3 4 5 6 7 8 9 10 11 |
Procédure remplir_fichier_client(p:entier) Ecrire('*** Remplir le fichier Clients.dat ***') Ouvrir(f_clients , "Clients.dat" , "wb") # Ouverture du fichier en écriture binaire Pour i de 0 à p-1 faire # Saisie des informations du client client['identifiant'] <- saisie(10) # Identifiant à 10 chiffres client['telephone'] <- saisie(8) # Téléphone à 8 chiffres Ecrire(f_clients,client) # Sauvegarde de l'enregistrement dans le fichier Fin pour Fermer(f_clients) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_clients | fichier |
| i | entier |
| client | Enregistrement |
La fonctionsomme_chiffres
Cette fonction calcule la somme des chiffres d’un code jusqu’à obtenir un seul chiffre.
|
1 2 3 4 5 6 7 8 9 |
Fonction somme_chiffres(code:chaine):entier Tant que long(code) != 1 faire somme <- 0 Pour i de 0 à long(code)-1 faire somme <- somme + Valeur(code[i]) Fin pour code <- str(somme) # Transformation en chaîne pour recommencer si nécessaire retourner code Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| somme | entier |
| i | entier |
La procédure afficher_gagnants()
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 |
Procédure afficher_gagnants(): 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
