Het spel "Hoger-Lager" bestaat erin om een getal te raden in een vooropgegeven interval, waarbij je telkens een hint krijgt of je poging te hoog of te laag is. Bedoeling is om het geheime getal in zo weinig mogelijk beurten te raden. In deze opgave bouwen we een aantal klassen, om mogelijke raadstrategieën te evalueren.

Klasse HogerLager

Deze klasse raliseert de basislogica van het spel. Voorzie in deze klasse:

• een constructor met drie argumenten, allen geheel niet negatief, namelijk:
  • de ondergrens a voor het geheime getal (inclusief)
  • de bovengrens b voor het geheime getal (inclusief)
  • het maximaal aantal beurten dat een speler kan raden (inclusief)
• een methode speel() met één argument die een speler voorstelt (zie verder). Deze methode onderneemt volgende stappen:
  • bepalen van een willekeurig geheel getal in het interval $$[a, b]$$ door 1 keer de methode random.randint() op te roepen (dit de enige plaats in de klasse HogerLager waar je een randomgetal mag genereren.
  • vragen aan de speler van een eerste poging door oproepen van de methode eerste_poging(), met als argumenten a en b
  • zolang het getal niet geraden is EN het maximaal aantal beurten is niet overschreden, wordt een volgende poging gevraagd aan de speler, door het oproepen van de methode nieuwe_poging(). Als argument geef je de waarde +1 mee (indien de vorige poging te hoog was) of de waarde -1 mee (indien de vorige poging te laag was)

De methode levert het aantal pogingen dat de speler nodig had om het geheime getal te raden.

Klasse SpelerDom

Deze klasse stelt een niet zo verstandige speler voor, die geen rekening houdt met de feedback (te hoog of te laag) van de klasse HogerLager:

• methode eerste_poging() levert een willekeurig getal in het interval $$[a, b]$$
• methode nieuwe_poging() idem

Per poging is 1 oproep naar de methode random.randint() toegelaten.

Klasse SpelerRandom

Deze klasse istelt een iets verstandiger speler voor:

• methode eerste_poging() levert een willekeurig getal in het interval $$[a, b]$$
• methode nieuwe_poging() levert een willekeurig getal op in een interval van mogelijke getallen. Dit betekent dat elke feedback in rekening gehouden wordt. Stel dat de poging getal $$x$$ suggereerde. Indien de feedback luidt dat deze poging te hoog is, dan zijn enkel pogingen $$\le x - 1$$ zinvol. Analoog, indien de feedback luidt dat deze poging te laag is, dan zijn enkel pogingen $$\ge x + 1$$ nog zinvol. Op die manier verkleint bij elke poging het interval van mogelijke getallen. De nieuwe poging is een willkeurig getal in het interval van mogelijke getallen.

Per poging is 1 oproep naar de methode random.randint() toegelaten.

Klasse SpelerSlim

De speler gebruikt nu de strategie om telkens het midden van het interval van mogelijk getallen te kiezen. Hierbij wordt naar beneden afgerond. Hier heb je dus geen generatie van willekeurige getallen nodig.

Evaluatie

Om deze strategieën te evalueren, moeten we een groot aantal keer het spel spelen, en het gemiddelde aantal vereiste beurten uitrekenen. Schrijf hiertoe een functie gemiddeld_aantal_beurten() met als argumenten:

• een object van de klasse HogerLager
• een speler (dit object beschikt dus over de methoden eerste_poging() en nieuwe_poging())
• het aantal spelletjes dat moet uitgevoerd worden

Het resultaat van de methode is het gemiddeld aantal beurten (over alle spelletjes heen), dat die speler nodig heeft om het geheime getal te vinden (indien het maximaal aantal beurten verstreken is, reken je dit maximaal aantal beurten mee in de berekening van het gemiddelde).

Voorbeeld

spel = HogerLager(0, 100, 1000)
speler1 = SpelerDom()
speler2 = SpelerRandom()
speler3 = SpelerSlim()
random.seed(50)     
print(gemiddeld_aantal_beurten(spel, speler1, 1000)) #101.088
random.seed(50)     
print(gemiddeld_aantal_beurten(spel, speler2, 1000)) #7.5
random.seed(50)     
print(gemiddeld_aantal_beurten(spel, speler3, 1000)) #5.868