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 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 |
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 procédure afficher_matrice
Cette procédure est d’afficher le contenu d’une matrice carrée M de taille n × n à l’écran de manière lisible.
Elle reçoit : m : une matrice (tableau à deux dimensions) et n : la dimension de la matrice (nombre de lignes et de colonnes).
Elle affiche d’abord un titre : “Matrice M”.
Ensuite , la première boucle Pour parcourt les lignes de la matrice et la deuxième boucle Pour parcourt les colonnes de chaque ligne.
chaque élément m[i][j] est affiché sur la même ligne.
Enfin écrire() permet de passer à la ligne suivante après chaque ligne de la matrice.
|
1 2 3 4 5 6 7 8 9 10 |
Procédure afficher_matrice(m:matrice, n:entier) Ecrire('****** Matrice M ******') # Parcours de la matrice et affichage des valeurs Pour i de 0 à n-1 faire Pour j de 0 à n-1 faire Ecrire(m[i][j]) Finpour Ecrire() # retour a la ligne Finpour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La fonction test_different
Le rôle de ce fonction est de vérifier si une chaîne de caractères contient au moins trois chiffres (ou caractères) différents, à condition que la chaîne ait une longueur minimale de 4.
1- La fonction test_different(ch) reçoit une chaîne de caractères ch.
2- Elle vérifie d’abord que la longueur de la chaîne est au moins 4.
3- Elle parcourt ensuite la chaîne caractère par caractère :
- à chaque position i, elle supprime le caractère ch[i] pour former une nouvelle chaîne ch1,
- elle teste si ce caractère n’existe plus dans ch1,
- si c’est le cas, cela signifie que ce caractère est différent des autres, et le compteur cp est incrémenté.
- La boucle s’arrête dès que 3 caractères différents sont trouvés ou que la chaîne est entièrement parcourue.
4- La fonction retourne :
Vrai si au moins 3 caractères différents sont détectés,
Faux sinon (ou si la chaîne contient moins de 4 caractères).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Fonction test_different(ch:chaine):booleen # La chaîne doit contenir au moins 4 caractères Si long(ch) >= 4 alors cp <- 0 # Compteur de chiffres différents i <- 0 # Parcours de la chaîne Tant que cp < 3 and i < long(ch) faire # Supprimer le caractère ch[i] ch1 = Sous_chaine(ch,0,i) + Sous_chaine(ch,i+1,long(ch)] # Vérifier si le caractère supprimé n’existe plus Si Pos(ch1,ch[i]) < 0 alors cp <- cp + 1 Fin si i <- i + 1 Fin tant que # Retourne True si au moins 3 chiffres sont différents returner cp <- 3 Sinon retourner Faux Finsi Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| cp | entier |
| i | entier |
| ch1 | chaîne |
La procédure remplir_fichier_diagonal
Le rôle de cette procédure est de construire les diagonales d’une matrice carrée, de les sauvegarder dans un fichier texte et d’afficher celles qui contiennent au moins trois chiffres différents.
La procédure remplir_fichier_diagonal(m, n) reçoit : m : une matrice carrée de taille n × n et n : la dimension de la matrice.
1- Elle ouvre le fichier diagonal.txt en mode écriture.
2- Pour chaque indice i de 0 à n−1 :
- elle construit une chaîne ligne contenant les éléments de la diagonale secondaire partielle définie par
m[j][i − j] pour j allant de 0 à i,
- les éléments de la diagonale sont concaténés sous forme de chiffres.
- Elle utilise la fonction test_different(ligne) pour vérifier si la chaîne contient au moins 3 chiffres différents : si oui, la diagonale est affichée à l’écran.
- Chaque diagonale construite est ensuite écrite dans le fichier diagonal.txt, qu’elle respecte la condition ou non.
3- Enfin, le fichier est fermé.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Procédure remplir_fichier_diagonal(m:matrice, n:entier) # Ouverture du fichier en écriture Ouvrir(f ,"diagonal.txt", "w") Ecrire('\nLes lignes contenant des chiffres qui ont au moins 3 chiffres différents') # Parcours des diagonales de la matrice Pour i de 0 à n-1 faire ligne <- '' # Construction de la chaîne à partir de la diagonale Pour j de 0 à i + 1 faire ligne <- ligne + Convch(m[j][i - j]) Fin pour # Test si la chaîne contient au moins 3 chiffres différents Si test_different(ligne) alors Ecrire(ligne) Finsi # Écriture de la chaîne dans le fichier Ecrire(f, ligne + '\n') Finpour # Fermeture du fichier Fermer(f_) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| ligne | chaîne |
| i | entier |
| j | entier |
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 |
from numpy import * import random # Dimensions maximales de la matrice lignes = 50 colonnes = 50 # Matrice M : contiendra les valeurs calculées (distances/sommes) m = array([[int()] * colonnes] * lignes) # =================================== # Fonction pour saisir un entier n # =================================== def saisie(): # Saisie d’un entier n n = int(input('donner n telque 5<=n<=10: ')) # Vérification de l’intervalle while (n < 5) or (n > 10): n = int(input('donner n telque 5<=n<=10: ')) # Retourner la valeur valide return n # ========================================= # Construction de la matrice M # ========================================= def remplir_matrice(m, n): # Remplissage de la première ligne avec des valeurs aléatoires entre 1 et 9 for j in range(n): m[0][j] = random.randint(1, 9) # Remplissage des autres lignes for i in range(1, n): for j in range(0, n - i): somme = 0 # Calcul de la somme des éléments de la ligne précédente # à partir de la colonne j jusqu'à la fin for k in range(j, n): somme = somme + m[i - 1][k] # Affectation de la somme à la case m[i][j] m[i][j] = somme # ========================================= # Affichage de la matrice M # ========================================= def afficher_matrice(m, n): print('****** Matrice M ******') # Parcours de la matrice et affichage des valeurs for i in range(n): for j in range(n): print(m[i][j], end=' ') print() # ===================================================== # Vérifie si une chaîne contient au moins 3 chiffres # différents # ===================================================== def test_different(ch): # La chaîne doit contenir au moins 4 caractères if len(ch) >= 4: cp = 0 # Compteur de chiffres différents i = 0 # Parcours de la chaîne while cp < 3 and i < len(ch): # Supprimer le caractère ch[i] ch1 = ch[0:i] + ch[i + 1:len(ch)] # Vérifier si le caractère supprimé n’existe plus if ch1.find(ch[i]) < 0: cp = cp + 1 i = i + 1 # Retourne True si au moins 3 chiffres sont différents return cp == 3 else: return False # ===================================================== # Construction et sauvegarde des diagonales # ===================================================== def remplir_fichier_diagonal(m, n): # Ouverture du fichier en écriture f = open("diagonal.txt", "w") print('\nLes lignes contenant des chiffres qui ont au moins 3 chiffres différents') # Parcours des diagonales de la matrice for i in range(n): ligne = '' # Construction de la chaîne à partir de la diagonale for j in range(i + 1): ligne = ligne + str(m[j][i - j]) # Test si la chaîne contient au moins 3 chiffres différents if test_different(ligne): print(ligne) # Écriture de la chaîne dans le fichier f.write(ligne + '\n') # Fermeture du fichier f.close() # ============================ # PROGRAMME PRINCIPAL # ============================ # Saisie de la dimension de la matrice n = saisie() # Remplissage de la matrice remplir_matrice(m, n) # Affichage de la matrice afficher_matrice(m, n) # Traitement des diagonales et sauvegarde dans un fichier remplir_fichier_diagonal(m, n) |
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
