antoine.perederii
/
IUT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a3adb9b55a'
${ noResults }
IUT/2A/Cryptographie/tp/tp5/.ipynb_checkpoints/tp5-checkpoint.ipynb

470 lines
26 KiB
Raw Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"cells": [
{
"cell_type": "markdown",
"id": "ffea363c-1570-4c55-9bec-9f29214ef8f0",
"metadata": {},
"source": [
"# RAPPEL : Code de Hamming (7,4) \n",
"Le code de Hamming (7, 4) 1 consiste à insérer de la redondance tous les 4 bits de sorte à détecter et corriger 1 erreur. Ainsi, une suite de 4 bits devient une suite de 7 bits avec des relations pour pouvoir détecter puis corriger. Si au plus l’un des 7 bits est erronés au cours de la transmission (un 1 devenu 0 ou inversement), alors l’algorithme le détecte et peut retrouver le message initial. Si plus d’erreurs se sont introduites, cette méthode ne permet pas de les détecter, ni de les corriger.\n",
"Plus précisément, si le mot binaire à transmettre est b1b2b3b4, il est alors encodé en c1c2c3c4c5c6c7 de sorte que :\n",
" c 1 = b 1\n",
"c =b 2 2 \n",
"c =b 33\n",
"c4=b4 (1) c =b +b +b mod2\n",
"5 1 2 3 \n",
"c =b +b +b mod2 6124\n",
"c7 = b2 + b3 + b4 mod 2\n",
"Lorsque c1c2c3c4c5c6c7 est reçu, il s’agit d’abord de vérifier s’il contient une erreur. Pour cela, chaque égalité est testée : est-ce que c5 = c1+c2+c3 mod 2, c6 = c1+c2+c4 mod 2 et c7 = c2+c3+c4 ? Si oui, alors le message ne comporte pas l’erreur. Si non, en admettant qu’une seule erreur s’est produite, il suffit d’analyser l’impact :\n",
"• si c1 est erroné, alors les égalités pour c5 et c6 ne sont pas vérifiées ;\n",
"• si c2 est erroné, alors les égalités pour c5, c6 et c7 ne sont pas vérifiées; • si c3 est erroné, alors les égalités pour c5 et c7 ne sont pas vérifiées ;\n",
"• si c4 est erroné, alors les égalités pour c6 et c7 ne sont pas vérifiées ;\n",
"• si c5 est erroné, alors l’égalité c5 n’est pas vérifiée ;\n",
"• si c6 est erroné, alors l’égalité c6 n’est pas vérifiée ;\n",
"• si c7 est erroné, alors l’égalité c7 n’est pas vérifiée ;\n",
"Ainsi, il y a trois calculs à faire sur une suite de 7 bits pour savoir s’il y a une erreur et les égalités non vérifiées indiquent le bit erroné. Il est alors possible de corriger l’erreur retirer les bits de redondance pour retrouver la suite de 4 bits. À noter qu’une erreur sur les bits c5, c6 ou c7 n’a pas d’impact sur le décodage."
]
},
{
"cell_type": "markdown",
"id": "eb4b514a-0a3e-4c1c-8067-4eb0a7e090c1",
"metadata": {},
"source": [
"# Exercice 3 (Encodage ASCII).\n",
"Écrivez une fonction qui renvoie la chaîne de bits obtenue en collant bout à bout les codes ASCII des caractères composant une chaîne de caractères donnée en paramètre. \n",
"Vous aurez peut-être l’usage des fonctions bin() et ord() de Python. Attention au nombre de bits des écritures binaires !"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "52226357-691f-44da-8660-8d6a35edf981",
"metadata": {},
"outputs": [],
"source": [
"def bit(nombre, n):\n",
" resBin = [0]*n\n",
" i = 0\n",
" while nombre > 0:\n",
" resBin[n-1-i] = nombre%2\n",
" nombre = nombre // 2\n",
" i += 1\n",
" return resBin\n",
"\n",
"def sToBit(s):\n",
" return bit(ord(s),8)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "12ed7be5-6a93-429d-a8ff-30e40546964d",
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "ord() expected a character, but string of length 22 found",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn[26], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMerci Pour les lettres\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43msToBit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mMerci Pour les lettres\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n",
"Cell \u001b[0;32mIn[25], line 11\u001b[0m, in \u001b[0;36msToBit\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msToBit\u001b[39m(s):\n\u001b[0;32m---> 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m bit(\u001b[38;5;28;43mord\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43ms\u001b[49m\u001b[43m)\u001b[49m,\u001b[38;5;241m8\u001b[39m)\n",
"\u001b[0;31mTypeError\u001b[0m: ord() expected a character, but string of length 22 found"
]
}
],
"source": [
"m = \"Merci Pour les lettres\"\n",
"print(sToBit(\"Merci Pour les lettres\"))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "ae01679b-3d95-4990-8e2f-e8c6f529a547",
"metadata": {},
"outputs": [],
"source": [
"def stringToBit(string):\n",
" resBin = []\n",
" for i in string:\n",
" resBin.append(sToBit(i))\n",
" return resBin"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "8d42d810-c82d-4612-bcaa-e5c4a15c3abe",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0, 1, 0, 0, 1, 1, 0, 1], [0, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 1, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 1, 1], [0, 1, 1, 0, 1, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 1, 0, 1], [0, 1, 1, 1, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 1, 1, 0, 0], [0, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 1, 0, 0, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 1, 1, 0, 0], [0, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 1, 0, 1, 0, 0], [0, 1, 1, 1, 0, 1, 0, 0], [0, 1, 1, 1, 0, 0, 1, 0], [0, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 1, 0, 0, 1, 1]]\n"
]
}
],
"source": [
"print(stringToBit(\"Merci pour les lettres\"))"
]
},
{
"cell_type": "code",
"execution_count": 46,
"id": "ae72e312-03f4-43ae-9639-55de55b7f3bc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"01000001\n"
]
}
],
"source": [
"def ascii_to_binary_string(input_string):\n",
" binary_string = ''\n",
" for char in input_string:\n",
" ascii_code = ord(char)\n",
" # Convertir le code ASCII en binaire et supprimer le préfixe '0b'\n",
" binary_representation = bin(ascii_code)[2:]\n",
" # Assurer que chaque séquence binaire a la même longueur (8 bits)\n",
" padded_binary = binary_representation.zfill(8)\n",
" binary_string += padded_binary\n",
" return binary_string\n",
"\n",
"input_string = \"Merci pour les lettres\"\n",
"result = ascii_to_binary_string(input_string)\n",
"print(result)"
]
},
{
"cell_type": "markdown",
"id": "df22f9f1-f1cd-4417-80bc-5e8bb5732545",
"metadata": {},
"source": [
"# Exercice 1 (Décodage ASCII). \n",
"Sur un champ de bataille, le message suivant est envoyé aux agents spéciaux pour confirmer ce qu’ils doivent faire : chaque caractère appartient à la table ASCII et est encodé sur 8 bits. \n",
"De plus, les nombres sont écrits en binaire. \n",
"01000011011011110110110101101101011001010110111001100011 \n",
"01100101011110100010000001110000011000010111001000100000 \n",
"01100011011000010111001101110011011001010111001000100000 \n",
"01101100011001010111001100100000011000110110111101110100 \n",
"01100101011100110010000001100100011001010010000001100011 \n",
"01100101001000000110100001100001011000110110101101100101 \n",
"01110010001000000111000001101111011101010111001000100000 \n",
"01101111011000100111010001100101011011100110100101110010 \n",
"00100000011001000110010101110011001000000110100101101110 \n",
"01100110011011110111001001101101011000010111010001101001 \n",
"01101111011011100111001100101110 \n",
"Écrivez une fonction renvoyant la chaîne de caractères dont est issue une chaîne de bits donnée en paramètre. \n",
"Vous aurez peut-être l’usage des fonctions int(,2) et chr() de Python."
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "274707b0-a16d-4901-b89c-55f85ee49ea2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Commencez par casser les cotes de ce hacker pour obtenir des informations.\n"
]
}
],
"source": [
"def binary_to_ascii(input_bits):\n",
" # Diviser la chaîne de bits en octets de 8 bits\n",
" octets = [input_bits[i:i+8] for i in range(0, len(input_bits), 8)]\n",
" # Convertir chaque octet binaire en un entier décimal, puis en un caractère ASCII\n",
" ascii_string = ''.join(chr(int(octet, 2)) for octet in octets)\n",
" return ascii_string\n",
"\n",
"chaine[:7] # prends les 7 premiers\n",
"chaine[7:] # prends tout sauf les 7 premiers\n",
"chaine[-7:] # prends les 7 derniers\n",
"chaine[:-7] # prends tout sauf les 7 derniers\n",
"\n",
"\n",
"# Chaîne de bits donnée dans l'énoncé\n",
"input_bits = \"01000011011011110110110101101101011001010110111001100011\\\n",
"01100101011110100010000001110000011000010111001000100000\\\n",
"01100011011000010111001101110011011001010111001000100000\\\n",
"01101100011001010111001100100000011000110110111101110100\\\n",
"01100101011100110010000001100100011001010010000001100011\\\n",
"01100101001000000110100001100001011000110110101101100101\\\n",
"01110010001000000111000001101111011101010111001000100000\\\n",
"01101111011000100111010001100101011011100110100101110010\\\n",
"00100000011001000110010101110011001000000110100101101110\\\n",
"01100110011011110111001001101101011000010111010001101001\\\n",
"01101111011011100111001100101110\"\n",
"result = binary_to_ascii(input_bits)\n",
"print(result)"
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "81b1a0fe-4da7-4f16-a2db-533b60370251",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"GHE\n",
"jcsdcjsd\n"
]
}
],
"source": [
"m = \"GHElleofjcsdcjsd\"\n",
"print(m[:3])\n",
"print(m[8:])"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "d9294b17-fadc-4fd5-86d9-2e2886f208bb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'0b1000001'"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bin(ord('A'))"
]
},
{
"cell_type": "markdown",
"id": "bf2410d0-294b-4fcb-bb49-bcc7aa9701c2",
"metadata": {},
"source": [
"# Exercice 4 (Encodage Hamming). \n",
"Écrivez une fonction qui effectue l’encodage d’une suite de bits passée en paramètre à l’aide du code de Hamming (7, 4), et renvoie la suite de bits obtenue."
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "00ef0231-4c0b-43dc-b912-d260255b915f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bits d'entrée: 1101\n",
"Bits encodés avec le code de Hamming (7, 4): 1010101\n"
]
}
],
"source": [
"def hamming_encode(input_bits):\n",
" # Vérifier que la longueur de la chaîne d'entrée est un multiple de 4\n",
" if len(input_bits) % 4 != 0:\n",
" raise ValueError(\"La longueur de la chaîne d'entrée doit être un multiple de 4 bits.\")\n",
" \n",
" encoded_bits = \"\"\n",
" # Parcourir la chaîne d'entrée par blocs de 4 bits\n",
" for i in range(0, len(input_bits), 4):\n",
" # Ajouter 3 bits de parité à chaque bloc de 4 bits\n",
" data_bits = input_bits[i:i+4]\n",
" parity_bits = calculate_parity_bits(data_bits)\n",
" # Concaténer les bits de données et de parité\n",
" encoded_bits = data_bits + parity_bits\n",
" \n",
" return encoded_bits\n",
"\n",
"def calculate_parity_bits(data_bits):\n",
" # Calculer les bits de parité en fonction des positions des bits de données\n",
" p1 = str(int(data_bits[0]) ^ int(data_bits[1]) ^ int(data_bits[3]))\n",
" p2 = str(int(data_bits[0]) ^ int(data_bits[2]) ^ int(data_bits[3]))\n",
" p3 = str(int(data_bits[1]) ^ int(data_bits[2]) ^ int(data_bits[3]))\n",
" return p1 + p2 + data_bits[0] + p3 + data_bits[1:]\n",
"\n",
"# Exemple d'utilisation\n",
"input_bits = \"1101\" # Exemple de 4 bits d'entrée\n",
"encoded_bits = hamming_encode(input_bits)\n",
"print(\"Bits d'entrée:\", input_bits)\n",
"print(\"Bits encodés avec le code de Hamming (7, 4):\", encoded_bits)"
]
},
{
"cell_type": "markdown",
"id": "f7d32ab1-8b2a-4e7e-80f0-c645a8d29793",
"metadata": {},
"source": [
"# Exercice 2 (Décodage Hamming).\n",
"En pratique, il est possible que des erreurs de transmission se produisent, ce qui introduit des erreurs dans le message reçu. \n",
"Pour pallier cela, il existe des codes détecteurs et correcteurs d’erreurs. \n",
"Le message ci-dessus n’est en réalité qu’une partie du message transmis sur le réseau. \n",
"Le message complet ci-dessous applique le code de Hamming (7,4) tous les 4 bits afin de pouvoir détecter et corriger 1 erreur.\n",
" \n",
"01001110011110011001011111110110010110101001100101101010 \n",
"01100100101100011001011101000110010001111001100100101100 \n",
"01110011010011001010100000000111001000000001100100001011 \n",
"01110010010101001010100000000110010001111001100100001011 \n",
"01110010011110011100100111100110010010110001110010010101 \n",
"00101010000000011001011000010110010010110001110010011110 \n",
"00101010000000011001000111100110010111111101110100100111 \n",
"01100100101100011100100111100010101000000001100100100111 \n",
"01100100101100001010100000000110010001111001100100101100 \n",
"00101010000000011001010001100110010000101101100100011110 \n",
"01100101011000011001001011000111001001010100101010000000 \n",
"01110010000000011001011111110111001010110001110010010101 \n",
"00101010000000011001011111110110010001010101110010100111 \n",
"01100100101100011001011101000110010100110101110010010101 \n",
"00101010000000011001001001110110010010110001110010011110 \n",
"00101010000000011001010011010110010111010001100100110010 \n",
"01100101111111011100100101010110010110101001100100001011 \n",
"01110010100111011001010011010110010111111101100101110100 \n",
"0111001001111000101011110100 \n",
"1. Écrivez une fonction qui renvoie la chaîne de bits constituée des bits d’information (sans correction) d’une chaîne de bits reçue en paramètre, en supposant que cette dernière est encodée avec le code de Hamming (7, 4). \n",
"2. Écrivez une fonction qui vérifie si une chaîne de bits (encodée avec le code de Hamming (7, 4)) reçue en paramètre contient des erreurs, les corrige et renvoie la chaîne de bits obtenue après correction."
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "e7758397-24c5-41ba-adf2-7bc9fcdd113e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bits d'information (sans correction) : 0111111010101111101000101010001010100100101011001010111010100100100110110000001100000011100010110100111001100110110010011110110001110010000010100111100101111111010011100001111001111110011001111011001011100\n"
]
}
],
"source": [
"def hamming_decode(input_bits):\n",
" decoded_bits = \"\"\n",
" # Parcourir la chaîne d'entrée par blocs de 7 bits\n",
" for i in range(0, len(input_bits), 7):\n",
" block = input_bits[i:i+7]\n",
" # Extraire les bits de données (ignorer les bits de parité)\n",
" data_bits = extract_data_bits(block)\n",
" decoded_bits += data_bits\n",
" return decoded_bits\n",
"\n",
"def extract_data_bits(encoded_block):\n",
" # Extraire les bits de données en sautant les bits de parité\n",
" data_bits = encoded_block[2] + encoded_block[4:7]\n",
" return data_bits\n",
"\n",
"# Exemple d'utilisation pour décoder une chaîne de bits\n",
"encoded_message = \"010011100111100110010111111101100101101010011001011010100110010010110001100101110100011001000111100110010010110001110011010011010100000000111001000000001100100001011011110010010101100100110100111001101001011001001011000111001001111000101010000000110010010011100110010101111111011101001001110110010100110101100101111111011001011101000111001001111000101011110100\"\n",
"decoded_message = hamming_decode(encoded_message)\n",
"print(\"Bits d'information (sans correction) :\", decoded_message)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "7866bbfb-318b-4675-b07e-93ada2d574c6",
"metadata": {},
"outputs": [
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn[33], line 43\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;66;03m# Exemple d'utilisation pour vérifier et corriger une chaîne de bits\u001b[39;00m\n\u001b[1;32m 42\u001b[0m received_message \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m01001110011110011001011111110110010110101001100101101010 01100100101100011001011101000110010001111001100100101100 01110011010011001010100000000111001000000001100100001011 01110010010101001010100000000110010001111001100100001011 01110010011110011100100111100110010010110001110010010101 00101010000000011001011000010110010010110001110010011110 00101010000000011001000111100110010111111101110100100111 01100100101100011100100111100010101000000001100100100111 01100100101100001010100000000110010001111001100100101100 00101010000000011001010001100110010000101101100100011110 01100101011000011001001011000111001001010100101010000000 01110010000000011001011111110111001010110001110010010101 00101010000000011001011111110110010001010101110010100111 01100100101100011001011101000110010100110101110010010101 00101010000000011001001001110110010010110001110010011110 00101010000000011001010011010110010111010001100100110010 01100101111111011100100101010110010110101001100100001011 01110010100111011001010011010110010111111101100101110100 0111001001111000101011110100\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m---> 43\u001b[0m corrected_message \u001b[38;5;241m=\u001b[39m \u001b[43mhamming_correct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreceived_message\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMessage après correction :\u001b[39m\u001b[38;5;124m\"\u001b[39m, corrected_message)\n",
"Cell \u001b[0;32mIn[33], line 7\u001b[0m, in \u001b[0;36mhamming_correct\u001b[0;34m(input_bits)\u001b[0m\n\u001b[1;32m 5\u001b[0m block \u001b[38;5;241m=\u001b[39m input_bits[i:i\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m7\u001b[39m]\n\u001b[1;32m 6\u001b[0m \u001b[38;5;66;03m# Vérifier et corriger les erreurs dans chaque bloc\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m corrected_block \u001b[38;5;241m=\u001b[39m \u001b[43mcorrect_block\u001b[49m\u001b[43m(\u001b[49m\u001b[43mblock\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 8\u001b[0m corrected_bits \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m corrected_block\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m corrected_bits\n",
"Cell \u001b[0;32mIn[33], line 32\u001b[0m, in \u001b[0;36mcorrect_block\u001b[0;34m(encoded_block)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 30\u001b[0m \u001b[38;5;66;03m# Identifier la position de l'erreur et la corriger\u001b[39;00m\n\u001b[1;32m 31\u001b[0m error_position \u001b[38;5;241m=\u001b[39m s1 \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;241m+\u001b[39m s2 \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m s3 \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m4\u001b[39m\n\u001b[0;32m---> 32\u001b[0m corrected_bit \u001b[38;5;241m=\u001b[39m \u001b[43mflip_bit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mencoded_block\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror_position\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m corrected_bit[\u001b[38;5;241m2\u001b[39m] \u001b[38;5;241m+\u001b[39m corrected_bit[\u001b[38;5;241m4\u001b[39m:\u001b[38;5;241m7\u001b[39m]\n",
"Cell \u001b[0;32mIn[33], line 38\u001b[0m, in \u001b[0;36mflip_bit\u001b[0;34m(block, position)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mflip_bit\u001b[39m(block, position):\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# Inverser le bit à la position donnée\u001b[39;00m\n\u001b[1;32m 37\u001b[0m corrected_block \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(block)\n\u001b[0;32m---> 38\u001b[0m corrected_block[position] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[43mcorrected_block\u001b[49m\u001b[43m[\u001b[49m\u001b[43mposition\u001b[49m\u001b[43m]\u001b[49m))\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(corrected_block)\n",
"\u001b[0;31mIndexError\u001b[0m: list index out of range"
]
}
],
"source": [
"def hamming_correct(input_bits):\n",
" corrected_bits = \"\"\n",
" # Parcourir la chaîne d'entrée par blocs de 7 bits\n",
" for i in range(0, len(input_bits), 7):\n",
" block = input_bits[i:i+7]\n",
" # Vérifier et corriger les erreurs dans chaque bloc\n",
" corrected_block = correct_block(block)\n",
" corrected_bits += corrected_block\n",
" return corrected_bits\n",
"\n",
"def correct_block(encoded_block):\n",
" # Extraire les bits de parité pour calculer les syndromes\n",
" p1 = int(encoded_block[0])\n",
" p2 = int(encoded_block[1])\n",
" p3 = int(encoded_block[3])\n",
" actual_p1 = int(encoded_block[2])\n",
" actual_p2 = int(encoded_block[4])\n",
" actual_p3 = int(encoded_block[6])\n",
" \n",
" # Calculer les syndromes\n",
" s1 = (p1 + int(encoded_block[2]) + int(encoded_block[4]) + int(encoded_block[6])) % 2\n",
" s2 = (p2 + int(encoded_block[2]) + int(encoded_block[5]) + int(encoded_block[6])) % 2\n",
" s3 = (p3 + int(encoded_block[4]) + int(encoded_block[5]) + int(encoded_block[6])) % 2\n",
" \n",
" # Identifier et corriger l'erreur, si elle existe\n",
" if s1 == 0 and s2 == 0 and s3 == 0:\n",
" # Pas d'erreur\n",
" return encoded_block[2] + encoded_block[4:7]\n",
" else:\n",
" # Identifier la position de l'erreur et la corriger\n",
" error_position = s1 * 1 + s2 * 2 + s3 * 4\n",
" corrected_bit = flip_bit(encoded_block, error_position)\n",
" return corrected_bit[2] + corrected_bit[4:7]\n",
"\n",
"def flip_bit(block, position):\n",
" # Inverser le bit à la position donnée\n",
" corrected_block = list(block)\n",
" corrected_block[position] = str(1 - int(corrected_block[position]))\n",
" return \"\".join(corrected_block)\n",
"\n",
"# Exemple d'utilisation pour vérifier et corriger une chaîne de bits\n",
"received_message = \"01001110011110011001011111110110010110101001100101101010 01100100101100011001011101000110010001111001100100101100 01110011010011001010100000000111001000000001100100001011 01110010010101001010100000000110010001111001100100001011 01110010011110011100100111100110010010110001110010010101 00101010000000011001011000010110010010110001110010011110 00101010000000011001000111100110010111111101110100100111 01100100101100011100100111100010101000000001100100100111 01100100101100001010100000000110010001111001100100101100 00101010000000011001010001100110010000101101100100011110 01100101011000011001001011000111001001010100101010000000 01110010000000011001011111110111001010110001110010010101 00101010000000011001011111110110010001010101110010100111 01100100101100011001011101000110010100110101110010010101 00101010000000011001001001110110010010110001110010011110 00101010000000011001010011010110010111010001100100110010 01100101111111011100100101010110010110101001100100001011 01110010100111011001010011010110010111111101100101110100 0111001001111000101011110100\"\n",
"corrected_message = hamming_correct(received_message)\n",
"print(\"Message après correction :\", corrected_message)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Reference in new issue View Git Blame Copy Permalink