Jeu SMS – Bac théorique – Section informatique – 2010
Sujet (Algo et programmation - Bac 2010)
Pour augmenter l'audience de ses émissions, une chaîne de télévision a organisé un jeu qui consiste à demander à n téléspectateurs de rappeler le classement des quatre pays demi-finalistes de la dernière coupe du monde de football 2006.
Les quatre pays demi-finalistes sont :
L'Allemagne, représentée par la lettre "A"
L'Italie, représentée par la lettre "I"
Le Portugal, représenté par la lettre "P"
La France, représentée par la lettre "F"
Chaque téléspectateur est appelé à envoyer par SMS, sa proposition de classement en mettant les lettres représentant chacun des pays demi-finalistes selon leur classement à la fin de la coupe du monde 2006. Ainsi, le texte d'un SMS n'est considéré valide que s'il contient une chaîne formée exactement des quatre lettres "A", "I", "P" et "F" et que chacune d'elles n'apparaît qu'une seule fois dans cette chaîne.
N.B : le programme doit accepter les lettres majuscules et minuscules.
Exemples :
a) Si le téléspectateur envoie la chaîne "PPIF", son SMS ne sera pas valide car il ne contient pas la lettre "A".
b) Si le téléspectateur envoie la chaîne "APAIF", son SMS ne sera pas valide car il contient plus de quatre lettres.
c) Si le téléspectateur envoie la chaîne "iPaF", son SMS sera valide et sa proposition de classement est :
1. Italie (I)
2. Portugal (P)
3. Allemagne (A)
4. France (F)
On se propose d'écrire un programme qui permet de gérer ce jeu télévisé.
Pour cela ce programme devra permettre :
1) de saisir les textes des SMS des n téléspectateurs (n < 5000) ainsi que leurs numéros de téléphone. Les textes des SMS valides ainsi que les numéros des téléphones correspondants seront sauvegardés dans un fichier "C:\SMS.dat". N.B : Le candidat n'est pas appelé à contrôler la saisie des numéros de téléphone.
2) de former à partir du fichier "SMS.dat", un tableau d'enregistrements intitulé Foot. Chaque enregistrement de ce tableau doit contenir les informations suivantes :
Le numéro de téléphone d'un participant
Le classement proposé par ce participant, c'est-à-dire les 4 lettres qui constituent son SMS
Le score de ce participant, qui est déterminé en fonction de la proposition du téléspectateur comparée à la chaîne gagnante. La chaîne gagnante étant "1FAP" puisque le classement à la fin de cette coupe du monde est le suivant :
1. Italie (I)
2. France (F)
3. Allemagne (A)
4. Portugal (P)
Le score est calculé d la façon saivante :
- 100 points si les quatre lettres sont à la bonne position
- 75 points si seulement trois lettres sont à la bonne position
- 50 points si seulement deux lettres sont à la bonne position
- 25 points si seulement une seule lettre est à la bonne position
- 0 point si aucune lettre n'est à la bonne position.
3) de créer un tableau NT contenant les numéros de téléphone (sans redondance) des participants ayant le score le plus élevé.
N.B : Un téléspectateur peut envoyer plus d'un SMS pour augmenter ses chances de gagner.
4) d'afficher le nom et le prénom du (ou des) gagnant(s), sachant que le nom et le prénom d'un téléspectateur, correspondant à un numéro de téléphone donné, sont supposés obtenus à partir d'un fichier nommé "abonnes.dat" fourni par une société de télécommunication, et dont la structure est la suivante :
- numéro de téléphone,
- nom
- prénom
N. B : Le candidat n'est pas appelé à saisir le contenu du fichier "abonnes.dat".
Travail demandé
1. Analyser le problème en le décomposant en modules et déduire l'algorithme du programme principal qui permet de réaliser le traitement décrit précédemment.
2. Analyser chacun des modules envisagés précédemment et en déduire les algorithmes correspondants.
Solution Algorithmique
Dans cet algorithme, On va utiliser sept fonctions et cinq procédures :
- la fonction verif_chaine()
- la fonction majus_ch()
- la fonction saisie_sms()
- la fonction saisie_n()
- la procédure remplir_fichier_abonnes()
- la procédure remplir_fichier_sms()
- la fonction calculer_score()
- la procédure remplir_tableau_foot()
- la fonction max_score()
- la fonction recherche_redondance()
- la procédure remplir_tableau_NT()
- la procédure afficher_gagnants()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 |
Algorithme jeu_sms Debut n <- saisie_n() remplir_fichier_abonnes(n) remplir_fichier_sms(n) remplir_tableau_foot(foot) remplir_tableau_NT(foot, nt, n) afficher_gagnants(nt, taille_nt) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| foot | tableau d'enregistrements des SMS |
| nt | tableau des chaînes contenant les numéros de téléphone |
| nt | entier |
La fonction verif_chaine
Cette fonction sert à vérifier la validité d’une chaîne de caractères ch.
Plus précisément, elle :
- vérifie que la chaîne contient exactement 4 caractères ;
- vérifie que la chaîne contient les quatre lettres A, I, P et F, sans tenir compte de la casse (majuscule ou minuscule).
Valeur retournée :
- Vrai : si la chaîne est de longueur 4 et contient les lettres A, I, P et F ;
- Faux : dans tous les autres cas.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction verif_chaine(ch:chaine): booleen Si long(ch) = 4 alors # Vérification de la longueur retourner ((Pos(ch,'a') >= 0) ou (Pos(ch,'A') >= 0)) et ((Pos(ch,'i') >= 0) ou (Pos(ch,'I') >= 0)) et ((Pos(ch,'p') >= 0) ou (Pos(ch,'P') >= 0)) et ((Pos(ch,'f') >= 0) ou (Pos(ch,'F') >= 0)) Sinon retourner Faux Finsi Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La fonction majus_ch
Cette fonction sert à vérifier la validité d’une chaîne de caractères ch.
Plus précisément, elle :
- vérifie que la chaîne contient exactement 4 caractères ;
- vérifie que la chaîne contient les quatre lettres A, I, P et F, sans tenir compte de la casse (majuscule ou minuscule).
Valeur retournée :
- Vrai : si la chaîne est de longueur 4 et contient les lettres A, I, P et F ;
- Faux : dans tous les autres cas.
|
1 2 3 4 5 6 7 |
Fonction majus_ch(ch:chaine): chaine ch1 <- '' Pour i de 0 à 3 faire ch1 <- ch1 + Majus(ch[i]) Fin pour retourner ch1 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch1 | chaîne |
| i | entier |
La fonction saisie_sms
Cette fonction permet de saisir une chaîne de caractères valide représentant un SMS, en s’assurant qu’elle respecte les conditions imposées.
Plus précisément, elle :
1- demande à l’utilisateur de saisir une chaîne de caractères ;
2- vérifie la validité de la chaîne à l’aide de la fonction verif_chaine ;
3- redemande la saisie tant que la chaîne est invalide ;
4- convertit la chaîne valide en majuscules grâce à la fonction majus_ch.
5- une chaîne de 4 caractères en majuscules, contenant obligatoirement les lettres A, I, P et F (dans n’importe quel ordre).
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_sms(): chaine Ecrire("donner une chaine de caractéres contenant les lettres A,I,P et F: ") Lire(ch) # Tant que la chaîne est invalide on redemande Tant que verif_chaine(ch) = Faux faire Ecrire("donner une chaine de caracteres contenant les lettres A,I,P et F: ") Lire(ch) Fin tant que retourner majus_ch(ch) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La fonction saisie
Ce programme permet de saisir un entier n compris entre 5 et 10 inclus, en contrôlant la validité de la saisie.
Il redemande la valeur tant que l’utilisateur entre un nombre en dehors de l’intervalle [1, 5000], puis retourne la valeur correcte une fois la condition respectée.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie(): entier # Saisie d’un entier n Ecrire('donner un entier n tq 0<n<=5000: ') Lire(n) # Vérification de l’intervalle Tant que (n <= 0) ou (n > 5000) faire Ecrire('donner un entier n tq 0<n<=5000: ') Lire(n) Fin tant que # Retourner la valeur valide return n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_fichier_abonnes
Cette procédure sert à créer et remplir un fichier binaire nommé abonnes.dat contenant les informations des abonnés.
Plus précisément, il :
- ouvre (ou crée) le fichier abonnes.dat en mode binaire écriture
- répète n fois la saisie des informations d’un abonné : le nom, le prénom et le numéro de téléphone
- stocke chaque abonné sous forme de dictionnaire dans le fichier "abonne.dat"
- ferme le fichier après la fin de l’enregistrement
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Procédure remplir_fichier_abonnes(n:entier) Ouvrir(f_abonnes , "abonnes.dat", "wb") # Ouverture du fichier binaire Pour i de 0 à n-1 faire Ecrire(" donner le nom de l'abonne: ") Lire(abonne["nom"]) Ecrire("donner le prenom de l'abonne: ") Lire(abonne["prenom"]) Ecrire("donner le telephone: ")) Lire(abonne["numero"]) Fin pour Ecrire( f_abonnes,abonne) # Sauvegarde du dictionnaire Fermer(f_abonnes) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_abonne | fichier |
| i | entier |
| abonne | Enregistrement : nom=chaîne, prenon=chaîne, numero=chaîne Fin |
La procédure remplir_fichier_sms
Cette procédure permet de créer et remplir un fichier texte nommé sms.dat contenant une liste de SMS associés à des numéros de téléphone.
Plus précisément, la procédure remplir_fichier_sms(n) :
1- ouvre (ou crée) le fichier texte sms.dat en mode écriture
2- répète n fois les opérations suivantes
3- saisit un message SMS à l’aide de la fonction saisie_sms()
4- demande à l’utilisateur de saisir un numéro de téléphone
5- écrit dans le fichier une ligne contenant le SMS suivi du numéro de téléphone
6- ferme le fichier après la fin de l’enregistrement
|
1 2 3 4 5 6 7 8 9 |
Procédure remplir_fichier_sms(n:entier) Ouvrir (f , "sms.dat" , "w") # Ouverture du fichier texte Pour i de 0 à n-1 faire sms <- saisie_sms() Ecrire("donner le telephone: ") Lire(tel) Ecrire( f ,sms + ' ' + tel + '\n') Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
| sms | chaîne |
La fonction calculer_score()
Cete fonction permet de calculer le score d’un participant en fonction de la position de certaines lettres dans une chaîne classement.
La fonction calculer_score(classement) :
1- initialise un score à 0
2- vérifie si chaque position du classement contient la lettre attendue :
'I' à la position 0,
'F' à la position 1,
'A' à la position 2,
'P' à la position 3 ;
3- ajoute 25 points pour chaque lettre correctement placée ;
4- retourne le score total, qui peut varier de 0 à 100 points.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction calculer_score(classement:chaine):entier score <- 0 Si classement[0] = 'I' alors score = score + 25 Finsi Si classement[1] = 'F' alors score <- score + 25 Finsi Si classement[2] = 'A' alors score <- score + 25 Finsi Si classement[3] = 'P' alors score <- score + 25 Finsi retourner score Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| score | entier |
La procédure remplir_tableau_foot
Cette procédure permet de remplir le tableau foot (ou t) à partir du fichier texte sms.dat, en traitant les informations de chaque participant au jeu.
Plus précisément, la procédure remplir_tableau_foot(t) :
1- ouvre le fichier sms.dat en mode lecture
2- lit toutes les lignes du fichier, chaque ligne correspondant à un participant ;
3- pour chaque participant :
a- supprime le caractère de fin de ligne
b- crée un dictionnaire représentant un participant
c- extrait le classement (partie avant l’espace)
d- extrait le numéro de téléphone (partie après l’espace) ;
e- calcule le score du participant à partir de son classement en utilisant la fonction calculer_score ;
f- stocke chaque dictionnaire dans le tableau t.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Procédure remplir_tableau_foot(t:tableau) Ouvrir (f , "sms.dat" , "r") Lire_lignes (f , participants) i <- 0 Pour participant dans participants faire ch <- participant # Dictionnaire d’un participant enregistrement = Enregistrement: numero=chaine, classement=chaine, score=entier fin enregistrement["numero"] <- Sous_chaine(ch , Pos(ch,' ')+ 1 , long(ch)) enregistrement["classement"] <- Sous_chaine(ch, 0 , Pos(ch,' ') enregistrement["score"] <- calculer_score(enregistrement["classement"]) t[i] <- enregistrement i <- i + 1 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| participants | contenu du fichier |
| participant | chaîne qui contient une ligne du fichier |
| i | entier |
La fonction max_score
Ce programme permet de déterminer et retourner le score maximal parmi les participants enregistrés dans le tableau t.
La fonction max_score(t, n) :
1- initialise le score maximal avec le score du premier participant ;
2- parcourt le tableau t du deuxième élément jusqu’au nième élément ;
3- compare chaque score avec le score maximal courant ;
4- met à jour le score maximal lorsqu’un score plus élevé est trouvé ;
5- retourne à la fin le score le plus élevé.
|
1 2 3 4 5 6 7 8 9 |
Fonction max_score(t:tableau, n:entier): entier score <- t[0]["score"] Pour i de 1 à n faire Si score < t[i]["score"] alors score <- t[i]["score"] Finsi Finpour return score Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| score | entier |
La fonction recherche_redondance
Cette fonction permet de vérifier si un numéro de téléphone existe déjà dans le tableau t afin d’éviter les doublons.
La fonction recherche_redondance(t, n, telephone) :
1- parcourt le tableau t de l’indice 0 jusqu’à n − 1 ;
2- compare chaque élément du tableau avec le numéro de téléphone recherché ;
3- s’arrête dès que le numéro est trouvé ou que la fin du tableau est atteinte ;
4- retourne Vrai si le numéro n’existe pas dans le tableau (aucune redondance) et Faux si le numéro existe déjà dans le tableau.
|
1 2 3 4 5 6 |
Fonction recherche_redondance(t:tableau, n:entier, telephone:chaine): booleen i <- 0 Tant que (i < n) et (t[i] != telephone) faire i <- i + 1 retourner i = n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La procédure remplir_tableau_NT
Cette procédure permet de remplir le tableau NT avec les numéros de téléphone des participants gagnants, c’est-à-dire ceux qui ont obtenu le score maximal.
La procédure remplir_tableau_NT(foot, nt, n) :
1- calcule d’abord le score maximal parmi les n participants du tableau foot ;
2- parcourt ensuite tous les participants ;
3- pour chaque participant ayant ce score maximal :
- ajoute son numéro de téléphone dans le tableau nt ;
- vérifie, à l’aide de la fonction recherche_redondance, que le numéro n’est pas déjà présent afin d’éviter les doublons ;
- met à jour la variable globale taille_nt qui représente le nombre de numéros gagnants enregistrés.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure remplir_tableau_NT(foot:tableau, nt:tableau, n:entier) score_max <- max_score(foot, n) Pour i de 0 à n-1 faire Si foot[i]["score"] = score_max alors Si taille_nt = 0 alors nt[0] <- foot[i]["numero"] taille_nt <- 1 Sinon recherche_redondance(nt, taille_nt, foot[i]["numero"]): nt[taille_nt] <- foot[i]["numero"] taille_nt = taille_nt + 1 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| score_max | entier |
| i | entier |
| taille_nt | entier (variable globale) |
| i | entier |
La procédure afficher_gagnants
Cette procédure permet d’afficher la liste des gagnants du jeu à partir du fichier des abonnés.
La procédure afficher_gagnants(t, n) :
1- affiche un titre indiquant la liste des gagnants
2- ouvre le fichier binaire abonnes.dat contenant les informations des abonnés
3- lit successivement chaque abonné enregistré dans le fichier
4- vérifie si le numéro de téléphone de l’abonné figure dans le tableau t des numéros gagnants (à l’aide de la fonction recherche_redondance)
5- affiche le nom et le prénom de chaque abonné gagnant
6- s’arrête à la fin du fichier et le ferme
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Procédure afficher_gagnants(t:tableau, n:entier) Ecrire("********* Liste des gagnants *********") Ouvrir(f_abonnes , "abonnes.dat" , "rb") Tant que Vrai faire Essayer: Ecrire(f_abonnes,abonne) Si recherche_redondance(t, n, abonne["numero"]) = Faux alors Ecrire(abonne["nom"] + " " + abonne["prenom"]) En cas d'erreur: # fin du fichier sortir de la boucle Fin tant que Fermer(f_abonnes) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_abonnes | fichier |
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 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 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 |
import pickle from pickle import load, dump from numpy import * # Tableau pour stocker les participants (numéro, classement, score) foot = array([{}] * 5000) # Tableau pour stocker les numéros gagnants (NT) nt = array([{str()}] * 5000) # Taille réelle du tableau nt taille_nt = 0 # Dictionnaire représentant un abonné abonne = dict( nom=str(), prenon=str(), numero=str() ) # --------------------------------------------------- # Vérifie si la chaîne contient exactement 4 caractères # et contient les lettres A, I, P et F (majuscule ou minuscule) # --------------------------------------------------- def verif_chaine(ch): if len(ch) == 4: # Vérification de la longueur return ((ch.find('a') >= 0) or (ch.find('A') >= 0)) and \ ((ch.find('i') >= 0) or (ch.find('I') >= 0)) and \ ((ch.find('p') >= 0) or (ch.find('P') >= 0)) and \ ((ch.find('f') >= 0) or (ch.find('F') >= 0)) else: return False # --------------------------------------------------- # Convertit une chaîne de 4 caractères en majuscules # --------------------------------------------------- def majus_ch(ch): ch1 = '' for i in range(4): ch1 = ch1 + ch[i].upper() return ch1 # --------------------------------------------------- # Saisie sécurisée d’un SMS valide # --------------------------------------------------- def saisie_sms(): ch = input("donner une chaine de caractéres contenant les lettres A,I,P et F: ") # Tant que la chaîne est invalide on redemande while verif_chaine(ch) == False: ch = input("donner une chaine de caractéres contenant les lettres A,I,P et F: ") return majus_ch(ch) # --------------------------------------------------- # Saisie d’un entier n compris entre 1 et 5000 # --------------------------------------------------- def saisie_n(): n = int(input("donner un entier n tq 0<n<=5000: ")) # Répéter tant que n n’est pas dans l’intervalle while (n < 0) or (n > 5000): n = int(input("donner un entier n tq 0<n<=5000: ")) return n # --------------------------------------------------- # Remplit le fichier binaire des abonnés # --------------------------------------------------- def remplir_fichier_abonnes(n): f_abonnes = open("abonnes.dat", "wb") # Ouverture du fichier binaire for i in range(n): abonne["nom"] = input("donner le nom de l'abonne: ") abonne["prenom"] = input("donner le prenom de l'abonne: ") abonne["numero"] = input("donner le telephone: ") dump(abonne, f_abonnes) # Sauvegarde du dictionnaire f_abonnes.close() # --------------------------------------------------- # Remplit le fichier texte des SMS # --------------------------------------------------- def remplir_fichier_sms(n): f = open("sms.dat", "w") # Fichier texte for i in range(n): sms = saisie_sms() tel = input("donner le telephone: ") f.write(sms + ' ' + tel + '\n') f.close() # --------------------------------------------------- # Calcule le score selon la position des lettres # --------------------------------------------------- def calculer_score(classement): score = 0 if classement[0] == 'I': score += 25 if classement[1] == 'F': score += 25 if classement[2] == 'A': score += 25 if classement[3] == 'P': score += 25 return score # --------------------------------------------------- # Remplit le tableau foot à partir du fichier sms.dat # --------------------------------------------------- def remplir_tableau_foot(t): f = open("sms.dat", "r") participants = f.readlines() i = 0 for participant in participants: ch = participant.rstrip('\n') # Dictionnaire d’un participant enregistrement = dict( numero=str(), classement=str(), score=int() ) enregistrement["numero"] = ch[ch.find(' ') + 1:len(ch)] enregistrement["classement"] = ch[0:ch.find(' ')] enregistrement["score"] = calculer_score(enregistrement["classement"]) t[i] = enregistrement i += 1 # --------------------------------------------------- # Retourne le score maximal # --------------------------------------------------- def max_score(t, n): score = t[0]["score"] for i in range(1, n): if score < t[i]["score"]: score = t[i]["score"] return score # --------------------------------------------------- # Vérifie si un numéro existe déjà dans le tableau # --------------------------------------------------- def recherche_redondance(t, n, telephone): i = 0 while (i < n) and (t[i] != telephone): i += 1 return i == n # --------------------------------------------------- # Remplit le tableau NT avec les numéros gagnants # --------------------------------------------------- def remplir_tableau_NT(foot, nt, n): score_max = max_score(foot, n) global taille_nt for i in range(n): if foot[i]["score"] == score_max: if taille_nt == 0: nt[0] = foot[i]["numero"] taille_nt = 1 elif recherche_redondance(nt, taille_nt, foot[i]["numero"]): nt[taille_nt] = foot[i]["numero"] taille_nt += 1 # --------------------------------------------------- # Affiche la liste des gagnants à partir du fichier abonnés # --------------------------------------------------- def afficher_gagnants(t, n): print("********* Liste des gagnants *********") f_abonnes = open("abonnes.dat", "rb") while True: try: abonne = pickle.load(f_abonnes) if recherche_redondance(t, n, abonne["numero"]) == False: print(abonne["nom"] + " " + abonne["prenom"]) except EOFError: break f_abonnes.close() # --------------------------------------------------- # Programme principal # --------------------------------------------------- n = saisie_n() remplir_fichier_abonnes(n) remplir_fichier_sms(n) remplir_tableau_foot(foot) remplir_tableau_NT(foot, nt, n) afficher_gagnants(nt, taille_nt) |
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
