Cryptage messages – Bac théorique – Section informatique – 2011
Sujet (Algo et programmation - Bac 2011)
Dans le cadre de la réalisation d'un projet scientifique, deux chercheurs résidants dans deux pays différents, s'échangent des données sur Internet. Pour assurer la confidentialité de leur projet, les messages &changes sont cryptes.
Le message initial se compose au maximum de 50 lignes et chaque ligne contient 50 caractères au maximum. Ce message est stocke dans un fichier texte intitule « Txtinit.txt » sur la rapine du lecteur C.
En supposant que ce texte est déjà saisi, on se propose de créer un deuxième fichier texte intitule « TxtCryp.txt » contenant le message qui sera crypte, de la manière suivante :
Première étape :
Remplir une matrice d'entiers MC par les codes ASCII (en base 10) des caractères du message initial. Chaque ligne de la matrice contiendra les codes ASCII des caractères d'une ligne du fichier « TxtInit.txt ».
Le nombre de lignes de la matrice MC est egal au nombre de lignes du fichier « Txtinit.txt » et le nombre de colonnes de la matrice MC est egal a la longueur (long_max) de la plus longue ligne du fichier.
Pour les lignes avant une longueur inferieure a long_max, on complète les cases restées vides par le code ASCII du caractère espace (qui est égal a 32).
Deuxième étape :
Convertir, dans la même matrice, tous les éléments de MC en base 8.
Troisième étape :
Stocker dans « TxtCryp.txt », les colonnes de la matrice MC, de la colonne la plus a gauche a la colonne la plus a droite. Chaque colonne de la matrice MC occupera une ligne et les éléments de cette ligne seront séparés par le caractère espace.
Travail demandé :
1. Analyser le problème en le décomposant en modules et en déduire L'algorithme programme principal.
2. Analyser chacun des modules envisages précédemment et en déduire les algorithmes correspondants.
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et cinq procédures:
- la fonction saisie_n()
- la fonction saisie_ch()
- la procédure remplir_fichierTxtInit()
- la procédure remplir_matrice_mc()
- la procédure afficher_matrice_mc()
- la fonction decimal_vers_base8()
- la procédure remplir_matrice_mc_base8()
- la procédure remplir_fichierTxtCryp()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Algorithme cryptage_messages Debut n <- saisie_n() long_max <- 0 Ecrire("**** Remplir le fichier TxtInit *****") remplir_fichierTxtInit(n) remplir_matrice_mc(mc) Ecrire("**** Matrice MC *****") afficher_matrice_mc(mc, n) remplir_matrice_mc_base8(mc, n) Ecrire("**** Matrice MC en base 8 *****") afficher_matrice_mc(mc, n) Ecrire("**** Contenu du fichier crypte *****") remplir_fichierTxtCryp(mc, n) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| long_max | entier |
| m | matrice des entiers |
La fonction saisie_n
Cette procédure permet de saisir un entier compris strictement entre deux bornes inf et sup, en contrôlant la validité de la saisie.
Plus précisément :
il demande à l’utilisateur d’entrer un entier n tel que 0 < n < 50. si la valeur saisie n’appartient pas à cet intervalle, le programme redemande la saisie jusqu’à obtenir une valeur correcte. une fois la saisie valide, la fonction retourne l’entier n.
|
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 0<n<50: ') Lire(n) # Tant que n n'est pas dans l'intervalle demandé, # on redemande la saisie Tant que (n <= 0) ou (n >= 50) faire Ecrire('donner n telque 0<n<50: ') 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 saisie_ch
La fonction saisie_ch permet de saisir une chaîne de caractères valide dont la longueur est comprise entre 1 et 50 caractères.
Elle demande à l’utilisateur de saisir une chaîne.
Elle vérifie la longueur de la chaîne saisie.
Tant que la chaîne est vide ou dépasse 50 caractères, la saisie est redemandée.
Une fois la chaîne valide, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_ch(): chaine Ecrire('donner une chaine formee de 50 caracteres au maximum: ') Lire(ch) # Tant que la chaîne n'est pas valide, on redemande la saisie Tant que (long(ch) = 0) ou (long(ch) > 50) faire Ecrire('donner une chaine formee de 50 caracteres au maximum: ') Lire(ch) Fin tant que retourner ch Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ch | chaîne |
La procédure remplir_fichierTxtInit
La procédure remplir_fichierTxtInit permet de remplir le fichier texte TxtInit.txt avec n chaînes de caractères saisies au clavier.
Elle ouvre le fichier TxtInit.txt en mode écriture.
Elle demande à l’utilisateur de saisir n chaînes (à l’aide de la fonction saisie_ch).
Elle détermine et mémorise la longueur maximale des chaînes saisies dans la variable globale long_max.
Elle écrit chaque chaîne sur une ligne du fichier.
Elle ferme le fichier après la fin de l’écriture.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure remplir_fichierTxtInit(n:entier) Ouvrir(f, "TxtInit.txt" , "w") # Ouverture du fichier en écriture Pour i de 0 à n-1 faire ch <- saisie_ch() # Saisie d'une chaîne Si long_max < long(ch) alors long_max <- long(ch) # Mise à jour de la longueur maximale Finsi Ecrire(f , ch + '\n') # Écriture dans le fichier Fin si Fermer(f) # Fermeture du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| long_max | entier (variable globale) |
La procédure remplir_matrice_mc
La procédure remplir_matrice_mc permet de remplir la matrice mc à partir du contenu du fichier TxtInit.txt.
Elle lit toutes les lignes du fichier texte.
Chaque chaîne lue est traitée caractère par caractère.
Chaque caractère est converti en son code ASCII et stocké dans la matrice mc.
Si une chaîne est plus courte que la longueur maximale long_max, les cases restantes de la ligne sont complétées par le code ASCII 32 (espace).
La matrice obtenue contient ainsi des lignes de longueur uniforme correspondant aux codes ASCII des caractères des chaînes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Procédure remplir_matrice_mc(mc:matrice) Ouvrir( f , "TxtInit.txt" , "r") # Ouverture du fichier en lecture lignes <- Lire_lignes(f) i <- 0 Pour ligne dans lignes faire ch <- ligne) Pour j de 0 à long(ch)-1 faire mc[i][j] <- ord(ch[j]) # Conversion caractère → code ASCII Fin pour # Compléter par des espaces si la chaîne est plus courte Si long(ch) < long_max alors Pour j de len(ch) à long_max-1 mc[i][j] <- 32 # Code ASCII de l'espace Fin pour Fin si i <- i + 1 Fin pour Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| f | fichier |
| lignes | chaîne |
| ligne | chaîne |
| ch | chaîne |
| j | entier |
La procédure afficher_matrice_mc
La procédure afficher_matrice_mc permet d’afficher à l’écran le contenu de la matrice mc.
Elle parcourt chaque ligne de la matrice (jusqu’à n lignes).
Pour chaque ligne, elle affiche tous les éléments jusqu’à long_max colonnes, séparés par deux espaces.
Après chaque ligne, elle effectue un retour à la ligne pour que l’affichage soit lisible sous forme de matrice.
|
1 2 3 4 5 6 7 8 |
Procédure afficher_matrice_mc(mc:matrice, n:entier)) Pour i de 0 à n-1 faire Pour j de 0 à long_max-1 faire Ecrire(mc[i][j], ' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | fichier |
| long_max | entier (variable globale) |
La fonction decimal_vers_base8
La fonction saisie_ch permet de saisir une chaîne de caractères valide dont la longueur est comprise entre 1 et 50 caractères.
Elle demande à l’utilisateur de saisir une chaîne.
Elle vérifie la longueur de la chaîne saisie.
Tant que la chaîne est vide ou dépasse 50 caractères, la saisie est redemandée.
Une fois la chaîne valide, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction decimal_vers_base8(n:entier): entier octal <- "" # Cas particulier : n = 0 Si n = 0 alors retourner "0" Fin si # Conversion par divisions successives Tant que n > 0 faire reste <- n % 8 octal <- Convch(reste) + octal n <- n div 8 Fin tant que retourner Valeur(octal) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| octal | chaîne |
| reste | chaîne |
La procédure afficher_matrice_mc_base8
La procédure remplir_matrice_mc_base8 permet de convertir tous les éléments de la matrice mc de la base décimale (10) vers la base 8.
Elle parcourt chaque ligne et chaque colonne de la matrice jusqu’à n lignes et long_max colonnes.
Pour chaque élément, elle applique la fonction decimal_vers_base8 pour transformer le code ASCII (décimal) en sa valeur en base 8.
Après l’exécution de cette fonction, la matrice mc contient donc les codes ASCII des caractères sous forme octale.
|
1 2 3 4 5 6 7 |
Procédure remplir_matrice_mc_base8(mc:matrice, n:entier)) Pour i de 0 à n-1 faire Pour j de 0 à long_max-1 faire mc[i][j] <- decimal_vers_base8(mc[i][j]) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | fichier |
| long_max | entier (variable globale) |
La procédure remplir_fichierTxtCryp
La procédure remplir_fichierTxtInit permet de remplir le fichier texte TxtInit.txt avec n chaînes de caractères saisies au clavier.
Elle ouvre le fichier TxtInit.txt en mode écriture.
Elle demande à l’utilisateur de saisir n chaînes (à l’aide de la fonction saisie_ch).
Elle détermine et mémorise la longueur maximale des chaînes saisies dans la variable globale long_max.
Elle écrit chaque chaîne sur une ligne du fichier.
Elle ferme le fichier après la fin de l’écriture.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Procédure remplir_fichierTxtCryp(mc:matrice ; n:entier) Ouvrir(f, "TxtInit.txt" , "w") # Ouverture du fichier en écriture Pour i de 0 à n-1 faire ch <- saisie_ch() # Saisie d'une chaîne Si long_max < long(ch) alors long_max <- long(ch) # Mise à jour de la longueur maximale Finsi Ecrire(f , ch + '\n') # Écriture dans le fichier Fin si Fermer(f) # Fermeture du fichier Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| long_max | entier (variable globale) |
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 |
# -------------------------------------------------- # Fonction qui permet de saisir un entier n tel que 0 < n < 50 # -------------------------------------------------- def saisie_n(): n = int(input('donner n telque 0<n<50: ')) # Tant que n n'est pas compris dans l'intervalle demandé while (n <= 0) or (n >= 50): n = int(input('donner n telque 0<n<50: ')) return n # -------------------------------------------------- # Fonction qui vérifie si une chaîne est formée # uniquement de chiffres et/ou de lettres # et que sa longueur est comprise entre 1 et 9 # -------------------------------------------------- def verif_ch(ch): if 1 <= len(ch) <= 9: # Vérification de la longueur de la chaîne i = 0 # Vérification caractère par caractère sauf le dernier while (('0' <= ch[i] <= '9') or ('A' <= ch[i].upper() <= 'Z')) and i < len(ch) - 1: i = i + 1 # Vérification du dernier caractère return ('0' <= ch[i] <= '9') or ('A' <= ch[i].upper() <= 'Z') else: return False # -------------------------------------------------- # Fonction qui permet de saisir une chaîne valide # (lettres et/ou chiffres uniquement) # -------------------------------------------------- def saisie_ch(): ch = input('donner une chaine formee des chiffres et/ou lettres: ') # Tant que la chaîne n'est pas valide, on redemande la saisie while verif_ch(ch) == False: ch = input('donner une chaine formee des chiffres et/ou lettres: ') return ch # -------------------------------------------------- # Fonction qui extrait uniquement les chiffres # d'une chaîne de caractères # -------------------------------------------------- def extraire_chiffres(ch): nombre = '' for i in range(len(ch)): if '0' <= ch[i] <= '9': # Si le caractère est un chiffre nombre = nombre + ch[i] return nombre # -------------------------------------------------- # Fonction qui teste si un nombre est divisible par 11 # en utilisant la règle de divisibilité par 11 # -------------------------------------------------- def test_divisible11(nombre): spair = 0 # Somme des chiffres de rang pair simpair = 0 # Somme des chiffres de rang impair for i in range(len(nombre)): if i % 2 == 0: spair = spair + int(nombre[i]) else: simpair = simpair + int(nombre[i]) # Le nombre est divisible par 11 si la différence # des deux sommes est un multiple de 11 return abs(spair - simpair) % 11 == 0 # -------------------------------------------------- # Fonction qui remplit deux fichiers : # - chaines.txt : contient les chaînes saisies # - nombres.dat : contient le résultat du test de divisibilité par 11 # -------------------------------------------------- def remplir_fichiers(n): f_chaine = open("chaines.txt", "w") # Fichier des chaînes f_nombre = open("nombres.dat", "w") # Fichier des résultats for i in range(n): ch = saisie_ch() # Saisie d'une chaîne valide f_chaine.write(ch + '\n') # Écriture de la chaîne dans le fichier # Extraction des chiffres de la chaîne if len(extraire_chiffres(ch)) > 0: nombre = extraire_chiffres(ch) # Test de divisibilité par 11 if test_divisible11(nombre): print(nombre + ' est divisible par 11') f_nombre.write(nombre + ' est divisible par 11\n') else: print(nombre + ' n est pas divisible par 11') f_nombre.write(nombre + ' n est pas divisible par 11\n') else: # Cas où la chaîne ne contient aucun chiffre print('1999999999 n est pas un nombre decimal') f_nombre.write('1999999999 n est pas un nombre decimal\n') # Fermeture des fichiers f_chaine.close() f_nombre.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie_n() # Saisie du nombre de chaînes à traiter remplir_fichiers(n) # Remplissage des fichiers |
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
