Codes Brailles – Bac théorique – Section informatique – 2012
Sujet (Algo et programmation - Bac 2012)
Louis Braille, est l'inventeur du système d'écriture tactile à points saillants, à l'usage des personnes aveugles ou fortement malvoyantes.
En Braille standard :
Un caractère est représenté par six points numérotés de 1 à 6 et disposés comme le montre la Figure 1.
Un point peut être saillant (en relief) ou non, comme le montre la Figure 2.
Le nombre et la disposition des points en relief définissent un caractère.
Dans la suite, on s'intéressera à la représentation des 26 lettres majuscules de l'alphabet français. Le tableau suivant, donne cette représentation.
N.B: Chaque point noir représente un point saillant.
Etant donné un fichier d'enregistrements intitulé "Codes_Braille.dat", où chaque enregistrement est composé de deux champs :
- un champ Lettre contenant une lettre majuscule de l'alphabet français,
- un champ Codage contenant une chaîne de 6 caractères représentant l'équivalent en braille de la lettre.
En utilisant le fichier "Codes_Braille.dat", on se propose de convertir le fichier texte intitulé "Braille.txt" contenant une représentation Braille d'un texte en son équivalent en alphabet français puis d'afficher le résultat obtenu.
Sachant que :
Chaque ligne du fichier "Braille.txt" contient la représentation d'un seul mot.
La représentation d'un mot est une concaténation de blocs de six caractères.
Chaque bloc de six caractères représente une lettre du mot.
Un caractère peut être un astérisque ("*") représentant un point saillant, ou un trait d'union ("-") représentant un point non saillant.
Les caractères "*" et "-" sont disposés selon l'ordre des numéros des points qu'ils représentent. Par exemple, la lettre H sera représentée par le bloc de six caractères suivant :
Exemple :
Etant donné le contenu du fichier "Codes_Braille.dat" dont une partie est représentée comme suit :
Si le contenu du fichier "Braille.txt" est le suivant :
Le programme affichera la chaîne : "EXAMEN DU BAC"
En effet :
- "EXAMEN" est l'équivalent en alphabet français de la première ligne du fichier "Braille.txt".
- "DU" est l'équivalent en alphabet français de la deuxième ligne du fichier "Braille.txt".
- "BAC" est l'équivalent en alphabet français de la troisième ligne du fichier "Braille.txt".
N.B: Le candidat n'est pas appelé à remplir les deux fichiers "Codes Braille.dat" et "Braille.txt".
Travail demandé :
1- Analyser le problème en le décomposant en modules.
2- Analyser chacun des modules envisagés.
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et deux procédures:
- la fonction saisie()
- la fonction verif_Braille()
- la fonction saisie_mot_braille()
- la procédure remplir_fichier_CodesBrailles()
- la procédure remplir_fichier_Braille()
- la procédure decrypter_Braille()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 |
Algorithme systeme_Braille Debut remplir_fichier_CodesBrailles() # Création du fichier des codes n <- saisie() # Saisie du nombre de mots remplir_fichier_Braille(n) # Saisie et stockage des mots Braille decrypter_Braille() # Décryptage et affichage du message Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction saisie
Cette fonction permet de saisir un entier strictement positif au clavier.
Plus précisément :
Elle demande à l’utilisateur de saisir un nombre entier.
Elle vérifie la validité de la saisie en s’assurant que le nombre est strictement supérieur à 0.
Tant que la valeur saisie est nulle ou négative, la fonction redemande la saisie.
Une fois une valeur correcte saisie, la fonction la retourne pour être utilisée dans la suite du programme.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Fonction saisie_n():entier # Première saisie de l'entier Ecrire('donner n telque n>0: ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <=0) faire Ecrire('donner n telque n>0: ') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | chaîne |
La fonction verif_Braille
Ce programme définit une fonction verif_Braille(ch) dont le rôle est de vérifier si une chaîne de caractères représentant un message en Braille est valide.
Plus précisément, la fonction :
- Vérifie que la longueur de la chaîne ch est un multiple de 6, car chaque caractère Braille est codé par 6 caractères.
- Découpe la chaîne en blocs successifs de 6 caractères.
Pour chaque bloc de 6 caractères, elle :
- ouvre le fichier CodesBrailles.dat,
- recherche si ce bloc existe parmi les codes Braille stockés dans ce fichier.
Si au moins un bloc n’est pas trouvé, la chaîne est considérée comme invalide.
Si tous les blocs sont reconnus, la chaîne est valide.
Valeur retournée :
Vrai : si la chaîne Braille est correctement formée et que tous les codes existent dans le fichier.
Faux : si la longueur n’est pas un multiple de 6 ou si au moins un code Braille est invalide.
|
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 |
Fonction verif_Braille(ch:chaine):booleen # Vérification que la longueur est un multiple de 6 Si long(ch) mod 6 = 0 alors i <- 0 # Indice de parcours de la chaîne trouve <- Vrai # Indicateur de validité # Parcours de la chaîne par blocs de 6 caractères Tant que i < long(ch) - 5 et trouve = Vrai faire # Ouverture du fichier des codes Braille Ouvrir(f , "CodesBrailles.dat", "r") # Lecture de la première ligne mot <- Lire_ligne(f) # Recherche du bloc de 6 caractères dans le fichier Tant que mot != "" et Sous_chaine(ch,i,i+6) != Sous_chaine(mot,2,long(mot)) alors mot <- Lire_ligne(f) Fin tant que # Fermeture du fichier Fermer(f) # Si le bloc n'a pas été trouvé, la chaîne est invalide Si Sous_chaine(ch,i,i+6) != Sous_chaine(mot,2,long(mot)) alors trouve <- Faux Fin si # Passage au bloc suivant i <- i + 6 Fin tant que # Retourne Vrai si tous les blocs sont valides return trouve = Vrai Sinon # Longueur invalide retourner Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| trouve | booléen |
| f | fichier |
| mot | chaîne |
La fonction saisie_mot_braille
Cette fonction permet de saisir une chaîne binaire valide composée d’octets (8 bits).
Plus précisément :
Elle demande à l’utilisateur de saisir une chaîne de caractères binaires.
Elle vérifie la validité de la chaîne en appelant la fonction verif_octets.
Tant que la chaîne saisie ne respecte pas les règles des octets (longueur multiple de 8 et caractères uniquement 0 ou 1), la fonction redemande la saisie.
Une fois une chaîne correcte saisie, la fonction la retourne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie_mot_braille():chaine # Saisie initiale de la chaîne Braille Ecrire('donner un mot sous forme Braille: ') Lire(ch) # Tant que la chaîne saisie n'est pas valide, # on redemande la saisie Tant que (verif_braille(ch) = Faux) faire Ecrire('donner un mot sous forme Braille: ') Lire(ch) ) Fin tant que # Retourne la chaîne valide retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichier_CodesBrailles
Ce programme définit une procédure remplir_fichier_CodesBrailles() dont le rôle est de créer et remplir le fichier CodesBrailles.dat avec les correspondances entre les lettres de l’alphabet (A à Z) et leurs codes Braille.
Plus précisément, la procédure :
- Affiche un message indiquant le début de l’opération de remplissage du fichier.
- Ouvre (ou crée) le fichier CodesBrailles.dat en mode écriture :
si le fichier existe déjà, son contenu est effacé, sinon, il est créé.
- Écrit dans le fichier les associations lettre / code Braille, chaque ligne contenant : une lettre majuscule, un espace, son code Braille composé de * et _, puis un retour à la ligne.
- Ferme le fichier après l’écriture pour sauvegarder correctement les données.
|
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 |
Procedure remplir_fichier_CodesBrailles(n:entier) Ecrire('*** Remplissage du fichier CodesBrailles.dat ***') # Ouverture du fichier en mode écriture Ouvrir(f , "CodesBrailles.dat", "w") # Écriture des codes Braille pour chaque lettre Ecrire(f , 'A *_____\n') Ecrire(f , 'B **____\n') Ecrire(f , 'C *__*__\n') Ecrire(f , 'D *__**_\n') Ecrire(f , 'E *___*_\n') Ecrire(f , 'F **_*__\n') Ecrire(f , 'G **_**_\n') Ecrire(f , 'H **__*_\n') Ecrire(f , 'I _*_*__\n') Ecrire(f , 'J _*_**_\n') Ecrire(f , 'K *_*___\n') Ecrire(f , 'L ***___\n') Ecrire(f , 'M *_**__\n') Ecrire(f , 'N *_***_\n') Ecrire(f , 'O *_*_*_\n') Ecrire(f , 'P ****__\n') Ecrire(f , 'Q *****_\n') Ecrire(f , 'R ***_*_\n') Ecrire(f , 'S _***__\n') Ecrire(f , 'T _****_\n') Ecrire(f , 'U *_*__*\n') Ecrire(f , 'V ***__*\n') Ecrire(f , 'W _*_***\n') Ecrire(f , 'X *_**_*\n') Ecrire(f , 'Y *_****\n') Ecrire(f , 'Z *_*_**\n') # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
La procédure remplir_fichier_Braille
Ce programme définit une procédure remplir_fichier_Braille(n) dont le rôle est de créer et remplir le fichier Braille.txt avec n mots en Braille saisis par l’utilisateur.
Plus précisément, la procédure :
- Affiche un message indiquant le début du remplissage du fichier Braille.txt.
- Ouvre (ou crée) le fichier Braille.txt en mode écriture : si le fichier existe déjà, son contenu est supprimé, sinon, il est créé.
- Répète n fois :
1- appelle la fonction saisie_mot_braille() pour permettre à l’utilisateur de saisir un mot codé en Braille,
2- écrit ce mot dans le fichier, une ligne par mot.
- Ferme le fichier afin d’enregistrer correctement les données.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure remplir_fichier_Braille(n:entier) Ecrire('*** Remplissage Fichier Braille.txt ***') # Ouverture du fichier en mode écriture Ouvrir(f , "Braille.txt", "w") # Saisie et écriture de n lignes Pour i de 0 à n-1 faire mot_braille <- saisie_mot_braille() Ecrire(f , mot_braille + '\n') Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| f | fichier |
| mot_braille | chaîne |
La procédure decrypter_Braille
Ce programme définit une procédure decrypter_Braille() dont le rôle est de décrypter (traduire) un message codé en Braille contenu dans le fichier Braille.txt et de l’afficher en clair à l’écran.
Plus précisément, la procédure :
- Affiche un message d’en-tête indiquant que le message décrypté va être affiché.
- Ouvre le fichier Braille.txt en mode lecture, qui contient des mots codés en Braille (un mot par ligne).
- Lit toutes les lignes du fichier dans une liste.
- Pour chaque mot Braille : supprime le caractère de fin de ligne, découpe le mot en blocs successifs de 6 caractères, chaque bloc représentant une lettre en Braille.
- Pour chaque bloc de 6 caractères : ouvre le fichier CodesBrailles.dat, recherche le code Braille correspondant, et affiche la lettre associée (premier caractère de la ligne du fichier).
- Ajoute un espace après chaque mot afin de bien séparer les mots décryptés.
- Ferme les fichiers utilisés après le traitement.
|
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 |
Procédure decrypter_Braille() Ecrire('*** Le message decrypte est : ***') # Ouverture du fichier Braille en mode lecture Ouvrir(f_braille , "Braille.txt", "r") # Lecture de toutes les lignes mots <- f_braille.readlines() # Parcours de chaque mot Braille Pour mot dans mots faire mot <- mot.rstrip('\n') # Suppression du retour à la ligne i <- 0 # Découpage du mot en blocs de 6 caractères Tant que i < long(mot) - 5 faire Ouvrir(f_code , "CodesBrailles.dat", "r") code <- Lire_ligne(f_code) # Recherche du code correspondant Tant que code != "" et Sous_chaine(mot,i,i+6) != Sous_chaine(code,2,long(code)) faire code <- Lire_ligne(f) Fin tant que # Affichage du caractère décodé Ecrire(code[0]) # Passage au bloc suivant i <- i + 6 Fermer(f_code) Fin tant que # Séparation entre les mots Ecrire(' ') Fin pour # Fermeture du fichier Fermer(f_braille) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_braille | fichier |
| i | entier |
| mots | chaîne |
| mot | chaîne |
| f_code | fichier |
| code | chaîne |
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 |
# -------------------------------------------------- # Fonction qui permet de saisir un entier strictement positif # -------------------------------------------------- def saisie(): # Demande à l'utilisateur de saisir le nombre de lignes n n = int(input('donner le nombre n des lignes tel que n > 0 : ')) # Tant que n est inférieur ou égal à 0, # on redemande la saisie à l'utilisateur while (n <= 0): n = int(input('donner le nombre n des lignes tel que n > 0 : ')) # Retourne la valeur valide saisie return n # -------------------------------------------------- # Fonction qui vérifie si une chaîne Braille est valide # - Sa longueur doit être un multiple de 6 # - Chaque groupe de 6 caractères doit exister # dans le fichier CodesBrailles.dat # -------------------------------------------------- def verif_Braille(ch): # Vérification que la longueur est un multiple de 6 if len(ch) % 6 == 0: i = 0 # Indice de parcours de la chaîne trouve = True # Indicateur de validité # Parcours de la chaîne par blocs de 6 caractères while i < len(ch) - 5 and trouve == True: # Ouverture du fichier des codes Braille f = open("CodesBrailles.dat", "r") # Lecture de la première ligne mot = f.readline().strip('\n') # Recherche du bloc de 6 caractères dans le fichier while mot != "" and ch[i:i+6] != mot[2:len(mot)]: mot = f.readline().strip('\n') # Fermeture du fichier f.close() # Si le bloc n'a pas été trouvé, la chaîne est invalide if ch[i:i+6] != mot[2:len(mot)]: trouve = False # Passage au bloc suivant i = i + 6 # Retourne True si tous les blocs sont valides return trouve == True else: # Longueur invalide return False # -------------------------------------------------- # Fonction qui permet de saisir une chaîne Braille valide # -------------------------------------------------- def saisie_mot_braille(): # Saisie initiale de la chaîne Braille ch = input('donner un mot sous forme Braille: ') # Tant que la chaîne saisie n'est pas valide, # on redemande la saisie while (verif_Braille(ch) == False): ch = input('donner un mot sous forme Braille: ') # Retourne la chaîne valide return ch # -------------------------------------------------- # Procédure qui remplit le fichier CodesBrailles.dat # avec les correspondances lettres / codes Braille # -------------------------------------------------- def remplir_fichier_CodesBrailles(): print('*** Remplissage du fichier CodesBrailles.dat ***') # Ouverture du fichier en mode écriture f = open("CodesBrailles.dat", "w") # Écriture des codes Braille pour chaque lettre f.write('A *_____\n') f.write('B **____\n') f.write('C *__*__\n') f.write('D *__**_\n') f.write('E *___*_\n') f.write('F **_*__\n') f.write('G **_**_\n') f.write('H **__*_\n') f.write('I _*_*__\n') f.write('J _*_**_\n') f.write('K *_*___\n') f.write('L ***___\n') f.write('M *_**__\n') f.write('N *_***_\n') f.write('O *_*_*_\n') f.write('P ****__\n') f.write('Q *****_\n') f.write('R ***_*_\n') f.write('S _***__\n') f.write('T _****_\n') f.write('U *_*__*\n') f.write('V ***__*\n') f.write('W _*_***\n') f.write('X *_**_*\n') f.write('Y *_****\n') f.write('Z *_*_**\n') # Fermeture du fichier f.close() # -------------------------------------------------- # Procédure qui remplit le fichier Braille.txt # avec n mots saisis par l'utilisateur # -------------------------------------------------- def remplir_fichier_Braille(n): print('*** Remplissage Fichier Braille.txt ***') # Ouverture du fichier en mode écriture f = open("Braille.txt", "w") # Saisie et écriture de n lignes for i in range(n): mot_braille = saisie_mot_braille() f.write(mot_braille + '\n') # Fermeture du fichier f.close() # -------------------------------------------------- # Procédure qui décrypte le message Braille # contenu dans le fichier Braille.txt # -------------------------------------------------- def decrypter_Braille(): print('*** Le message decrypte est : ***') # Ouverture du fichier Braille en mode lecture f_braille = open("Braille.txt", "r") # Lecture de toutes les lignes mots = f_braille.readlines() # Parcours de chaque mot Braille for mot in mots: mot = mot.rstrip('\n') # Suppression du retour à la ligne i = 0 # Découpage du mot en blocs de 6 caractères while i < len(mot) - 5: f_code = open("CodesBrailles.dat", "r") code = f_code.readline().strip('\n') # Recherche du code correspondant while code != "" and mot[i:i+6] != code[2:len(code)]: code = f_code.readline().strip('\n') # Affichage du caractère décodé print(code[0], end='') # Passage au bloc suivant i = i + 6 f_code.close() # Séparation entre les mots print(end=' ') # Fermeture du fichier f_braille.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- remplir_fichier_CodesBrailles() # Création du fichier des codes n = saisie() # Saisie du nombre de mots remplir_fichier_Braille(n) # Saisie et stockage des mots Braille decrypter_Braille() # Décryptage et affichage du message |
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
