Visage impassible

introduction

Leo aime jouer au poker, mais son travail chez Tech Inc. est trop exigeant pour qu'il apprenne à bien jouer. Leo, étant un informaticien, n'est pas découragé. Il décide de prendre plus de temps qu'il n'aurait fallu pour simplement apprendre le poker et l'utiliser pour écrire un robot de poker pour l'aider à mieux jouer. Mais maintenant, Leo a un problème: afin de comprendre comment jouer un peu mieux, Leo doit observer plusieurs jeux de plusieurs "personnes", mais les "personnes" ont besoin de styles de jeu différents pour améliorer la qualité et la réalité du jeu.

Le défi

Leo se souvient qu'il existe en fait un site Web dédié aux défis de programmation et sollicite votre aide! Votre travail consiste à écrire un programme qui joue à "Pokerface" une version modifiée du poker à 5 cartes. Le programme prendra l'entrée comme une main de 5 cartes dans le format que vous souhaitez, après quoi le programme sortira:

• Exactement (sensible à la casse) "vrai" "1" ou "t" si le joueur souhaite échanger des cartes, toute autre sortie non vide sinon.
• Si vrai, liste des index des cartes et / ou des noms de cartes que le joueur souhaite échanger.
• Un nombre unique entre 0 et 3, qui spécifie combien de cartes supplémentaires le joueur veut.
• Imprimez la main que le joueur souhaite utiliser.

(Voir le formatage ci-dessous)

Règles de Pokerface

• Le pokerface étant un jeu d'aventure basé sur du texte, les cartes doivent être présentées de manière cohérente. Les cartes sont représentées par deux codes de caractères, le premier caractère est la couleur et le second est le nom de la carte.
  • Cartes:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Reine = Q
    • Roi = K
    • Ace = A
  • Costume:
    • Pique = S
    • Clubs = C
    • Coeurs = H
    • Diamant = D

Donc l'as de pique serait SA, le 10 de cœur est HT, le 4e de diamant est D4, etc.

• Un seul tour de Pokerface se compose de quatre étapes:
  • Le paquet est remélangé et une main de cinq cartes est distribuée à chaque joueur.
  • Chaque joueur a la possibilité d'échanger autant de cartes qu'il le souhaite.
  • Chaque joueur a la chance de gagner jusqu'à trois cartes supplémentaires.
  • Chaque joueur doit révéler sa meilleure main.
• La meilleure main gagne et gagne un point à ce joueur. En cas d'égalité, les deux joueurs obtiennent un point.
• Dans une seule partie, dix tours sont joués et le joueur avec le plus de points gagne et gagne un seul "point de victoire". En cas d'égalité, les deux joueurs gagnent un point de victoire.
• Leo n'a pas vraiment beaucoup d'argent, donc votre bot peut supposer que c'est un monde parfait sans pari.

Mains

• Les mains font exactement 5 cartes (entrée initiale et sortie finale).
• Les mains sont classées conformément aux règles décrites ici .

Entrée sortie

