Cara de póquer

Introducción

Leo disfruta jugar al póker, pero su trabajo en Tech Inc. es demasiado exigente para que aprenda a jugar bien. Leo, siendo un informático, no se desanima. Decide dedicar más tiempo del necesario para aprender póker y usarlo para escribir un bot de póker que lo ayude a jugar mejor. Pero ahora Leo tiene un problema: para entender cómo jugar un poco mejor, Leo necesita observar múltiples juegos de múltiples "personas", pero las "personas" necesitan diferentes estilos de juego para mejorar la calidad y la realidad del juego.

El reto

Leo recuerda que en realidad hay un sitio web dedicado a los desafíos de programación, ¡y está solicitando su ayuda! Su trabajo es escribir un programa que juegue "Pokerface", una versión modificada del póker de 5 cartas. El programa tomará la entrada como una mano de 5 cartas en cualquier formato que desee, después de lo cual el programa generará:

• Exactamente (distingue entre mayúsculas y minúsculas) "verdadero" "1" o "t" si el jugador desea intercambiar cartas, de lo contrario, cualquier otra salida no vacía.
• Si es verdadero, una lista de índices de cartas y / o nombres de cartas que el jugador desea intercambiar.
• Un solo número entre 0 y 3, que especifica cuántas cartas adicionales quiere el jugador.
• Imprime la mano que el jugador desea usar.

(Ver formato a continuación)

Reglas de Pokerface

• Dado que pokerface es un juego de aventuras basado en texto, las cartas deben presentarse de manera consistente. Las tarjetas están representadas por dos códigos de personaje, el primer personaje es el palo y el segundo es el nombre de la tarjeta.
  • Tarjetas:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Reina = Q
    • Rey = K
    • As = A
  • Trajes:
    • Picas = S
    • Clubes = C
    • Corazones = H
    • Diamante = D

Entonces el as de espadas sería SA, el 10 de corazones es HT, el 4to de diamantes es D4, etc.

• Una sola ronda de Pokerface consta de cuatro pasos:
  • La baraja se reorganiza y se reparte una mano de cinco cartas a cada jugador.
  • Cada jugador tiene la oportunidad de intercambiar tantas cartas como quiera.
  • Cada jugador tiene la oportunidad de ganar hasta tres cartas más.
  • Cada jugador debe revelar su mejor mano.
• La mejor mano gana y gana un punto para ese jugador. En caso de empate, ambos jugadores obtienen un punto.
• En un solo juego, se juegan diez rondas y el jugador con más puntos gana y gana un solo "punto de victoria". En caso de empate, ambos jugadores ganan un punto de victoria.
• Leo realmente no tiene una gran cantidad de dinero, por lo que su bot puede suponer que este es un mundo perfecto sin apuestas.

Manos

• Las manos tienen exactamente 5 cartas de longitud (entrada inicial y salida final).
• Las manos se clasifican de acuerdo con las reglas descritas aquí .

De entrada y salida

• Leo solo conoce Java, por lo que su programa debe ser ejecutable a través de la API de proceso (línea de comando) y usar STDIN y STDOUT para entrada y salida, respectivamente.
• Para cada paso de entrada y salida detallado anteriormente, la entrada y la salida deben existir en una línea.
• Debe haber al menos una nueva línea posterior después de la salida final. (Esto se debe a la forma en que se lee la entrada de STDIN)
• No se permiten entradas / salidas extrañas, aparte de los espacios iniciales y finales. El analizador simplemente no entiende cosas como final_hand=...o draw 0.
• Al dibujar, la salida es un número entero único, cuando el intercambio de salida es una lista de enteros y / o cartas definidas a continuación, y cuando se reparte la mano original, la salida es una lista de cartas definidas a continuación.
• Todos los números de entrada / salida deben ser enteros positivos en la base 10.
• Puede definir el formato para la entrada de la tarjeta (consulte el formato de publicación a continuación).
• Verdadero se define como exactamente "verdadero", "1" o "t" y falso es cualquier otro valor no vacío.
• Durante el paso de intercambio:
  • Los índices de las tarjetas se deben generar con al menos un espacio entre ellos (p 3 4 0. Ej. )
  • Los nombres de las tarjetas deben aparecer con al menos un espacio entre ellos (p H4 S8. Ej. )
  • Los nombres e índices de las tarjetas pueden mezclarse en la salida (p 0 H7 3 D3. Ej. )
  • Se permiten espacios finales y principales.
  • La entrada como resultado de la salida del reproductor anterior se formateará según lo especificado por el bot.jlscarchivo, en el mismo orden en que se solicitó
