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
|
1 2 3 4 5 6 |
Algorithme generation_cle Debut n = saisie_n() # lecture de n remplir(t, n) # remplissage du tableau generer_cle(t, n) # génération de la clé 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 180 181 182 183 184 185 186 |
# ========================================================== # Importation des bibliothèques nécessaires # ========================================================== from numpy import array # Pour créer des tableaux de taille fixe import random # Pour générer des nombres aléatoires # ========================================================== # Déclaration des structures de données # t : tableau d'entiers de taille maximale 50 # ========================================================== t = array([int()] * 50) # ========================================================== # Fonction : saisie_n # Rôle : saisir un entier n compris entre 5 et 50 # et vérifier sa validité. # ========================================================== def saisie_n(): # Lecture de la valeur de n n = int(input("donner 10<=n<=50 : ")) # Répéter la saisie tant que n est hors limites while not (5 <= n <= 50): n = int(input("donner 10<=n<=50 : ")) # Retourner la valeur valide return n # ========================================================== # Procédure : remplir # Rôle : remplir le tableau t par n entiers aléatoires # compris entre 2 et 100 puis afficher son contenu. # ========================================================== def remplir(t, n): # Remplissage aléatoire du tableau for i in range(n): t[i] = random.randint(2, 100) ''' Jeu de données de test (à utiliser à la place des valeurs aléatoires si nécessaire) t[0]=6 t[1]=5 t[2]=17 t[3]=11 t[4]=31 t[5]=4 t[6]=2 t[7]=8 t[8]=7 t[9]=13 t[10]=25 t[11]=2 t[12]=3 t[13]=31 ''' # Affichage des éléments du tableau print('T=', end=' ') for i in range(n): print(t[i], end=' ') print() # ========================================================== # Fonction : test_premier # Rôle : vérifier si un entier est 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 # Recherche d'un diviseur entre 2 et n//2 else: i = 2 while (i <= n // 2) and (n % i != 0): i = i + 1 # Aucun diviseur trouvé → nombre premier return (n % i != 0) # ========================================================== # Fonction : generer_cle # Rôle : # - rechercher les séquences de nombres premiers # consécutifs dans le tableau ; # - compter le nombre de segments de nombres premiers ; # - compter le nombre total de nombres premiers # appartenant à ces segments ; # - concaténer les valeurs situées à des indices premiers ; # - construire et retourner une clé. # ========================================================== def generer_cle(t, n): # 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 for i in range(n - 1): # Deux nombres premiers consécutifs if (test_premier(t[i]) and test_premier(t[i + 1])): np = np + 1 ajout = True # Ajouter la valeur si son indice est premier if test_premier(i): cle = cle + str(t[i]) # Fin d'un segment de nombres premiers elif test_premier(t[i]) and (ajout == True): np = np + 1 ns = ns + 1 # Ajouter la valeur si son indice est premier if test_premier(i): cle = cle + str(t[i]) # Sortie du segment ajout = False # Traitement particulier du dernier élément if test_premier(t[n - 1]) and (ajout == True): np = np + 1 ns = ns + 1 # Ajouter le dernier élément si son indice est premier if test_premier(n - 1): cle = cle + str(t[n - 1]) # 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 return cle # ========================================================== # Programme principal # ========================================================== # Saisie de la taille du tableau n = saisie_n() # Remplissage et affichage du tableau remplir(t, n) # Génération et affichage de la clé print('cle= ', 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
