Een vierkant speelveld bestaat uit n bij n velden, genummerd via een tuple gehele getallen. Het eerste getal stelt hierbij een rijnummer voor en het tweede een kolomnummer. Beide getallen liggen dus tussen 0 en n-1 (grenzen inbegrepen). Op dit bord worden een aantal velden gedefinieerd die ontoegankelijk zijn voor een speelstuk. Bedoeling is om na te gaan of vanuit het veld (0,0) het veld (n-1, n-1) bereikbaar is door enkel horizontaal of verticaal te bewegen, zonder een verboden speelveld te gebruiken. Programmeer in de klasse DiagonaalPad:

• een constructor met 1 argument n, namelijk de grootte van het speelveld
• de operator += heeft het volgende effect :
  • indien het rechteroperand een tuple is dat bestaat uit 2 gehele getallen in het correcte bereik, dan wordt het veld dat overeenkomt met dit tuple als verboden bestempeld. Indien het tuple al een verboden veld voorstelt, heeft der operator geen effect.
  • indien het rechteroperand een object een lijst is, dan wordt de operator uitgevoerd op elk element van de lijst (met dus hetzelfde gedrag per tuple als in het vorige puntje)
  • in alle andere gevallen heeft de operator geen effect
• de methode verboden_velden() levert de lijst van verboden velden (elk veld voorgesteld door een tuple), in de volgorde waarin ze toegevoegd werden.
• de methode alle_borden() levert een lijst van lijsten op. Elk van de lijsten stelt een reeks van verboden velden voor. Deze lijst van verboden velden moet voldoen aan:
  • per rij is er precies 1 verboden veld
  • per kolom is er precies 1 verboden veld
  • de lijst is gesorteerd volgen opklimmend kolomnummer
  De gevraagde methode levert een lijst op van alle lijsten die aan bovenstaande voorwaarde voldoen.
• een traject op het bord wordt gekenmerkt door een reeks tuples, waarbij elk tuple een veld op het bord voorstelt. Om naar het volgende veld te gaan, moet je aan volgende regels voldoen:
  • je moet ofwel 1 vakje horizontaal of verticaal bewegen
  • je mag het bord niet verlaten
  • je mag NIET naar een verboden veld gaan
  • je mag NIET naar een veld gaan dat al in het traject zit (m.a.w. lussen in het traject zijn niet toegelaten)
  Programmeer de methode eindpunten() met als enig argument een niet-negatief geheel getal k. De methode levert een lijst van eindpunten op die bereikbaar zijn vanuit het veld (0,0) in precies k stappen. Let hierbij op onderstaande speciale gevallen:
  • indien het veld (0,0) een verboden veld is, dan is het resultaat van deze methode een lege lijst
  • voor k = 0 is het resultaat de lijst [(0,0)] indien het veld (0,0) GEEN verboden veld is.
• de methode trajecten() levert een lijst van lijsten. Elk van de lijsten is een traject dat start in (0,0) en eindigt in (n-1, n-1). Zorg dat de methode alle geldige trajecten (zie hoger) teruggeeft.

Voorbeeld

Tabblad 1

d = DiagonaalPad(2)
d += (1, 1)
print(d.verboden_velden()) #[(1, 1)]
d += (1, 1)
print(d.verboden_velden()) #[(1, 1)]

d = DiagonaalPad(6)
d += (3, 4)
print(d.verboden_velden()) #[(3, 4)]
d += (4, 4)
print(d.verboden_velden()) #[(3, 4), (4, 4)]
d += [(-3, 5), (1, 1), (3, 5), (-1, -3), (5, 1), (1, 3)]
print(d.verboden_velden()) #[(3, 4), (4, 4), (1, 1), (3, 5), (5, 1), (1, 3)]

Tabblad 2

d = DiagonaalPad(2)
print(sorted(d.alle_borden())) #[[(0, 0), (1, 1)], [(1, 0), (0, 1)]]

d = DiagonaalPad(3)
print(sorted(d.alle_borden())) #[[(0, 0), (1, 1), (2, 2)], [(0, 0), (2, 1), (1, 2)], [(1, 0), (0, 1), (2, 2)], [(1, 0), (2, 1), (0, 2)], [(2, 0), (0, 1), (1, 2)], [(2, 0), (1, 1), (0, 2)]]

Tabblad 3

d = DiagonaalPad(4)
d += [(3, 0), (2, 1), (0, 2), (1, 3)]
print(sorted(d.eindpunten(5))) #[(2, 3), (3, 2)]
print(sorted(d.trajecten())) #[[(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (2, 3), (3, 3)], [(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (3, 2), (3, 3)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 3), (3, 3)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (3, 2), (3, 3)]]

d = DiagonaalPad(2)
d += [(0, 0), (1, 1)]
print(sorted(d.eindpunten(3))) #[]
print(sorted(d.trajecten())) #[]

d = DiagonaalPad(5)
d += [(4, 0), (0, 1), (3, 2), (2, 3), (1, 4)]
print(sorted(d.eindpunten(5))) #[(0, 3), (1, 2), (2, 1), (3, 0), (4, 1)]
print(sorted(d.trajecten())) #[[(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 1), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 1), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (1, 1), (1, 2), (2, 2), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)], [(0, 0), (1, 0), (1, 1), (2, 1), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (1, 1), (2, 1), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)], [(0, 0), (1, 0), (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (1, 1), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)], [(0, 0), (1, 0), (2, 0), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (2, 0), (2, 1), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)], [(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (3, 3), (3, 4), (4, 4)], [(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4)]]