Index- und Pokerspiele

Wöchentliche Herausforderung 291

Jede Woche verschickt Mohammad S. Anwar die Weekly Challenge, eine Chance für uns alle, Lösungen für zwei wöchentliche Aufgaben zu finden. Meine Lösungen werden zunächst in Python geschrieben und dann in Perl konvertiert. Es ist eine großartige Möglichkeit für uns alle, etwas Codierung zu üben.

Herausforderung, meine Lösungen

Aufgabe 1: Mittlerer Index

Aufgaben

Sie erhalten ein Array von Ganzzahlen, @ints.

Schreiben Sie ein Skript, um den ganz linken mittleren Index (MI) zu finden, d. h. den kleinsten unter allen möglichen.

Ein mittlerer Index ist ein Index, bei dem ints[0] ints[1] … ints[MI-1] == ints[MI 1] ints[MI 2] … ints[ints.length-1].

• Wenn MI == 0, wird die Summe auf der linken Seite als 0 betrachtet. Ebenso
• Wenn MI == ints.length - 1, wird die Summe auf der rechten Seite als 0 betrachtet.

Meine Lösung

Das ist relativ einfach. Ich durchlaufe die Position von 0 bis eins weniger als die Länge der Eingaben. An jeder Position sehe ich, ob die Bedingung erfüllt ist.

def middle_index(ints: list) -> int:
    for i in range(len(ints)):
        if sum(ints[:i]) == sum(ints[i + 1:]):
            # It is, so return this position
            return i

    return -1

Beispiele

$ ./ch-1.py 2 3 -1 8 4
3

$ ./ch-1.py 1 -1 4
2

$ ./ch-1.py 2 5
-1

Aufgabe 2: Rangliste der Pokerblätter

Aufgabe

Eine Draw-Pokerhand besteht aus 5 Karten, die aus einem Kartenspiel mit 52 Karten gezogen werden: keine Joker, keine Wildcards. Ein Ass kann entweder einen hohen oder einen niedrigen Rang haben.

Schreiben Sie ein Skript, um die folgenden drei Dinge zu bestimmen:

1. Wie viele verschiedene 5-Karten-Hände können ausgeteilt werden?
2. Wie viele verschiedene Hände jeder der 10 Ränge können ausgeteilt werden? Beschreibungen der 10 Ränge der Pokerhände finden Sie hier: https://en.wikipedia.org/wiki/List_of_poker_hands#Hand-ranking_categories
3. Überprüfen Sie die zehn Zahlen, die Sie in Schritt 2 erhalten, indem Sie sie addieren und zeigen, dass sie mit der Zahl übereinstimmen, die Sie in Schritt 1 erhalten.

Meine Lösung

Schnall dich an, denn das wird ein langer Beitrag. Es ist auch das erste Mal seit langer Zeit, dass für eine Aufgabe keine Eingaben erforderlich sind. Bei den Herausforderungen, die ich abgeschlossen habe, war die letzte Nr. 177.

Um die erste Frage zu beantworten: Es gibt 311.875.200 mögliche Permutationen von Karten, die ausgeteilt werden können (52 × 51 × 50 × 49 × 48). Die Reihenfolge der Karten spielt jedoch keine Rolle. Fünf beliebige gezogene Karten können auf 120 Arten angeordnet werden (5 × 4 × 3 × 2 × 1). Daher gibt es 2.598.960 einzigartige Kombinationen.

Ich beginne damit, ein Kartenspiel zu erstellen. Dafür habe ich einen Rang (Kartennummer) von 1 bis 13. 1 ist ein Ass, 2 bis 10 sind die Zahlen, 11 ist Bube, 12 ist Dame und der König ist 13. Ich habe auch eine Farbe s, c, d und h (Ersatz, Keule, Raute bzw. Herz). Mit einer doppelten for-Schleife erzeuge ich alle 52 Karten (ein Tupel aus Rang und Farbe) und speichere dies in einer Liste namens Deck.

Ich gehe dann jede einzigartige Fünf-Karten-Kombination des Decks durch und bestimme, welche Hand ich halte. Zum Schluss drucke ich die Ergebnisse aus.

def middle_index(ints: list) -> int:
    for i in range(len(ints)):
        if sum(ints[:i]) == sum(ints[i + 1:]):
            # It is, so return this position
            return i

    return -1

Das ist der einfache Teil :)

Für die Funktion get_hands erstelle ich zunächst ein Diktat von Listen, sortiert nach Rang (die Zahl auf der Karte) und Farbe (das Symbol auf der Karte). Ich zähle auch die Häufigkeit der Ränge, da diese oft zur Bestimmung der Hand verwendet wird.

$ ./ch-1.py 2 3 -1 8 4
3

$ ./ch-1.py 1 -1 4
2

$ ./ch-1.py 2 5
-1

