Cryptage des phrases – Bac pratique – Section informatique – 2013
Sujet (Algo et programmation - Bac 2013)
On se propose de crypter une phrase de la manière suivante :
Chaque lettre d'un mot sera remplacée par la lettre qui la suit de P positions dans l'alphabet français, où -P est le rang du mot dans la phrase.
On suppose que le caractère qui suit la lettre "Z" est le caractère "A" et celui qui suit la lettre "z" est le caractère "a".
Le caractère espace ne subit aucune modification.
Travail demandé :
Ecrire un programme en Python intitulé Cryptage qui permet de :
- saisir et stocker dans un fichier texte "Phrases.txt", N phrases (avec N < 50), dont les mots doivent être formés uniquement de lettres alphabétiques et séparés par un seul espace. Chaque phrase occupera une ligne dans le fichier "Phrases.txt".
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et deux procédures:
- la fonction saisie()
- la fonction supprimer_espaces()
- la fonction verif_phrase()
- la fonction saisie_phrase()
- la procédure remplir_fichier_phrases()
- la fonction crypter_caractere()
- la procédure remplir_fichier_ph_crypt()
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme cryptage Debut n <- saisie(0, 51) # Saisie du nombre de phrases remplir_fichier_phrases(n) # Remplissage du fichier phrases.txt remplir_fichier_ph_crypt() # Création du fichier crypté Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction carre
Cette fonction carre(x) a pour rôle de calculer et retourner le carré d’un nombre réel x.
Elle prend un nombre x en paramètre, effectue le calcul x×x, puis renvoie le résultat.
|
1 2 3 4 |
Fonction carre(x:entier):entier # Retourne le carré de x retourner x*x Fin |
La fonction aire_rectangles
Ce programme définit une fonction aire_rectangles qui calcule une approximation de l’aire sous la courbe d’une fonction à l’aide de la méthode des rectangles.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction aire_rectangles(a:entier, b:entier, n:entier):reel # Largeur de chaque subdivision h <- (b - a) / n # Somme des aires des rectangles s <- 0 # Abscisse de départ x <- a # Calcul de la somme des carre(x) aux points gauches Pour de i de 0 à n-1 faire s <- s + carre(x) x <- x + h Fin pour # Aire approximative retourner s * h Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| h | réel |
| s | entier |
| x | réel |
La fonction aire_trapezes
Ce programme définit une fonction aire_trapezes qui calcule une approximation de l’aire sous la courbe d’une fonction à l’aide de la méthode des trapèzes. Cette méthode est plus précise que celle des rectangles car elle prend en compte la pente entre les points consécutifs.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction aire_trapezes(a:entier, b:entier, n:entier):reel # Largeur de chaque subdivision h <- (b - a) / n # Somme initiale avec les bornes s <- (carre(a) + carre(b)) / 2 # Premier point intérieur x <- a + h # Ajout des valeurs intermédiaires Pour i de 1 à n-1 faire s = s + carre(x) x = x + h Fin pour # Aire approximative retourner s * h Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| h | réel |
| s | entier |
| x | réel |
La fonction saisie_epsilon
Cette fonction permet de saisir un entier strictement positif au clavier.
Plus précisément :
Elle demande à l’utilisateur de saisir un nombre entier.
Elle vérifie la validité de la saisie en s’assurant que le nombre est strictement supérieur à 0.
Tant que la valeur saisie est nulle ou négative, la fonction redemande la saisie.
Une fois une valeur correcte saisie, la fonction la retourne pour être utilisée dans la suite du programme.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_epsilon(): reel Ecrire("Donner epsilon tel que 0.001 < epsilon < 0.1 : ") Lire(epsilon) # Répéter la saisie tant que epsilon est invalide Tant que non (0.001 < epsilon < 0.1) faire Ecrire("Donner epsilon tel que 0.001 < epsilon < 0.1 : ") Lire(epsilon) Fin tant que retourner epsilon Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| epsilon | réel |
La procédure remplir_fichier_calcul
La procédure remplir_fichier_circul(p, q) a pour rôle est de déterminer et enregistrer tous les nombres premiers circulaires compris entre deux entiers p et q.
Plus précisément, cette procédure :
- affiche un message indiquant le début du remplissage
- ouvre le fichier Circul.dat en mode écriture
- parcourt tous les entiers de p à q (bornes incluses)
- teste pour chaque entier s’il est premier circulaire à l’aide de la fonction test_circulaire()
- affiche chaque nombre premier circulaire trouvé
- écrit chaque nombre premier circulaire dans le fichier, un nombre par ligne
- ferme le fichier après la fin du traitement
|
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 |
Procédure remplir_fichier_calcul(epsilon:entier) # Ouverture du fichier en mode écriture Ouvrir(f , "Calcul.dat", "w") Ecrire('****************************************') # Initialisation du nombre de subdivisions n <- 1 # Calcul initial des aires aire_rect <- aire_rectangles(a, b, n) aire_trap <- aire_trapezes(a, b, n) # Tant qu’aucune des deux méthodes n’a convergé Tant que (abs(aire_rect - aire_exacte) > epsilon) et (abs(aire_trap - aire_exacte) > epsilon) faire # Calcul des aires pour le nombre courant de subdivisions aire_rect <- aire_rectangles(a, b, n) aire_trap <- aire_trapezes(a, b, n) # Affichage des résultats Ecrire(n + ", aire rectangulaire: " + aire_rect + ", aire trapeze: " + aire_trap) # Stockage dans le fichier Ecrire(f , n + ", aire rectangulaire: " + aire_rect + ", aire trapeze: " + aire_trap + "\n") # Passage au nombre de subdivisions suivant n <- n + 1 Fin tant que Ecrire('****************************************') # Détermination de la méthode qui converge la première Si abs(aire_rect - aire_exacte) <= epsilon alors Ecrire("La méthode qui converge la première est la méthode des rectangles") Ecrire("Nombre de subdivisions =", n - 1) Ecrire("Aire calculée =", aire_rect) Sinon Ecrire("La méthode qui converge la première est la méthode des trapèzes") Ecrire("Nombre de subdivisions =", n - 1) Ecrire("Aire calculée =", aire_trap) Fin si # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| n | entier |
| aire_rect | réel |
| aire_trap | réel |
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 |
# -------------------------------------------------- # Fonction mathématique f(x) = x² # -------------------------------------------------- def carre(x): # Retourne le carré de x return x * x # -------------------------------------------------- # Fonction qui calcule l’aire par la méthode des rectangles # a : borne inférieure de l’intervalle # b : borne supérieure de l’intervalle # n : nombre de subdivisions # -------------------------------------------------- def aire_rectangles(a, b, n): # Largeur de chaque subdivision h = (b - a) / n # Somme des aires des rectangles s = 0 # Abscisse de départ x = a # Calcul de la somme des carre(x) aux points gauches for i in range(n): s += carre(x) x += h # Aire approximative return s * h # -------------------------------------------------- # Fonction qui calcule l’aire par la méthode des trapèzes # -------------------------------------------------- def aire_trapezes(a, b, n): # Largeur de chaque subdivision h = (b - a) / n # Somme initiale avec les bornes s = (carre(a) + carre(b)) / 2 # Premier point intérieur x = a + h # Ajout des valeurs intermédiaires for i in range(1, n): s += carre(x) x += h # Aire approximative return s * h # -------------------------------------------------- # Fonction qui permet de saisir une valeur correcte de epsilon # avec 0.001 < epsilon < 0.1 # -------------------------------------------------- def saisie_epsilon(): epsilon = float(input("Donner epsilon tel que 0.001 < epsilon < 0.1 : ")) # Répéter la saisie tant que epsilon est invalide while not (0.001 < epsilon < 0.1): epsilon = float(input("Donner epsilon tel que 0.001 < epsilon < 0.1 : ")) return epsilon # -------------------------------------------------- # Procédure qui remplit le fichier Calcul.dat # et détermine la méthode qui converge la première # -------------------------------------------------- def remplir_fichier_calcul(epsilon): # Ouverture du fichier en mode écriture f = open("Calcul.dat", "w") print('****************************************') # Initialisation du nombre de subdivisions n = 1 # Calcul initial des aires aire_rect = aire_rectangles(a, b, n) aire_trap = aire_trapezes(a, b, n) # Tant qu’aucune des deux méthodes n’a convergé while (abs(aire_rect - aire_exacte) > epsilon) and \ (abs(aire_trap - aire_exacte) > epsilon): # Calcul des aires pour le nombre courant de subdivisions aire_rect = aire_rectangles(a, b, n) aire_trap = aire_trapezes(a, b, n) # Affichage des résultats print(str(n) + ", aire rectangulaire: " + str(aire_rect) + ", aire trapeze: " + str(aire_trap)) # Stockage dans le fichier f.write(str(n) + ", aire rectangulaire: " + str(aire_rect) + ", aire trapeze: " + str(aire_trap) + "\n") # Passage au nombre de subdivisions suivant n = n + 1 print('****************************************') # Détermination de la méthode qui converge la première if abs(aire_rect - aire_exacte) <= epsilon: print("La méthode qui converge la première est la méthode des rectangles") print("Nombre de subdivisions =", n - 1) print("Aire calculée =", aire_rect) else: print("La méthode qui converge la première est la méthode des trapèzes") print("Nombre de subdivisions =", n - 1) print("Aire calculée =", aire_trap) # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- # Bornes de l’intervalle a = 0 b = 3 # Aire exacte de l’intégrale aire_exacte = 9 # Saisie de epsilon epsilon = saisie_epsilon() # Remplissage du fichier et comparaison des méthodes remplir_fichier_calcul(epsilon) |
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
