Pokerface

Einführung

Leo spielt gerne Poker, aber sein Job bei Tech Inc. ist zu anspruchsvoll, als dass er lernen könnte, wie man gut spielt. Leo ist Informatiker und lässt sich nicht entmutigen. Er beschließt, sich mehr Zeit zu nehmen als nötig, um nur Poker zu lernen, und damit einen Poker-Bot zu schreiben, der ihm hilft, besser zu spielen. Aber jetzt hat Leo ein Problem: Um zu verstehen, wie man ein bisschen besser spielt, muss Leo mehrere Spiele von mehreren "Leuten" beobachten, aber die "Leute" brauchen unterschiedliche Spielstile, um die Qualität und Realität des Spiels zu verbessern.

Die Herausforderung

Leo erinnert sich, dass es tatsächlich eine Website gibt, die sich den Programmierherausforderungen widmet, und bittet um Ihre Hilfe! Ihre Aufgabe ist es, ein Programm zu schreiben, das "Pokerface", eine modifizierte Version von 5-Karten-Poker, spielt. Das Programm nimmt Eingaben als 5-Karten-Hand in einem beliebigen Format entgegen. Anschließend gibt das Programm Folgendes aus:

• Genau (Groß- / Kleinschreibung beachten) "true" "1" oder "t", wenn der Spieler Karten austauschen möchte, ansonsten jede andere nicht leere Ausgabe.
• Wenn dies zutrifft, Liste der Kartenindizes und / oder Kartennamen, die der Spieler austauschen möchte.
• Eine einzelne Zahl zwischen 0 und 3, die angibt, wie viele zusätzliche Karten der Spieler haben möchte.
• Drucken Sie die Hand aus, die der Spieler verwenden möchte.

(Siehe Formatierung unten)

Pokerface Regeln

• Da pokerface ein textbasiertes Abenteuerspiel ist, müssen Karten einheitlich dargestellt werden. Karten werden durch zwei Zeichencodes dargestellt, wobei das erste Zeichen die Farbe und das zweite den Namen der Karte darstellt.
  • Karten:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Königin = Q
    • König = K
    • Ass = A
  • Anzüge:
    • Pik = S
    • Vereine = C
    • Herzen = H
    • Diamant = D

Das Pik-As wäre also SA, die Herz-10 ist HT, die 4. der Diamanten ist D4 usw.

• Eine einzelne Runde von Pokerface besteht aus vier Schritten:
  • Das Deck wird neu gemischt und jeder Spieler erhält eine Hand mit fünf Karten.
  • Jeder Spieler hat die Möglichkeit, beliebig viele Karten auszutauschen.
  • Jeder Spieler hat die Möglichkeit, bis zu drei weitere Karten zu erhalten.
  • Jeder Spieler muss sein bestes Blatt zeigen.
• Das beste Blatt gewinnt und der Spieler erhält einen Punkt. Bei einem Gleichstand erhalten beide Spieler einen Punkt.
• In einem einzelnen Spiel werden zehn Runden gespielt, und der Spieler mit den meisten Punkten gewinnt und erhält einen einzelnen "Gewinnpunkt". Bei einem Gleichstand erhalten beide Spieler einen Siegpunkt.
• Leo hat nicht wirklich viel Geld, also kann Ihr Bot davon ausgehen, dass dies eine perfekte Welt ohne Wetten ist.

Hände

• Die Hände sind genau 5 Karten lang (anfängliche Eingabe und endgültige Ausgabe).
• Die Rangfolge der Hände entspricht den hier beschriebenen Regeln .

Input-Output

