Het spelletje "∞ lus" wordt gespeeld met $$m \times n$$ tegels, gerangschikt in een $$m \times n$$ rooster met $$m$$ rijen en $$n$$ kolommen. Er zijn in totaal 16 verschillende tegelconfiguraties:

Elke tegel kan aansluitingen hebben naar boven, naar rechts, naar beneden, en naar links. De tegelconfiguraties worden dus gevormd door alle mogelijke combinaties van aansluitingen in deze vier richtingen, inclusief de tegel zonder aansluitingen.

Bij aanvang van het spel wordt het rooster gevuld met een selectie van tegels. De speler kiest vervolgens een tegel, en draait die 90° in wijzerzin of tegenwijzerzin. Als we bijvoorbeeld tegel ┣ in wijzerin draaien dan bekomen we tegel ┳, tegel ┛ wordt ┗, maar tegel ╋ blijft ╋. De speler kan deze procedure eindeloos blijven herhalen.

Het doel van het spel is om gesloten circuits te vormen: elke aansluiting moet connecteren op een aansluiting van de naburige tegel langs dezelfde zijde. Als een tegel bijvoorbeeld een aansluiting naar rechts heeft, dan moet de tegel rechts daarvan in het rooster een aansluiting naar links hebben. Bij wijze van illustratie toont onderstaand videofragment een speler die puzzels uit het spelletje "∞ lus" probeert op te lossen.

Opgave

Een eenvoudige manier om tegels voor te stellen — zonder gebruik te moeten maken van Unicode-karakters — is door gebruik te maken van een bitmasktechniek. Hierbij wordt elke tegel voorgesteld als een natuurlijk getal uit het interval $$[0, 15]$$ door gebruik te maken van de volgende code:

• begin met 0

• als de tegel een aansluiting naar boven heeft, tel er dan 1 bij op

• als de tegel een aansluiting naar rechts heeft, tel er dan 2 bij op

• als de tegel een aansluiting naar onder heeft, tel er dan 4 bij op

• als de tegel een aansluiting naar links heeft, tel er dan 8 bij op

Grafisch ziet dat er als volgt uit:

Op die manier kan de tegel ┫ voorgesteld worden als het getal $$1 + 4 + 8 = 13$$. Als we de binaire voorstelling van het getal bekijken, dan zien we dat

• het eerste cijfer vanaf rechts aangeeft of de tegel een aansluiting naar boven heeft

• het tweede cijfer vanaf rechts aangeeft of de tegel een aansluiting naar rechts heeft

• het derde cijfer vanaf rechts aangeeft of de tegel een aansluiting naar onder heeft

• het vierde cijfer vanaf rechts aangeeft of de tegel een aansluiting naar links heeft

Zo komt 13 overeen met het binaire getal 1101, waaruit we direct kunnen afleiden dat de tegel aansluitingen heeft naar alle richtingen behalve naar rechts.

Tegel

Definieer een klasse Tegel waarmee tegels uit het spelletje "∞ lus" kunnen voorgesteld worden. Bij het aanmaken van een nieuwe tegel (Tegel) zijn er drie mogelijkheden:

• er wordt een natuurlijk getal (int) uit het interval $$[0, 15]$$ doorgegeven; dit getal beschrijft een tegel op basis van de hierboven beschreven bitmasktechniek

• er wordt een karakter (str) doorgegeven dat correspondeert met één van de 16 Unicode-karakters in de tabel uit de inleiding van deze opgave

• er wordt geen argument doorgegeven; dit correspondeert met een tegel zonder aansluitingen

Als er een argument wordt doorgegeven dat niet correspondeert met één van de eerste twee mogelijkheden, dan moet een AssertionError opgeworpen worden met de boodschap ongeldige tegel.

Als er een tegel $$t$$ (Tegel) wordt doorgegeven aan de ingebouwde functie int, dan moet die het natuurlijk getal (int) uit het interval $$[0, 15]$$ teruggeven dat correspondeert met tegel $$t$$.