• El número de cartas que un jugador quiere agregar a su mano puede tener espacios iniciales y finales.
• Las manos deben salir con al menos un espacio entre ellas (por ejemplo H4 D5 CA), se permiten espacios finales y espacios iniciales.
• No es necesario que las manos salgan en el orden correcto (por ejemplo, H4 D4 C4 DA SAy H4 DA D4 SA C4ambas representan 4, 4, 4, As, As, que es una casa llena).
• Si desea construir una estrategia analizando las manos de los oponentes, puede almacenar datos en un <botname>/datadirectorio.
  • Después de que los bots de la competencia hayan mostrado sus manos, se escribirán en cada directorio de datos de bots, en hands.txt, con cada mano en una nueva línea (separada por \ n). El archivo se codificará en US_ASCII.
• Después de que su bot solicite nuevas tarjetas o tarjetas de intercambio, las tarjetas se ingresarán según el formato que especifique en el bot.jlscarchivo.

Formato de publicación

• Cada publicación debe incluir dos cosas:
  • El código fuente de su bot, o un enlace a un repositorio público.
  • Un archivo zip que contiene:
    • La versión compilada / ejecutable de su bot (si el archivo es un archivo .exe u otro archivo no descompilable, solo incluya instrucciones de compilación en su publicación).
    • Un bot.jlscarchivo, ver más abajo (nota al margen: la extensión .jlsc se debe solo a un proyecto paralelo mío, un formato de configuración. El archivo a continuación coincide con la sintaxis adecuada, así que no se preocupe).
  • El archivo .zip debe tener el mismo nombre que su bot.
• Si no tiene acceso a Windows o alguna otra utilidad de compresión, o no puede hacer un .zip por alguna razón, simplemente incluya el texto del archivo bot.jlsc en su publicación

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

Dónde:

