Examen du Baccalauréat Informatique : Fichiers, Matrices, Cryptographie

République Tunisienne
Ministère de l'Éducation EXAMEN DU BACCALAURÉAT Section : Informatique Durée : 3 heures Coeff. : 4
ÉPREUVE : FICHIERS · MATRICES · CRYPTOGRAPHIE
Baccalauréat Informatique | Année scolaire 2024–2025
Contexte : Un fichier texte mot.txt contient, sur une seule ligne, des mots en MAJUSCULES et des entiers
positifs séparés par des espaces. On note n le nombre total d'éléments lus (mots + nombres).
EXERCICE UNIQUE
Q
1Lire le fichier mot.txt et séparer son contenu en deux listes : mots (chaînes de caractères) et nombres
(entiers). Afficher les deux listes.
Q
2Parmi la liste mots, identifier et afficher les palindromes (mots qui se lisent identiquement dans les
deux sens).
Q
3Créer une matrice carrée dynamique de taille p×p, où p est le plus petit entier vérifiant p² ≥ n. La
remplir ligne par ligne avec tous les éléments lus (mots d'abord, puis nombres) ; les cases vides
reçoivent la valeur '*'. Afficher la matrice.
Q
4Extraire la diagonale principale et la diagonale secondaire de la matrice. Parmi les éléments qui
sont des mots, afficher ceux dont la longueur est un nombre premier.
Q
5Depuis la liste nombres, identifier les nombres premiers. Demander à l'utilisateur une base b (2 ≤ b ≤
16) et convertir chaque nombre premier dans cette base. Afficher les résultats.
Q
6Calculer la clé de chiffrement :
K = ( A(n, 2) + C(n, 2) ) mod 26
avec A(n,2) = n×(n−1) et C(n,2) = n×(n−1) / 2.
Q
7Crypter chaque mot sélectionné en Q4 en appliquant, pour chaque caractère :
① Code ASCII du caractère ② Conversion en base b ③ Inversion des chiffres ④ Reconversion en
décimal ⑤ Ajout de K ⑥ Caractère chr() correspondant.
Afficher chaque mot original et son mot crypté.
Q
8Organiser tous les mots cryptés dans une nouvelle matrice carrée de taille p, triés par ordre
lexicographique. Les cases vides restent à '*'. Afficher cette matrice.
Q
9Sauvegarder dans le fichier binaire resultat.dat : la clé K, la liste des mots cryptés et la matrice
cryptée.
Q
1
0
Relire le fichier resultat.dat et afficher son contenu. Comparer les mots cryptés relus avec ceux
calculés en Q7 et afficher 'OK' ou 'ERREUR'.

CORRIGÉ — ÉLÉMENTS DE CORRECTION
Baccalauréat Informatique — Fichiers · Matrices · Cryptographie
Fichier mot.txt utilisé dans les exemples :
RADAR BONJOUR KAYAK NIVEAU LEVEL 3 7 11 4 13
→ mots = ['RADAR','BONJOUR','KAYAK','NIVEAU','LEVEL']
→ nombres = [3, 7, 11, 4, 13]
→ n = 10
Q1 — Lecture et séparation
Algorithme :
Algorithme Lire_Fichier(nomFichier) Variables : ligne, elem : Chaîne mots : Liste de chaînes
nombres : Liste d'entiers Début Ouvrir nomFichier en lecture Lire ligne Pour chaque elem dans
Découper(ligne, ' ') Faire Si EstNombre(elem) Alors Ajouter Entier(elem) à nombres Sinon Ajouter
elem à mots FinSi FinPour Fermer nomFichier Afficher "Mots :", mots Afficher "Nombres :",
nombres Retourner mots, nombres Fin
Code Python :
def lire_fichier(nom): mots, nombres = [], [] with open(nom, 'r') as f: for elem in
f.read().split(): if elem.lstrip('-').isdigit(): nombres.append(int(elem)) else:
mots.append(elem) print("Mots :", mots) print("Nombres :", nombres) return mots, nombres mots,
nombres = lire_fichier('mot.txt') n = len(mots) + len(nombres)
# Sortie : # Mots : ['RADAR', 'BONJOUR', 'KAYAK', 'NIVEAU', 'LEVEL'] # Nombres : [3, 7, 11,
4, 13]
Q2 — Palindromes
Algorithme :
Algorithme Est_Palindrome(mot) : Booléen Début Retourner mot = Inverser(mot) Fin Algorithme
Afficher_Palindromes(mots) Début Pour chaque mot dans mots Faire Si Est_Palindrome(mot) Alors
Afficher mot FinSi FinPour Fin
Code Python :
def est_palindrome(mot): return mot == mot[::-1] palindromes = [m for m in mots if
est_palindrome(m)] print("Palindromes :", palindromes)
# Sortie : # Palindromes : ['RADAR', 'KAYAK', 'LEVEL']
Q3 — Matrice carrée dynamique
Algorithme :
Algorithme Creer_Matrice(mots, nombres, n) Variables : p, i, j, k : Entier elements : Liste
matrice : Tableau 2D Début p ← Plafond(Racine(n)) elements ← mots + nombres Créer matrice p×p
remplie de '*' k ← 0 Pour i ← 0 à p-1 Faire Pour j ← 0 à p-1 Faire Si k < n Alors matrice[i][j]
← elements[k] k ← k + 1 FinSi FinPour FinPour Afficher matrice Retourner matrice, p Fin
Code Python :
import math def creer_matrice(mots, nombres, n): p = math.ceil(math.sqrt(n)) elements = mots +
[str(x) for x in nombres] matrice = [['*'] * p for _ in range(p)] k = 0 for i in range(p): for j
in range(p): if k < n: matrice[i][j] = elements[k] k += 1 for ligne in matrice: print(ligne)
return matrice, p matrice, p = creer_matrice(mots, nombres, n)
# Sortie (n=10, p=4) : # ['RADAR', 'BONJOUR', 'KAYAK', 'NIVEAU'] # ['LEVEL', '3', '7', '11' ]
# ['4', '13', '*', '*' ] # ['*', '*', '*', '*' ]

Q4 — Diagonales et longueurs premières
Algorithme :
Algorithme Est_Premier(n) : Booléen Début Si n < 2 Alors Retourner Faux Pour i ← 2 à Racine(n)
Faire Si n mod i = 0 Alors Retourner Faux FinPour Retourner Vrai Fin Algorithme
Diagonales_Filtre(matrice, p) Variables : i : Entier diag_p, diag_s, selection : Listes Début
Pour i ← 0 à p-1 Faire Ajouter matrice[i][i] à diag_p Ajouter matrice[i][p-1-i] à diag_s FinPour
Pour chaque elem dans (diag_p + diag_s) sans doublons Faire Si EstChaîne(elem) ET elem≠'*' ET
Est_Premier(Longueur(elem)) Alors Ajouter elem à selection FinSi FinPour Afficher "Diag.
principale :", diag_p Afficher "Diag. secondaire :", diag_s Afficher "Sélection :", selection
Retourner selection Fin
Code Python :
def est_premier(n): if n < 2: return False for i in range(2, int(n**0.5)+1): if n % i == 0:
return False return True def diagonales_filtre(matrice, p): diag_p = [matrice[i][i] for i in
range(p)] diag_s = [matrice[i][p-1-i] for i in range(p)] # union sans doublons, ordre conservé
vus, tous = set(), [] for e in diag_p + diag_s: if e not in vus: tous.append(e); vus.add(e)
select = [e for e in tous if isinstance(e, str) and e != '*' and est_premier(len(e))]
print("Diag. principale :", diag_p) print("Diag. secondaire :", diag_s) print("Mots sélectionnés
:", select) return select mots_selec = diagonales_filtre(matrice, p)
# Sortie : # Diag. principale : ['RADAR', 'BONJOUR'(7✓), '3', '*'] ← len 5✓ et 7✓ # Diag.
secondaire : ['NIVEAU', 'LEVEL'(5✓), '7', '*'] ← len 6✗ et 5✓ # Mots sélectionnés :
['RADAR', 'BONJOUR', 'LEVEL']
Q5 — Nombres premiers en base b
Algorithme :
Algorithme Convertir_Base(nb, b) : Chaîne Variables : digits : "0123456789ABCDEF" ; res : Chaîne
Début Si nb = 0 Alors Retourner "0" res ← "" Tant que nb > 0 Faire res ← digits[nb mod b] + res
nb ← nb div b FinTantQue Retourner res Fin Algorithme Premiers_En_Base(nombres, b) Début Pour
chaque x dans nombres Faire Si Est_Premier(x) Alors Afficher x, "→", Convertir_Base(x, b) FinSi
FinPour Fin
Code Python :
DIGITS = "0123456789ABCDEF" def convertir_base(nb, b): if nb == 0: return "0" res = "" while nb >
0: res = DIGITS[nb % b] + res nb //= b return res b = int(input("Entrez la base b (2 ≤ b ≤ 16) :
")) premiers_nb = [x for x in nombres if est_premier(x)] print("Nombres premiers :",
premiers_nb) for x in premiers_nb: print(f" {x} → base {b} : {convertir_base(x, b)}")
# Sortie (b=2) : # Nombres premiers : [3, 7, 11, 13] # 3 → base 2 : 11 # 7 → base 2 : 111 #
11 → base 2 : 1011 # 13 → base 2 : 1101
Q6 — Calcul de la clé K
Algorithme :
Algorithme Calcul_K(n) : Entier Variables : A, C, K : Entier Début A ← n × (n - 1) C ← n × (n -
1) / 2 K ← (A + C) mod 26 Afficher "A(n,2) =", A, " C(n,2) =", C, " K =", K Retourner K Fin
Code Python :
def calcul_k(n): A = n * (n - 1) C = n * (n - 1) // 2 K = (A + C) % 26 print(f"A(n,2)={A}
C(n,2)={C} K={K}") return K K = calcul_k(n)
# Sortie (n=10) : # A(n,2)=90 C(n,2)=45 K=5 (car (90+45) mod 26 = 135 mod 26 = 5)

Q7 — Chiffrement
Algorithme :
Algorithme Chiffres_Base(n, b) : Liste Variables : res : Liste Début Si n = 0 Alors Retourner [0]
res ← [] Tant que n > 0 Faire Insérer (n mod b) en tête de res n ← n div b FinTantQue Retourner
res Fin Algorithme Crypter_Mot(mot, b, K) : Chaîne Variables : c, code : Entier ; chiffres, inv :
Listes ; res : Chaîne Début res ← "" Pour chaque caractère c dans mot Faire code ← ASCII(c)
chiffres ← Chiffres_Base(code, b) inv ← Inverser(chiffres) code ← BaseVersDécimal(inv, b) code
← code + K res ← res + Caractère(code) FinPour Retourner res Fin
Code Python :
def chiffres_base(n, b): if n == 0: return [0] res = [] while n > 0: res.insert(0, n % b) n //= b
return res def base_vers_decimal(chiffres, b): val = 0 for d in chiffres: val = val * b + d
return val def crypter_mot(mot, b, K): crypte = "" for c in mot: code = ord(c) chiffres =
chiffres_base(code, b) inv = chiffres[::-1] code = base_vers_decimal(inv, b) code += K crypte +=
chr(code) return crypte mots_cryptes = [] for mot in mots_selec: c = crypter_mot(mot, b, K)
mots_cryptes.append(c) print(f"{mot} → {c}")
# Sortie (b=2, K=5) : # RADAR → (mot crypté correspondant) # BONJOUR → (mot crypté
correspondant) # LEVEL → (mot crypté correspondant) # Chaque caractère : ASCII → base 2 →
inversion → décimal → +5 → chr
Q8 — Matrice des mots cryptés
Algorithme :
Algorithme Matrice_Cryptee(mots_cryptes, p) Variables : tries : Liste ; k, i, j : Entier mat_c :
Tableau p×p Début tries ← Trier(mots_cryptes) Créer mat_c p×p remplie de '*' k ← 0 Pour i ← 0 à
p-1 Faire Pour j ← 0 à p-1 Faire Si k < Taille(tries) Alors mat_c[i][j] ← tries[k] ; k ← k + 1
FinSi FinPour FinPour Afficher mat_c Retourner mat_c Fin
Code Python :
def matrice_cryptee(mots_cryptes, p): tries = sorted(mots_cryptes) mat_c = [['*'] * p for _ in
range(p)] k = 0 for i in range(p): for j in range(p): if k < len(tries): mat_c[i][j] = tries[k] k
+= 1 for ligne in mat_c: print(ligne) return mat_c mat_c = matrice_cryptee(mots_cryptes, p)
# Sortie : matrice p×p avec les mots cryptés triés # lexicographiquement, cases restantes à
'*'
Q9 — Sauvegarde dans resultat.dat
Algorithme :
Algorithme Sauvegarder(K, mots_cryptes, mat_c) Début Ouvrir "resultat.dat" en écriture binaire
Écrire_Pickle({ 'K': K, 'mots_cryptes': mots_cryptes, 'matrice': mat_c }) Fermer fichier
Afficher "Sauvegarde OK" Fin
Code Python :
import pickle def sauvegarder(K, mots_cryptes, mat_c, nom='resultat.dat'): donnees = {'K': K,
'mots_cryptes': mots_cryptes, 'matrice': mat_c} with open(nom, 'wb') as f: pickle.dump(donnees,
f) print(f"Sauvegarde OK dans '{nom}'") sauvegarder(K, mots_cryptes, mat_c)
Q10 — Relecture et vérification
Algorithme :
Algorithme Relire_Verifier(mots_cryptes_ref) Variables : donnees : Dictionnaire Début Ouvrir
"resultat.dat" en lecture binaire donnees ← Lire_Pickle() Fermer fichier Afficher "K :",
donnees['K'] Afficher "Mots cryptés :", donnees['mots_cryptes'] Afficher "Matrice :",
donnees['matrice'] Si donnees['mots_cryptes'] = mots_cryptes_ref Alors Afficher "OK" Sinon
Afficher "ERREUR" FinSi Fin
Code Python :
def relire_verifier(mots_cryptes_ref, nom='resultat.dat'): with open(nom, 'rb') as f: donnees =
pickle.load(f) print("=== Contenu de resultat.dat ===") print("K :", donnees['K']) print("Mots
cryptés :", donnees['mots_cryptes']) print("Matrice :") for ligne in donnees['matrice']: print("
", ligne) # Vérification statut = "OK" if donnees['mots_cryptes'] == mots_cryptes_ref else

"ERREUR" print("Vérification :", statut) relire_verifier(mots_cryptes)
# Sortie attendue : # === Contenu de resultat.dat === # K : 5 # Mots cryptés : [...] #
Matrice : [...] # Vérification : OK
Les algorithmes doivent déclarer toutes les variables. En Python, soigner l'indentation. La gestion des cas limites (liste vide, b
hors bornes) est valorisée.