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 trois fonctions et deux procédures :
- la fonction verif_code()
- la fonction saisie()
- la procédure remplir_fichier_client()
- la fonction somme_chiffres()
- la procédure afficher_gagnants()
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme jeu Debut p <- Alea(4, 10) # Nombre aléatoire de clients à créer remplir_fichier_client(p) # Remplir le fichier Clients.dat avec ces clients afficher_gagnants() # Vérifier et afficher les clients gagnants Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| p | entier |
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 fonction somme_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 <- Convch(somme) # Transformation en chaîne pour recommencer si nécessaire retourner code Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| somme | entier |
| i | entier |
| code | chaîne |
La procédure afficher_gagnants()
Cette procédure a pour rôle d’identifier et d’afficher les clients gagnants en comparant un nombre calculé à partir de leur numéro de téléphone avec une liste de numéros gagnants enregistrés dans un fichier.
|
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 afficher_gagnants(): Ecrire('Les clients gagnants sont :') Ouvrir(f_clients , "Clients.dat", "rb") # Ouverture du fichier des clients en lecture binaire Tant que Vrai faire Essayez: Ecrire(f_clients , client) # Lire un dictionnaire client somme <- somme_chiffres(client['telephone']) # Calculer le chiffre chance à partir du téléphone # Ouverture du fichier Chance.txt contenant les numéros gagnants Ouvrir(f_chances , "Chance.txt", "r") chance <- f_chances.readline().strip('\n') test <- Faux # Indicateur si le client a gagné # Parcours du fichier des chances pour vérifier si le client est gagnant Tant que (chance != '') et (test == False) faire Si chance = somme alors test <- Vrai Fin si chance <- Lire_ligne(f_chances).strip('\n') Fin tant que # Affichage si le client est gagnant Si test = Vrai alors Ecrire('Identifiant: ' + client['identifiant'] + ' - N° Telephone: ' + client['telephone']) Fin si En cas d'erreur: # Fin du fichier clients Sortir Fin tant que Fermer(f_clients) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_clients | fichier |
| somme | entier |
| f_chances | fichier |
| chance | chaîne |
| test | booléen |
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 |
import pickle from pickle import load, dump import random # -------------------------------------------------- # Dictionnaire représentant un client # Contient deux champs : identifiant et numéro de téléphone # -------------------------------------------------- client = dict( identifiant = str(), telephone = str() ) # -------------------------------------------------- # Fonction qui vérifie si une chaîne ch est composée # exactement de 'longueur' chiffres # -------------------------------------------------- def verif_code(ch, longueur): if len(ch) == longueur: 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 une chaîne de chiffres # de longueur spécifiée et qui contrôle la validité # -------------------------------------------------- def saisie(longueur): # Saisie initiale ch = input('donner un code forme de '+str(longueur)+' chiffres : ') # Répéter tant que la saisie est invalide while not verif_code(ch, longueur): ch = input('donner un code forme de '+str(longueur)+' chiffres : ') # Retourner la valeur valide return ch # -------------------------------------------------- # Procédure qui remplit le fichier Clients.dat # en enregistrant p clients # -------------------------------------------------- def remplir_fichier_client(p): print('*** Remplir le fichier Clients.dat ***') f_clients = open("Clients.dat", "wb") # Ouverture du fichier en écriture binaire for i in range(p): # Saisie des informations du client client['identifiant'] = saisie(10) # Identifiant à 10 chiffres client['telephone'] = saisie(8) # Téléphone à 8 chiffres dump(client, f_clients) # Sauvegarde du dictionnaire dans le fichier f_clients.close() # -------------------------------------------------- # Fonction qui calcule la somme des chiffres d'un code # et répète l’opération jusqu’à obtenir un seul chiffre # -------------------------------------------------- def somme_chiffres(code): while len(code) != 1: somme = 0 for i in range(len(code)): somme = somme + int(code[i]) code = str(somme) # Transformation en chaîne pour recommencer si nécessaire return code # -------------------------------------------------- # Procédure qui affiche les clients gagnants # -------------------------------------------------- def afficher_gagnants(): print('Les clients gagnants sont :') f_clients = open("Clients.dat", "rb") # Ouverture du fichier des clients en lecture binaire while True: try: client = pickle.load(f_clients) # Lire un dictionnaire client somme = somme_chiffres(client['telephone']) # Calculer le chiffre chance à partir du téléphone # Ouverture du fichier Chance.txt contenant les numéros gagnants f_chances = open("Chance.txt", "r") chance = f_chances.readline().strip('\n') test = False # Indicateur si le client a gagné # Parcours du fichier des chances pour vérifier si le client est gagnant while (chance != '') and (test == False): if chance == somme: test = True chance = f_chances.readline().strip('\n') # Affichage si le client est gagnant if test == True: print('Identifiant: ' + client['identifiant'] + ' - N° Telephone: ' + client['telephone']) except EOFError: # Fin du fichier clients break f_clients.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- p = random.randint(4, 10) # Nombre aléatoire de clients à créer remplir_fichier_client(p) # Remplir le fichier Clients.dat avec ces clients afficher_gagnants() # Vérifier et afficher les clients gagnants |
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
