Validité d’un message – Bac théorique – Section informatique – 2024
Sujet (Algo et programmation - Bac 2024)
La méthode de transmission en série asynchrone est une technique de transmission de données numériques qui permet d’envoyer les données d’un message caractère par caractère. L’envoi d’un caractère se fait selon le principe suivant :
- Convertir le code ASCII du caractère à transmettre en binaire sur 8 bits.
- Ajouter à gauche des 8 bits obtenus un bit de départ dont la valeur est 0 et à droite un bit d'arrêt dont la valeur est 1 pour former une séquence contenant 10 bits.
Exemple : pour la chaîne de caractères "BA" on obtient les deux séquences suivantes :
On se propose de vérifier la validité du contenu d’un tableau T contenant le codage en binaire, d’un message initial formé uniquement par des lettres majuscules.
Le contenu du tableau T est valide s’il vérifie les contraintes suivantes :
- La taille du tableau T est un multiple de 10.
- Chaque case du tableau T doit contenir soit la valeur 0 soit la valeur 1.
- Chaque séquence de 10 bits doit commencer par 0 (bit de départ) et doit se terminer par 1 (bit d’arrêt).
- Les 8 bits compris entre le bit de départ et le bit d’arrêt de chaque séquence doivent représenter l’équivalent binaire du code ASCII d’une lettre majuscule.
Exemple :
Le contenu du tableau T est valide car :
- La taille du tableau T est égale à 30 qui est un multiple de
- Toutes les cases du tableau T ne contiennent que les valeurs 0 et 1.
- Chaque séquence de 10 bits commence par 0 et se termine par 1.
- Les 8 bits compris entre le bit de départ et le bit d’arrêt de chaque séquence représentent l’équivalent binaire du code ASCII d’une lettre majuscule.
En effet :
- l’équivalent en décimal des 8 bits 01000010 est 66 qui correspond au code ASCII de la lettre "B".
- l’équivalent en décimal des 8 bits 01000001 est 65 qui correspond au code ASCII de la lettre "A".
- l’équivalent en décimal des 8 bits 01000011 est 67 qui correspond au code ASCII de la lettre "C".
Travail demandé :
Ecrire un algorithme d’une fonction booléenne Verif (T , N) qui permet de vérifier, selon les contraintes décrites précédemment, si le contenu du tableau T de type Tab et de taille N est valide ou non.
Solution Algorithmique
Dans cet algorithme, On va utiliser sept fonctions et une procédure :
- la fonction saisie()
- la procédure remplir_tableau()
- la fonction verif_01()
- la fonction verif_10bits()
- la fonction exposant()
- la fonction verif_ASCII()
- la fonction verif_ASCII()
- la fonction verif()
Algorithme du programme Principal
|
1 2 3 4 5 6 |
Algorithme validation_message Debut n <- saisie() # Saisie de la taille du tableau remplir_tableau(t, n) # Remplissage du tableau verif_tableau_ASCII(t, n) # Vérification ASCII Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
| t | tableau |
La fonction saisie
Cette fonction permet de saisir et retourner un entier strictement positifs en contrôlant la validité de la saisie.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction saisie():entier # Demande à l'utilisateur de saisir un entier n > 0 Ecrire('donner un entier n > 0') Lire(n) # Vérification de la validité de la saisie Tant que Non (n > 0) faire Ecrire('donner un entier n > 0 : ') Lire(n) Fin tant que # Retourne la valeur valide saisie par l'utilisateur retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La procédure remplir_tableau
Cette procédure permet de remplir les n premières cases du tableau t par des valeurs saisies par l’utilisateur, chacune devant être égale à 0 ou à 1.
|
1 2 3 4 5 6 |
Procedure remplir_tableau(t:tabeau, n:entier) Pour i de 0 à n-1 faire Ecrire('donner 0 ou 1 : ') Lire(t[i]) Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction verif_01
Cette fonction vérifie que les n premiers éléments du tableau t sont tous égaux à 0 ou à 1 et retourne Vrai si la condition est satisfaite, sinon Faux.
|
1 2 3 4 5 6 7 8 9 |
Fonction verif_01(t:tableau, n:entier):booleen i <- 0 # Parcours du tableau tant que les valeurs sont 0 ou 1 Tant que (0 <= t[i] <= 1) et (i < n - 1) faire i <- i + 1 Fin tant que # Retourne Vrai si le dernier élément est aussi 0 ou 1 retourner (0 <= t[i] <= 1) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction verif_10bits
Cette fonction vérifie que le tableau t est constitué de blocs de 10 bits, chaque bloc commençant par 0 et se terminant par 1. Elle retourne Vrai si la structure est correcte, sinon Faux.
|
1 2 3 4 5 6 7 8 9 |
Fonction verif_10bits(t:tableau, n:entier):booleen i <- 0 # Vérification bloc par bloc Tant que (t[i] = 0) et (t[i + 9] = 1) et (i < n - 9) faire i <- i + 10 Fin tant que # Vérifie le dernier bloc retourner (t[i] = 0) et (t[i+9] = 1) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction exposant
Cette fonction calcule et retourne la valeur de 2e en utilisant des multiplications successives.
|
1 2 3 4 5 6 7 |
Fonction exposant(e:entier):entier resultat <- 1 Pour i de 0 à e-1 faire resultat <- resultat * 2 Fin pour retourner resultat Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| resultat | entier |
La fonction verif_ASCII
Cette fonction convertit un octet binaire en son équivalent décimal, affiche le caractère ASCII correspondant, puis vérifie si ce code est compris entre 65 et 97.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction verif_ASCII(octet:chaine):booleen code <- 0 # Conversion de l’octet binaire en décimal Pour i de 0 à 7 faire code <- code + Valeur(octet[7-i]) * exposant(i) # Affichage du caractère ASCII correspondant Ecrire(chr(code)) # Retourne Vrai si le code ASCII est valide retourner 65 <= code <= 97 Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| code | chaîne |
| i | entier |
La procédure verif_tableau_ASCII
Cette procédure parcourt le tableau t par blocs de 10 bits, extrait les octets centraux et vérifie si chacun correspond à un caractère ASCII valide. Elle affiche ensuite si le tableau est valide ou non.
|
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 |
Procedure verif_tableau_ASCII(t:tableau , nl:entier) i <- 0 test_ascii <- Vrai # Parcours du tableau par blocs de 10 bits Tant que (i < n-9) et (test_ascii = Vrai) faire octet <- '' # Extraction des 8 bits centraux Pour j de i+1 à i+8 faire octet <- octet + str(t[j]) Fin tant que # Affichage de l’octet Ecrire(octet, '=', end=' ') # Vérification ASCII de l’octet Si verif_ASCII(octet) = Faux alors test_ascii <- False Fin si # Passage au bloc suivant i <-i+10 Fin tant que # Affichage du résultat final Si test_ascii = Vrai alors Ecrire('Le tableau T est valide') Sinon Ecrire('Le tableau T est non valide') Fin si Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| test_ascii | booléen |
| octet | chaîne |
| j | entier |
La fonction verif
Cette fonction vérifie globalement qu’un tableau t est constitué de blocs de 10 bits correctement formés, contenant uniquement des 0 et 1, avec des octets centraux représentant des caractères ASCII valides. Elle retourne Vrai si le tableau est valide, sinon Faux.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
Fonction verif(t:tableau;n:entier):booleen # Le nombre d’éléments doit être un multiple de 10 Si n mod 10 = 0 alors Si verif_01(t, n) alors Si verif_10bits(t, n) alors Si verif_tableau_ASCII(t, n) alors return Vrai Finsi Sinon retourner Faux Finsi Sinon retourner Faux Finsi Sinon retourner Faux Finsi Fin |
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 |
from numpy import * # -------------------------------------------------- # Déclaration d’un tableau global de taille 50 # Il servira à stocker des bits (0 ou 1) # -------------------------------------------------- t = array([int()] * 50) # -------------------------------------------------- # Fonction de saisie d’un entier strictement positif # -------------------------------------------------- def saisie(): # Demande à l'utilisateur de saisir un entier n n = int(input('donner n > 0 : ')) # Vérification de la validité de la saisie # Tant que n n’est pas strictement positif, # on redemande la saisie while not (n > 0): n = int(input('donner n > 0 : ')) # Retourne la valeur valide de n return n # -------------------------------------------------- # Procédure qui remplit le tableau t avec n valeurs # Chaque valeur saisie doit être 0 ou 1 # -------------------------------------------------- def remplir_tableau(t, n): for i in range(n): t[i] = int(input('donner 0 ou 1 : ')) # -------------------------------------------------- # Fonction qui vérifie que tous les éléments du # tableau sont bien des bits (0 ou 1) # -------------------------------------------------- def verif_01(t, n): i = 0 # Parcours du tableau tant que les valeurs sont 0 ou 1 while (0 <= t[i] <= 1) and (i < n - 1): i = i + 1 # Retourne True si le dernier élément est aussi 0 ou 1 return (0 <= t[i] <= 1) # -------------------------------------------------- # Fonction qui vérifie la structure par blocs de 10 bits # Chaque bloc doit commencer par 0 et se terminer par 1 # -------------------------------------------------- def verif_10bits(t, n): i = 0 # Vérification bloc par bloc while (t[i] == 0) and (t[i + 9] == 1) and (i < n - 9): i = i + 10 # Vérifie le dernier bloc return (t[i] == 0) and (t[i + 9] == 1) # -------------------------------------------------- # Fonction qui calcule 2^e (puissance de 2) # -------------------------------------------------- def exposant(e): resultat = 1 for i in range(e): resultat = resultat * 2 return resultat # -------------------------------------------------- # Fonction qui vérifie si un octet correspond # à un caractère ASCII compris entre 65 et 97 # -------------------------------------------------- def verif_ASCII(octet): code = 0 # Conversion de l’octet binaire en décimal for i in range(8): code = code + int(octet[7 - i]) * exposant(i) # Affichage du caractère ASCII correspondant print(chr(code)) # Retourne True si le code ASCII est valide return 65 <= code <= 97 # -------------------------------------------------- # Procédure qui vérifie si le tableau représente # une suite de caractères ASCII valides # -------------------------------------------------- def verif_tableau_ASCII(t, n): i = 0 test_ascii = True # Parcours du tableau par blocs de 10 bits while (i < n - 9) and (test_ascii == True): octet = '' # Extraction des 8 bits centraux for j in range(i + 1, i + 9): octet = octet + str(t[j]) # Affichage de l’octet print(octet, '=', end=' ') # Vérification ASCII de l’octet if verif_ASCII(octet) == False: test_ascii = False # Passage au bloc suivant i = i + 10 # Affichage du résultat final if test_ascii == True: print('Le tableau T est valide') else: print('Le tableau T est non valide') # -------------------------------------------------- # Fonction globale de vérification du tableau # -------------------------------------------------- def verif(t, n): # Le nombre d’éléments doit être un multiple de 10 if n % 10 == 0: if verif_01(t, n): if verif_10bits(t, n): if verif_tableau_ASCII(t, n): return True else: return False else: return False else: return False # -------------------------------------------------- # Programme principal # -------------------------------------------------- n = saisie() # Saisie de la taille du tableau remplir_tableau(t, n) # Remplissage du tableau verif_tableau_ASCII(t, n) # Vérification ASCII |
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
