Faccia da poker

introduzione

A Leo piace giocare a poker, ma il suo lavoro in Tech Inc. è troppo impegnativo per imparare a giocare bene. Leo, essendo un informatico, non è scoraggiato. Decide di dedicare più tempo di quanto ci sarebbe voluto solo per imparare il poker e usarlo per scrivere un bot di poker per aiutarlo a giocare meglio. Ma ora Leo ha un problema: per capire come giocare un po 'meglio, Leo deve osservare più giochi di più "persone", ma le "persone" hanno bisogno di stili di gioco diversi per migliorare la qualità e la realtà del gioco.

La sfida

Leo ricorda che in realtà esiste un sito Web dedicato alle sfide di programmazione e sta chiedendo aiuto! Il tuo compito è scrivere un programma che riproduca "Pokerface" una versione modificata del poker a 5 carte. Il programma prenderà l'input come una mano di 5 carte in qualsiasi formato desiderato, dopodiché il programma mostrerà:

• "True" "1" o "t" esatto (con distinzione tra maiuscole e minuscole) se il giocatore desidera scambiare carte, altrimenti qualsiasi altra uscita non vuota.
• Se vero, elenco di indici di carte e / o nomi di carte che il giocatore desidera scambiare.
• Un singolo numero compreso tra 0 e 3, che specifica quante carte aggiuntive desidera il giocatore.
• Stampa la mano che il giocatore desidera utilizzare.

(Vedi formattazione di seguito)

Regole di Pokerface

• Dato che pokerface è un gioco di avventura basato su testo, le carte devono essere presentate in modo coerente. Le carte sono rappresentate da due codici personaggio, il primo è il seme e il secondo è il nome della carta.
  • Carte:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Regina = Q
    • Re = K
    • Asso = A
  • Suits:
    • Picche = S
    • Club = C
    • Hearts = H
    • Diamante = D

Quindi l'asso di picche sarebbe SA, il 10 di cuori è HT, il 4 di quadri è D4, ecc.

• Un singolo round di Pokerface consiste in quattro passaggi:
  • Il mazzo viene rimescolato e una mano di cinque carte viene distribuita a ciascun giocatore.
  • Ogni giocatore ha la possibilità di scambiare tutte le carte che vuole.
  • Ogni giocatore ha la possibilità di guadagnare fino a tre carte in più.
  • Ogni giocatore deve rivelare la sua mano migliore.
• La mano migliore vince e guadagna un punto per quel giocatore. In caso di pareggio, entrambi i giocatori ottengono un punto.
• In una singola partita, vengono giocati dieci round e il giocatore con il maggior numero di punti vince e guadagna un singolo "punto vittoria". In caso di pareggio, entrambi i giocatori guadagnano un punto vittoria.
• Leo non ha davvero una grande quantità di denaro, quindi il tuo bot può presumere che questo sia un mondo perfetto senza scommesse.

Mani

• Le mani hanno esattamente 5 carte di lunghezza (input iniziale e output finale).
• Le mani sono classificate coerentemente con le regole descritte qui .

Input Output

• Leo conosce solo Java, quindi il tuo programma deve essere eseguibile tramite l' API di processo (riga di comando) e utilizzare rispettivamente STDIN e STDOUT per l'input e l'output.
• Per ogni passaggio di input e output sopra descritto, l'input e l'output devono esistere ciascuno su una riga.
• Deve esserci almeno una nuova riga finale dopo l'output finale. (Ciò è dovuto al modo in cui l'input viene letto da STDIN)
• Non sono consentiti input / output estranei, tranne spazi finali e iniziali. Il parser semplicemente non capisce cose come final_hand=...o draw 0.
• Quando si disegna, l'output è un singolo intero, quando si scambia l'output è un elenco di numeri interi e / o carte definiti di seguito e quando viene distribuita la mano originale, l'output è un elenco di carte definito di seguito.
• Tutti i numeri di input / output devono essere numeri interi positivi nella base 10.
• È possibile definire il formato per l'immissione delle carte (vedere il formato dei post di seguito).
• Vero è definito esattamente come "vero", "1" o "t" e falso è qualsiasi altro valore non vuoto.
• Durante la fase di scambio:
  • Gli indici delle carte devono essere emessi con almeno uno spazio tra loro (ad es. 3 4 0)
  • I nomi delle carte devono essere emessi con almeno uno spazio tra loro (es. H4 S8)
  • Nomi e indici delle carte possono essere mescolati nell'output (ad es. 0 H7 3 D3)
  • Sono consentiti spazi finali e iniziali.
  • L'input come risultato del giocatore che emette quanto sopra sarà formattato come specificato dal bot.jlscfile, nello stesso ordine richiesto
