In een dobbelspel met $$N$$ dobbelstenen is het de bedoeling om de som van de ogen van alle dobbelstenen zo groot mogelijk te maken. Elke dobbelsteen levert een resultaat tussen 1 en 6 (grenzen inbegrepen). Hierbij kan de speler een aantal keer gooien, en na elke gooi beslissen om een aantal dobbelstenen afzonderlijk te houden, en de waarde ervan constant te houden (met deze stenen wordt dus niet langer gegooid). In deze oefening programmeren we een aantal strategieëen om stenen afzonderlijk te houden, en kijken we na wat de invloed op de score is. Om de uitvoer van het programma eenduidig te maken, worden alle dobbelstenen genummerd (startend bij 0 t.e.m. $$N-1$$). Elke dobbelsteen krijgt dus een rangnummer.

de klasse HogeOgen

Dit is de basisklasse, die een (weinig intelligente) standaarstrategie implementeert. Programmeer in deze klasse het volgende:

een constructor met 1 argument (geheel en strikt groter dan 0), namelijk het aantal dobbelstenen waarmee gegooid wordt. De waarde van elke dobbelsteen wordt op 0 geplaatst, en geen enkele dobbelsteen staat als "constant" gemarkeerd.
de methode __str__(): deze methode levert een stringgedaante, die bestaat uit de stringgedaante van twee lijsten, namelijk:
- de lijst van de rangnummers van de dobbelstenen waarmee NIET meer gegooid wordt (in volgorde waarin de stenen afzonderlijk gehouden werden). Deze lijst bevat geen dubbels (een dobbelsteen kan maar 1 keer afzonderlijk geplaatst worden)
- de lijst die het aantal ogen op elke dobbelsteen weergeeft (in volgorde van rangnummer)
de methode nieuwe_worp() zorgt voor een nieuw dobbelresultaat. Hierbij loop je alle rangnummers van dobbelstenen af, startend bij 0 en eindigend bij $$N-1$$. Indien een dobbelsteen NIET afzonderlijk gehouden wordt, ken je aan de dobbelsteen een nieuwe waarde toe via het oproepen van de methode random.randint().
de methode constant() met 1 argument van het type int. Dit argument geeft de index aan van de dobbelsteen die constant gehouden wordt (er wordt niet meer mee gegooid). Je mag aannemen dat dit argument tussen 0 en $$N-1$$ ligt (grenzen inbegrepen). Indien de dobbelsteen al als constant gemarkeerd werd, heeft het oproepen van deze methode geen effect.
de methode reset() : de waarden van alle dobbelstenen wordt opnieuw op 0 geplaatst, en geen enkele dobbelsteen wordt als "constant" gemarkeerd.
de methode aantal_ogen() levert het totaal aantal ogen.
de methode plaats_afzonderlijk() : deze methode bepaalt de strategie om dobbelstenen als "constant" te markeren. In deze klasse wordt een dobbelsteen tijdens een spel nooit als "constant" gemarkeerd.
de methode speel_spel() met 1 natuurlijk argument (type int, strikt groter dan 0), namelijk $$max$$. Deze methode speelt het spel 1 keer, gebruik makend van de strategie in de methode plaats_afzonderlijk en levert als resultaat het aantal ogen dat op het eind van het spel door alle dobbelstenen samen getoond wordt. Hierbij initialiseer je eerst de dobbelstenen via de reset()-methode. Je werpt met de dobbelstenen tot ofwel alle dobbelstenen als "constant" gemarkeerd werden of het aantal beurten $$max$$ bereikt werd.
de methode gemiddelde_score() met twee argumenten, namelijk:
- het maximaal aantal beurten per spel (geheel en strikt groter dan 0)
- het aantal spelletjes dat gespeeld wordt
Het resultaat is het gemiddelde aantal ogen.

de klasse Strategie6

Deze klasse erft over van de klasse HogeOgen en herdefinieert de strategie-methode plaats_afzonderlijk(). Nu worden alle dobbelstenen met waarde 6 constant gehouden.

de klasse StrategieMinstensM

Ook deze klasse erft over van de klasse HogeOgen, en definieert:

een constructor met twee gehele argumenten (positief en strikt groter dan 0), namelijk
- het aantal dobbelstenen waarmee gegooid wordt
- een parameter $$M$$
de strategie-methode plaats_afzonderlijk() maakt nu alle dobbelstenen constant waarvan het aantal ogen minstens $$M$$ bedraagt ($$M$$ inbegrepen).

LET OP: verander de seed niet, en gebruik ook de randomgenerator enkel zoals hierboven aangegeven (anders is het resultaat niet controleerbaar via Dodona).

Voorbeeld

random.seed(100)
spel = HogeOgen(5)
print(spel)	#[][0, 0, 0, 0, 0]
spel.nieuwe_worp()
print(spel)	#[][2, 4, 4, 2, 6]
spel.constant(1)
spel.constant(1)
spel.constant(4)
print(spel)	#[1, 4][2, 4, 4, 2, 6]
spel.nieuwe_worp()
print(spel) #[1, 4][4, 4, 6, 3, 6]
print(spel.aantal_ogen()) #23

print(spel.speel_spel(5))	#18
print(spel.gemiddelde_score(5, 1000)) #17.604

spel6 = Strategie6(5)
print(spel6.speel_spel(5))	#16
print(spel6.gemiddelde_score(5, 1000)) #23.87

spel_m = StrategieMinstensM(5, 3)
print(spel_m.speel_spel(5)) #20
print(spel_m.gemiddelde_score(5, 1000)) #22.282