Für die Karten 10s, 10h, 9d, 8h, 2d würde also Folgendes eingestellt werden:

• cards_by_rank {10: ['s', 'h'], 9: ['d'], 8: ['h'], 2: ['d']}
• cards_by_suit {'s': [10], 'h': [10, 8], 'd': [9, 2]}
• count_by_rank {1: 3, 2: 1} (es gibt drei Ränge, die einmal erscheinen, und einen mit zwei Karten)

Dann ist es an der Zeit herauszufinden, welche Hand ich halte. Wir beginnen mit dem Straight Flush und dem Flush. Dies sind die einzigen Hände, die die Farbe der Karten berücksichtigen und dass alle Fünferkarten die gleiche Farbe haben. Dies wird bestimmt, wenn das Diktat „cards_by_suit“ nur einen Wert hat.

Um festzustellen, ob es sich um einen Straight Flush handelt, ordne ich die Karten numerisch (von 1 bis 13). Wenn die erste Karte 1 (ein Ass) und die letzte Karte 13 (König) ist, entferne ich die erste Karte und hänge 14 an das Ende der Liste an. Dadurch können eine 10, ein Bube, eine Dame, ein König und ein Ass als Straight Flush betrachtet werden. Ein Straight Flush liegt vor, wenn die Differenz zwischen der ersten und der letzten Kartennummer vier beträgt.

from collections import Counter, defaultdict
from itertools import combinations

def main():
    deck = [(rank, suit) for rank in range(1, 14) for suit in ('s', 'c', 'd', 'h')]
    hands = defaultdict(int)

    for cards in combinations(deck, 5):
        hand = get_hand(cards)
        hands[hand] += 1

    display_results(hands)

Für die Vierlingshand (Vier mit einem Rang und eine zufällige letzte Karte) und das Full House (Drei mit einem Rang, zwei mit unterschiedlichem Rang) kann ich den Befehl count_by_rank verwenden, um zu sehen, ob die Hand übereinstimmt die angegebenen Kriterien.

def get_hand(cards):
    cards_by_rank = defaultdict(list)
    cards_by_suit = defaultdict(list)

    for card in cards:
        number, suit = card
        cards_by_rank[number].append(card[1])
        cards_by_suit[suit].append(card[0])

    count_by_rank = Counter(len(cards_by_rank[r]) for r in cards_by_rank)

Um festzustellen, ob die Hand gerade ist, verwende ich eine ähnliche Logik wie beim Straight Flush. Ich überprüfe zunächst, ob ich fünf eindeutige Ränge (Kartennummern) habe, ordne sie, verschiebe bei Bedarf das Ass und überprüfe, ob die Differenz zwischen hoch und niedrig 4 beträgt.

    if len(cards_by_suit) == 1:
        cards = sorted(cards_by_rank)
        if cards[0] == 1 and cards[4] == 13:
            cards.pop(0)
            cards.append(14)

        if cards[4] - cards[0] == 4:
            return 'Straight flush'

        return 'Flush'

Drei Gleiche (drei Karten mit einem Wert, zwei Karten mit unterschiedlichem Wert), zwei Paare (zwei Karten mit einem Wert, zwei Karten mit unterschiedlichem Wert, zufällige letzte Karte), ein Paar (zwei Karten mit einem Wert). Rang, jeweils drei Karten mit unterschiedlichem Rang) können alle mit dem Count_by_rank-Dikt berechnet werden.

    if count_by_rank[4]:
        return 'Four of a kind'

    if count_by_rank[3] and count_by_rank[2]:
        return 'Full house'

Und schließlich, wenn nichts übereinstimmt, geben Sie „Hohe Karte“ zurück. Sie werden Ihr Haus auf keinen Fall wetten wollen, wenn Sie diese Hand halten :)

    if len(cards_by_rank) == 5:
        # Get the card ranks in the possible flush
        cards = sorted(cards_by_rank)
        if cards[0] == 1 and cards[4] == 13:
            cards.pop(0)
            cards.append(14)

        if cards[4] - cards[0] == 4:
            return 'Straight'

Die Funktion display_results zeigt einfach die Ergebnisse (nach Rang geordnet) in einem einheitlichen Layout an. Wie eingangs erwähnt, gibt es für jede Kombination 120 Permutationen, in denen die Karte bestellt werden kann.

    if count_by_rank[3]:
        return 'Three of a kind'

    if count_by_rank[2] == 2:
        return 'Two pair'

    if count_by_rank[2]:
        return 'One pair'

Ausgabe

    return 'High card'

Die Ausführung auf meinem Heim-PC dauerte etwa 15 Sekunden.

Wie wir in der unteren Reihe sehen können, haben wir 2.598.960 Kombinationen und 311.875.200 Permutationen. Dies entspricht dem, was wir in der Ausgabe erwartet hatten.

Das obige ist der detaillierte Inhalt vonIndex- und Pokerspiele. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!