Spieltheorie

Es gibt 12 Antworten in diesem Thema. Der letzte Beitrag () ist von picoflop.

    Spieltheorie

    Mal angenommen:

    Kartenspiel mit 20 Karten, mit Werten von 1-20. 2 Spieler. Jeder bekommt zufällig 10 Karten (verdeckt). Jeder spieler legt jeweils eine Karte verdeckt auf den Tisch. Wenn beide Karten liegen, wird aufdeckt und der Spieler mit der höheren Karte bekommt den Stich. Gewonnen hat, wer mehr Punkte hat.

    Fragen:
    Gibt es eine "optimale" Strategie? Wenn ja welche? Kann man das irgendwo nachlesen?

    also ich kenne dabei ein leicht ähnliches Spiel:
    de.wikipedia.org/wiki/Hol%27s_der_Geier

    ist recht lustig und ich meine, dass ich darin auch recht gut bin...nur gibt es hierbei auch noch zufällig eine Punktzahl welche man gewinnen kann(inklusive minus Punkte, die bekommt der mit den niedrigeren Werten)...
    also ich versuche meistens die kleineren Karten recht früh "los" zu werden, da die meisten Gegenspieler oft zu hoch ansetzen->da sie gewinnen wollen und sie später nur noch kleine Karten haben...hinzu kommt einfach, dass ich es nach Gefühl mach...xD

    aber da dein Beispiel etwas anders ist, denke ich stimmt meins auch nicht mehr ganz so...

    das wäre meine "Strategie", ob diese aber "Optimal" ist, ist wohl eher fraglich und alles eine Glückssache, da es ja noch auf den Gegenspieler ankommt...

    gut dabei ist, dass du genau weißt, welche Karten dein Gegenspieler hat ;)
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    jvbsl schrieb:

    da es ja noch auf den Gegenspieler ankommt...

    Das wäre meine Überlegung:
    Macht eine "Strategie" überhaupt Sinn, oder spielt man die karten mehr oder weniger zufällig?
    Nehmen wir an, ich habe alle geraden und der Gegner alle ungeraden.
    Ich überlege, die 20 zu spielen - die gewinnt ja auf jeden Fall. Mein Gegner weiß, dass ich die 20 habe und antizipiert meinen Zug. Er nimmt also die 1. Wenn ich jetzt seine Antwort antizipiere, spiele ich stattdessen die 2. Das könnte der Gegner wieder antizipieren und stattdessen die 19 spielen. Würde ich das jetzt antizipieren ... usw usw ;)

    Müsste man vlt mal simulieren ...

    Madd Eye schrieb:

    Also um bei diesem spiel wirklich eine Strategie zu entwickeln musst du die Mathematik hernehmen

    Oder Mondphasen? Toller Link ... not :(


    Selbst mal rumgespielt:
    SimulatorKlasse:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Enum Strategie
    2. Zufall
    3. Niedrig
    4. Hoch
    5. End Enum
    7. Public Class GameSim
    9. Private BaseSet As New List(Of Integer)
    10. Private Shuffler As New Random(13245768)
    11. Private Chooser As New Random
    13. Public Sub New()
    15. For i = 1 To 20
    16. BaseSet.Add(i)
    17. Next
    19. End Sub
    21. Public Sub NewGame(ByRef SetA As List(Of Integer), ByRef SetB As List(Of Integer))
    23. Dim r() As Integer = (From i As Integer In BaseSet Order By Shuffler.NextDouble Select i).ToArray
    24. SetA = New List(Of Integer)
    25. SetB = New List(Of Integer)
    26. For i = 0 To 9
    27. SetA.Add(r(i))
    28. SetB.Add(r(10 + i))
    29. Next
    31. End Sub
    33. Public Function Choose(ByVal SetX As List(Of Integer), ByVal s As Strategie) As Integer
    35. Select Case s
    36. Case Strategie.Zufall
    37. Return SetX(Chooser.Next(0, SetX.Count))
    38. Case Strategie.Niedrig
    39. Return SetX.Min
    40. Case Strategie.Hoch
    41. Return SetX.Max
    42. End Select
    44. End Function
    46. Public Sub Remove(ByVal SetX As List(Of Integer), ByVal i As Integer)
    48. Dim j As Integer = -1
    49. For j = 0 To SetX.Count - 1
    50. If SetX(j) = i Then Exit For
    51. Next
    52. SetX.RemoveAt(j)
    54. End Sub
    56. End Class


    Aufrufcode:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Module Module1
    3. Sub Main()
    6. Simulate(Strategie.Hoch, Strategie.Niedrig)
    7. Simulate(Strategie.Niedrig, Strategie.Hoch)
    8. Simulate(Strategie.Niedrig, Strategie.Niedrig)
    9. Simulate(Strategie.Hoch, Strategie.Hoch)
    10. Simulate(Strategie.Zufall, Strategie.Zufall)
    12. Console.ReadLine()
    14. End Sub
    16. Private Sub Simulate(ByVal sA As Strategie, ByVal sB As Strategie)
    18. Dim seta As List(Of Integer) = Nothing
    19. Dim setb As List(Of Integer) = Nothing
    20. Dim a, b As Integer
    21. Dim awin, bwin, draw As Integer
    22. Dim asum, bsum As Integer
    24. Dim g As New GameSim
    25. For i = 1 To 100000
    26. g.NewGame(seta, setb)
    27. asum = 0
    28. bsum = 0
    29. For j = 1 To 10
    30. a = g.Choose(seta, sA)
    31. b = g.Choose(setb, sB)
    32. If a > b Then
    33. asum += (a + b)
    34. Else
    35. bsum += (a + b)
    36. End If
    37. g.Remove(seta, a)
    38. g.Remove(setb, b)
    39. Next
    40. If asum > bsum Then
    41. awin += 1
    42. ElseIf bsum > asum Then
    43. bwin += 1
    44. Else
    45. draw += 1
    46. End If
    48. Next
    50. Dim stb As New System.Text.StringBuilder
    51. With stb
    52. .AppendLine("Player A: " & sA.ToString)
    53. .AppendLine("Player B: " & sB.ToString)
    54. .AppendLine(String.Format("A: {0} B: {1} - {2}", awin, bwin, draw))
    55. .AppendLine("")
    56. End With
    57. Debug.Print(stb.ToString)
    58. Console.WriteLine(stb.ToString)
    60. End Sub
    62. End Module


    Output:

    Quellcode

    1. Player A: Hoch
    2. Player B: Niedrig
    3. A: 48720 B: 49159 - 2121
    6. Player A: Niedrig
    7. Player B: Hoch
    8. A: 48720 B: 49159 - 2121
    11. Player A: Niedrig
    12. Player B: Niedrig
    13. A: 48822 B: 48860 - 2318
    16. Player A: Hoch
    17. Player B: Hoch
    18. A: 48822 B: 48860 - 2318
    21. Player A: Zufall
    22. Player B: Zufall
    23. A: 49279 B: 49621 - 1100


    Was ich sehe: Strategie schein wurscht zu sein.
    wobei ich mich frage, ob ich irgendwo nen logischen Fehler habe, weil hoch-niedrig das gleiche ergibt wie niedrig-hoch (bzw hoch-hoch und niedrig-niedrig). Irgendwo ein Fehler?

    xCM2x schrieb:

    Ich schätze irgendwas stimmt mit dem Shuffler nicht.

    Derselbe Output ist beabsichtigt. Der ZufGen für's Kartenverteilen wird mit einer Konstanten initialisiert, damit man die Ergebnisse besser vergleichen kann. Die Karten sind also zufällig aber jedesmal gleich ;)
    Beim KartenLEGEN wird aber zufälliger Zufall verwendet.

    Nein, da ist kein Logikfehler. Allerdings sagt dein versuch nix aus über die strategien.
    Es ist bei gleich bleibendem Blatt egal ob hoch - niedrig oder anders herum.
    Ausschlag gebend ist bei welchem zug der Schnittpunkt ist. Bis zu diesem bekommt der hoch stratege jeden stich. Danach keinen.
    Aber egal wierum mans spielt,das Ergebnis bleibt gleich. Ebenso ist es bei niedrig -niesrig vs hoch-hoch.
    Die kartenpaare und damit der ausgang des stichs bleibt gleich.

    Ich bezweifle das es eine sichere strategie gibt, da man nicht alle aspekte kalkulieren kann.(gezogene karten +Handlung des gegners sind nicht berechenbar )
    Das ist meine Signatur und sie wird wunderbar sein!

    Ich habe gestern Abend noch einmal eine eigene Version programmiert (Ich habe zugegebenermaßen ein bisschen übernommen ^^ ), in meiner Version gibt es deutliche Unterschiede zwischen den Strategien.

    Spielklasse

    VB.NET-Quellcode

    1. Public Class cardSim
    3. Private deck As New List(Of Integer)
    4. Public deckSpielerA As New List(Of Integer)
    5. Public deckSpielerB As New List(Of Integer)
    6. Private mischer As New Random
    7. Private letzeKarteHoch As Boolean = False
    9. Sub New()
    11. For i = 1 To 20
    12. deck.Add(i)
    13. Next
    15. End Sub
    17. Public Sub neuesSpiel(ByVal spA As Strategie, ByVal spB As Strategie)
    19. Dim tKarte As Integer
    20. Dim karteA As Integer
    21. Dim karteB As Integer
    23. For j = 1 To 50
    24. karteA = mischer.Next(0, 20)
    25. karteB = mischer.Next(0, 20)
    26. tKarte = deck(karteB)
    27. deck(karteB) = deck(karteA)
    28. deck(karteA) = tKarte
    29. Next
    31. deckSpielerA.AddRange(deck.GetRange(0, 10))
    32. deckSpielerB.AddRange(deck.GetRange(10, 10))
    33. End Sub
    35. Public Function auswaehlen(ByVal st As Strategie, ByVal d As List(Of Integer))
    36. Select Case st
    37. Case Strategie.hoechste
    38. Return d.Max
    39. Case Strategie.niedrigste
    40. Return d.Min
    41. Case Strategie.hochNiedrigAbwechselnd
    42. If letzeKarteHoch Then
    43. Return d.Min
    44. Else
    45. Return d.Max
    46. End If
    47. letzeKarteHoch = Not letzeKarteHoch
    48. Case Strategie.zufaellige
    49. Return d(mischer.Next(0, d.Count))
    50. End Select
    51. End Function
    53. Public Sub entferne(ByVal d As List(Of Integer), ByVal karte As Integer)
    54. d.RemoveAt(d.IndexOf(karte))
    55. End Sub
    57. Public Enum Strategie
    58. hoechste
    59. niedrigste
    60. zufaellige
    61. hochNiedrigAbwechselnd
    62. End Enum
    63. End Class


    Aufruf

    VB.NET-Quellcode

    1. Module Module1
    2. Dim karten As cardSim
    3. Sub Main()
    4. karten = New cardSim()
    5. Do While True
    6. Simuliere(cardSim.Strategie.niedrigste, cardSim.Strategie.niedrigste)
    7. Simuliere(cardSim.Strategie.niedrigste, cardSim.Strategie.hoechste)
    8. Simuliere(cardSim.Strategie.hoechste, cardSim.Strategie.hoechste)
    9. Simuliere(cardSim.Strategie.zufaellige, cardSim.Strategie.zufaellige)
    10. Simuliere(cardSim.Strategie.zufaellige, cardSim.Strategie.hochNiedrigAbwechselnd)
    11. Simuliere(cardSim.Strategie.niedrigste, cardSim.Strategie.hochNiedrigAbwechselnd)
    12. Simuliere(cardSim.Strategie.hoechste, cardSim.Strategie.hochNiedrigAbwechselnd)
    13. Simuliere(cardSim.Strategie.niedrigste, cardSim.Strategie.zufaellige)
    14. Simuliere(cardSim.Strategie.hoechste, cardSim.Strategie.zufaellige)
    15. Console.ReadLine()
    16. Loop
    17. End Sub
    19. Sub Simuliere(ByVal stA As cardSim.Strategie, ByVal stB As cardSim.Strategie)
    20. Dim a, b As Integer
    21. Dim aTotal, bTotal As Integer
    22. Dim aWin, bWin, draw As Integer
    24. For i = 1 To 100000
    25. karten.neuesSpiel(stA, stB)
    26. For j = 1 To 10
    27. a = karten.auswaehlen(stA, karten.deckSpielerA)
    28. b = karten.auswaehlen(stB, karten.deckSpielerB)
    29. If a > b Then
    30. aTotal = a + b
    31. Else
    32. bTotal = a + b
    33. End If
    34. karten.entferne(karten.deckSpielerA, a)
    35. karten.entferne(karten.deckSpielerB, b)
    36. Next
    38. If aTotal > bTotal Then
    39. aWin += 1
    40. ElseIf bTotal > aTotal Then
    41. bWin += 1
    42. Else
    43. draw += 1
    44. End If
    45. Next
    47. Console.WriteLine("A: " & stA.ToString)
    48. Console.WriteLine("B: " & stB.ToString)
    50. Console.WriteLine(aWin & " - " & bWin & " - " & draw & vbNewLine & vbNewLine)
    51. End Sub
    52. End Module


    Output

    Quellcode

    1. A: niedrigste
    2. B: niedrigste
    3. 48698 - 48591 - 2711
    6. A: niedrigste
    7. B: hoechste
    8. 39950 - 40238 - 19812
    11. A: hoechste
    12. B: hoechste
    13. 48404 - 48898 - 2698
    16. A: zufaellige
    17. B: zufaellige
    18. 48106 - 48249 - 3645
    21. A: zufaellige
    22. B: hochNiedrigAbwechselnd
    23. 56677 - 38725 - 4598
    26. A: niedrigste
    27. B: hochNiedrigAbwechselnd
    28. 39940 - 39916 - 20144
    31. A: hoechste
    32. B: hochNiedrigAbwechselnd
    33. 48877 - 48404 - 2719
    36. A: niedrigste
    37. B: zufaellige
    38. 38442 - 56889 - 4669
    41. A: hoechste
    42. B: zufaellige
    43. 38293 - 57107 - 4600


    Da könnte man ja fast meinen der Zufall wär die beste Strategie... :(

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „xCM2x“ ()

    Mono schrieb:

    Es ist bei gleich bleibendem Blatt egal ob hoch

    Kann denn heutzutage keiner mehr Code lesen? ;)

    Ich erzeuge nicht 10.000 gleiche Blätter. Es werden 10.000 verschiedene Blätter erzeugt und mit einer Strategiekombination getestet. Damit ich die Kombis vergleichen kann, wird aber für jede Kombi dieselbe Blattfolge von Karten erzeugt.

    Also bleibt das Blatt auch für die kombis gleich und bringt das gleiche Ergebnis.

    kurz: gleiches blatt für kombi niedrig - hoch, hoch - niedrig
    = gleiches resultat.
    Dasselbe gilt für hoch hoch vs niedrig niedrig.
    Das ist meine Signatur und sie wird wunderbar sein!

    Mono schrieb:

    kurz: gleiches blatt für kombi niedrig - hoch, hoch - niedrig

    Das meinte ich ja.
    Mit einem gegebenen Blatt X und der Verteilung A(X) und B(X) ist es offensichtlich egal, wer von den beiden Spielern "niedrig" und wer "hoch" spielt. Das Ergebnis ist jeweils identisch. Aber inzwischen ist mir wenigstens auch klar, warum ;)

    niedrig_hoch
    A B
    1 6
    3 4
    5 2

    bzw hoch_niedrig
    A B
    5 2
    3 4
    1 6

    Die Kombinationen bleiben ja jeweils gleich, da ich BEIDE sortierungen umdrehe und zweimal - egibt ja wieder + ;)
    War also ein Denkfehler meinerseits, jeweils die Gegenkombi zu prüfen.

    Ach so:
    Hatte auch mal mitgezählt, wer jeweils das "bessere" Blatt (Summe der Karten) hat: B liegt bei der gegebenen Zuf bei rund +350 (hat also 350 Mal ein besseres Blatt) und gewinnt ja auch entsprechend häufiger. Scheint also evtl egal zu sein, welche Strat man spielt, Hauptsache man hat die besseren Karten ;)
    Aber vlt findet ja noch jemand eine "gute" Strategie?

Facebook
Telefonspende