• Leo ne connaît que Java, votre programme doit donc être exécutable via l' API Process (ligne de commande) et utiliser respectivement STDIN et STDOUT pour l'entrée et la sortie.
• Pour chaque étape d'entrée et de sortie détaillée ci-dessus, l'entrée et la sortie doivent chacune exister sur une seule ligne.
• Il doit y avoir au moins une nouvelle ligne de fin après la sortie finale. (Cela est dû à la façon dont l'entrée est lue depuis STDIN)
• Aucune entrée / sortie étrangère n'est autorisée, à l'exception des espaces de fin et de début. L'analyseur ne comprend tout simplement pas des choses comme final_hand=...ou draw 0.
• Lors du dessin, la sortie est un entier unique, lorsque l'échange de sortie est une liste d'entiers et / ou de cartes définis ci-dessous, et lorsque la main d'origine est distribuée, la sortie est une liste de cartes définies ci-dessous.
• Tous les nombres d'entrée / sortie doivent être des entiers positifs dans la base 10.
• Vous pouvez définir le format de saisie de la carte (voir format de publication ci-dessous).
• True est défini comme exactement "true", "1" ou "t" et false est toute autre valeur non vide.
• Pendant l'étape d'échange:
  • Les index des cartes doivent être sortis avec au moins un espace entre eux (par exemple 3 4 0)
  • Les noms de carte doivent être sortis avec au moins un espace entre eux (par exemple H4 S8)
  • Les noms et les index des cartes peuvent être mélangés dans la sortie (par exemple 0 H7 3 D3)
  • Les espaces de fin et de début sont autorisés.
  • L'entrée résultant de la sortie du lecteur ci-dessus sera formatée comme spécifié par le bot.jlscfichier, dans le même ordre que celui demandé
• Le nombre de cartes qu'un joueur veut ajouter à sa main peut avoir des espaces de début et de fin.
• Les mains doivent être sorties avec au moins un espace entre elles (par exemple H4 D5 CA), les espaces de fin et les espaces de tête sont autorisés.
• Les aiguilles n'ont pas besoin d'être sorties dans le bon ordre (par exemple, H4 D4 C4 DA SAet les H4 DA D4 SA C4deux représentent 4, 4, 4, Ace, Ace, qui est une maison pleine).
• Si vous souhaitez construire une stratégie en analysant les mains des adversaires, vous pouvez stocker des données dans un <botname>/datarépertoire.
  • Une fois que les robots concurrents ont affiché leurs mains, ils seront écrits dans chaque répertoire de données de robots, dans hands.txt, chaque main sur une nouvelle ligne (séparée par \ n). Le fichier sera encodé en US_ASCII.
• Une fois que votre robot a demandé de nouvelles cartes ou des cartes d'échange, les cartes seront entrées en fonction du format que vous spécifiez dans le bot.jlscfichier.

Format du message

• Chaque message doit inclure deux choses:
  • Le code source de votre bot ou un lien vers un référentiel public.
  • Un fichier zip contenant:
    • La version compilée / exécutable de votre bot (si le fichier est un fichier .exe ou autre non décompilable, veuillez simplement inclure des instructions de compilation dans votre article).
    • Un bot.jlscfichier, voir ci-dessous (note latérale: l'extension .jlsc est juste à cause d'un de mes projets secondaires, un format de configuration. Le fichier ci-dessous correspond à la syntaxe appropriée, alors ne vous inquiétez pas).
  • Le fichier .zip doit être nommé de la même manière que votre bot.
• Si vous n'avez pas accès à Windows ou à un autre utilitaire de fermeture à glissière, ou si vous ne pouvez pas créer un .zip pour une raison quelconque, incluez simplement le texte du fichier bot.jlsc dans votre message

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

Où:

• "cmd" est la commande de ligne de commande Windows pour exécuter votre bot. Notez que votre bot sera dans le répertoire <botname>, ajustez donc la commande en conséquence.
• "nom" est le nom de votre bot.
• "lien" est le lien vers votre réponse, vous devrez le modifier après la publication.
  • "input_hand" est la façon dont vous souhaitez que le deal d'origine soit formaté ($ {#} représentant les cartes 0-4).
• "input_1" est la façon dont vous souhaitez que l'entrée d'une carte supplémentaire soit formatée.
• "input_2" est la façon dont vous souhaitez que l'entrée de deux cartes supplémentaires soit formatée.
• "input_3" est la façon dont vous souhaitez que l'entrée de trois cartes supplémentaires soit formatée.
• "input_4" est la façon dont vous souhaitez que l'entrée de quatre cartes supplémentaires soit formatée.

Détails

• Ces failles sont interdites (voir «pièges courants»)
• Vous ne pouvez pas écrire un bot qui produira toujours la meilleure main possible, à chaque fois, dans le jeu de règles. (c.-à-d. pas de robots à force brute de longue durée, rien ne devrait être aussi «bon» que LeoBot)
• Votre bot devrait fonctionner en ~ 100 ms ou moins (indulgente sur ce point, max ~ 1 seconde)
• Toute sortie du bot après sa main choisie sera ignorée.
• Les failles standard ne sont pas autorisées.
• Oui, je sais que Linux est meilleur, mais j'ai un PC Windows, alors assurez-vous que la version compilée / exécutable de votre programme peut être exécutée à partir de la ligne de commande Windows.
  • J'ai déjà installé python et java sur mon ordinateur, mais je suis prêt à mettre à jour vers de nouvelles versions et à installer d'autres environnements, veuillez donc spécifier le type d'environnement requis par votre programme.
• Vous ne pouvez pas écrire un bot qui fait la même chose qu'un autre bot dans tous les cas. Les robots anti-spam sont autorisés, mais découragés.
• Votre bot ne peut utiliser que les cartes qu'il possède. Les cartes perdues par échange ou non distribuées au départ ne sont pas valides dans la dernière main.
• L'entrée et la sortie ne peuvent contenir que des caractères ASCII.

Tournois

• Les tournois se dérouleront quand j'aurai le temps (mon emploi du temps est presque aussi chargé que celui de Leo, donc cela peut être un peu rare. Désolé pour le dérangement.).
• Les bots seront opposés les uns aux autres dans des jeux à 4 personnes, et il y aura un jeu pour chaque sous-ensemble possible de bots (c'est-à-dire beaucoup de jeux).
  • Ce processus sera répété cinq fois.
  • En raison de la façon dont le gestionnaire du tournoi crée les groupes de bots, jusqu'à trois bots de remplissage seront ajoutés pour rendre le nombre de bots divisible par 4. Ces bots retourneront simplement la main à laquelle ils ont été initialement distribués.
• Après chaque manche et chaque match, les scores des bots seront calculés en fonction du nombre de matchs gagnés.
  • Plusieurs bots peuvent partager une position (égalité pour les premiers gagnés par les premiers publiés).
• Après la fin d'un tournoi, les scores seront ajoutés en bas de ce post.

Notation

Règles normales de KoTH. Le ou les bots qui remportent le plus de matchs remportent le défi.

LeoBot

Le robot de Leo est assez intelligent. Il n'échange aucune carte, c'est trop difficile, mais il demande le nombre maximum de cartes supplémentaires, il détermine la meilleure main possible qu'il peut faire et joue cette main. La logique principale de leobot est ci-dessous.

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

}

Notez que si LeoBot remporte régulièrement les tournois et qu'il y a une bonne quantité d'inscriptions, je cesserai de l'inclure dans la course.

Liens importants

• Robot de tournois et bibliothèque
• Le robot de Leo

Avertissement

Leo et Tech Inc. sont des éléments d'histoire et toute ressemblance avec des entreprises ou des personnes réelles est purement involontaire. (Cependant, lorsque la `` situation '' de Leo ajoute ou soustrait des conditions à la question, celles-ci font en fait partie de la question ...)

(Python), Pairbot, pas tout à fait en compétition (je ne sais pas comment faire des commandes cmd et d'autres choses)

Pairbot sera en compétition dès que quelqu'un aidera avec les fichiers bot.jlsc, zip, etc.

Pairbot sait que vous n'avez pas toujours de bonnes mains. Il sait que les bonnes mains sont rares. Pairbot sait que les paires et autres doublons sont parmi les meilleures mains. Pairbot sait également que la main la plus basse que vous pouvez obtenir est un high de sept, donc il sait que s'il a 6 high, c'est en fait une quinte (pairbot ne sait pas pourquoi il le sait). Il sait également que si sa carte la plus basse est de 10, (sans paires), c'est aussi une ligne droite (pairbot sait qu'il peut obtenir une quinte royale de cette façon). Pairbot vérifie principalement les mêmes nombres de dupes, mais vérifie également deux types de lignes droites dans des cas spéciaux.

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

Le format d'entrée est le même que dans l'exemple: séparé par des espaces

Si Socratic Phoenix pouvait aider avec les fichiers, ce serait bien

Plombier, Python

Le plombier est une question de chasse d'eau. Le plombier donne également la priorité aux cartes de valeur supérieure (ce qui signifie qu'il peut parfois obtenir des quinte flush, en particulier des cartes royales (si elles se produisent).) Le plombier aura des bouffées de chaleur environ 20% du temps, si les calculs de Sherlock9 sont corrects

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

Prend également les entrées séparées par des espaces comme les autres mes deux robots

LadyGaga, Python 3

• Est un peu aveugle aux costumes
• A une robe pleine d'insectes

• Et aime jouer au Poker Face de temps en temps

  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) modélisé d'après PlumberBot -Edit: Corrections de bugs étendus grâce à la pastèque destructible -Edit: En raison de nouvelles règles, un retour à la ligne après la sortie finale

LuckyBot, Python

Pairbot a invité son copain Luckybot, qui a sauté sur l'occasion. Luckybot avait regardé beaucoup de poker fictif et estimait qu'il avait découvert le secret du poker: la chance. Tout le monde sait que les vrais pros (James Bond, par exemple) comptent vraiment et obtiennent de bonnes mains, pas des compétences. Par conséquent, il ne regarde pas ses cartes et essaie de leur apporter autant de chance que possible

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