Cryptage image – Bac pratique – Section informatique – 2021

Bac Info 15-01-26

14 0

Sujet (Algo et programmation - Bac 2021)

Soit une image numérique dont les valeurs des pixels sont représentées par des nombres hexadécimaux enregistres dans un fichier texte nomme "ImgHexa.txt" à raison d'un nombre par ligne.

Aim de crypter le contenu du fichier "Inigllexa.txt", on utilise le Principe suivant :

1- Transférer le contenu du fichier "Ilmgileln.txt" vers un tableau d'enregistrements T. Chaque enregistrement est forme de trois champs commi suit :

- He : contient le nombre hexadécimal.

- Num : contient le numéro de la ligne du nombre hexadécimal dans le fichier.

- Dec contient l'équivalent décimal du nombre hexadécimal.

2- Trier le tableau T dans l'ordre croissant des valeurs du champ Dee.

3- Générer un code. sous forme (rune chaines de caractères. pour chaque nombre décimal du tableau T et l'enregistrer ainsi que son numéro de ligne Num dans Lin fichier texte nomme "Resultat.txt". Chaque ligne du fichier contiendra le code généré suivi par son numéro de ligne séparés par un espace.

NB : Utiliser la fonction Genere ci-dessous qui permet de générer un code a partir d'un nombre décimal Nb.

Fonction generer(nb):mot
Début
     mot<-''
     r <- nb mod 3
     Selon r faire
       0 : y <- "Ma"
       1 : y <- "Des"
       2 : y <- "Son"
     Fin selon
     mot <- y+mot
     nb <- nb div 3 
     Tant que (nb!=0) faire
       r <- nb mod 3
       Selon r faire
         0 : y  <- "Ma"
         1 : y <- "Des"
         2 : y <- "Son"
       Fin selon
       mot <- y+mot
       nb <- nb div 3
     Fin selon
     retourner mot
Fin

Fonction generer(nb):mot

Début

mot<-''

r <- nb mod 3

Selon r faire

0 : y <- "Ma"

1 : y <- "Des"

2 : y <- "Son"

Fin selon

mot <- y+mot

nb <- nb div 3

Tant que (nb!=0) faire

r <- nb mod 3

Selon r faire

0 : y <- "Ma"

1 : y <- "Des"

2 : y <- "Son"

Fin selon

mot <- y+mot

nb <- nb div 3

Fin selon

retourner mot

Fin

Travail demandé :

En utilisant un éditeur de texte disponible (Bloc-notes. Notepad, Notepad++, ...), créer un fichier texte nommé "ImgHexa.txt" et y saisir les nombres hexadécimaux ci-dessous, représentant les valeurs des pixels d'une image. a raison d'un nombre par ligne.

41, 26. 4D. 2D, 37. 74, AB, 26, 85, 68, 37, 82, AE, 94, 80, 35, 44, BO, 87, 56, 8C. 8E, SD, 8B, 38, 48

Ecrire un programme en Python intitule Cryptage qui permet de crier et de remplir un fichier texte "Resultat.1x1" par le résultat de cryptage du contenu du fichier texte "ImgHexa.txt" en utilisant le principe décrit précédemment.

Solution Algorithmique

Dans cet algorithme, On va utiliser trois fonctions et cinq procédures:

- la fonction exposant()

- la fonction conversion_decimale()

- la procédure remplir_tableau()

- la procédure afficher_tableau()

- la procédure trier_tableau()

- la fonction generer()

- la procédure remplir_fichier_resultat()

- la procédure afficher_fichier_resultat()

Algorithme du programme Principal

Algorithme cryptage
Debut 
      index = 0

# Remplissage du tableau à partir du fichier
remplir_tableau(t)

# Tri du tableau selon la valeur décimale
trier_tableau(t, index)

print('*** Tableau T trie ***')
afficher_tableau(t, index)

# Génération du fichier résultat
remplir_fichier_resultat(t, index)

print('*** Contenu du fichier Resultat ***')
afficher_fichier_resultat()

Fin

Algorithme cryptage

Debut

index = 0

# Remplissage du tableau à partir du fichier

remplir_tableau(t)

# Tri du tableau selon la valeur décimale

trier_tableau(t, index)

print('*** Tableau T trie ***')

afficher_tableau(t, index)

# Génération du fichier résultat

remplir_fichier_resultat(t, index)

print('*** Contenu du fichier Resultat ***')

afficher_fichier_resultat()

Fin

Déclaration des objets

Objet	Type / Nature
index	entier
t	tableau

La fonction exposant

Cette fonction permet de calculer la puissance d’un nombre entier

Fonction exposant(n:entier;e:entier):entier
    p <- 1
    Pour i de 0 à e-1 faire
        p <- p * n
    Fin pour
    retourner p 
Fin

Fonction exposant(n:entier;e:entier):entier

p <- 1

Pour i de 0 à e-1 faire

p <- p * n

Fin pour

retourner p

Fin

Déclaration des objets

Objet	Type / Nature
p	entier

La fonction conversion_decimale

Le rôle de cette fonction est de convertir un nombre écrit en base 16 (hexadécimal) sous forme de chaîne de caractères en un nombre entier en base 10 (décimal).

Fonction conversion_decimale(nombre_hexa:chaîne):entier
    decimal <- 0      # Résultat en base 10
    puissance <- 1    # Représente 16^0 au départ
    
    # Parcours de la chaîne de droite à gauche
    Pour i de long(nombre_hexa)-1 à 0 (pas=-1) faire
        chiffre <- nombre_hexa[i]
        
        # Conversion du caractère en valeur numérique
        Si '0' <= chiffre <= '9' alors
            valeur <- ord(chiffre) - ord('0')
        Sinon
            valeur <- ord(chiffre) - ord('A') + 10
        Fin si
        # Ajout de la contribution du chiffre
        decimal = decimal + valeur * puissance
        
        # Passage à la puissance suivante de 16
        puissance <- puissance * 16
    Fin pour
    retourner decimal  
 Fin

Fonction conversion_decimale(nombre_hexa:chaîne):entier

decimal <- 0 # Résultat en base 10

puissance <- 1 # Représente 16^0 au départ

# Parcours de la chaîne de droite à gauche

Pour i de long(nombre_hexa)-1 à 0 (pas=-1) faire

chiffre <- nombre_hexa[i]

# Conversion du caractère en valeur numérique

Si '0' <= chiffre <= '9' alors

valeur <- ord(chiffre) - ord('0')

Sinon

valeur <- ord(chiffre) - ord('A') + 10

Fin si

# Ajout de la contribution du chiffre

decimal = decimal + valeur * puissance

# Passage à la puissance suivante de 16

puissance <- puissance * 16

Fin pour

retourner decimal

Fin

Déclaration des objets

Objet	Type / Nature
decimal	entier
puissance	entier
chiffre	chaîne
valeur	valeur

La procédure remplir_tableau

Le rôle de cette procédure est de lire les nombres hexadécimaux contenus dans le fichier ImgHexa.txt et de remplir le tableau t avec des enregistrements contenant leurs informations.

Procédure remplir_tableau(t:tableau)
    # Ouverture du fichier en lecture
    Ouvrir (f , "ImgHexa.txt", "r")
    
    # Lecture de toutes les lignes du fichier
    nombres_hexa <- Lire_lignes(f)
    
    Pour nombre_hexa dans nombres_hexa faire
        nombre_hexa <- nombre_hexa.strip('\n')  # Suppression du retour à la ligne
        
        # Création d'un enregistrement sous forme de dictionnaire
        enregistrement = Enregistrement(
            Hex=str(),   # Valeur hexadécimale
            Num=int(),   # Numéro d'ordre
            Dec=int()    # Valeur décimale
        )
        
        # Remplissage du dictionnaire
        enregistrement['Hex'] <- nombre_hexa
        enregistrement['Num'] <- index + 1
        enregistrement['Dec'] <- conversion_decimale(nombre_hexa)
        
        # Stockage dans le tableau
        t[index] <- enregistrement
        index <- index + 1
    Fin pour   
Fin

Procédure remplir_tableau(t:tableau)

# Ouverture du fichier en lecture

Ouvrir (f , "ImgHexa.txt", "r")

# Lecture de toutes les lignes du fichier

nombres_hexa <- Lire_lignes(f)

Pour nombre_hexa dans nombres_hexa faire

nombre_hexa <- nombre_hexa.strip('\n') # Suppression du retour à la ligne

# Création d'un enregistrement sous forme de dictionnaire

enregistrement = Enregistrement(

Hex=str(), # Valeur hexadécimale

Num=int(), # Numéro d'ordre

Dec=int() # Valeur décimale

)

# Remplissage du dictionnaire

enregistrement['Hex'] <- nombre_hexa

enregistrement['Num'] <- index + 1

enregistrement['Dec'] <- conversion_decimale(nombre_hexa)

# Stockage dans le tableau

t[index] <- enregistrement

index <- index + 1

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
nombres_hexa	chaîne
nombre_hexa	chaîne
enregistrement	Enregistrement
index	entier (variale globale)

La procédure afficher_tableau

Cette procédure affiche à l’écran les n premiers enregistrements du tableau t.

Procédure afficher_tableau(t:tableau;n:entier):
    Pour i de 0 à n-1 faire
        Ecrire(t[i])
    Fin pour
Fin

Procédure afficher_tableau(t:tableau;n:entier):

Pour i de 0 à n-1 faire

Ecrire(t[i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure trier_tableau

Cette procédure trie le tableau t par ordre croissant en se basant sur le champ Dec en utilisant la méthode du tri par sélection.

Procédure trier_tableau(t:tableau; n:entier)
    Pour i de 0 à n-2 faire
        min_index <- i
        
        # Recherche du plus petit élément
        Pour j de i à n-1
            Si t[min_index]['Dec'] > t[j]['Dec'] alors
                min_index <- j
            Fin si
        Fin pour
        # Échange des éléments si nécessaire
        Si min_index != i alors
            temp <- t[i]['Hex']
            t[i]['Hex'] <- t[min_index]['Hex']
            t[min_index]['Hex'] <- temp
            
            temp <- t[i]['Num']
            t[i]['Num'] <- t[min_index]['Num']
            t[min_index]['Num'] <- temp
            
            temp <- t[i]['Dec']
            t[i]['Dec'] <- t[min_index]['Dec']
            t[min_index]['Dec'] <- temp
        Fin si
    Fin pour  
Fin

Procédure trier_tableau(t:tableau; n:entier)

Pour i de 0 à n-2 faire

min_index <- i

# Recherche du plus petit élément

Pour j de i à n-1

Si t[min_index]['Dec'] > t[j]['Dec'] alors

min_index <- j

Fin si

Fin pour

# Échange des éléments si nécessaire

Si min_index != i alors

temp <- t[i]['Hex']

t[i]['Hex'] <- t[min_index]['Hex']

t[min_index]['Hex'] <- temp

temp <- t[i]['Num']

t[i]['Num'] <- t[min_index]['Num']

t[min_index]['Num'] <- temp

temp <- t[i]['Dec']

t[i]['Dec'] <- t[min_index]['Dec']

t[min_index]['Dec'] <- temp

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
min_index	entier
j	entier
temp	entier

La procédure remplir_fichier_resultat

Cette procédure trie le tableau t par ordre croissant en se basant sur le champ Dec en utilisant la méthode du tri par sélection.

Procédure remplir_fichier_resultat(t:tableau; n:entier)
    # Ouverture du fichier en écriture
    Ouvrir(f , "Resultat.txt", "w")

    Pour i de 0 à n-1
       code <- generer(t[i]['Dec'])
       Ecrire(f , code + ' ' + Convch(t[i]['Num']) + '\n')
    Fin pour
    Fermer(f)
Fin

Procédure remplir_fichier_resultat(t:tableau; n:entier)

# Ouverture du fichier en écriture

Ouvrir(f , "Resultat.txt", "w")

Pour i de 0 à n-1

code <- generer(t[i]['Dec'])

Ecrire(f , code + ' ' + Convch(t[i]['Num']) + '\n')

Fin pour

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
i	entier
code	chaîne

Solution en Python

from numpy import *

# --------------------------------------------------
# Création d'un tableau 'serie' de 100 entiers initialisés à 0
# Utilisé plus tard dans la fonction divis7
# --------------------------------------------------
serie = array([int()] * 100)

# --------------------------------------------------
# Fonction qui saisit un entier n >= 5
# --------------------------------------------------
def saisie():
    # Saisie initiale
    n = int(input('donner un nombre >=5: '))

    # Vérification de la validité de la saisie
    while not (n >= 5):
        n = int(input('donner un nombre >=5: '))

    # Retourner la valeur valide
    return n

# --------------------------------------------------
# Procédure qui remplit le fichier "Nombre.txt"
# avec n entiers saisis par l'utilisateur
# --------------------------------------------------
def remplir_fichier_nombre(n):
    print('*** Remplir fichier Nombre.txt ***')

    # Ouverture du fichier en écriture
    f = open("Nombre.txt", "w")

    # Saisie et écriture des entiers dans le fichier
    for i in range(n):
        nbr = input('donner un entier: ')
        f.write(nbr + '\n')  # Chaque entier est écrit sur une nouvelle ligne

    # Fermeture du fichier
    f.close()

# --------------------------------------------------
# Fonction qui vérifie si un nombre est divisible par 13
# en utilisant une méthode de regroupement des 3 derniers chiffres
# --------------------------------------------------
def divis13(n):
    s = 0      # Somme partielle
    sg = -1    # Alternance du signe (-1, +1)
    
    # Tant que le nombre a plus de 3 chiffres
    while len(n) > 3:
        # Prendre les 3 derniers chiffres
        v = int(n[len(n)-3:len(n)])
        s = s + v * sg   # Ajouter à la somme avec le signe
        sg = -sg         # Inverser le signe pour la prochaine tranche
        n = n[0:len(n)-3]  # Retirer les 3 derniers chiffres
    
    # Ajouter les chiffres restants
    v = int(n)
    s = s + v * sg
    
    # Retourner True si divisible par 13, False sinon
    return abs(s) % 13 == 0

# --------------------------------------------------
# Fonction qui vérifie si un nombre est divisible par 7
# en utilisant la série [1,3,2,-1,-3,-2] de manière répétitive
# --------------------------------------------------
def divis7(n, serie):
    # Réduire le nombre à un chiffre par itérations
    while len(n) != 1:
        s = 0
        k = 0
        for i in range(len(n)):
            # Somme pondérée selon la série
            s = s + int(n[len(n)-1-i]) * serie[k]
            if k < 5:
                k = k + 1
            else:
                k = 0
        n = str(s)  # Réduire le nombre à la somme calculée
    
    # Vérification finale : divisible par 7 si résultat = 0 ou 7
    if n == '7' or n == '0':
        return True
    else:
        return False

# --------------------------------------------------
# Procédure qui remplit les fichiers "Div13.txt" et "Div7.txt"
# --------------------------------------------------
def remplir_fichiers_div():
    # Ouverture des fichiers
    f_nbr = open("Nombre.txt", "r")  # Fichier source
    f_div13 = open("Div13.txt", "w") # Fichier pour les nombres divisibles par 13
    f_div7 = open("Div7.txt", "w")   # Fichier pour les nombres divisibles par 7
    
    # Lecture de tous les nombres
    nombres = f_nbr.readlines()
    for nombre in nombres:
        nombre = nombre.strip('\n')  # Supprimer le saut de ligne
        if divis13(nombre):          # Vérifier divisibilité par 13
            f_div13.write(nombre + '\n')
        if divis7(nombre, serie):   # Vérifier divisibilité par 7
            f_div7.write(nombre + '\n')
    
    # Fermeture des fichiers
    f_nbr.close()
    f_div13.close()
    f_div7.close()

# --------------------------------------------------
# Procédure qui affiche le contenu d'un fichier
# --------------------------------------------------
def afficher_fichiers_div(nom_fichier):
    print('*** Contenu fichier ' + nom_fichier + ' ***')
    
    # Ouverture en lecture
    f = open(nom_fichier, "r")
    nombres = f.readlines()
    
    # Affichage ligne par ligne
    for nombre in nombres:
        nombre = nombre.strip('\n')
        print(nombre)
    
    # Fermeture du fichier
    f.close()

# --------------------------------------------------
# Initialisation de la série utilisée pour divis7
# --------------------------------------------------
serie[0] = 1
serie[1] = 3
serie[2] = 2
serie[3] = -1
serie[4] = -3
serie[5] = -2

# --------------------------------------------------
# Programme principal
# --------------------------------------------------
n = saisie()                          # Saisie du nombre d'entiers
remplir_fichier_nombre(n)             # Remplissage du fichier Nombre.txt
remplir_fichiers_div()                # Remplissage des fichiers Div13.txt et Div7.txt
afficher_fichiers_div("Div13.txt")   # Affichage des nombres divisibles par 13
afficher_fichiers_div("Div7.txt")    # Affichage des nombres divisibles par 7

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

from numpy import *

# --------------------------------------------------

# Création d'un tableau 'serie' de 100 entiers initialisés à 0

# Utilisé plus tard dans la fonction divis7

# --------------------------------------------------

serie = array([int()] * 100)

# --------------------------------------------------

# Fonction qui saisit un entier n >= 5

# --------------------------------------------------

def saisie():

# Saisie initiale

n = int(input('donner un nombre >=5: '))

# Vérification de la validité de la saisie

while not (n >= 5):

n = int(input('donner un nombre >=5: '))

# Retourner la valeur valide

return n

# --------------------------------------------------

# Procédure qui remplit le fichier "Nombre.txt"

# avec n entiers saisis par l'utilisateur

# --------------------------------------------------

def remplir_fichier_nombre(n):

print('*** Remplir fichier Nombre.txt ***')

# Ouverture du fichier en écriture

f = open("Nombre.txt", "w")

# Saisie et écriture des entiers dans le fichier

for i in range(n):

nbr = input('donner un entier: ')

f.write(nbr + '\n') # Chaque entier est écrit sur une nouvelle ligne

# Fermeture du fichier

f.close()

# --------------------------------------------------

# Fonction qui vérifie si un nombre est divisible par 13

# en utilisant une méthode de regroupement des 3 derniers chiffres

# --------------------------------------------------

def divis13(n):

s = 0 # Somme partielle

sg = -1 # Alternance du signe (-1, +1)

# Tant que le nombre a plus de 3 chiffres

while len(n) > 3:

# Prendre les 3 derniers chiffres

v = int(n[len(n)-3:len(n)])

s = s + v * sg # Ajouter à la somme avec le signe

sg = -sg # Inverser le signe pour la prochaine tranche

n = n[0:len(n)-3] # Retirer les 3 derniers chiffres

# Ajouter les chiffres restants

v = int(n)

s = s + v * sg

# Retourner True si divisible par 13, False sinon

return abs(s) % 13 == 0

# --------------------------------------------------

# Fonction qui vérifie si un nombre est divisible par 7

# en utilisant la série [1,3,2,-1,-3,-2] de manière répétitive

# --------------------------------------------------

def divis7(n, serie):

# Réduire le nombre à un chiffre par itérations

while len(n) != 1:

s = 0

k = 0

for i in range(len(n)):

# Somme pondérée selon la série

s = s + int(n[len(n)-1-i]) * serie[k]

if k < 5:

k = k + 1

else:

k = 0

n = str(s) # Réduire le nombre à la somme calculée

# Vérification finale : divisible par 7 si résultat = 0 ou 7

if n == '7' or n == '0':

return True

else:

return False

# --------------------------------------------------

# Procédure qui remplit les fichiers "Div13.txt" et "Div7.txt"

# --------------------------------------------------

def remplir_fichiers_div():

# Ouverture des fichiers

f_nbr = open("Nombre.txt", "r") # Fichier source

f_div13 = open("Div13.txt", "w") # Fichier pour les nombres divisibles par 13

f_div7 = open("Div7.txt", "w") # Fichier pour les nombres divisibles par 7

# Lecture de tous les nombres

nombres = f_nbr.readlines()

for nombre in nombres:

nombre = nombre.strip('\n') # Supprimer le saut de ligne

if divis13(nombre): # Vérifier divisibilité par 13

f_div13.write(nombre + '\n')

if divis7(nombre, serie): # Vérifier divisibilité par 7

f_div7.write(nombre + '\n')

# Fermeture des fichiers

f_nbr.close()

f_div13.close()

f_div7.close()

# --------------------------------------------------

# Procédure qui affiche le contenu d'un fichier

# --------------------------------------------------

def afficher_fichiers_div(nom_fichier):

print('*** Contenu fichier ' + nom_fichier + ' ***')

# Ouverture en lecture

f = open(nom_fichier, "r")

nombres = f.readlines()

# Affichage ligne par ligne

for nombre in nombres:

nombre = nombre.strip('\n')

print(nombre)

# Fermeture du fichier

f.close()

# --------------------------------------------------

# Initialisation de la série utilisée pour divis7

# --------------------------------------------------

serie[0] = 1

serie[1] = 3

serie[2] = 2

serie[3] = -1

serie[4] = -3

serie[5] = -2

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

n = saisie() # Saisie du nombre d'entiers

remplir_fichier_nombre(n) # Remplissage du fichier Nombre.txt

remplir_fichiers_div() # Remplissage des fichiers Div13.txt et Div7.txt

afficher_fichiers_div("Div13.txt") # Affichage des nombres divisibles par 13

afficher_fichiers_div("Div7.txt") # Affichage des nombres divisibles par 7

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Cryptage image – Bac pratique – Section informatique – 2021

Bac Info 15-01-26

Divisibilité par 13 et 7 – Bac pratique – Section informatique – 2020

Bac Info 14-01-26

Crypter un message – Bac théorique – Section informatique – 2019

Bac Info 13-01-26

Calcul du PPCM – Bac pratique – Section informatique – 2019

Bac Info 13-01-26

Simulation de la multiplication – Bac théorique – Section informatique – 2018

Bac Info 12-01-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 10920vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 10474vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9278vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino UNO 8885vues

Allumer une LED par la carte ESP32

ESP32 8877vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 28 commentaires

Premiers pas avec Micro:bit et MakeCode

Micro:bit 23 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino UNO 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Cryptage image – Bac pratique – Section informatique – 2021

Sujet (Algo et programmation - Bac 2021)

Solution Algorithmique

Algorithme du programme Principal

La fonction exposant

La fonction conversion_decimale

La procédure remplir_tableau

La procédure afficher_tableau

La procédure trier_tableau

La procédure remplir_fichier_resultat

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles