Générer clé – Examen théorique informatique [Bac scientifique 2026]
Sujet bac informatique théorique (Bac scientifique 2026)
Les nombres premiers et leurs propriétés mathématiques sont au coeur de nombreux algorithmes de sécurité informatique. Afin d'assurer la protection des données, le responsable informatique d'une société envisage de créer et afficher un code CLE reposant sur l'exploitation des propriétés des nombres premiers, selon les étapes suivantes :
Etape 1: Saisir un entier N tel que 10 ≤ N ≤ 50.
Etape 2: Générer aléatoirement un tableau T de N entiers compris entre 2 et 100.
Etape 3: Déterminer le nombre de séquences NS formées par les entiers premiers consécutifs contenus dans le tableau T et le nombre
d'entiers premiers NP figurant dans ces séquences.
N.B. Une séquence se compose d'au moins deux entiers premiers adjacents.
Etape 4: Générer un nombre E en concaténant les entiers premiers, ayant des indices premiers, qui figurent dans les séquences selon leur ordre d'apparition.
Etape 5: Construire le code CLE par la concaténation ordonnée, de gauche vers la droite, les nombres NS, NP et E.
Etape 6: Répéter les étapes de 2 à 5 jusqu'à obtenir un code CLE composé d'au moins 8 chiffres.
Travail demandé :
1) Écrire un algorithme du programme principal, solution à ce problème, en le décomposant en
modules.
2) Écrire un algorithme de chaque module envisagé.
Solution Algorithmique
Dans cet algorithme, On va utiliser trois fonctions et deux procédures :
- la fonction saisie_n()
- la procédure remplir()
- la fonction somme_chiffres()
- la fonction test_nombre_fort()
- la procédure NbrFort()
Algorithme du programme Principal
Le programme principal permet de saisir la taille du tableau, de le remplir par des nombres aléatoires, puis de générer une clé dont la longueur est au moins égale à 8 caractères en répétant le remplissage si nécessaire, avant d'afficher cette clé.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Algorithme generation_cle Debut # Saisie de la taille du tableau n <- saisie_n() # Premier remplissage du tableau remplir(t, n) # Tant que la clé générée contient moins de 8 caractères, # on génère un nouveau tableau aléatoire. Tant que (long(generer_cle(t, n)) < 8) faire remplir(t, n) # Affichage de la clé obtenue Ecrire("Clé = ", generer_cle(t, n)) Fin tant que Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| t | tableau des entiers |
La fonction saisie_n
Cette fonction permet de saisir et retourner un entier entre 10 et 50 en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_n():entier Ecrire('saisir 10<=n<=50: ') Lire(n) # Tant que la valeur saisie n’est pas valide, on redemande Tant que Non (10<=n<=50) faire Ecrire('saisir 10<=n<=50: ') Lire(n) Fin tant que retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir
Cette procédure permet de remplir un tableau t avec n valeurs aléatoires comprises entre 2 et 100.
|
1 2 3 4 5 6 |
Procédure remplir(t:tab, n:entier) # Génération de n valeurs aléatoires entre 2 et 100 Pour i de 0 à n-1 faire t[i] = Aléa(2, 100) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction test_premier
Cette fonction permet de déterminer si un nombre entier n est un nombre premier ou non.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Fonction test_premier(n:entier):booléen # 1 n'est pas premier Si n = 1 alors retourner Faux # 2 est premier Sinon: Si n = 2 alors retourner Vrai # Vérification des diviseurs de 2 à n//2 Sinon i <- 2 Tant que (i <= n div 2) et (n div i != 0) faire i <- i + 1 Fin tant que # Si aucun diviseur trouvé → nombre premier retourner (n mod i != 0) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction generer_cle
Cette fonction génère et retourne une clé en calculant le nombre de séquences de nombres premiers consécutifs, le nombre de nombres premiers qu'elles contiennent et en concaténant les nombres premiers d'indices premiers appartenant à ces séquences.
|
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 |
Fonction generer_cle(t:tab, n:entier):chaîne # Nombre de segments de nombres premiers ns <- 0 # Nombre total de nombres premiers appartenant # aux segments détectés np <- 0 # Variable non utilisée j <- 0 # Chaîne qui contiendra la clé finale cle <- '' # Indique si l'on est actuellement dans un segment ajout <- False # Parcours du tableau jusqu'à l'avant-dernier élément Pour i de 0 à n-2 faire # Deux nombres premiers consécutifs Si (test_premier(t[i]) et test_premier(t[i + 1])) alors np <- np + 1 ajout <- Vrai # Ajouter la valeur si son indice est premier Si test_premier(i): cle <- cle + Convch(t[i]) Finsi # Fin d'un segment de nombres premiers Sinon Si test_premier(t[i]) et (ajout = Vrai): np <- np + 1 ns <- ns + 1 # Ajouter la valeur si son indice est premier Si test_premier(i) alors cle <- cle + Convch(t[i]) Fin si # Sortie du segment ajout <- False Fin si Fin pour # Traitement particulier du dernier élément Si test_premier(t[n - 1]) et (ajout = Vrai) alors np <- np + 1 ns <- ns + 1 # Ajouter le dernier élément si son indice est premier Si test_premier(n - 1) alors cle <- cle + Conch(t[n-1]) Finsi Finsi # La clé est formée de : # - ns : nombre de segments # - np : nombre total de nombres premiers # - cle : concaténation des valeurs retenues cle <- str(ns) + str(np) + cle # Retour de la clé générée retourner cle Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| ns | entier |
| np | entier |
| j | entier |
| cle | chaîne des caractères |
| ajout | booléen |
| 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 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 |
# ========================================================== # Importation des bibliothèques nécessaires # ========================================================== from numpy import array # Permet de créer des tableaux de taille fixe import random # Permet de générer des nombres aléatoires # ========================================================== # Déclaration des structures de données # t : tableau pouvant contenir au maximum 50 entiers # ========================================================== t = array([int()] * 50) # ========================================================== # Fonction : saisie_n # Rôle : # Saisir un entier n compris entre 5 et 50. # La saisie est répétée tant que la valeur n'est pas valide. # ========================================================== def saisie_n(): # Saisie de la taille du tableau n = int(input("donner 10<=n<=50 : ")) # Vérification de la validité de la saisie while not (5 <= n <= 50): n = int(input("donner 10<=n<=50 : ")) # Retour de la valeur valide return n # ========================================================== # Procédure : remplir # Rôle : # Remplir les n premières cases du tableau par des # nombres aléatoires compris entre 2 et 100. # ========================================================== def remplir(t, n): # Parcours des n premières cases du tableau for i in range(n): # Génération d'un entier aléatoire entre 2 et 100 t[i] = random.randint(2, 100) # ========================================================== # Fonction : test_premier # Rôle : # Vérifier si un entier est un nombre premier. # Retourne True si le nombre est premier, # sinon False. # ========================================================== def test_premier(n): # Le nombre 1 n'est pas premier if n == 1: return False # Le nombre 2 est premier else: if n == 2: return True else: # Initialisation du premier diviseur à tester i = 2 # Recherche d'un diviseur de n while (i <= n // 2) and (n % i != 0): i = i + 1 # Retourne True si aucun diviseur n'a été trouvé return (n % i != 0) # ========================================================== # Fonction : generer_cle # Rôle : # Construire une clé à partir des segments de nombres # premiers présents dans le tableau. # # La clé est composée de : # - ns : nombre de segments de nombres premiers ; # - np : nombre total de nombres premiers appartenant # à ces segments ; # - la concaténation des valeurs situées à des indices # premiers dans ces segments. # ========================================================== def generer_cle(t, n): # Nombre de segments de nombres premiers ns = 0 # Nombre total de nombres premiers appartenant aux segments np = 0 # Variable inutilisée (peut être supprimée) j = 0 # Chaîne contenant la clé finale cle = '' # Indique si le parcours est actuellement dans un segment ajout = False # Parcours du tableau jusqu'à l'avant-dernier élément for i in range(n - 1): # Cas où deux nombres premiers sont consécutifs if (test_premier(t[i]) and test_premier(t[i + 1])): # Comptage du nombre premier np = np + 1 # Début ou poursuite d'un segment ajout = True # Si l'indice est premier, ajouter la valeur à la clé if test_premier(i): cle = cle + str(t[i]) # Cas où le segment se termine elif test_premier(t[i]) and (ajout == True): # Comptage du dernier nombre premier du segment np = np + 1 # Comptage du segment ns = ns + 1 # Si l'indice est premier, ajouter la valeur à la clé if test_premier(i): cle = cle + str(t[i]) # Fin du segment ajout = False # Traitement particulier du dernier élément du tableau if test_premier(t[n - 1]) and (ajout == True): # Comptage du dernier nombre premier np = np + 1 # Comptage du dernier segment ns = ns + 1 # Ajouter la valeur si son indice est premier if test_premier(n - 1): cle = cle + str(t[n - 1]) # Construction finale de la clé # (nombre de segments + nombre total de nombres premiers # + concaténation des valeurs retenues) cle = str(ns) + str(np) + cle # Retour de la clé générée return cle # ========================================================== # Programme principal # ========================================================== # Saisie de la taille du tableau n = saisie_n() # Premier remplissage du tableau remplir(t, n) # Tant que la clé générée contient moins de 8 caractères, # on génère un nouveau tableau aléatoire. while len(generer_cle(t, n)) < 8: remplir(t, n) # Affichage de la clé obtenue print("Clé = ", generer_cle(t, 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
