^{Terinspirasi oleh tantangan ini dan terkait dengan yang ini .}

Latar Belakang

Badugi [bæduːɡiː] adalah varian draw-poker low-ball.

^{Ajang Poker Online Piala Dunia Pokerstars $ 1K akan dimulai dalam 3 jam dan aku harus tahu seberapa bagus tanganku!}

Gim ini menggunakan dek standar yang terdiri dari 52 kartu empat suit dan tiga belas peringkat. Gugatan tidak tertata dan harus dilabeli cdhs; peringkat - dipesan dari tertinggi Kke terendah A- adalah KQJT98765432A. Dengan demikian dek penuh dapat direpresentasikan sebagai berikut (dipisahkan ruang):

Kc Kd Kh Ks Qc Qd Qh Qs Jc Jd Jh Js Tc Td Th Ts 9c 9d 9h 9s 8c 8d 8h 8s 7c 7d 7h 7s 6c 6d 6h 6s 5c 5d 5h 5s 4c 4d 4h 4s 3c 3d 3h 3s 2c 2d 2h 2s Ac Ad Ah As 

Setiap pemain diberikan empat kartu dari deck, ada empat ronde pertaruhan dengan tiga ronde draw di antaranya (seorang pemain selalu memiliki empat kartu, mereka memiliki opsi untuk mengubah 0-4 kartu mereka dengan yang baru dari dealer pada setiap kartu). dari tiga putaran menggambar).

Jika lebih dari satu pemain masih aktif setelah semua ronde ini ada showdown, di mana tangan terkuat memenangkan taruhan dipertaruhkan.

Permainan ini dimainkan dengan bola-rendah, sehingga tangan yang paling rendah menang, dan seperti yang disebutkan di atas A(ace) rendah. Selain itu peringkat tangan berbeda dari bentuk poker lainnya, dan dapat agak membingungkan bagi pemula.

Kartu "hand" yang dimainkan adalah kombinasi peringkat terendah yang dibuat dari jumlah kartu "off-suit" (all-different-suit) dan "off-rank" (all-berbeda-peringkat) tertinggi yang dimungkinkan (dari empat kartu yang ditahan) ). Yaitu: jika salah satu memegang empat kartu dari kedua setelan yang berbeda dan jajaran yang berbeda satu memiliki tangan 4 kartu (disebut "Badugi"); jika seseorang tidak memiliki kartu 4-tangan tetapi memiliki beberapa set atau set tiga kartu dari kedua jenis kartu yang berbeda dan peringkat yang berbeda, seseorang memiliki kartu 3-kartu (satu memilih yang terbaik); jika seseorang tidak memiliki kartu 4 tangan atau kartu 3 orang mungkin memiliki kartu 2 tangan, tetapi jika tidak ada kartu 1 tangan.

• Dengan demikian kartu terbaik yang dimiliki adalah kartu 4-kartu 4-3-2-A- kartu dengan peringkat terendah dari empat jenis kartu yang berbeda , sering disebut "nomor-1". Kartu yang terlemah adalah kartu 1 kartu Kdan hanya bisa dipegang dengan tepat Kc Kd Kh Ks.

• Perhatikan bahwa 4c 3h 2c Asini bukan "nomor-1", karena 4cdan 2cdari jenis yang sama, tetapi itu adalah yang terkuat dari kartu 3-kartu 3-2-A,, itu menarik dengan kartu lain 3-2-1(seperti Kh 3d 2s Ah) dan mengalahkan semua kartu 3-kartu lainnya tetapi kalah dari semua kartu 4 tangan (yang bisa menjadi sangat lemah K-Q-J-T).

  • Mungkin tangan 3-kartu lain yang bisa dibuat dari 4c 3h 2c Asadalah 4-3-A, tapi itu lebih lemah (lebih tinggi) sehingga tidak dipilih.