• "cmd" es el comando de línea de comando de Windows para ejecutar su bot. Tenga en cuenta que su bot estará en el directorio <botname>, así que ajuste el comando en consecuencia.
• "nombre" es el nombre de tu bot.
• "link" es el enlace a tu respuesta, tendrás que editarlo después de publicarlo.
  • "input_hand" es cómo desea que se formatee la operación original (con $ {#} representando las tarjetas 0-4).
• "input_1" es cómo desea que se formatee la entrada de una tarjeta adicional.
• "input_2" es cómo desea que se formatee la entrada de dos tarjetas adicionales.
• "input_3" es cómo desea que se formatee la entrada de tres tarjetas adicionales.
• "input_4" es cómo desea que se formatee la entrada de cuatro tarjetas adicionales.

Detalles específicos

• Estas lagunas no están permitidas (ver 'trampas comunes')
• No puede escribir un bot, siempre saldrá la mejor mano posible, siempre, dentro del conjunto de reglas. (es decir, no hay bots de fuerza bruta de larga duración, nada debería ser tan "bueno" como LeoBot)
• Su bot debe ejecutarse en ~ 100 ms o menos (Lenient en este punto, máximo de ~ 1 segundo)
• Cualquier salida del bot después de su mano elegida será ignorada.
• Las lagunas estándar no están permitidas.
• Sí, sé que Linux es mejor, pero tengo una PC con Windows, así que asegúrese de que la versión compilada / ejecutable de su programa se pueda ejecutar desde la línea de comandos de Windows.
  • Ya tengo Python y Java instalados en mi computadora, pero estoy dispuesto a actualizar a nuevas versiones e instalar otros entornos, así que especifique qué tipo de entorno requiere su programa.
• No puede escribir un bot que haga lo mismo que otro bot en todos los casos. Los bots de spam están permitidos, pero desaconsejados.
• Tu bot solo puede usar cartas que tenga. Las cartas perdidas a través del intercambio o no tratadas para empezar son salidas inválidas en la mano final.
• La entrada y salida solo pueden contener caracteres ASCII.

Torneos

• Los torneos se ejecutarán cuando tenga el tiempo (mi agenda está casi tan llena como la de Leo, así que esto puede ser un poco infrecuente. Disculpe las molestias).
• Los bots se enfrentarán entre sí en juegos de 4 personas, y habrá un juego para cada posible subconjunto de bots (es decir, muchos juegos).
  • Este proceso se repetirá cinco veces.
  • Debido a la forma en que el manejador del torneo forma los grupos de bots, se agregarán hasta tres bots de relleno para que el número de bots sea divisible por 4. Estos bots simplemente devolverán la mano con la que se repartieron originalmente.
• Después de cada ronda y juego, los puntajes de los bots se calcularán en función de la cantidad de juegos que ganaron.
  • Múltiples bots pueden compartir una posición (empates para el primer ganado por primera publicación).
• Después de que termine un torneo, los puntajes se agregarán al final de esta publicación.

Puntuación

Reglas normales de KoTH. Los bots que ganan más juegos ganan el desafío.

LeoBot

El bot de Leo es bastante inteligente. No intercambia ninguna carta, eso es demasiado difícil, pero solicita la cantidad máxima de cartas adicionales, y determina la mejor mano posible que puede hacer, y juega esa mano. La lógica principal de leobot está a continuación.

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

}

Tenga en cuenta que si LeoBot gana constantemente los torneos, y hay una buena cantidad de entradas, dejaré de incluirlo en la carrera.

Links importantes

• Torneo bot y biblioteca
• El robot de Leo

Descargo de responsabilidad

Leo y Tech Inc. son elementos de la historia y cualquier parecido con empresas o personas de la vida real es puramente involuntario. (Sin embargo, cuando la 'situación' de Leo agrega o resta condiciones a la pregunta, en realidad son parte de la pregunta ...)

(Python), Pairbot, no del todo competitivo (no sé cómo hacer comandos de cmd y esas cosas)

Pairbot competirá tan pronto como alguien ayude con el bot.jlsc, los archivos zip, etc.

Pairbot sabe que no siempre obtienes buenas manos. Él sabe que las buenas manos son raras. Pairbot sabe que los pares y otros duplicados son algunas de las mejores manos. Pairbot también sabe que la mano más baja que puedes obtener es un siete alto, por lo que sabe que si tiene 6 alto, eso es en realidad una escalera (pairbot no sabe por qué lo sabe). También sabe si su carta más baja es 10 (sin pares), eso también es una escalera (pairbot sabe que puede obtener escalera real de esta manera). Pairbot comprueba principalmente si hay dups del mismo número, pero también busca dos tipos de rectas en casos especiales.

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

El formato para la entrada es el mismo que en el ejemplo: separados por espacios

Si Socratic Phoenix pudiera ayudar con el archivo, eso sería bueno

Fontanero, pitón

Fontanero tiene que ver con los rubores. El fontanero también da prioridad a las cartas de mayor valor (lo que significa que a veces puede obtener rubores rectos, especialmente los reales (en caso de que ocurran)). El fontanero se sonrojará aproximadamente el 20% del tiempo, si los cálculos de Sherlock9 son correctos

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

También toma entradas separadas por espacios como otros mis dos bots

LadyGaga, Python 3

• Es algo ciego a los trajes.
• Tiene un vestido lleno de bichos

• Y le gusta jugar Poker Face de vez en cuando

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

  • (E / S) modelado a partir de PlumberBot -Edit: Correcciones de errores extensas gracias a Destructible Watermelon -Edit: Debido a las nuevas reglas, una nueva línea final después de la salida final

LuckyBot, Python

Pairbot invitó a su amigo Luckybot, quien brincó por la oportunidad. Luckybot había visto mucho póker ficticio, y calculó que había descubierto el secreto del póker: la suerte. Todos saben que los verdaderos profesionales (James Bond, por ejemplo) realmente confían y obtienen buenas manos, no habilidades. Por lo tanto, no mira sus cartas e intenta meter tanta suerte en ellas como sea posible.

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