• Il numero di carte che un giocatore vuole aggiungere alla propria mano può avere spazi iniziali e finali.
• Le mani devono essere emesse con almeno uno spazio tra loro (ad es. H4 D5 CA), Sono consentiti spazi finali e spazi iniziali.
• Le mani non devono essere emessi in modo corretto (ad esempio, H4 D4 C4 DA SAed H4 DA D4 SA C4entrambi rappresentano 4, 4, 4, Ace, Ace, che è una casa piena).
• Se desideri costruire una strategia analizzando le mani degli avversari, puoi archiviare i dati in una <botname>/datadirectory.
  • Dopo che i robot in competizione hanno mostrato le loro mani, saranno scritti in ogni directory dei dati dei bot, in hands.txt, con ogni mano su una nuova linea (separate da \ n). Il file verrà codificato in US_ASCII.
• Dopo che il tuo bot richiede nuove carte o scambia carte, le carte verranno inserite in base al formato specificato nel bot.jlscfile.

Formato post

• Ogni post deve includere due cose:
  • Il codice sorgente del bot o un collegamento a un repository pubblico.
  • Un file zip contenente:
    • La versione compilata / eseguibile del tuo bot (se il file è un file .exe o un altro file non decompilabile, includi semplicemente le istruzioni di compilazione nel tuo post).
    • Un bot.jlscfile, vedi sotto (nota a margine: l'estensione .jlsc è solo a causa di un mio progetto laterale, un formato di configurazione. Il file seguente corrisponde alla sintassi corretta, quindi non preoccuparti).
  • Il file .zip deve avere lo stesso nome del tuo bot.
• Se non hai accesso a Windows o ad altre utilità di zippatura o non riesci a creare un .zip per qualsiasi motivo, includi semplicemente il testo del file bot.jlsc nel tuo post

file bot.jlsc:

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}"

Dove:

• "cmd" è Windows comando da riga di comando di per eseguire il tuo bot. Nota che il tuo bot sarà nella directory <botname>, quindi regola il comando di conseguenza.
• "nome" è il nome del tuo bot.
• "link" è il link alla tua risposta, dovrai modificarlo dopo aver pubblicato.
  • "input_hand" è il modo in cui si desidera formattare la distribuzione originale (con $ {#} che rappresenta le carte 0-4).
• "input_1" è il modo in cui si desidera formattare l'ingresso di una scheda aggiuntiva.
• "input_2" è il modo in cui si desidera formattare l'ingresso di due schede aggiuntive.
• "input_3" è il modo in cui si desidera formattare l'ingresso di tre schede aggiuntive.
• "input_4" è il modo in cui si desidera formattare l'ingresso di quattro schede aggiuntive.

specifiche

• Queste scappatoie non sono ammesse (vedere "insidie ​​comuni")
• Non puoi scrivere un bot, ma otterrai sempre la mano migliore possibile, ogni volta, all'interno del set di regole. (ovvero nessun robot a forza bruta di lunga durata, niente dovrebbe essere "buono" come LeoBot)
• Il tuo bot dovrebbe funzionare in ~ 100 ms o meno (Lenient su questo punto, max di ~ 1 secondo)
• Qualsiasi output del bot dopo la sua mano scelta verrà ignorato.
• Le scappatoie standard non sono ammesse.
• Sì, so che Linux è migliore, ma ho un PC Windows, quindi assicurati che la versione compilata / eseguibile del tuo programma possa essere eseguita dalla riga di comando di Windows.
  • Ho già installato Python e Java sul mio computer, ma sono disposto ad aggiornare le nuove versioni e installare altri ambienti, quindi specifica il tipo di ambiente richiesto dal tuo programma.
• Non puoi scrivere un bot che faccia la stessa cosa di un altro bot in ogni caso. I robot spam sono consentiti, ma scoraggiati.
• Il tuo bot può usare solo le carte che ha. Le carte perse attraverso lo scambio o non distribuite all'inizio non sono prodotte nell'ultima mano.
• L'input e l'output possono contenere solo caratteri ASCII.

tornei

• I tornei si terranno quando avrò il tempo (il mio programma è quasi impacchettato come quello di Leo, quindi questo è un po 'raro. Ci scusiamo per l'inconveniente.).
• I robot si scontreranno a vicenda in partite a 4 persone e ci sarà una partita per ogni possibile sottoinsieme di robot (cioè molte partite).
  • Questo processo verrà ripetuto cinque volte.
  • A causa del modo in cui il gestore del torneo crea i gruppi di robot, verranno aggiunti fino a tre bot di riempimento per rendere il numero di bot divisibili per 4. Questi robot restituiranno semplicemente la mano in cui erano stati inizialmente distribuiti.
• Dopo ogni round e gioco, i punteggi dei robot verranno calcolati in base al numero di partite vinte.
  • Più robot possono condividere una posizione (vincoli per il primo vinto per primo pubblicato).
• Al termine di un torneo, i punteggi verranno aggiunti in fondo a questo post.

punteggio

Regole normali di KoTH. I bot che vincono il maggior numero di giochi vincono la sfida.

LeoBot

Il robot di Leo è piuttosto intelligente. Non scambia nessuna carta, è troppo difficile, ma richiede il numero massimo di carte aggiuntive e determina la migliore mano possibile e gioca quella mano. La logica principale del leobot è di seguito.

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;
    }

}