• Demikian pula 8d 6h 3s 2htangan 3-kartu dimainkan sebagai 8-3-2- ada dua kombinasi off-rank off-suit ukuran 3 dan 8-3-2lebih baik (lebih rendah) daripada 8-6-3karena tiga (atau "trey") lebih rendah dari enam.

Membandingkan tangan dengan satu sama lain mengikuti logika yang sama - 4 kartu mengalahkan 3 kartu, 3 kartu mengalahkan 2 kartu dan 2 kartu mengalahkan 1 kartu, sedangkan tangan dengan jumlah kartu yang sama digunakan dibandingkan dari pangkat tertinggi hingga terendah (misalnya: 8-4-2ketukan 8-5-Atetapi tidak ada 8-4-A, 8-3-2atau 7-6-5)

Tantangan:

Diberikan dua koleksi tidak berurutan, masing-masing dari empat kartu, identifikasi kartu yang memenangkan Badugi showdown (identifikasi keduanya jika itu seri).

Masukan mungkin masuk akal:

• string tunggal dari kedelapan kartu yang berlabel di atas (dengan atau tanpa spasi) dengan empat kiri satu tangan dan kanan yang lain (dengan pemisah opsional); atau daftar karakter dengan cara yang sama
• daftar dua string - satu per tangan, atau daftar daftar karakter dengan cara yang sama
• dua string atau daftar input terpisah, satu per tangan
• kartu-kartu di dalam tangan mungkin sudah terpisah juga (jadi daftar daftar daftar boleh saja)

Namun, perhatikan:

• kartu tidak dapat diatur dalam urutan apa pun sebelum dimasukkan
• ... dan setelan dan pangkat ditetapkan sebagai label karakter yang ditentukan di sini - Jika bahasa Anda tidak mendukung konstruksi seperti itu hanya sarankan sesuatu yang masuk akal dan tanyakan apakah itu merupakan alternatif yang dapat diterima mengingat kendala bahasa Anda.

Outputnya juga harus

• diformat sama dengan input, atau representasi cetak daripadanya; atau
• menjadi salah satu dari tiga hasil yang berbeda dan konsisten (misalnya: "left", "right", "both", atau 1, 2, 3; dll)

Sungguh - selama jelas mana dari dua input yang diidentifikasi itu harus baik-baik saja.

Uji kasus

input                      ->  output
                                   (notes)
----------------------------------------------------------------------------
3c 2s 4d Ah - As 3h 2d 4h  ->  3c 2s 4d Ah
                                   (4-card 4-3-2-A beats 3-card 3-2-A)

3c 2s 4d Ah - As 2c 3d 4h  ->  3c 2s 4d Ah - As 2c 3d 4h
                                   (4-card 4-3-2-A draws with 4-card 4-3-2-A)

2d Ac 4h 3c - Kh Ad 9s 2c  ->  Kh Ad 9s 2c
                                   (3-card 4-2-A loses to 4-card K-9-2-A)

Kc Tc Qc Jc - Ac Ad Ah As  ->  Ac Ad Ah As
                                   (1-card T loses to 1-card A)

9c 9h Qc Qh - Qs Kh Jh Kd  ->  Qs Kh Jh Kd
                                   (2-card Q-9 loses to 3-card K-Q-J)

2d 5h 7c 5s - 2h 3c 8d 6c  ->  2d 5h 7c 5s
                                   (3-card 7-5-2 beats 3-card 8-3-2)

3s 6c 2d Js - 6h Jd 3c 2s  ->  6h Jd 3c 2s
                                   (3-card 6-3-2 loses to 4-card J-6-3-2)

Ah 6d 4d Ac - 3h 2c 3s 2s  ->  3h 2c 3s 2s
                                   (2-card 4-A loses to 2-card 3-2)

2h 8h 6h 4h - 6d 2d 5d 8d  ->  2h 8h 6h 4h - 6d 2d 5d 8d
                                   (1-card 2 = 1-card 2)

Ini adalah kode-golf , jadi kode terpendek dalam byte menang per bahasa, dan kode terpendek menang secara keseluruhan. Jangan biarkan bahasa golf menunda pengiriman Anda dalam bahasa lain, dan ... bersenang-senanglah!

Perl 6 , 128 byte

{.map({.combinations(1..4).grep({!.join.comb.repeated}).map({-$_,$_».trans('ATK'=>'1BZ')».ord.sort(-*)}).min}).minpairs».key}

Cobalah online!

Mengambil daftar tangan (juga lebih dari dua) yang merupakan daftar kartu yang berupa string Kc. Mengembalikan indeks tangan dengan skor terendah. Untuk dua tangan ini adalah (0)jika tangan pertama menang, (1)jika tangan kedua menang, dan (0, 1)untuk hasil seri.

Dijelaskan:

{
    # Map hands to best "played hand".
    .map({
        # Generate all combinations of length 1 to 4.
        .combinations(1..4)
        # Remove hands with repeated characters.
        .grep({!.join.comb.repeated})
        # Map to a cmp-arable representation. This works because
        # lists are compared element-wise. Translate some characters
        # so that ASCII order works. Sort in reverse order so that
        # element-wise comparison will go from highest to lowest.
        .map({ -$_, $_».trans('ATK'=>'1BZ')».ord.sort(-*) })
        # Find best hand.
        .min
    })
    # Return indices of lowest scoring hands. It's a shame that
    # `minpairs` doesn't support a filter like `min`.
    .minpairs».key
}

JavaScript (ES6), 209 202 192 182 181 byte

Disimpan 7 byte berkat @Neil

Mengambil input sebagai array array string. Kembali truejika tangan pertama menang, falsejika tangan kedua menang, atau 2dalam hal seri.

a=>([a,b]=a.map(a=>a.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).map(a=>!/(\w).*\1/.test(a)*a.length+a.map(a=>'KQJT98765432A'.search(a[0])+10).sort()).sort().pop()),a==b?2:a>b)

Uji kasus

let f =

a=>([a,b]=a.map(a=>a.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).map(a=>!/(\w).*\1/.test(a)*a.length+a.map(a=>'KQJT98765432A'.search(a[0])+10).sort()).sort().pop()),a==b?2:a>b)

console.log(f([["3c","2s","4d","Ah"], ["As","3h","2d","4h"]])) // true  (1st hand wins)
console.log(f([["3c","2s","4d","Ah"], ["As","2c","3d","4h"]])) // 2     (tie)
console.log(f([["2d","Ac","4h","3c"], ["Kh","Ad","9s","2c"]])) // false (2nd hand wins)
console.log(f([["Kc","Tc","Qc","Jc"], ["Ac","Ad","Ah","As"]])) // false (2nd hand wins)
console.log(f([["9c","9h","Qc","Qh"], ["Qs","Kh","Jh","Kd"]])) // false (2nd hand wins)
console.log(f([["2d","5h","7c","5s"], ["2h","3c","8d","6c"]])) // true  (1st hand wins)
console.log(f([["3s","6c","2d","Js"], ["6h","Jd","3c","2s"]])) // false (2nd hand wins)
console.log(f([["Ah","6d","4d","Ac"], ["3h","2c","3s","2s"]])) // false (2nd hand wins)
console.log(f([["2h","8h","6h","4h"], ["6d","2d","5d","8d"]])) // 2     (tie)

Bagaimana?

a => (
  // store the best combination for both hands in a and b respectively
  [a, b] = a.map(a =>
    // compute the powerset of the hand
    a.reduce((a, x) => [...a, ...a.map(y => [x, ...y])], [[]])
    // for each entry:
    .map(a =>
      // invalidate entries that have at least 2 cards of same rank or same value
      !/(\w).*\1/.test(a) *
      // the score of valid entries is based on their length ...
      a.length +
      // ... and their card values, from highest to lowest
      // (we map 'KQJT98765432A' to [10 - 22], so that the resulting
      // strings can be safely sorted in lexicographical order)
      a.map(a => 'KQJT98765432A'.search(a[0]) + 10).sort()
    )
    // keep the best one
    .sort().pop()
  ),
  // compare a with b
  a == b ? 2 : a > b
)

