Een $$\verb!Bericht!$$ dat over een netwerk (dat aan fouten onderhevig is) gestuurd wordt, wordt gekenmerkt door de boodschap die verstuurd wordt en de $$\verb!Code!$$ die gebruikt wordt om de communicatie foutbestendig te maken.

Programmeer het onderstaande in de klasse $$\verb!Bericht!$$:

• een constructor met twee argumenten, namelijk de te versturen boodschap (type string), en de gebruiken $$\verb!Code!$$. Je mag veronderstellen de code een geldige code voorstelt.
• de methode $$\verb!__str__!$$ die de boodschap van het $$\verb!Bericht!$$ tussen '[' en ']' weergeeft, gevolgd door de gebruiksvriendelijke stringgedaante van de $$\verb!Code!$$ van het $$\verb!Bericht!$$.
• de methode $$\verb!codeer()!$$ (zonder argumenten). Deze methode zet de boodschap van het $$\verb!Bericht!$$ om in een lijst van '1'-en en '0'-en die als resultaat teruggegeven wordt. Hierbij ga je als volgt tewerk:
  • Zet de boodschap van het bericht om naar een lijst van bits. Hierbij wordt elk karakter van de boodschap overlopen, en we zetten dit karakter om naar een geheel getal tussen 0 en 255 via de ingebouwde functie $$\verb!ord()!$$. Deze byte wordt op zijn beurt naar een rij van 8 bits omgezet. De boodschap $$\verb!'A'!$$ (int-waarde 65), wordt dus omgezet naar de lijst $$\verb![1,0,0,0,0,0,1,0]!$$ , de boodschap $$\verb!'B'!$$ naar de lijst $$\verb![0,1,0,0,0,0,1,0]!$$, en de boodschap $$\verb!'AB'!$$ in naar de lijst $$\verb![1,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0]!$$.
  • Het is niet zeker dat de hierboven geconstrueerde lijst een lengte heeft die een geheel veelvoud is van $$m$$ (we zullen elk groepje van $$m$$ bits immers coderen naar een codewoord van $$n$$ bits). Vul daarom de lijst die hierboven geconstrueerd werd aan met symbolen 0 tot je een geheel veelvoud van $$m$$ als lijstlengte hebt. Voor een $$(15,2048,3)$$-code (met dus $$m=11$$) moeten we de rij die $$\verb!"AB"!$$ voorstelt (en een lengte heeft van 16) dus aanvullen met 6 nullen. Er komt op die manier $$\verb![1,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0]!$$.
  • Bepaal voor elk groepje van $$m$$ symbolen uit de hierboven construeerde lijst het bijhorende codewoord van $$n$$ symbolen. Bouw de resultaatlijst als aaneenschakeling van deze codewoorden.
• de methode $$\verb!decodeer()!$$, met als argument een te decoderen lijst van bits. Ga hierbij als volgt tewerk:
  • Je overloopt elk groepje van $$n$$ bits uit de argumentlijst, en decodeert dit groepje (eventueel met correctie) naar een groepje van $$m$$ bits. Je bekomt een lijst van gedecodeerde bits.
  • Je zet elke groep van 8 bits om naar een geheel getal, en zoekt het bijhorende karakter via de ingebouwde methode $$\verb!chr()!$$. Overtollige 0-bits (door aanvullen ontstaan) laat je hierbij buiten beschouwing.
  • Je overschrijft de boodschap van het bericht met de zonet gedecodeerde string.

Om dit te testen krijg je de functie $$\verb!ruis(bitlijst, n, a)!$$ gegeven, met als argumenten:

• een lijst van bits waarin fouten toegevoegd worden.
• $$n \gt 0$$ lengte van een bitgroepje.
• $$a \ge 0$$ het aantal fouten dat geïntroduceerd wordt per groepje van $$n$$ bits.

Dien je oplossing voor de klassen $$\verb!BinaireVeelterm!$$, $$\verb!Code!$$ en $$\verb!Bericht!$$ in.

import random
def ruis(bit, n, a):
	for i in range(len(bit)//n):
		index = list(range(n))
		random.shuffle(index)
		for j in range(a):
			bit[i*n+index[j]] = 1 if bit[i*n+index[j]] == 0 else 0

Voorbeeld

b_A = Bericht('A', code)
print(b_A)                      # [A](15,2048)[x**4+x**1+1]
c_A = b_A.codeer()
print(str(c_A))                 # [1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0]
b_cA = Bericht('?', code)
b_cA.decodeer(c_A)
print(b_cA)                     # [A](15,2048)[x**4+x**1+1]

b_AB = Bericht('AB', code)
print(b_AB)                     # [AB](15,2048)[x**4+x**1+1]
c_AB = b_AB.codeer()
print(str(c_AB))                # [1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1,
								#  0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
b_cAB = Bericht('?', code)
b_cAB.decodeer(c_AB)
print(b_cAB)                    # [AB](15,2048)[x**4+x**1+1]

b_w = Bericht('abc123', code)
print(b_w)                      # [abc123](15,2048)[x**4+x**1+1]
c = b_w.codeer()
print(str(c))                    # [1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
								#  0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1,
								#  1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0,
								#  1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0,
								#  1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
b_c = Bericht('?', code)
b_c.decodeer(c)                    # [abc123](15,2048)[x**4+x**1+1]
print(b_c))
print(b_c)