Nota che se LeoBot vince costantemente i tornei e ci sono molte iscrizioni, smetterò di includerlo nella corsa.

Link importanti

• Bot e libreria del torneo
• Il robot di Leo

disconoscimento

Leo e Tech Inc. sono elementi della storia e qualsiasi somiglianza con le società o le persone nella vita reale è puramente involontaria. (Tuttavia, quando la "situazione" di Leo aggiunge o sottrae condizioni dalla domanda, quelle fanno effettivamente parte della domanda ...)

(Python), Pairbot, non del tutto in competizione (non so come fare comandi e cose cmd)

Pairbot competerà non appena qualcuno ti aiuterà con bot.jlsc, e file zip ecc.

Pairbot sa che non sempre ottieni buone mani. Sa che le buone mani sono rare. Pairbot sa che le coppie e altri duplicati sono alcune delle mani migliori. Pairbot sa anche che la mano più bassa che puoi ottenere è un sette, quindi sa se ha 6 high, che in realtà è una scala (pairbot non sa perché lo sappia). Sa anche se la sua carta più bassa è 10, (senza coppie), anche questa è una scala (pairbot sa che può ottenere scala reale in questo modo). Pairbot verifica principalmente lo stesso numero di duplicati, ma verifica anche due tipi di rettilinei in casi speciali.

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))

Il formato per l'input è lo stesso dell'esempio: separato da spazi

Se Socratic Phoenix potesse aiutare con le cose del file, sarebbe bene

Idraulico, Python

L'idraulico ha a che fare con i rossori. L'idraulico dà anche la priorità alle carte di valore più alto (il che significa che a volte può ottenere scala reale, specialmente quelle reali (se dovessero verificarsi)). L'idraulico è praticamente incasinato se non ottiene una scala, tranne per il fatto che potrebbe essere abbastanza fortunato per una scala. L'idraulico riceverà vampate circa il 20% delle volte, se i calcoli di Sherlock9 sono corretti

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]))

Prende anche input separati da spazi come gli altri miei due robot

LadyGaga, Python 3

• È un po 'cieco per soddisfare
• Ha un vestito pieno di insetti

• E gli piace giocare a Poker Face di tanto in tanto

  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) modellato su PlumberBot -Edit: correzioni di bug estese grazie all'anguria distruttibile -Edit: a causa di nuove regole, una nuova riga finale dopo l'output finale

LuckyBot, Python

Pairbot ha invitato il suo amico Luckybot, che è scattato per l'occasione. Luckybot aveva visto un sacco di poker immaginario, e pensava che avesse scoperto il segreto del poker: la fortuna. Tutti sanno che i veri professionisti (James Bond, per esempio) fanno davvero affidamento e ottengono buone mani, non abilità. Quindi, non guarda le sue carte e cerca di racimolare quanta più fortuna possibile in esse

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])