• Leo kennt nur Java, daher muss Ihr Programm über die Prozess-API (Befehlszeile) ausführbar sein und STDIN und STDOUT für die Eingabe bzw. Ausgabe verwenden.
• Für jeden oben beschriebenen Ein- und Ausgabeschritt müssen die Ein- und Ausgaben jeweils in einer Zeile vorhanden sein.
• Nach der endgültigen Ausgabe muss mindestens eine neue Zeile am Ende stehen. (Dies liegt an der Art und Weise, wie die Eingabe von STDIN gelesen wird.)
• Es ist keine externe Eingabe / Ausgabe zulässig, außer abschließenden und führenden Leerzeichen. Der Parser versteht einfach nichts wie final_hand=...oder draw 0.
• Beim Zeichnen ist die Ausgabe eine einzelne Ganzzahl, beim Austauschen der Ausgabe eine Liste von Ganzzahlen und / oder Karten, die unten definiert sind, und wenn die ursprüngliche Hand ausgegeben wird, ist die Ausgabe eine Liste von Karten, die unten definiert sind.
• Alle Eingabe- / Ausgabenummern müssen positive ganze Zahlen in Basis 10 sein.
• Sie können das Format für die Karteneingabe festlegen (siehe Beitragsformat unten).
• Wahr ist als genau "wahr", "1" oder "t" definiert, und falsch ist jeder andere nicht leere Wert.
• Während des Austauschschrittes:
  • Kartenindizes müssen mit mindestens einem Leerzeichen dazwischen ausgegeben werden (zB 3 4 0)
  • Kartennamen müssen mit mindestens einem Leerzeichen dazwischen ausgegeben werden (zB H4 S8)
  • Kartennamen und -indizes können in der Ausgabe gemischt werden (zB 0 H7 3 D3)
  • Nachgestellte und führende Leerzeichen sind zulässig.
  • Die Eingabe als Ergebnis der Ausgabe durch den Player wird bot.jlscin der von der Datei angegebenen Reihenfolge formatiert
• Die Anzahl der Karten, die ein Spieler seiner Hand hinzufügen möchte, kann führende und nachfolgende Leerzeichen enthalten.
• Hände müssen mit mindestens einem Leerzeichen zwischen ihnen ausgegeben werden (z. B. H4 D5 CA), nachfolgende Leerzeichen und führende Leerzeichen sind zulässig.
• Hände müssen nicht in der richtigen Reihenfolge ausgegeben werden (z. B. H4 D4 C4 DA SAund H4 DA D4 SA C4beide repräsentieren 4, 4, 4, Ass, Ass, was ein Full House ist).
• Wenn Sie eine Strategie entwickeln möchten, indem Sie die Hände des Gegners analysieren, können Sie Daten in einem <botname>/dataVerzeichnis speichern .
  • Nachdem konkurrierende Bots ihre Hände angezeigt haben, werden sie in jedes Bots-Datenverzeichnis in hands.txt geschrieben, wobei sich jede Hand in einer neuen Zeile befindet (durch \ n getrennt). Die Datei wird in US_ASCII codiert.
• Nachdem Ihr Bot neue Karten angefordert oder Karten ausgetauscht hat, werden die Karten abhängig von dem in der bot.jlscDatei angegebenen Format eingegeben .

Beitragsformat

• Jeder Beitrag muss zwei Dinge enthalten:
  • Der Quellcode Ihres Bots oder ein Link zu einem öffentlich zugänglichen Repository.
  • Eine zip-Datei mit:
    • Die kompilierte / ausführbare Version Ihres Bots (Wenn es sich bei der Datei um eine EXE-Datei oder eine andere nicht dekompilierbare Datei handelt, fügen Sie Ihrem Post einfach eine Kompilierungsanleitung bei).
    • Eine bot.jlscDatei, siehe unten (Randnotiz: Die Erweiterung .jlsc ist nur auf ein Nebenprojekt von mir zurückzuführen, ein Konfigurationsformat. Die folgende Datei entspricht der richtigen Syntax, also keine Sorge).
  • Die .zip-Datei muss den gleichen Namen haben wie Ihr Bot.
• Wenn Sie keinen Zugriff auf Windows oder ein anderes Dienstprogramm zum Zippen haben oder aus irgendeinem Grund keine ZIP-Datei erstellen können, fügen Sie einfach den Text der Datei bot.jlsc in Ihren Beitrag ein

bot.jlsc Datei:

name= "Botty"
link= "example.com"
cmd= "java -jar Botty.jar"
input_hand= "${0} ${1} ${2} ${3} ${4}"
input_1= "${0}"
input_2= "${0} ${1}"
input_3= "${0} ${1} ${2}"
input_4= "${0} ${1} ${2} ${3}"

Wo:

• "cmd" ist der Windows- Befehlszeilenbefehl zum Ausführen Ihres Bots. Beachten Sie, dass sich Ihr Bot im Verzeichnis <botname>befindet. Passen Sie den Befehl entsprechend an.
• "name" ist der Name Ihres Bots.
• "link" ist der Link zu Ihrer Antwort, den Sie nach dem Posten bearbeiten müssen.
  • "input_hand" ist die Art und Weise, wie der ursprüngliche Deal formatiert werden soll (wobei $ {#} für Karten 0-4 steht).
• Mit "input_1" soll die Eingabe einer zusätzlichen Karte formatiert werden.
• "input_2" ist, wie Sie die Eingabe von zwei zusätzlichen Karten formatieren möchten.
• "input_3" ist, wie Sie die Eingabe von drei zusätzlichen Karten formatieren möchten.
• "input_4" ist, wie Sie die Eingabe von vier zusätzlichen Karten formatieren möchten.

Besonderheiten

• Diese Schlupflöcher sind nicht zulässig (siehe "Allgemeine Fallstricke").
• Sie dürfen keinen Bot schreiben, der immer die bestmögliche Hand innerhalb des Regelsatzes ausgibt. (dh keine langjährigen Brute-Force-Bots, nichts sollte so gut sein wie LeoBot)
• Dein Bot sollte in ~ 100 ms oder weniger laufen (in diesem Punkt maximal ~ 1 Sekunde)
• Jede Ausgabe des Bots nach seiner gewählten Hand wird ignoriert.
• Standardlücken sind nicht zulässig.
• Ja, ich weiß, dass Linux besser ist, aber ich besitze einen Windows-PC. Stellen Sie daher sicher, dass die kompilierte / ausführbare Version Ihres Programms über die Windows-Befehlszeile ausgeführt werden kann.
  • Ich habe bereits Python und Java auf meinem Computer installiert, aber ich bin bereit, auf neue Versionen zu aktualisieren und andere Umgebungen zu installieren. Geben Sie daher bitte an, welche Art von Umgebung Ihr Programm benötigt.
• Sie dürfen keinen Bot schreiben, der in jedem Fall dasselbe tut wie ein anderer Bot. Spam-Bots sind erlaubt, aber nicht erwünscht.
• Ihr Bot darf nur Karten benutzen, die er hat. Durch Tausch verloren gegangene oder von vornherein nicht behandelte Karten sind in der letzten Hand ungültig.
• Ein- und Ausgabe dürfen nur ASCII-Zeichen enthalten.

Turniere

• Turniere werden durchgeführt, wenn ich die Zeit dafür habe (mein Zeitplan ist fast so voll wie der von Leo, daher bin ich etwas selten. Entschuldigen Sie die Unannehmlichkeiten.).
• Bots treten in 4-Personen-Spielen gegeneinander an und es gibt ein Spiel für jede mögliche Teilmenge von Bots (dh viele Spiele).
  • Dieser Vorgang wird fünfmal wiederholt.
  • Aufgrund der Art und Weise, wie der Turnierleiter die Gruppen von Bots zusammenstellt, werden bis zu drei Füllbots hinzugefügt, um die Anzahl der Bots durch 4 teilbar zu machen. Diese Bots geben einfach die Hand zurück, auf die sie ursprünglich gegeben wurden.
• Nach jeder Runde und jedem Spiel werden die Punktzahlen der Bots anhand der Anzahl der Spiele berechnet, die sie gewonnen haben.
  • Mehrere Bots können sich eine Position teilen (Gleichstand für den ersten Gewinn durch den ersten Beitrag).
• Nach dem Ende eines Turniers werden die Ergebnisse am Ende dieses Beitrags angehängt.

Wertung

Normale KoTH-Regeln. Die Bot (s), die die meisten Spiele gewinnen, gewinnen die Herausforderung.

LeoBot

Leos Bot ist ziemlich schlau. Es werden keine Karten ausgetauscht, was zu schwer ist, aber es wird die maximale Anzahl zusätzlicher Karten angefordert, und es wird die bestmögliche Hand bestimmt, die es machen kann, und diese Hand wird gespielt. Die Hauptlogik von Leobot ist unten.

package com.gmail.socraticphoenix.pokerface.leobot;

import com.gmail.socraticphoenix.pokerface.lib.card.Card;
import com.gmail.socraticphoenix.pokerface.lib.card.Deck;
import com.gmail.socraticphoenix.pokerface.lib.rule.HandRegistry;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class LeoBot {

    public static void main(String[] args) {
        List<Card> hand = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);
        hand.addAll(Card.parseHand(scanner.nextLine()));
        System.out.println(false);

        System.out.println(3);
        hand.addAll(Card.parseHand(scanner.nextLine()));

        List<List<Card>> possibleHands = LeoBot.getSubsets(hand, 5);
        System.out.println(Deck.toString(possibleHands.stream().sorted((a, b) -> HandRegistry.determineWinner(b, a).comparable()).findFirst().get()));
    }

    private static <T> void getSubsets(List<T> superSet, int k, int idx, List<T> current, List<List<T>> solution) {
        if (current.size() == k) {
            solution.add(new ArrayList<>(current));
            return;
        }
        if (idx == superSet.size()) return;
        T x = superSet.get(idx);
        if (!current.contains(x)) {
            current.add(x);
        }
        getSubsets(superSet, k, idx + 1, current, solution);
        current.remove(x);
        getSubsets(superSet, k, idx + 1, current, solution);
    }

    public static <T> List<List<T>> getSubsets(List<T> superSet, int k) {
        List<List<T>> res = new ArrayList<>();
        getSubsets(superSet, k, 0, new ArrayList<T>(), res);
        return res;
    }

}

Beachten Sie, dass LeoBot nicht mehr am Rennen teilnimmt, wenn er die Turniere regelmäßig gewinnt und es eine gute Anzahl von Einsendungen gibt.

Wichtige Links

• Turnierbot und Bibliothek
• Leos Bot

Haftungsausschluss

Leo und Tech Inc. sind Story-Elemente und jede Ähnlichkeit mit realen Unternehmen oder Personen ist rein unbeabsichtigt. (Wenn jedoch Leos 'Situation' der Frage Bedingungen hinzufügt oder von ihnen subtrahiert, sind diese tatsächlich Teil der Frage ...)

(Python), Pairbot, nicht ganz konkurrierend (ich weiß nicht, wie man Cmd-Befehle und ähnliches erstellt)

Pairbot wird konkurrieren, sobald jemand mit der bot.jlsc und zip-Dateien usw. hilft.

Pairbot weiß, dass Sie nicht immer gute Hände bekommen. Er weiß, dass gute Hände selten sind. Pairbot weiß, dass Paare und andere Duplikate einige der besten Hände sind. Pairbot weiß auch, dass die niedrigste Hand, die Sie bekommen können, ein Siebenhoch ist. Wenn er also ein Sechshoch hat, ist das eigentlich eine Straße (Pairbot weiß nicht, warum er das weiß). Er weiß auch, ob seine niedrigste Karte 10 ist (ohne Paare), das ist auch eine Straße (Pairbot weiß, dass er auf diese Weise Royal Flush bekommen kann). Pairbot prüft hauptsächlich auf die gleiche Anzahl von Dupes, prüft aber in besonderen Fällen auch auf zwei Arten von Straights.

card_values={"2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8,
             "9":9, "T":10, "J":11, "Q":12, "K":13, "A":14,}
straight=False
def card_valuing(item):
    return card_values[item[1]]

input_list=input().split()
pairs_to_keep=[]
for item in input_list:
    if sum(item[1]==card[1] for card in input_list)>1:
        pairs_to_keep+=[item]
cards_to_remove=input_list
for item in pairs_to_keep:cards_to_remove.remove(item)#we want to remove all non pairs
hand=pairs_to_keep
if pairs_to_keep==[]:
    input_list.sort(key=card_valuing, reverse=True)
    if card_values[input_list[0][1]]==6:
        straight=True
        hand=input_list
    elif card_values[input_list[-1][1]]==10:
        straight=True
        hand=input_list
    else:
        print("true\n"+" ".join(input_list[1:]))
        hand+=input_list[0]+input().split()
elif input_list!=[]:
    print("true\n"+" ".join(input_list))
    hand+=input().split()
else:print(0, end=', ')
if straight:print("0\n0\n"+" ".join(hand))
else:
    print("3")
    hand+=input().split()
    same_number_dict={} #holds the amount of each type (A, 2, 3, etc.)

    def dict_value(item):
        return int(same_number_dict[item[1]])*100+card_values[item[1]]

    for card in hand:
        same_number_dict[card[1]]=sum(card[1] == item[1] for item in hand)

    hand=list(sorted(hand, key=dict_value, reverse=True))
    final_hand =[]
    last_number=hand[0][1]
    hand_taken=0
    while hand_taken < 5:
        if last_number==hand[0][1]:
            final_hand+=[hand[0]]
            hand=hand[1:]
            hand_taken+=1
        else:
            for card in hand:
                if same_number_dict[card[1]]>5-hand_taken:
                    same_number_dict[card[1]]=5-hand_taken
            hand=list(sorted(hand, key=dict_value, reverse=True))
            last_number=hand[0][1]
    print(" ".join(final_hand))

Das Format für die Eingabe ist das gleiche wie im Beispiel: durch Leerzeichen getrennt

Wenn Socratic Phoenix bei den Akten helfen könnte, wäre das gut

Klempner, Python

Klempner dreht sich alles um Spülen. Der Klempner priorisiert auch Karten mit höherem Wert (was bedeutet, dass er manchmal Straight Flushes bekommen kann, insbesondere Royal Flushes (falls sie auftreten).) Der Klempner ist ziemlich durcheinander, wenn er keinen Flush bekommt, außer dass er das Glück hat, einen Straight zu spielen. Klempner erhalten in etwa 20% der Fälle eine Spülung, wenn die Berechnungen von Sherlock9 korrekt sind

hand=input().split()
suit_in_hand={"S":0,"C":0,"D":0,"H":0}
card_values={"2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8,
             "9":9, "T":10, "J":11, "Q":12, "K":13, "A":14,}
def value_sort(x):
    return card_values[x[1]]
def suit_sort(x):
    return suit_in_hand[x[0]]

for card in hand:
    suit_in_hand[card[0]]+=1

hand.sort(key=suit_sort, reverse=True)

print(" ".join(hand[suit_in_hand[hand[0][0]]:]))
hand=hand[:suit_in_hand[hand[0][0]]]

for new_card in input().split():
    hand+=[new_card]
    suit_in_hand[new_card[0]]+=1

print(3)

for new_card in input().split():
    hand+=[new_card]
    suit_in_hand[new_card[0]]+=1
hand.sort(key=value_sort, reverse=True)
hand.sort(key=suit_sort, reverse=True)
print(" ".join(hand[:5]))

Nimmt auch durch Leerzeichen getrennte Eingaben entgegen wie andere meine beiden Bots

LadyGaga, Python 3

• Ist etwas blind für Anzüge
• Hat ein Kleid voller Käfer

• Und spielt ab und zu gerne Poker Face

  from math import ceil as f
  M=lambda A:max(set(A),key=A.count)
  K=lambda A:A.count(M(A))
  O=lambda A:range(len(A))
  J=lambda A:A[0]+str(U(A[1]))
  X={"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"T":10,"J":11,"Q":12,"K":13,"A":14}
  def V(A):return([A[0]]+[int(X[A[1]])])
  def U(c):
   if c==10:c='T'
   if c==11:c='J'
   if c==12:c='Q'
   if c==13:c='K'
   if c==14:c='A'
   return(c)
  def P(A):
   S=[];C=[];t=len(A)
   for x in A:S.append(x[0]);C.append(x[1])
   B=[0]*9;q=len(set(C));p=K(C);D=list(set(C));D.sort()
   B[2]=1/f(13**(4-p));B[6]=1/f(13**(3-p));B[8]=1/f(13**(2-p))
   if (p,q)==(2,4):B[3]=1/1100;B[7]=5/34
   if (p,q)==(3,3):B[3]=1/169;B[7]=1/169
   if (p,q)==(4,2):B[3]=1/13;B[7]=1
   if (p,q)==(2,3):B[3]=5/169;B[7]=1
   if (p,q)==(3,2):B[3]=1;B[7]=1
   for x in O(D):D[x]-=x
   j=M(D);h=K(D)-5;B[5]=13**h
   for x in O(D):
    if j+h<D[x]<j-h and D[x]!=j:B[5]*=13
   W=K(S);B[4]=(4**(W-t))*(13-W)/52
   return(B,M(S))
  def E(B,h,u):
   x=0;D=[];C=[]
   while 1:
    k=list(C)
    C=[]
    while 1:
     p=list(B);del p[x]
     if len(D)==3:break
     if P(p)[0][h]>=P(B)[0][h]:C.append(B[x])
     x+=1
     if x>len(p):break
    if len(C)==0:break
    for x in O(C):
     if k==C or not((u in C[x])and(len(C)-1)):D.append(C[x]);del B[B.index(C[x])]
   return(D)
  s=input()
  A=s.split(' ')
  b=list(map(V,A));G,u=P(b);F=[649739,72192,4164,693,508,254,46.3,20,1.4];H=[]
  for x in O(F):F[x]=1-((1-(1/F[x]))**4)
  for x in O(F):H.append(G[x]-F[x])
  Y=H.index(max(H));p=[]
  e=E(list(b),Y,u);g=list(e)
  for x in O(e):e[x]=J(e[x])
  print(' '.join(e)if len(e)else'')
  for x in g:
   if x in b:del b[b.index(x)]
  s=input()
  if len(s):
   A=s.split(' ')
   b+=list(map(V,A))
  print(3)
  s=input()
  A=s.split(' ')
  b+=list(map(V,A));G,u=P(b);H=[]
  for x in O(F):H.append(G[x]-F[x])
  Y=H.index(max(H))
  e=E(list(b),Y,u)
  for x in e:
   if x in b:del b[b.index(x)]
  for x in O(b):b[x]=J(b[x])
  print(' '.join(b[:5]))
  print()
  

  • (I / O) modelliert nach PlumberBot -Edit: Umfangreiche Bugfixes dank Destructible Watermelon -Edit: Aufgrund neuer Regeln folgt nach der endgültigen Ausgabe eine nachgestellte Newline

LuckyBot, Python

Pairbot lud seinen Kumpel Luckybot ein, der die Chance wahrnahm. Luckybot hatte sich eine Menge fiktives Poker angesehen und vermutet, dass er das Geheimnis des Pokers herausgefunden hatte: Glück. Jeder kennt die wahren Profis (zum Beispiel James Bond), die sich wirklich verlassen und gute Hände bekommen, nicht Geschicklichkeit. Daher schaut er nicht auf seine Karten und versucht, so viel Glück wie möglich in sie zu stecken

lucky_number=24 #IMPORTANT

from random import randint as roll


def lucky_shuffle(i):
    return sorted(i, key=lucky_dice)


def lucky_dice(seed):
    return sum(roll(1,6)for i in range(roll(1,6)))


hand=lucky_shuffle(input().split())

throw=lucky_dice(lucky_number)%5
print("true\n"+" ".join(hand[throw:]))

hand=hand[:throw]+lucky_shuffle(input().split())

hand=lucky_shuffle(hand)
hand=lucky_shuffle(hand)
#One more for good luck
hand=lucky_shuffle(hand)
#maybe one more
hand=lucky_shuffle(hand)
#I got a good feeling about this one
hand=lucky_shuffle(hand)

hand=lucky_shuffle(hand)
#I think I'm done
hand=lucky_shuffle(hand)
#for real this time


hand=lucky_shuffle(hand)

print("3")
hand=hand+lucky_shuffle(input().split())
#All right, I got a real good feeling about this,
#let me shuffle some more luck into them cards!


def extra_super_lucky_shuffle(item):
 return lucky_shuffle(lucky_shuffle(lucky_shuffle(\
    lucky_shuffle(lucky_shuffle(lucky_shuffle(\
        lucky_shuffle(lucky_shuffle(lucky_shuffle(item)))))))))


def super_duper_extra_ultra_uber_luckyshuffle(item):
    return extra_super_lucky_shuffle(extra_super_lucky_shuffle(\
        extra_super_lucky_shuffle(extra_super_lucky_shuffle(item))))


hand=super_duper_extra_ultra_uber_luckyshuffle(super_duper_extra_ultra_uber_luckyshuffle(hand))
#cmoooooooooooooooon
print(hand[:5])