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

Programmeer het onderstaande in de klasse Bericht:

• een constructor met twee argumenten, namelijk de te versturen boodschap (type string), en de gebruiken Code. Je mag veronderstellen de code een geldige code voorstelt.
• de methode __str__() die de boodschap van het Bericht tussen [ en ] weergeeft, gevolgd door de gebruiksvriendelijke stringgedaante van de Code van het Bericht.
• de methode codeer() (zonder argumenten). Deze methode zet de boodschap van het 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 ord(). Deze byte wordt op zijn beurt naar een rij van 8 bits omgezet. De boodschap 'A' (int-waarde 65), wordt dus omgezet naar de lijst [1,0,0,0,0,0,1,0] (bemerk dat de meest-significante bit uiterst rechts staat!), de boodschap 'B' naar de lijst [0,1,0,0,0,0,1,0], en de boodschap 'AB' naar de lijst [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 "AB" voorstelt (en een lengte heeft van 16) dus aanvullen met 6 nullen. Er komt op die manier [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 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 chr(). Overtollige 0-bits (door aanvullen ontstaan) laat je hierbij buiten beschouwing.
  • Je overschrijft de boodschap van het bericht met de zonet gedecodeerdestring.

Om dit te testen krijg je de functie 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.

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

TIP: In je code zal je een bericht (string) moeten omzetten naar een bitpatroon. Hierbij kunnen volgende tips helpen om je code wat compacter te houden:

• de oproep format(ord(c), '08b') zet een karakter c om naar een binaire string. Let erop dat in deze string de MINST significante bit achteraan staat.
• om een string som te draaien, kan je de slice s[::-1] gebruiken!
• je kan gebruik maken van ''.join(...) om bitpatronen (strings) aaneen te schakelen als je een for-lus wil vermijden.
• je kan een string omzetten naar een lijst van bits, via een list-comprehension

Je hoeft je oplossing voor de klassen BinaireVeelterm en Code niet mee in te dienen op Dodona (maar dit mag wel).

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)