Poker yüzü

Giriş

Leo poker oynamaktan hoşlanır, ancak Tech Inc.'deki işi onun nasıl iyi oynayacağını öğrenmesi için çok talep eder. Bilgisayar bilimcisi olan Leo, cesaretini kırmadı. Sadece pokeri öğrenmek için gerekenden daha fazla zaman almaya karar verir ve daha iyi oynamasına yardımcı olmak için bir poker botu yazmak için kullanır. Ama şimdi Leo'nun bir sorunu var: Biraz daha iyi oynamayı anlamak için Leo'nun birden fazla "insan" ın birden fazla oyununu gözlemlemesi gerekiyor, ancak "insanlar" oyunun kalitesini ve gerçekliğini geliştirmek için farklı oyun tarzlarına ihtiyaç duyuyor.

Meydan okuma

Leo, aslında programlama zorluklarına adanmış bir web sitesi olduğunu hatırlıyor ve yardımınızı alıyor! İşiniz, 5 kartlı pokerin değiştirilmiş bir versiyonunu "Pokerface" oynayan bir program yazmaktır. Program, girişinizi istediğiniz formatta 5 kartlı bir el olarak alacak ve daha sonra program çıktı verecektir:

• Oynatıcı kart değiştirmek istiyorsa, tam olarak (büyük / küçük harfe duyarlı) "true" "1" veya "t", aksi takdirde boş olmayan diğer çıktılar.
• Doğruysa, oyuncunun değiştirmek istediği kart indeksleri ve / veya kart isimleri listesi.
• Oyuncunun kaç ek kart istediğini belirten 0 ile 3 arasında tek bir sayı.
• Oynatıcının kullanmak istediği eli yazdırın.

(Aşağıdaki biçimlendirmeye bakın)

Pokerface kuralları

• Pokerface metin tabanlı bir macera oyunu olduğundan, kartlar tutarlı bir şekilde sunulmalıdır. Kartlar iki karakter koduyla temsil edilir, ilk karakter takımdır ve ikincisi kartın adıdır.
  • Kartlar:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Kraliçe = Q
    • Kral = K
    • Ace = A
  • Takım elbise:
    • Maça = S
    • Kulüpler = C
    • Kalpler = H
    • Elmas = D

Yani maça ası SA, kalplerin 10'u HT, elmasların dördüncü'si D4 vb.

• Tek bir Pokerface turu dört adımdan oluşur:
  • Deste değişikliği yapılır ve her oyuncuya beş kartlık bir el dağıtılır.
  • Her oyuncuya istediği kadar kart değiştirme şansı verilir.
  • Her oyuncuya en fazla üç kart kazanma şansı verilir.
  • Her oyuncu en iyi elini göstermelidir.
• En iyi el kazanır ve oyuncuya bir puan kazandırır. Beraberlik durumunda, her iki oyuncu da bir puan alır.
• Tek bir oyunda on tur oynanır ve en çok puana sahip olan oyuncu kazanır ve tek bir "kazanma puanı" kazanır. Beraberlik durumunda, her iki oyuncu da bir kazanma puanı kazanır.
• Leo'nun gerçekten çok fazla parası yok, bu yüzden botunuz bunun bahissiz mükemmel bir dünya olduğunu varsayabilir.

Eller

• Eller tam olarak 5 kart uzunluğundadır (ilk giriş ve son çıkış).
• Eller, burada açıklanan kurallara uygun olarak sıralanır .

Giriş çıkış

