Sulit Ditebak

pengantar

Leo menikmati bermain poker, tetapi pekerjaannya di Tech Inc. terlalu menuntut baginya untuk belajar bermain dengan baik. Leo, sebagai ilmuwan komputer, tidak berkecil hati. Dia memutuskan untuk mengambil lebih banyak waktu daripada yang dibutuhkan untuk hanya belajar poker, dan menggunakannya untuk menulis bot poker untuk membantunya bermain lebih baik. Tapi sekarang Leo memiliki masalah: untuk memahami cara bermain sedikit lebih baik, Leo perlu mengamati beberapa game dari beberapa "orang," tetapi "orang" membutuhkan gaya bermain yang berbeda untuk meningkatkan kualitas dan realitas permainan.

Tantangan

Leo ingat bahwa sebenarnya ada situs web yang didedikasikan untuk tantangan pemrograman, dan meminta bantuan Anda! Tugas Anda adalah menulis sebuah program yang memainkan "Pokerface" versi modifikasi dari 5-kartu poker. Program akan menerima input sebagai kartu 5 kartu dalam format apa pun yang Anda inginkan, setelah itu program akan menampilkan:

• Tepat (peka huruf besar kecil) "benar" "1" atau "t" jika pemain ingin bertukar kartu, keluaran non-kosong lainnya.
• Jika benar, daftar indeks kartu dan / atau nama kartu yang ingin ditukar pemain.
• Nomor tunggal antara 0 dan 3, yang menentukan berapa banyak kartu tambahan yang diinginkan pemain.
• Cetak tangan yang ingin digunakan pemain.

(Lihat pemformatan di bawah)

Aturan Pokerface

• Karena pokerface adalah game petualangan berbasis teks, kartu harus disajikan dengan cara yang konsisten. Kartu diwakili oleh dua kode karakter, karakter pertama adalah suit, dan yang kedua adalah nama kartu.
  • Kartu-kartu:
    • 2-9 = 2-9
    • 10 = T
    • Jack = J
    • Ratu = Q
    • Raja = K
    • Ace = A
  • Setelan:
    • Sekop = S
    • Klub = C
    • Hati = H
    • Berlian = D

Jadi ace of spade adalah SA, 10 hati adalah HT, 4th of the diamond adalah D4, dll.

• Satu putaran Pokerface terdiri dari empat langkah:
  • Geladak dirombak ulang dan lima kartu dibagikan kepada setiap pemain.
  • Setiap pemain diberi kesempatan untuk bertukar kartu sebanyak yang mereka inginkan.
  • Setiap pemain diberi kesempatan untuk mendapatkan hingga tiga kartu lagi.
  • Setiap pemain harus mengungkapkan tangan terbaik mereka.
• Tangan terbaik menang, dan mendapatkan poin bagi pemain itu. Dalam hal seri, kedua pemain mendapatkan poin.
• Dalam satu pertandingan, sepuluh putaran dimainkan dan pemain dengan poin terbanyak menang dan mendapat satu "poin kemenangan". Dalam hal seri, kedua pemain mendapatkan poin kemenangan.
• Leo tidak benar-benar memiliki banyak uang, jadi bot Anda dapat berasumsi bahwa ini adalah dunia yang sempurna tanpa taruhan.

Tangan

• Panjang tangan persis 5 kartu (input awal dan output akhir).
• Tangan diberi peringkat konsisten dengan aturan yang dijelaskan di sini .

Input output

• Leo hanya mengenal Java, jadi program Anda harus dapat dieksekusi melalui API Proses (baris perintah), dan masing-masing menggunakan STDIN dan STDOUT untuk input dan output.
• Untuk setiap langkah input dan output yang dirinci di atas, input dan output masing-masing harus ada pada satu baris.
• Harus ada setidaknya satu garis baru setelah hasil akhir. (Ini karena cara input dibaca dari STDIN)
• Tidak ada input / output asing yang diizinkan, selain spasi tambahan dan terkemuka. Parser tidak mengerti hal-hal seperti final_hand=...atau draw 0.
• Saat menggambar, output adalah bilangan bulat tunggal, ketika bertukar output adalah daftar bilangan bulat dan / atau kartu yang ditentukan di bawah ini, dan ketika ditangani tangan asli, output adalah daftar kartu yang didefinisikan di bawah ini.
• Semua angka input / output harus bilangan bulat positif di basis 10.
• Anda dapat menentukan format untuk input kartu (lihat format posting di bawah).
• Benar didefinisikan sebagai tepat "benar," "1" atau "t" dan salah adalah nilai non-kosong lainnya.
• Selama langkah pertukaran:
  • Indeks kartu harus berupa output dengan setidaknya satu ruang di antaranya (mis. 3 4 0)
  • Nama kartu harus berupa output dengan setidaknya satu ruang di antara mereka (mis. H4 S8)
  • Nama dan indeks kartu dapat dicampur dalam output (misalnya 0 H7 3 D3)
  • Ruang tertinggal dan terdepan diizinkan.
  • Input sebagai hasil dari pemain yang mengeluarkan di atas akan diformat seperti yang ditentukan oleh bot.jlscfile, dalam urutan yang sama seperti yang diminta
