Crypter une matrice – Bac théorique – Section informatique – 2013
Sujet (Algo et programmation - Bac 2013)
Pour permettre la diffusion d'une émission payante, une chaîne télévisée transmet périodiquement aux récepteurs des abonnés, un fichier texte nommé "F_Code.txt", généré selon le procédé suivant :
- On remplit aléatoirement une matrice carrée M de dimension NxN par des lettres majuscules.
- A partir de la matrice M, on génère un fichier texte nommé "F_Inter.txt" en parcourant la matrice M sous une forme circulaire où chaque ligne du fichier contient la concaténation des valeurs des cases du même niveau en commençant de la case du coin haut à gauche, comme le montre l'exemple ci-après.
- On remplit le fichier "F_Code.txt" de la manière suivante :
- La première ligne contient l'équivalent de N en binaire.
- Chacune des autres lignes contient les conversions en hexadécimal des codes ASCII des caractères d'une ligne du fichier "F_Inter.txt", séparés par le caractère "#".
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 trois fonctions et quatre procédures:
- la fonction saisie()
- la fonction saisie_element()
- la procédure remplir_matrice()
- la procédure afficher_matrice()
- la fonction conversion_binaire()
- la procédure concatiner_circulaire()
- la procédure afficher_fichier_Inter()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 |
Algorithme Sequence Debut Ecrire('*** Saisie la taille de la matrice ***') # Saisie de la taille de la matrice carrée n <- saisie() # Appels des différentes procédures remplir_matrice(m, n) afficher_matrice(m, n) concatiner_circulaire(m, n) afficher_fichier_Inter() Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| m | matrice |
La fonction saisie
La fonction saisie() permet à l’utilisateur de saisir un entier strictement positif, tout en vérifiant la validité de la saisie.
Le programme demande à l’utilisateur d’entrer un nombre entier n.
Si n est inférieur ou égal à 0, la saisie est refusée.
Le programme redemande la saisie autant de fois que nécessaire jusqu’à ce que l’utilisateur fournisse un entier strictement positif.
Une fois la valeur correcte saisie, elle est retournée par la fonction.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie():entier # Demande à l'utilisateur de saisir un entier n Ecrire('donner n tel que n > 0: ') Lire(n) # Tant que n est inférieur ou égal à 0, on redemande la saisie # on redemande la saisie Tant que (n <= 0) faire Ecrire('donner n tel que n > 0:') Lire(n) Fin tant que # Retourne la valeur correcte saisie retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_matrice
La procédure remplir_matrice remplit une matrice carrée M de taille n × n avec des lettres majuscules aléatoires.
La procédure parcourt la matrice ligne par ligne et colonne par colonne.
Pour chaque case m[i][j] :
- elle génère un nombre aléatoire compris entre 65 et 90 ;
- ce nombre correspond aux codes ASCII des lettres majuscules (A à Z) ;
- la fonction chr() transforme ce code en caractère.
La lettre obtenue est stockée dans la case correspondante de la matrice.
|
1 2 3 4 5 6 7 8 |
Procedure remplir_matrice(m:matrice, n:entier) Ecrire('*** Remplir la matrice M ***') Pour i de 0 à n-1 faire Pour j de 0 à n-1 faire m[i][j] <- m[i][j] = chr(Alea(65, 90)) Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure afficher_matrice
La procédure afficher_matrice afficher à l’écran le contenu d’une matrice carrée M de taille n × n de façon lisible.
Le programme affiche d’abord un message indiquant le début de l’affichage.
Il parcourt la matrice ligne par ligne :
- chaque élément m[i][j] est affiché sur la même ligne, séparé par un espace
- après l’affichage de tous les éléments d’une ligne, un retour à la ligne est effectué.
Le résultat est une représentation claire de la matrice sous forme de tableau.
|
1 2 3 4 5 6 7 8 9 |
Procedure afficher_matrice(m:matrice, l:entier, c:entier) Ecrire(''*** Contenu de la matrice M ***'') Pour i de 0 à l-1 faire Pour j de 0 à c-1 faire Ecrire(m[i][j],' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La fonction conversion_binaire
La fonction conversion_binaire convertit un entier décimal positif en sa représentation binaire.
La fonction utilise la méthode des divisions successives par 2.
À chaque itération :
- le reste de la division (n % 2) constitue un bit du nombre binaire ;
- ce bit est ajouté au début de la chaîne binaire ;
- le nombre est divisé par 2 (n // 2).
La boucle s’arrête lorsque n devient égal à 0.
La fonction retourne la chaîne contenant le nombre en binaire.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction conversion_binaire(n:entier): chaine binaire <- "" # Conversion par divisions successives par 2 Tant que n > 0 faire binaire <- Convch(n mod 2) + binaire n = n div 2 Fin tant que # Retourne la chaîne binaire obtenue retourner binaire Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| binaire | chaîne |
La procédure concatiner_circulaire
Ce programme définit une procédure concatiner_circulaire dont le rôle est de parcourir une matrice carrée M de taille n × n de manière circulaire (en spirale), de concaténer les caractères rencontrés, puis d’enregistrer les résultats dans deux fichiers.
Explication du fonctionnement
Tout d'abord, la valeur de n convertie en binaire est écrite dans le fichier F_Code.txt.
La matrice est parcourue par couches successives, de l’extérieur vers l’intérieur.
Pour chaque couche :
- les éléments sont lus dans le sens circulaire (ligne supérieure, colonne droite, ligne inférieure, colonne gauche) ;
- les caractères sont concaténés dans une chaîne mot ;
- leurs codes ASCII sont concaténés dans une chaîne code, séparés par #.
Le contenu parcouru est affiché à l’écran.
Les résultats sont enregistrés :
- dans F_Inter.txt : la chaîne des caractères concaténés ;
- dans F_Code.txt : les codes ASCII correspondants.
|
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 |
Procédure concatiner_circulaire(m:matrice, n:matrice) Ecrire('*** Contenu du fichier Long_Seq.txt ***') # Ouverture des fichiers en mode écriture Ouvrir(f_inter , "F_Inter.txt", "w") ouvrir(f_code , "F_Code.txt", "w") # Écriture de n en binaire dans le fichier F_Code.txt Ecrire( f_code, conversion_binaire(n) + '\n') k <- 0 # Parcours des couches circulaires de la matrice Tant que (k < (n div 2) + 1) faire mot <- "" # Chaîne contenant les caractères concaténés code <- "" # Chaîne contenant les codes ASCII # Parcours de la ligne supérieure de la couche Pour j de k à n - k) faire Ecrire(m[k][j], ' ') mot <- mot + m[k][j] code <- code + Conch(ord(m[k][j])) + '#' Fin pour # Parcours de la colonne droite Pour i de 1 + k à n - k -1 faire Ecrire(m[i][n - 1 - k], ' ') mot <- mot + m[i][n - 1 - k] code <- code + str(ord(m[i][n - 1 - k])) + '#' Fin pour # Parcours de la ligne inférieure Pour i de 1 + k à n - k faire Ecrire(m[n - 1 - k][n - i - 1], ' ') mot <- mot + m[n - 1 - k][n - i - 1] code <- code + str(ord(m[n - 1 - k][n - i - 1])) + '#' Fin pour # Parcours de la colonne gauche Pour j de 2 + k à n - k - 1 faire Ecrire(m[n - j][k], end=' ') mot <- mot + m[n - j][k] code <- code + str(ord(m[n - j][k])) + '#' Fin pour # Écriture des résultats dans les fichiers Ecrire(f_inter, mot + '\n') Ecrire(f_code, code + '\n') Ecrire() k <- k + 1 Fin tant que # Fermeture des fichiers Fermer(f_inter) Fermer(f_code) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_inter | fichier |
| f_code | fichier |
| mot | chaîne |
| code | chaîne |
| i | entier |
| j | entier |
| k | entier |
La procédure afficher_fichier_Inter
La procédure afficher_fichier_Inter affiche à l’écran le contenu du fichier texte F_Code.txt.
Explication du fonctionnement
La procédure affiche d’abord un message indiquant le début de l’affichage.
Elle ouvre le fichier F_Code.txt en mode lecture.
Elle lit toutes les lignes du fichier.
Chaque ligne est affichée à l’écran après suppression du caractère de fin de ligne (\n).
Le fichier est ensuite correctement fermé.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Procedure afficher_fichier_Inter() Ecrire('*** Contenu du fichier F_Code.txt ***') # Ouverture du fichier en mode lecture Ouvrir(f , "F_Code.txt", "r") # Lecture et affichage du contenu du fichier codes <- Lire_lignes(f) Pour code dans codes faire Ecrire(code) Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| codes | chaîne |
| 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 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 colonnes = 50 # Création d'une matrice M de taille 50x50 # Chaque case est initialisée par une chaîne vide m = array([[str()] * colonnes] * lignes) # -------------------------------------------------- # Fonction qui permet de saisir un entier strictement positif # -------------------------------------------------- def saisie(): # Première saisie de l'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 de n return n # -------------------------------------------------- # Procédure qui remplit la matrice M par des lettres majuscules # -------------------------------------------------- def remplir_matrice(m, n): # Parcours des lignes for i in range(n): # Parcours des colonnes for j in range(n): # Génère une lettre majuscule aléatoire (ASCII de 65 à 90) m[i][j] = chr(random.randint(65, 90)) # -------------------------------------------------- # Procédure qui affiche la matrice M à l'écran # -------------------------------------------------- def afficher_matrice(m, n): print('*** Contenu de la matrice M ***') for i in range(n): for j in range(n): # Affiche chaque élément sur la même ligne print(m[i][j], end=' ') # Retour à la ligne après chaque ligne de la matrice print() # -------------------------------------------------- # Fonction qui convertit un entier décimal en binaire # -------------------------------------------------- def conversion_binaire(n): binaire = "" # Conversion par divisions successives par 2 while n > 0: binaire = str(n % 2) + binaire n = n // 2 # Retourne la chaîne binaire obtenue return binaire # -------------------------------------------------- # Procédure qui concatène circulairement les éléments de la matrice # -------------------------------------------------- def concatiner_circulaire(m, n): print('*** Contenu du fichier Long_Seq.txt ***') # Ouverture des fichiers en mode écriture f_inter = open("F_Inter.txt", "w") f_code = open("F_Code.txt", "w") # Écriture de n en binaire dans le fichier F_Code.txt f_code.write(conversion_binaire(n) + '\n') k = 0 # Parcours des couches circulaires de la matrice while (k < (n // 2) + 1): mot = "" # Chaîne contenant les caractères concaténés code = "" # Chaîne contenant les codes ASCII # Parcours de la ligne supérieure de la couche for j in range(k, n - k): print(m[k][j], end=' ') mot = mot + m[k][j] code = code + str(ord(m[k][j])) + '#' # Parcours de la colonne droite for i in range(1 + k, n - k): print(m[i][n - 1 - k], end=' ') mot = mot + m[i][n - 1 - k] code = code + str(ord(m[i][n - 1 - k])) + '#' # Parcours de la ligne inférieure for i in range(1 + k, n - k): print(m[n - 1 - k][n - i - 1], end=' ') mot = mot + m[n - 1 - k][n - i - 1] code = code + str(ord(m[n - 1 - k][n - i - 1])) + '#' # Parcours de la colonne gauche for j in range(2 + k, n - k): print(m[n - j][k], end=' ') mot = mot + m[n - j][k] code = code + str(ord(m[n - j][k])) + '#' # Écriture des résultats dans les fichiers f_inter.write(mot + '\n') f_code.write(code + '\n') print() k = k + 1 # Fermeture des fichiers f_inter.close() f_code.close() # -------------------------------------------------- # Procédure qui affiche le contenu du fichier F_Code.txt # -------------------------------------------------- def afficher_fichier_Inter(): print('*** Contenu du fichier F_Code.txt ***') # Ouverture du fichier en mode lecture f = open("F_Code.txt", "r") # Lecture et affichage du contenu du fichier codes = f.readlines() for code in codes: print(code.strip('\n')) # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- print('*** Saisie la taille de la matrice ***') # Saisie de la taille de la matrice carrée n = saisie() # Appels des différentes procédures remplir_matrice(m, n) afficher_matrice(m, n) concatiner_circulaire(m, n) afficher_fichier_Inter() |
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