Jelly , 36 byte

ẎŒQȦ;L;Ṗ€Ṣ$
“A+KYTE”yḲONŒPÇ€ṢṪµ€⁼€Ṁ$

Tautan monadik yang mengambil daftar dua daftar karakter
- masing-masing merupakan representasi tangan yang terpisah dari ruang (misalnya "Ac 2d 4s 3h")
mengembalikan daftar dua angka yang mengidentifikasi pemenang (s) dengan 1dan siapa yang kalah dengan 0
- yaitu [1, 0]= menang kiri; [0, 1]= kemenangan yang tepat; [1, 1]= menggambar.

Cobalah online! atau lihat test-suite .

Bagaimana?

ẎŒQȦ;L;Ṗ€Ṣ$ - Link 1, sortKey: list of lists of numbers representing some cards (see Main)
Ẏ           - flatten into a single list of numbers
 ŒQ         - distinct sieve (1 at first occurrence of anything, 0 at the rest)
   Ȧ        - Any & All? zero if any are 0 or if empty; 1 otherwise (i.e. playable hand?)
     L      - length of input (number of cards in the hand)
    ;       - concatenate
          $ - last two links as a monad:
       Ṗ€   -   pop each (get just the rank portions)
         Ṣ  -   sort (Main's translation & negation of ordinals ensures A>2>3>...>Q>K)
      ;     - concatenate (now we have [isPlayable; nCards; [lowToHighCards]])

“A+KYTE”yḲONŒPÇ€ṢṪµ€⁼€Ṁ$ - Main link: list of lists of characters, hands
                  µ€     - for €ach of the two hands:
“A+KYTE”                 -   literal list of characters "A+KYTE" (compressing doesn't help - lower case would be “£Ḅṁ⁽>» though -- I'll stick with kyte though it's kind of nice.)
        y                -   translate - change As to +s, Ks to Ys and Ts to Es
                         -               note the ranks are now in ordinal order:
                         -               +<2<3<4<5<6<7<8<9<E<J<Q<Y
         Ḳ               -   split at spaces - split the four cards up
          O              -   to ordinals '+'->43, '2'->50, ...
           N             -   negate - effectively reverse the ordering
            ŒP           -   power-set - get all combinations of 0 to 4 cards inclusive
              Ç€         -   call the last link (1) as a monad for €ach such selection
                Ṣ        -   sort these keys
                 Ṫ       -   tail - get (one of) the maximal keys
                         -                       (the key of a best, playable selection)
                       $ - last two links as a monad:
                      Ṁ  -   maximum (the better of the two best, playable selection keys)
                    ⁼€   -   equals? for €ach (1 if the hand is a winner, 0 if not)

Python 3 , 207 204 byte

lambda i,j:L(h(i))-L(h(j))if L(h(i))!=L(h(j))else(h(i)<h(j))-(h(i)>h(j))
L=len
def h(l):s=set();return[x[0]for x in sorted(y.translate({65:49,75:90,84:65})for y in l)if not(s&set(x)or s.update(*x))][::-1]

Cobalah online!

Disimpan 3 byte berkat Jonathan Frech

Kembali 1jika tangan pertama menang, -1jika tangan kedua menang dan 0dalam kasus seri.

Fungsi hmenghitung daftar yang mewakili tangan.

Lambda membandingkan dua representasi tangan. Saya pikir ini mungkin dipersingkat, tetapi saya ingin mengembalikan hanya tiga nilai dan tidak menemukan cara yang lebih sederhana untuk melakukan perbandingan.