• Leo yalnızca Java'yı biliyor, bu nedenle programınızın İşlem API'sı (komut satırı) aracılığıyla yürütülebilir olması ve giriş ve çıkış için sırasıyla STDIN ve STDOUT kullanması gerekir.
• Yukarıda ayrıntıları verilen her girdi ve çıktı adımı için, girdi ve çıktıların her biri bir satırda bulunmalıdır.
• Nihai çıktıdan sonra en az bir yeni satır olmalıdır. (Bunun nedeni girişin STDIN'den okunmasıdır)
• Sondaki ve öndeki boşluklar dışında herhangi bir yabancı giriş / çıkışa izin verilmez. Ayrıştırıcı, final_hand=...veya gibi şeyleri anlamıyor draw 0.
• Çizim yaparken, çıktı tek bir tamsayıdır, çıktı alışverişi aşağıda tanımlanan tamsayıların ve / veya kartların bir listesi olduğunda ve orijinal el dağıtılırken çıktı aşağıda tanımlanan kartların bir listesidir.
• Tüm giriş / çıkış numaraları, taban 10'daki pozitif tamsayılar olmalıdır.
• Kart girişi için format tanımlayabilirsiniz (aşağıdaki yazı formatına bakınız).
• True, tam olarak "true", "1" veya "t" olarak tanımlanır ve false, boş olmayan başka bir değerdir.
• Değişim adımı sırasında:
  • Kart endeksleri aralarında en az bir boşluk çıkışı olmalıdır (örneğin 3 4 0)
  • Kart adları, aralarında en az bir boşluk bırakılmalıdır (ör. H4 S8)
  • Kart adları ve indeksler çıktıda karışık olabilir (ör. 0 H7 3 D3)
  • Sondaki ve öndeki boşluklara izin verilir.
  • Yukarıdakilerin çıkışını yapan oynatıcının sonucu olarak girdi, bot.jlscdosya tarafından belirtildiği şekilde , istendiği gibi aynı sırada biçimlendirilir
• Bir oyuncunun eline eklemek istediği kart sayısı önde ve arkada olabilir.
• Eller, aralarında en az bir boşluk (örneğin H4 D5 CA) olacak şekilde verilmelidir , sondaki boşluklar ve önde gelen boşluklara izin verilir.
• Ellerin uygun sırada çıkmasına gerek yoktur (örneğin H4 D4 C4 DA SAve H4 DA D4 SA C4her ikisi de tam bir ev olan 4, 4, 4, Ace, Ace'i temsil eder).
• Rakiplerin ellerini analiz ederek bir strateji oluşturmak isterseniz, verileri bir <botname>/datadizinde saklayabilirsiniz .
  • Rakip botlar ellerini görüntüledikten sonra, her bot yeni bir satırda (\ n ile ayrılmış) hands.txt içinde her bot veri dizinine yazılır. Dosya US_ASCII olarak kodlanacaktır.
• Botunuz yeni kartlar veya kart alışverişi istediğinde, kartlar bot.jlscdosyada belirttiğiniz biçime bağlı olarak girilir .

Yazı Biçimi

• Her yazı iki şey içermelidir:
  • Botunuzun kaynak kodu veya halka açık bir depoya bağlantı.
  • Şunları içeren bir zip dosyası:
    • Botunuzun derlenmiş / yürütülebilir sürümü (Dosya bir .exe veya başka bir derlenemeyen dosyaysa, lütfen gönderinize derleme talimatlarını ekleyin).
    • Bir bot.jlscdosya, aşağıya bakın (yan not: .jlsc uzantısı sadece bir yan projemden, bir yapılandırma biçiminden kaynaklanmaktadır. Aşağıdaki dosya uygun sözdizimiyle eşleştiğinden endişelenmeyin).
  • .Zip dosyası botunuzla aynı şekilde adlandırılmalıdır.
• Pencerelere veya başka bir sıkıştırma yardımcı programına erişiminiz yoksa veya herhangi bir nedenle bir .zip yapamıyorsanız, yazınıza bot.jlsc dosyasının metnini ekleyin

bot.jlsc dosyası:

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

Nerede:

• "cmd" botunuzu çalıştırmak için kullanılan windows komut satırı komutudur. Botunuzun dizinde olacağını unutmayın <botname>, bu yüzden komutu uygun şekilde ayarlayın.
• "name", botunuzun adıdır.
• "bağlantı" cevabınızın bağlantısıdır, yayınladıktan sonra bunu düzenlemeniz gerekir.
  • "input_hand", orijinal işlemin nasıl biçimlendirilmesini istediğinizdir ($ {#}, 0-4 numaralı kartları temsil eder).
• "input_1", ek bir kartın girişinin nasıl biçimlendirilmesini istediğinizdir.
• "input_2" iki ek kart girişinin nasıl biçimlendirilmesini istediğinizdir.
• "input_3" üç ek kart girişinin nasıl biçimlendirilmesini istediğinizdir.
• "input_4" dört ek kart girişinin nasıl biçimlendirilmesini istediğinizdir.

Ayrıntılı Bilgiler

• Bu boşluklara izin verilmiyor (bkz. 'Ortak tuzaklar')
• Kural setinde her zaman mümkün olan en iyi eli verecek bir bot yazamazsınız. (yani uzun süren kaba kuvvet botları yok, hiçbir şey LeoBot kadar 'iyi' olmamalı)
• Botunuz ~ 100 ms veya daha az bir sürede çalışmalıdır (Bu noktada Lenient, en fazla ~ 1 saniye)
• Seçilen elden sonra botun herhangi bir çıkışı göz ardı edilecektir.
• Standart boşluklara izin verilmez.
• Evet, linux'un daha iyi olduğunu biliyorum, ancak bir Windows PC'im var, bu yüzden programınızın derlenmiş / yürütülebilir sürümünün windows komut satırından çalıştırılabileceğinden emin olun.
  • Bilgisayarımda zaten python ve java yüklü, ancak yeni sürümlere güncelleme yapmaya ve diğer ortamları yüklemeye hazırım, bu yüzden lütfen programınızın ne tür bir ortam gerektirdiğini belirtin.
• Her durumda başka bir bot ile aynı şeyi yapan bir bot yazamazsınız. Spam botlarına izin verilir, ancak önerilmez.
• Botunuz sadece sahip olduğu kartları kullanabilir. Takas ile kaybedilen veya başlamak için dağıtılmayan kartlar nihai eldeki geçersiz çıktıdır.
• Giriş ve çıkış yalnızca ASCII karakterleri içerebilir.

Turnuvalar

• Zamanı aldığımda turnuvalar düzenlenecek (programım neredeyse Leo'nunki kadar dolu, bu yüzden bu benim biraz seyrek. Rahatsızlık için özür dilerim.).
• Botlar 4 kişilik oyunlarda birbirine karşı çukur olacak ve her olası bot alt kümesi için bir oyun olacak (yani birçok oyun).
  • Bu işlem beş kez tekrarlanacaktır.
  • Turnuva işleyicisinin bot gruplarını yapma şekli nedeniyle, bot sayısını 4'e bölünebilir hale getirmek için üç taneye kadar dolgu botu eklenecektir. Bu botlar ilk başta ele alındıkları eli geri getirecektir.
• Her tur ve maç yapıldıktan sonra, kazanılan sayı oyunlarına göre botların puanları hesaplanacaktır.
  • Birden fazla bot bir pozisyonu paylaşabilir (ilk kaydedilen ilk kazanma için bağlar).
• Turnuva bittikten sonra skorlar bu yazının sonuna eklenir.

puanlama

Normal KoTH kuralları. En fazla oyunu kazanan botlar mücadeleyi kazanır.

LeoBot

Leo'nun botu oldukça akıllı. Herhangi bir kart takas etmez, bu çok zordur, ancak maksimum sayıda ek kart talep eder ve yapabileceği en iyi eli belirler ve o eli oynar. Leobot'un ana mantığı aşağıdadır.

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

}

LeoBot sürekli olarak turnuvaları kazanırsa ve iyi miktarda giriş varsa, onu koşuya dahil etmeyi bırakacağımı unutmayın.

Önemli Linkler

• Turnuva botu ve kütüphanesi
• Leo'nun botu

feragat

Leo ve Tech Inc. hikaye ögeleridir ve gerçek hayattaki şirketlere veya insanlara herhangi bir benzerlik tamamen kasıtsızdır. (Ancak, Leo'nun 'durumu' soruya koşul eklediğinde veya çıkardığında, bunlar aslında sorunun bir parçasıdır ...)

(Python), Pairbot, pek rekabet etmiyor (cmd komutlarını nasıl yapacağımı bilmiyorum)

Pairbot, bot.jlsc ve zip dosyalarına vb. Yardımcı olur olmaz yarışacaktır.

Pairbot her zaman iyi eller bulamayacağınızı bilir. İyi ellerin nadir olduğunu biliyor. Pairbot, çiftlerin ve diğer kopyaların en iyi ellerden bazıları olduğunu bilir. Pairbot ayrıca alabileceğiniz en düşük elin yedi yüksek olduğunu biliyor, bu yüzden 6 yüksek olup olmadığını biliyor, bu aslında düz (pairbot bunu neden bildiğini bilmiyor). Ayrıca en düşük kartının 10 olup olmadığını (çiftsiz) biliyor, bu da düz (pairbot bu şekilde royal flush alabileceğini biliyor). Pairbot esas olarak aynı sayıda çiftleri kontrol eder, ancak özel durumlarda iki tür düzlüğü kontrol eder.

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

Girdi biçimi, örnekteki ile aynıdır: boşluklarla ayrılmış

Sokratik Phoenix dosyalara yardımcı olabilirse, bu iyi olurdu

Tesisatçı, Python

Tesisatçı tamamen sifonlarla ilgilidir. Tesisatçı ayrıca daha yüksek değerli kartlara da öncelik verir (yani bazen floşlar, özellikle kraliyet olanlar da olabilir) Sherlock9 tarafından yapılan hesaplamalar doğruysa tesisatçı zamanın yaklaşık% 20'sini temizleyecektir

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

Ayrıca diğer iki botum gibi boşluklarla ayrılmış girdi alır

LadyGaga, Python 3

• Takım elbise için biraz kör mü
• Böcek dolu bir elbise var

• Ve arada sırada Poker Face oynamayı sever

  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) - PlumberBot -Edit'ten sonra modellenmiştir: Yıkılabilir Karpuz sayesinde kapsamlı hata düzeltmeleri

LuckyBot, Python

Pairbot, şansı yakalayan arkadaşı Luckybot'u davet etti. Luckybot birçok kurgusal poker izlemişti ve pokerin sırrını anladığını düşünüyor: şans. Herkes gerçek profesyonellerin (örneğin James Bond'un) gerçekten güvendiğini ve iyi eller elde ettiğini bilir, beceri değil. Bu nedenle, kartlarına bakmaz ve onlara mümkün olduğunca çok şans getirmeye çalışır

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