Message décrypté – Bac théorique – Section informatique – 2012
Sujet (Algo et programmation - Bac 2012)
Etant donné un fichier texte intitulé "MsgCrypte.txt" contenant un texte crypté d'un message formé de N lignes, où chaque ligne représente un mot crypté.
Le principe du cryptage est le suivant :
1- Chaque mot est crypté caractère par caractère.
2- Chaque caractère est crypté par sa représentation binaire, sur 8 bits, de son code ASCII.
On se propose:
1- de décrypter les lignes du fichier "MsgCrypte.txt" pour obtenir tous les mots formant le message initial,
2- d'afficher le texte décrypté, en séparant les mots par des espaces.
Exemple :
Pour N = 4 et le contenu du fichier "MsgCrypte.txt" suivant :
| 01000010 0110000101100011
01101001011011100110011001101111 011010100 11101010110100101101110 00110010001100000011000100110010 |
Après décryptage, le programme affichera le message suivant : Bac info juin 2012
Notons que, le code ASCII du caractère "B" (le premier caractère du premier mot) est 66, dont la représentation binaire est 01000010 (les huit premiers bits de la première ligne du fichier "MsgCrypte.txt").
N.B Le candidat n'est pas appelé à créer le fichier "MsgCrypte.txt".
Travail à faire :
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_octets()
- la fonction saisie_octet()
- la procédure remplir_fichier_MsgCrypte()
- la fonction exposant()
- la fonction conversion_caractere()
- la procédure decrypter_Msg()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 |
Algorithme matrice_espace Debut # Saisie du nombre de lignes à crypter n <- saisie() # Remplissage du fichier avec le message crypté remplir_fichier_MsgCrypte(n) # Décryptage et affichage du message decrypter_Msg(n) 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_octets
Cette fonction permet de vérifier la validité d’une chaîne binaire représentant des octets.
Plus précisément :
Elle vérifie que la longueur de la chaîne est un multiple de 8, condition nécessaire pour former des octets.
Elle vérifie que tous les caractères de la chaîne sont des bits valides, c’est-à-dire uniquement '0' ou '1'.
Si ces deux conditions sont respectées, la fonction retourne Vrai.
Sinon, elle retourne Faux.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Fonction verif_octets(ch:chaine):booleen # Vérifie si la longueur de la chaîne est multiple de 8 Si long(ch) mod 8 = 0 alors i <- 0 # Parcourt la chaîne caractère par caractère # tant que les caractères sont '0' ou '1' Tant que (i < long(ch) - 1) et ('0' <= ch[i] <= '1') faire i <- i + 1 Fin tant que # Vérifie le dernier caractère retournet '0' <= ch[i] <= '1' Sinon # Longueur non multiple de 8 retourner Faux Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_octet
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_octet():chaine # Demande à l'utilisateur de saisir une chaîne binaire Ecrire('donner des carcateres sous forme 8 bits: ') Lire(ch) # Tant que la chaîne saisie n'est pas valide, # on redemande la saisie Tant que (verif_octets(ch) = Faux) faire Ecrire('donner des carcateres sous forme 8 bits: ') Lire(ch) ) Fin tant que # Retourne la chaîne binaire valide retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichier_MsgCrypte
Cette procédure permet de créer et remplir le fichier MsgCrypte.txt avec des chaînes binaires cryptées.
Plus précisément :
- Elle crée le fichier MsgCrypte.txt en mode écriture.
- Elle demande à l’utilisateur de saisir n chaînes binaires valides, chacune représentant des caractères codés sur 8 bits.
- Chaque chaîne saisie est écrite sur une ligne du fichier.
- Une fois les n lignes écrites, le fichier est correctement fermé.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procedure remplir_fichier_MsgCrypte(n:entier) Ecrire('*** Remplissage Fichier MsgCrypte.txt ***') # Ouverture du fichier en mode écriture Ouvrir( f , "MsgCrypte.txt", "w") # Saisie et écriture de n lignes dans le fichier Pour i de 0 à n-1 faire caractere <- saisie_octet() Ecrire(f, caractere + '\n') # Écriture dans le fichier ligne par ligne Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
La fonction exposant
Cette fonction permet de calculer la puissance d’un nombre.
Plus précisément :
Elle calcule la valeur de n élevé à la puissance e.
Le calcul est réalisé à l’aide d’une boucle de multiplications successives.
Le résultat du calcul est ensuite retourné par la fonction.
|
1 2 3 4 5 6 |
Fonction exposant(n:entier ; e:entier):entier exp <- 1 Pour i de 0 à e-1 exp <- exp * n retourner exp Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| exp | entier |
La fonction conversion_caractere
Cette fonction permet de convertir un octet binaire (8 bits) en caractère ASCII.
Plus précisément :
Elle transforme une chaîne binaire représentant un octet en sa valeur décimale.
Cette conversion est effectuée en additionnant les puissances de 2 correspondant aux bits égaux à 1.
Une fois le code ASCII obtenu, elle est converti en caractère à l’aide de la fonction chr.
Le caractère correspondant est ensuite retourné.
|
1 2 3 4 5 6 7 8 9 |
Fonction conversion_caractere(octet):chaine code_ascii <- 0 # Conversion du binaire vers le décimal Pour i de 0 à long(octet)-1 faire code_ascii <- code_ascii + (Valeur(octet[long(octet) - 1 - i]) * exposant(2, i)) Fin pour # Conversion du code ASCII en caractère retourner chr(code_ascii) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| code_ascii | entier |
| i | entier |
La procédure decrypter_Msg
Cette fonction permet d’identifier et d’afficher les zones de concentration du chiffre 1 dans la matrice m.
Plus précisément :
La matrice est découpée en sous-matrices de taille dn × dn.
La fonction parcourt chaque sous-matrice à l’aide des indices i et j.
Pour chaque zone, elle calcule le nombre de 1 en utilisant la fonction nbr_occurences1.
Si ce nombre est supérieur ou égal au degré de concentration minimum deg_min, la zone est considérée comme une zone de concentration.
Les coordonnées de la zone (ligne et colonne de départ) ainsi que le nombre de 1 sont affichées.
Un compteur numero_case permet de numéroter les zones trouvées.
À la fin, le programme affiche le nombre total de zones de concentration détecté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 |
Procédure decrypter_Msg(n:entier) Ecrire('*** Le message decrypte est : ***') # Ouverture du fichier en mode lecture Ouvrir(f , "MsgCrypte.txt", "r") # Lecture de toutes les lignes du fichier message = Lire_lignes(f) # Parcours de chaque ligne du fichier Pour ligne dans message: bits <- ligne # Suppression du saut de ligne octet <- '' # Regroupement des bits par octet (8 bits) Pour i de 0 à long(bits)-1 faire octet <- octet + bits[i] Si ((i + 1) mod 8) = 0 alors # Conversion de l'octet en caractère Ecrire(conversion_caractere(octet)) octet <- '' Fin si Fin pour # Espace entre les lignes décodées print(' ') Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| message | chaîne |
| ligne | chaîne |
| bits | chaîne |
| octet | chaîne |
| i | 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 132 133 134 135 136 137 138 139 140 141 142 |
# -------------------------------------------------- # Fonction qui permet de saisir un entier strictement positif # -------------------------------------------------- def saisie(): # Demande à l'utilisateur de saisir un entier n n = int(input('donner n tel que n > 0 : ')) # Tant que n est inférieur ou égal à 0, on redemande la saisie while (n <= 0): n = int(input('donner n tel que n > 0 : ')) # Retourne la valeur correcte saisie return n # -------------------------------------------------- # Fonction qui vérifie si une chaîne est composée # uniquement de 0 et de 1 et si sa longueur est # un multiple de 8 (octets valides) # -------------------------------------------------- def verif_octets(ch): # Vérifie si la longueur de la chaîne est multiple de 8 if len(ch) % 8 == 0: i = 0 # Parcourt la chaîne caractère par caractère # tant que les caractères sont '0' ou '1' while (i < len(ch) - 1) and ('0' <= ch[i] <= '1'): i = i + 1 # Vérifie le dernier caractère return '0' <= ch[i] <= '1' else: # Longueur non multiple de 8 return False # -------------------------------------------------- # Fonction qui permet de saisir une chaîne binaire # représentant des caractères codés sur 8 bits # -------------------------------------------------- def saisie_octet(): # Demande à l'utilisateur de saisir une chaîne binaire ch = input('donner des carcateres sous forme 8 bits: ') # Tant que la chaîne saisie n'est pas valide, # on redemande la saisie while (verif_octets(ch) == False): ch = input('donner des carcateres sous forme 8 bits: ') # Retourne la chaîne binaire valide return ch # -------------------------------------------------- # Procédure qui remplit le fichier "MsgCrypte.txt" # avec n lignes de caractères binaires (cryptés) # -------------------------------------------------- def remplir_fichier_MsgCrypte(n): print('*** Remplissage Fichier MsgCrypte.txt ***') # Ouverture du fichier en mode écriture f = open("MsgCrypte.txt", "w") # Saisie et écriture de n lignes dans le fichier for i in range(n): caractere = saisie_octet() f.write(caractere + '\n') # Écriture dans le fichier ligne par ligne # Fermeture du fichier f.close() # -------------------------------------------------- # Fonction qui calcule n à la puissance e # (équivalent à n**e, mais sans utiliser l'opérateur **) # -------------------------------------------------- def exposant(n, e): exp = 1 for i in range(e): exp = exp * n return exp # -------------------------------------------------- # Fonction qui convertit un octet binaire (8 bits) # en caractère ASCII # -------------------------------------------------- def conversion_caractere(octet): code_ascii = 0 # Conversion du binaire vers le décimal for i in range(len(octet)): code_ascii = code_ascii + (int(octet[len(octet) - 1 - i]) * exposant(2, i)) # Conversion du code ASCII en caractère return chr(code_ascii) # -------------------------------------------------- # Procédure qui décrypte le message contenu # dans le fichier "MsgCrypte.txt" # -------------------------------------------------- def decrypter_Msg(n): print('*** Le message decrypte est : ***') # Ouverture du fichier en mode lecture f = open("MsgCrypte.txt", "r") # Lecture de toutes les lignes du fichier message = f.readlines() # Parcours de chaque ligne du fichier for ligne in message: bits = ligne.rstrip('\n') # Suppression du saut de ligne octet = '' # Regroupement des bits par octet (8 bits) for i in range(len(bits)): octet = octet + bits[i] if ((i + 1) % 8) == 0: # Conversion de l'octet en caractère print(conversion_caractere(octet), end='') octet = '' # Espace entre les lignes décodées print(end=' ') # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- # Saisie du nombre de lignes à crypter n = saisie() # Remplissage du fichier avec le message crypté remplir_fichier_MsgCrypte(n) # Décryptage et affichage du message decrypter_Msg(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
