Simulation eines Kartenhaufens

Anforderungen an ein Kartenhaufen-Software-Objekt

Unter einem Kartenhaufen soll hier eine Ansammlung von Karten verstanden werden. Einem solchen Kartenhaufen kann man weitere Karten hinzufügen. Ein Kartenhaufen hat zudem einen Gesamtwert (das ist die Summe der Werte aller Karten des Kartenhaufens). Im vorliegenden Beispiel beträgt der Gesamtwert 23.

Kartenhaufen

Ziel ist es, Kartenhaufen mit geeigneten Software-Objekten zu simulieren. Der folgende Python-Dialog zeigt, wie eine Verwendung eines solchen Software-Objekts aussehen könnte.

>>> 
>>> meinKartenhaufen = Kartenhaufen()
>>> meinKartenhaufen.hinzufuegen('H-D')
>>> meinKartenhaufen.hinzufuegen('X-A')
>>> meinKartenhaufen.hinzufuegen('K-9')
>>> meinKartenhaufen.kartenListe
['H-D', 'X-A', 'K-9']
>>> meinKartenhaufen.wert
23

Ein Bauplan für Kartenhaufen-Objekte - Entwurf

Zur Erzeugung eines Software-Objekts benötigt man einen Bauplan. Dieser Bauplan muss genau beschreiben, welchen Daten vom Software-Objekt verwaltet werden sollen und welche Operationen zur Verarbeitung der Daten bereitgestellt werden sollen.

Einen ersten Entwurf für einen solchen Bauplan zeigt das folgende Klassendiagramm:

Klassendiagramm Kartenhaufen

Aufgabe 1

Welche Bestandteile des Klassendiagramms sind für die Verwaltung der Daten / Verarbeitung der Daten zuständig?

Ein Bauplan für Kartenhaufen-Objekte - Implementierung

Wir implementieren einen Bauplan für Software-Objekte zur Simulation von Kartenhaufen mit einer Klassendeklaration in Python.

class Kartenhaufen(object):
    def __init__(self):
        self.kartenListe = # ...
        self.wert = # ...

    def hinzufuegen(self, karte):
        self.kartenListe = # ...
        if karte[2] == 'A':
            kartenwert = 11
        elif karte[2] == 'K':
            kartenwert = 4
        elif karte[2] == 'D':
            kartenwert = 3
        elif karte[2] == 'B':
            kartenwert = 2
        elif karte[2] == '1':
            kartenwert = 10
        elif karte[2] == '9':
            kartenwert = 9
        elif karte[2] == '8':
            kartenwert = 8
        elif karte[2] == '7':
            kartenwert = 7
        self.wert = # ...

Aufgabe 2

(a) Welcher Bestandteil der Klassendeklaration könnte für die Erzeugung von Objekten zuständig sein?

(b) Die Klassendeklaration ist noch nicht ganz fertig. Kannst du die fehlenden Teile (mit #... markiert) ergänzen? Zur Auswahl stehen die folgenden Codeschnipsel:

(c) Wenn du die Klassendeklaration richtig ergänzt hast, dann kannst du den folgenden Python-Dialog führen. Vorher musst du die Klassendeklaration aber einmal ausführen, damit sie vom Python-Ausführsystem übernommen wird.

>>> 
>>> meinKartenhaufen = Kartenhaufen()
>>> meinKartenhaufen.hinzufuegen('H-D')
>>> meinKartenhaufen.hinzufuegen('X-A')
>>> meinKartenhaufen.hinzufuegen('K-9')
>>> meinKartenhaufen.kartenListe
['H-D', 'X-A', 'K-9']
>>> meinKartenhaufen.wert
23

Aufgabe 3

Speichere die Klassendeklarationen der Klassen Kartenstapel und Kartenhaufen in einer gemeinsamen Datei ab und führe sie einmal aus.

Simuliere anschließend ein 17-und-4-Spiel mit zwei Spielern. Hier der Beginn einer solchen Simulation.

>>> 
>>> kartenstapel = Kartenstapel()
>>> kartenstapel.mischen()
>>> kartenhaufenSpieler1 = Kartenhaufen()
>>> kartenhaufenSpieler2 = Kartenhaufen()
>>> karte = kartenstapel.karteZiehen()
>>> kartenhaufenSpieler1.hinzufuegen(karte)
>>> karte = kartenstapel.karteZiehen()
>>> kartenhaufenSpieler2.hinzufuegen(karte)
>>> kartenhaufenSpieler1.wert
10
>>> kartenhaufenSpieler2.wert
3
>>> ...

Aufgabe 4

In der Datei kartenspiel.py befinden sich die Deklarationen der Klassen Kartenstapel und Kartenhaufen.

(a) Analysiere das folgende Testprogramm. Stelle eine Vermutung auf, was es leistet. Überprüfe anschließend deine Vermutung, indem du es ausführst. Das Testprogramm muss sich dabei im selben Verzeichnis wie die Datei kartenspiel.py befinden.

from kartenspiel import Kartenstapel, Kartenhaufen
# Testprogramm
kartenstapel = Kartenstapel()
kartenstapel.mischen()
kartenhaufenSpieler1 = Kartenhaufen()
kartenhaufenSpieler2 = Kartenhaufen()
print('Spieler 1:')
karte = kartenstapel.karteZiehen()
print(karte)
kartenhaufenSpieler1.hinzufuegen(karte)
print(kartenhaufenSpieler1.wert)
print()
print('Spieler 2:')
karte = kartenstapel.karteZiehen()
print(karte)
kartenhaufenSpieler2.hinzufuegen(karte)
print(kartenhaufenSpieler2.wert)
print()

(b) Ein Spieler zieht seine Karten nach der folgenden Strategie: Solange der Gesamtwert aller Karten noch kleiner als 18 ist, wird eine Karte gezogen. Entwickle ein Simulationsprogramm zu dieser Strategie.

(c) Ein Spieler zieht seine Karten immer nach der folgenden Strategie: Solange der Kartenwert noch kleiner als 18 ist, wird eine Karte gezogen. Ermittle mit einer Simulation, wie oft der Spieler bei dieser Strategie im Mittel über der 21 landet.
Zusatz: Das Ziehen von zwei Assen als erste und zweite Karte soll dabei als Sieg zählen.

X

Fehler melden

X

Suche