• Jumlah kartu yang ingin ditambahkan pemain ke tangan mereka dapat memiliki ruang awal dan akhir.
• Tangan harus dihasilkan dengan setidaknya satu ruang di antara mereka (misalnya H4 D5 CA), spasi tambahan dan ruang utama diizinkan.
• Tangan tidak harus berupa output dalam urutan yang benar (mis. H4 D4 C4 DA SADan H4 DA D4 SA C4keduanya mewakili 4, 4, 4, Ace, Ace, yang merupakan rumah penuh).
• Jika Anda ingin membangun strategi dengan menganalisis tangan lawan, Anda dapat menyimpan data dalam <botname>/datadirektori.
  • Setelah bot yang bersaing menampilkan tangan mereka, mereka akan ditulis ke setiap direktori data bot, di hands.txt, dengan masing-masing tangan di baris baru (dipisahkan oleh \ n). File akan dikodekan dalam US_ASCII.
• Setelah bot Anda meminta kartu baru atau kartu pertukaran, kartu akan dimasukkan tergantung pada format apa yang Anda tentukan dalam bot.jlscfile.

Format Posting

• Setiap posting harus menyertakan dua hal:
  • Kode sumber bot Anda, atau tautan ke repositori yang menghadap publik.
  • File zip yang berisi:
    • Versi bot Anda yang dikompilasi / dieksekusi (Jika file tersebut adalah .exe atau file yang tidak dapat dikompilasi lainnya, harap cukup sertakan instruksi kompilasi dalam posting Anda).
    • Sebuah bot.jlscfile, lihat di bawah (catatan: ekstensi .jlsc hanya karena proyek sampingan saya, format konfigurasi File di bawah ini pertandingan sintaks yang tepat, jadi jangan khawatir.).
  • File .zip harus dinamai sama dengan bot Anda.
• Jika Anda tidak memiliki akses ke windows atau utilitas zip lainnya, atau tidak dapat membuat .zip untuk alasan apa pun, cukup sertakan teks file bot.jlsc dalam posting Anda

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

Dimana:

