Een kaartspel wordt gespeeld met een stapel kaarten, een "deck" genoemd. Elke kaart heeft een numerieke waarde. De bedoeling is dat een speler een kaart vraagt van de gedekte stapel, en hierbij een waarde in zijn hand realiseert die zo dicht mogelijk ligt bij een vooropgegeven waarde $$N$$, zonder die $$N$$ te overtreffen.

In deze oefening bouwen we eerst twee klassen die een strategie vastleggen op basis waarvan de speler beslist hoeveel kaarten hij/zij wenst te nemen, namelijk de klassen GrensStrategie en FraudeStrategie. Daarna worden deze klassen gebruikt om een groot aantal spelrondes te spelen in de klasse KaartSpel.

Klasse GrensStrategie

Programmeer in deze klasse het volgende:

• een constructor met als enig argument een geheel getal $$g > 0$$. Dit getal zal de grens vastleggen die de speler zal gebruiken om te beslissen of hij/zij al dan niet een kaart bijvraagt.
• de methode __str__() levert volgende string-gedaante: $$\verb!GrensStrategie[grens]!$$ waarbij de grens $$g$$ tussen de vierkante haakjes weergegeven wordt.
• de methode neem_kaarten() heeft als argumenten:
  • de stapel kaarten waarvan er kaarten kunnen genomen worden. Deze stapel is een lijst waarbij elk element een geheel getal strikt groter dan 0 voorstelt. Elk lijstelement stelt de waarde van een kaart in deze stapel voor.
  • de aflegstapel bevat de waarden van de kaarten die al weggenomen werden van de originele stapel, in volgorde waarin ze weggenomen werden
  • een geheel getal, strikt groter dan 0, dat aangeeft hoeveel kaarten maximaal genomen mogen worden
  Het resultaat van de methode is een tuple met drie elementen, namelijk:
  • de genomen kaarten (in volgorde waarin ze van de stapel genomen werden). Hierbij worden kaarten genomen, zolang de som van de waarden van de reeds genomen kaarten strikt kleiner is dan de grens $$g$$ (zie constructor). Kaarten worden genomen in volgorde waarin ze in de stapel voorkomen.
  • de nieuwe stapel (namelijk de originele stapel waarin aan de kop een aantal kaarten weggenomen werden)
  • de nieuwe aflegstapel (namelijk de orginele stapel waaraan aan het eind de genomen kaarten toegevoegd werden

Voorbeel

stapel = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
s = GrensStrategie(11)
str(s)				# 'GrensStrategie[11]'
kaarten, stapel, aflegstapel = s.neem_kaarten(stapel, [], 6)
str(kaarten)		# '[1, 2, 3, 4, 5]'
str(stapel)			# '[6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]'
str(aflegstapel)	# '[1, 2, 3, 4, 5]'

Klasse FraudeStrategie

In deze klasse implementeren we een frauduleuze strategie: de speler kan een kaart bekijken vooraleer te beslissen om ze al dan niet te nemen (je kan dus een kaart terugleggen).

De klasse FraudeStrategie erft over van de klasse GrensStrategie en overschrijft volgende methodes van de klasse GrensStrategie:

• de methode __str__() levert nu als resultaat de string $$\verb!FraudeStrategie[grens]!$$ waarbij opieuw de grens tussen de vierkante haakjes als geheel getal weergegeven wordt.
• de methode neem_kaarten() met zelfde argumenten en resultaten als in de klasse GrensStrategie realiseert nu een andere strategie: je neemt kaarten zoals in de klasse GrensStrategie. Indien de som van de waarden van de kaarten kleiner of gelijk is aan de grens, is het resultaat identiek aan het resultaat van de gelijknamige methode uit de klasse GrensStrategie. Indien echter de laatst genomen kaart ervoor zorgt dat de grens overschreden wordt (dus gezamenlijke waarde strikt groter dan de grens), dan leg je die laatstgenomen kaart terug. In dit geval van overschrijden betekent dit concreet dat :
  • het eerste resultaat (namelijk de genomen kaarten) 1 element korter wordt t.o.v. het resultaat van dezelfde methode uit de klasse GrensStrategie. De laast genomen kaart wordt immers teruggelegd (en die kaart verdwijnt dus uit de lijst genomen kaarten).
  • het tweede resultaat (namelijk de nieuwe stapel) 1 element meer bevat (vooraan in de lijst) t.o.v. het resultaat van dezelfde methode uit de klasse GrensStrategie. De kaart wordt dus teruggelegd op de stapel niet gebruikte kaarten, en deze kaart is de eerstvolgende die genomen wordt in de volgende ronde.
  • het derde resultaat (namelijk de nieuwe aflegstapel) 1 element minder bevat (achteraan de lijst) t.o.v. het resultaat van dezelfde methode uit de klasse GrensStrategie. De laatst genomen kaart wordt immers teruggelegd op de stapel niet-gebruikte kaarten, en komt dus niet op de aflegstapel terecht!

Voorbeeld

stapel = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
s = FraudeStrategie(11)
str(s)		# 'FraudeStrategie[11]'
kaarten, stapel, aflegstapel = s.neem_kaarten(stapel, [], 6)
str(kaarten)		# '[1, 2, 3, 4]'
str(stapel)			# '[5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]'
str(aflegstapel)	# '[1, 2, 3, 4]'

Klasse KaartSpel

Programmeer in deze klasse:

• een constructor met volgende argumenten:
  • een lijst die de originele stapel kaarten voorstelt
  • de waarde $$N$$ die de speler zo dicht mogelijk moet benaderen door kaarten te vragen, zonder deze waarde te overtreffen ($$N$$ is geheel en strikt groter dan 0)
  • de waarde $$maximum$$ die aangeeft hoeveel kaarten maximaal genomen mogen worden. Deze waarde is geheel en strikt groter dan 0.
  • de waarde $$beloning$$ die aangeeft wat de beloning is (uitgedrukt in punten) indien de speler erin slaagt om precies de waarde $$N$$ te realiseren.
• een methode __str__() levert volgende stringgedaante $$\verb![N,maximum]!$$, dus de waarden van de parameters $$N$$ en $$maximum$$ (zie constructor), gescheiden door een komma en tussen vierkante haakjes (geen spaties).
• een methode speel_rondes(): deze methode heeft als doel een aantal spelrondes te spelen, en hierbij een bepaalde strategie te volgen. Er zijn twee stapels kaarten, namelijk een stapel van nog niet genomen kaarten, en een stapel van kaarten die al gebruikt werden (de aflegstapel). In elke ronde neemt de speler kaarten (van de nog niet gebruikte stapel kaarten) volgens een bepaalde strategie. Er wordt gekeken hoeveel punten hij/zij in deze ronde haalt (om dit aantal punten te bepalen, worden hieronder de regels gegeven). Daarna legt de speler de genomen kaarten op de aflegstapel, en neemt (opnieuw dezelfde strategie volgend) een aantal kaarten. Dit herhaalt zich voor het opgegeven aantal rondes. Indien er onvoldoende kaarten overblijven op de stapel (meer specifiek indien het aantal kaarten kleiner is dan het aantal kaarten dat een speler mag nemen $$maximum$$), dan wordt een verse stapel kaarten genomen, en wordt de aflegstapel leeg gemaakt. Het resultaat is het totaal aantal punten dat een speler verzamelt na het spelen van die rondes, indien hij/zij de opgegeven strategie volgt. De methode heeft als argumenten:
  • een object dat over een methode neem_kaarten() beschikt, zoals voorhanden in de klassen GrensStrategie en FraudeStrategie
  • een geheel getal, strikt groter dan 0, dat het aantal te spelen rondes bevat
  De methode implementeert volgende logica:
  1. start met een verse stapel (zie eerste argument van de constructor) en haal die dooreen via de methode

     random.shuffle(stapel)

     , de aflegstapel is uiteraard leeg
  2. indien de stapel minder kaarten bevat dan er per spelronde mogen genomen worden (derde argument van de constructor), start je met een verse stapel (door opnieuw de originele stapel via

      random.shuffle(stapel) 

     dooreen te halen, en de aflegstapel leeg te maken)
  3. bepaal de genomen kaarten via de methode neem_kaarten() van de strategie (eerste argument)
  4. bepaal het aantal punten behaald in deze ronde als volgt:
     • indien de waarde exact gelijk is een $$N$$ krijg je $$beloning$$ punten
     • indien de waarde strikt groter is dan $$N$$ krijg je een negatief aantal punten, namelijk $$-2\times beloning$$
     • indien de waarde strikt kleiner is dan $$N$$ dan krijg je als beloning $$beloning \times \frac{waarde}{N}$$
  5. tel dit aantal punten op bij het totaal aantal punten
  6. herhaal vanaf stap 2 tot het gewenst aantal rondes gespeeld is
  7. het resultaat van de methode is het totaal aantal punten
  Let erop de stapels precies te schudden zoals hierboven aangegeven, en ook geen extra oproepen uit te voeren die random-getallen genereren. Als je dit toch doet, is verificatie via Dodona van dit vraagonderdeel niet mogelijk. Ter info: voor de 2 eerste testcases op Dodona wordt de seed 200 gebruikt.

  Voorbeeld

  spel = KaartSpel([1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5], 10, 3, 10)
  str(spel)									# '[10,3]'
  g = GrensStrategie(8)
  f = FraudeStrategie(10)
  punten_grens = spel.speel_rondes(g, 25)		# '80.0'
  punten_fraude = spel.speel_rondes(f, 25) 	# '203.0'