Als er een tegel $$t$$ (Tegel) wordt doorgegeven aan de ingebouwde functie str, dan moet die het Unicode-karakter (str) teruggeven dat correspondeert met tegel $$t$$.

Als er een tegel $$t$$ (Tegel) wordt doorgegeven aan de ingebouwde functie repr, dan moet die een string (str) teruggeven die leest als een Python-expressie waarmee een nieuwe tegel (Tegel) kan aangemaakt worden met dezelfde aansluitingen als tegel $$t$$. In die expressie moet er altijd een Unicode-karakter als argument doorgegeven worden.

Een tegel $$t$$ (Tegel) moet minstens de volgende getters (of eigenschappen) hebben:

• boven: Booleaanse waarde (bool) die aangeeft of tegel $$t$$ een aansluiting naar boven heeft

• rechts: Booleaanse waarde (bool) die aangeeft of tegel $$t$$ een aansluiting naar rechts heeft

• onder: Booleaanse waarde (bool) die aangeeft of tegel $$t$$ een aansluiting naar onder heeft

• links: Booleaanse waarde (bool) die aangeeft of tegel $$t$$ een aansluiting naar links heeft

Daarnaast moet je op een tegel $$t$$ (Tegel) een methode draai kunnen aanroepen, waaraan een Booleaanse waarde (bool) kan doorgegeven worden (standaardwaarde: True). Als de waarde True wordt doorgegeven, dan moet tegel $$t$$ 90° in wijzerzin gedraaid worden. Anders moet tegel $$t$$ 90° in tegenwijzerzin gedraaid worden. De methode moet een verwijzing naar tegel $$t$$ teruggeven.

Zorg ervoor dat de volgende bewerkingen het corresponderende resultaat opleveren voor tegels $$t$$, $$t_1$$ en $$t_2$$ (Tegel) en natuurlijk getal $$s$$ (int):

Geen van deze bewerkingen mag tegels $$t$$, $$t_1$$ of $$t_2$$ wijzigen.

OneindigeLus

Definieer ook nog een klasse OneindigeLus waarmee puzzels van het spelletje "∞ lus" kunnen voorgesteld worden. Bij het aanmaken van een nieuwe puzzel (OneindigeLus) moeten twee argumenten doorgegeven worden: i) een reeks (list of tuple) met natuurlijke getallen (int) uit het interval $$[0, 15]$$ die de tegels in het rooster voorstellen, uitgelezen in de leesrichting (van links naar rechts en van boven naar onder), en ii) een natuurlijk getal (int) dat aangeeft hoeveel kolommen het rooster telt. Als deze argumenten niet corresponderen met een geldig rooster van tegels, dan moet een AssertionError opgeworpen worden met de boodschap ongeldig rooster.

Als er een puzzel $$p$$ (OneindigeLus) wordt doorgegeven aan de ingebouwde functie str, dan moet die een stringvoorstelling (str) teruggeven van het rooster met tegels van puzzel $$p$$. Daarin vormt elke rij een afzonderlijke regel (opgelijst van boven naar onder), en worden de tegels op een rij voorgesteld door hun Unicode-karakter (opgelijst van links naar rechts).

Als er een puzzel $$p$$ (OneindigeLus) wordt doorgegeven aan de ingebouwde functie repr, dan moet die een string (str) teruggeven die leest als een Python-expressie waarmee een nieuwe puzzel (OneindigeLus) kan aangemaakt worden met dezelfde configuratie als puzzel $$p$$. In die expressie moet het eerste argument als een lijst (list) doorgegeven worden.

Op een puzzel $$p$$ (OneindigeLus) moet je minstens de volgende methoden kunnen aanroepen:

• Een methode draai waaraan het rijnummer (int) en het kolomnummer (int) van een tegel uit het rooster van puzzel $$p$$ moeten doorgegeven worden. Hierbij worden de rijen van boven naar onder genummerd, en de kolommen van links naar rechts, telkens vanaf 0. Bovendien kan als derde argument ook nog een Booleaanse waarde (bool) doorgegeven worden (standaardwaarde: True). Als het rij- en kolomnummer geen geldige positie van een tegel in het rooster van puzzel $$p$$ aanwijzen, dan moet een AssertionError opgeworpen worden met de boodschap ongeldige positie. Anders moet de tegel op de aangegeven positie in het rooster van puzzel $$p$$ 90° gedraaid worden: in wijzerzin als de de derde parameter de waarde True heeft of anders in tegenwijzerzin. De methode moet een verwijzing naar puzzel $$p$$ teruggeven.

• Een methode isopgelost waaraan geen argumenten moeten doorgegeven worden. De methode moet een Booleaanse waarde (bool) teruggeven, die aangeeft of de tegels in het rooster van puzzel $$p$$ gesloten circuits vormen. Dat is het geval als elke aansluiting connecteert op een aansluiting van de naburige tegel langs dezelfde zijde.

Voorbeeld

>>> tegel = Tegel(11)
>>> int(tegel)
11
>>> str(tegel)
'┻'
>>> tegel
Tegel('┻')
>>> tegel.boven
True
>>> tegel.rechts
True
>>> tegel.onder
False
>>> tegel.links
True
>>> tegel.draai()
Tegel('┣')
>>> tegel
Tegel('┣')
>>> tegel.draai().draai()
Tegel('┫')
>>> tegel.draai(False)
Tegel('┳')
>>> tegel.draai(False).draai(False)
Tegel('┻')
>>> tegel >> 3
Tegel('┫')
>>> tegel
Tegel('┻')
>>> tegel << 6
Tegel('┳')
>>> tegel
Tegel('┻')

>>> Tegel('┛') == Tegel('┓')
False
>>> Tegel('┛') != Tegel('┓')
True
>>> Tegel('┛') == Tegel('┓').draai()
True

>>> Tegel('┓') | Tegel('┗')
Tegel('╋')
>>> Tegel('┣') & Tegel('┻')
Tegel('┗')
>>> tegel | Tegel('┫')
Tegel('╋')
>>> tegel
Tegel('┻')
>>> Tegel('┃') & tegel
Tegel('╹')
>>> tegel
Tegel('┻')

>>> puzzel = OneindigeLus([9, 12, 12, 6, 10, 13, 13, 5, 3, 3, 9, 3], 4)
>>> puzzel
OneindigeLus([9, 12, 12, 6, 10, 13, 13, 5, 3, 3, 9, 3], 4)
>>> print(puzzel)
┛┓┓┏
━┫┫┃
┗┗┛┗
>>> puzzel.isopgelost()
False
>>> puzzel.draai(0, 0).draai(0, 0).draai(0, 2, False).draai(0, 3)
OneindigeLus([6, 12, 6, 12, 10, 13, 13, 5, 3, 3, 9, 3], 4)
>>> print(puzzel)
┏┓┏┓
━┫┫┃
┗┗┛┗
>>> puzzel.isopgelost()
False
>>> puzzel.draai(1, 0).draai(1, 1).draai(1, 1)
OneindigeLus([6, 12, 6, 12, 5, 7, 13, 5, 3, 3, 9, 3], 4)
>>> print(puzzel)
┏┓┏┓
┃┣┫┃
┗┗┛┗
>>> puzzel.isopgelost()
False
>>> puzzel.draai(2, 1, False).draai(2, 2).draai(2, 3, False)
OneindigeLus([6, 12, 6, 12, 5, 7, 13, 5, 3, 9, 3, 9], 4)
>>> print(puzzel)
┏┓┏┓
┃┣┫┃
┗┛┗┛
>>> puzzel.isopgelost()
True