• "cmd" adalah perintah baris perintah windows untuk menjalankan bot Anda. Perhatikan bahwa bot Anda akan berada di direktori <botname>, jadi sesuaikan perintahnya.
• "name" adalah nama bot Anda.
• "tautan" adalah tautan ke jawaban Anda, Anda harus mengedit ini setelah mengeposkan.
  • "input_hand" adalah bagaimana Anda ingin transaksi asli diformat (dengan $ {#} mewakili kartu 0-4).
• "input_1" adalah cara Anda ingin input dari satu kartu tambahan diformat.
• "input_2" adalah cara Anda ingin input dari dua kartu tambahan diformat.
• "input_3" adalah bagaimana Anda ingin input dari tiga kartu tambahan diformat.
• "input_4" adalah cara Anda ingin input empat kartu tambahan diformat.

Spesifik

• Celah ini tidak diizinkan (lihat 'perangkap umum')
• Anda tidak boleh menulis bot dan akan selalu menampilkan hasil terbaik, setiap kali, dalam aturan yang ditetapkan. (Yaitu tidak ada bot kekuatan lama, tidak ada yang harus sebagus LeoBot)
• Bot Anda harus berjalan dalam ~ 100 ms atau kurang (Lenient pada titik ini, maks ~ 1 detik)
• Setiap output dari bot setelah tangan yang dipilih akan diabaikan.
• Celah standar tidak diijinkan.
• Ya, saya tahu linux lebih baik, tetapi saya memiliki PC windows, jadi pastikan versi kompilasi / eksekusi program Anda dapat dijalankan dari baris perintah windows.
  • Saya sudah menginstal python dan java di komputer saya, tetapi saya bersedia memperbarui ke versi baru dan menginstal lingkungan lain, jadi tolong tentukan jenis lingkungan apa yang dibutuhkan oleh program Anda.
• Anda tidak boleh menulis bot yang melakukan hal yang sama dengan bot lain dalam setiap kasus. Bot spam diizinkan, tetapi berkecil hati.
• Bot Anda hanya dapat menggunakan kartu yang dimilikinya. Kartu yang hilang melalui pertukaran atau tidak dibagikan untuk memulai adalah hasil yang tidak valid di tangan terakhir.
• Input dan output hanya dapat berisi karakter ASCII.

Turnamen

• Turnamen akan dijalankan ketika saya mendapatkan waktu (jadwal saya hampir sama padatnya dengan Leo, jadi ini saya menjadi sedikit jarang. Maaf atas ketidaknyamanan.).
• Bot akan diadu satu sama lain dalam game 4 orang, dan akan ada satu game untuk setiap subset bot yang mungkin (yaitu banyak game).
  • Proses ini akan diulang lima kali.
  • Karena cara pawang turnamen membuat kelompok bot, hingga tiga bot pengisi akan ditambahkan untuk membuat jumlah bot dapat dibagi 4. Bot ini hanya akan mengembalikan tangan yang semula mereka tangani.
• Setelah setiap putaran dan pertandingan dijalankan, skor bot akan dihitung berdasarkan jumlah pertandingan yang dimenangkan.
  • Beberapa bot dapat berbagi posisi (ikatan untuk yang pertama dimenangkan dengan yang pertama kali diposting).
• Setelah turnamen selesai, skor akan ditambahkan ke bagian bawah posting ini.

Mencetak gol

Aturan KoTH normal. Bot yang memenangkan sebagian besar pertandingan memenangkan tantangan.

LeoBot

Bot Leo cukup pintar. Itu tidak bertukar kartu apa pun, itu terlalu sulit, tetapi ia meminta jumlah maksimum kartu tambahan, dan menentukan kartu terbaik yang dapat dibuat, dan memainkan kartu itu. Logika utama leobot adalah di bawah ini.

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

}

Perhatikan bahwa jika LeoBot secara konsisten memenangkan turnamen, dan ada jumlah entri yang baik, saya akan berhenti memasukkannya dalam pertandingan.

Tautan Penting

• Bot dan perpustakaan turnamen
• Bot Leo

Penolakan

Leo dan Tech Inc. adalah elemen cerita dan kemiripan dengan perusahaan atau orang-orang di kehidupan nyata adalah murni tidak disengaja. (Namun, ketika 'situasi' Leo menambah atau mengurangi kondisi dari pertanyaan, mereka sebenarnya adalah bagian dari pertanyaan ...)

(Python), Pairbot, tidak cukup bersaing (Saya tidak tahu cara membuat perintah cmd dan lainnya)

Pairbot akan bersaing segera setelah seseorang membantu dengan bot.jlsc, dan file zip dll.

Pairbot tahu bahwa Anda tidak selalu mendapatkan tangan yang baik. Dia tahu tangan yang baik itu langka. Pairbot tahu pasangan dan duplikat lain adalah beberapa yang terbaik. Pairbot juga tahu tangan terendah yang bisa Anda dapatkan adalah tujuh tinggi, jadi dia tahu jika ia memiliki 6 tinggi, itu sebenarnya lurus (pairbot tidak tahu mengapa ia tahu itu). Dia juga tahu jika kartu terendahnya adalah 10, (tanpa pasangan), itu juga lurus (pairbot tahu dia bisa mendapatkan royal flush dengan cara ini). Pairbot memeriksa terutama untuk dupes nomor yang sama, tetapi juga memeriksa dua jenis lurus dalam kasus khusus.

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

Format untuk input sama dengan contoh: dipisahkan dengan spasi

Jika Socratic Phoenix dapat membantu dengan file barang, itu akan baik

Tukang ledeng, Python

Tukang ledeng adalah tentang flushes. Tukang ledeng juga memprioritaskan kartu bernilai lebih tinggi (artinya ia kadang-kadang bisa mendapatkan flush lurus, terutama yang royal (jika terjadi).) Tukang ledeng cukup berantakan jika ia tidak mendapatkan flush, kecuali bahwa ia mungkin cukup beruntung untuk straight. Tukang ledeng akan mendapatkan flush sekitar 20% dari waktu, jika perhitungan oleh Sherlock9 benar

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

Juga mengambil input yang dipisahkan oleh spasi seperti dua bot saya yang lain

LadyGaga, Python 3

• Agak buta untuk jas
• Memiliki gaun penuh bug

• Dan suka bermain Poker Face sesekali

  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) dimodelkan setelah PlumberBot -Edit: Perbaikan bug yang luas berkat Destructible Semangka -Edit: Karena aturan baru, garis akhir yang membuntuti setelah hasil akhir

LuckyBot, Python

Pairbot mengundang temannya Luckybot, yang muncul untuk kesempatan itu. Luckybot telah menonton banyak poker fiksi, dan dia telah menemukan rahasia untuk bermain poker: keberuntungan. Semua orang tahu pro sebenarnya (James Bond, misalnya) benar-benar mengandalkan dan mendapatkan tangan yang baik, bukan keterampilan. Oleh karena itu, ia tidak melihat kartunya, dan mencoba mengemas keberuntungan semaksimal mungkin

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