^{Zainspirowany tym wyzwaniem i związany z tym .}

tło

Badugi [bæduːɡiː] to wariant pokera z niską piłką.

^{Turniej Pokerstars World Cup Of Online Poker o wartości 1 000 $ rozpoczyna się w ciągu 3 godzin i muszę wiedzieć, jak dobre są moje ręce!}

Gra wykorzystuje standardową talię 52 kart czterech kolorów i trzynastu rang. Kombinezony są nieuporządkowane i powinny być oznakowane cdhs; szeregi - uporządkowane od najwyższej Kdo najniższej A- są KQJT98765432A. Jako taki, pełna talia może być przedstawiona w następujący sposób (oddzielone spacją):

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 

Każdy gracz otrzymuje cztery karty z talii, są cztery rundy licytacji z trzema rundami losowania pomiędzy nimi (gracz zawsze ma cztery karty, ma możliwość zmiany 0-4 swoich kart na nowe od dealera na każdej z nich z trzech rund rysunkowych).

Jeśli więcej niż jeden gracz jest nadal aktywny po tych wszystkich rundach, następuje showdown, w wyniku którego najsilniejsze ręce wygrywają postawione zakłady.

Gra rozgrywana jest z małą piłką, więc wygrywa najniższa ręka, a jak wspomniano powyżej A(as) jest niska. Ponadto ranking rozdań różni się od innych form pokera i może być nieco mylący dla początkujących.

Rozgrywana „ręka” jest kombinacją o najniższym rankingu złożoną z najwyższej możliwej liczby kart „off-suit” (wszystkie w różnych kolorach) i „off-rank” (wszystkie w różnych poziomach) (z czterech posiadanych kart ). To znaczy: jeśli ktoś ma cztery karty w obu różnych kolorach i różnych rangach, ma rękę z 4 kartami (zwaną „badugi”); jeśli ktoś nie ma 4-kartowego układu, ale ma jakiś zestaw lub zestawy trzech kart o różnych kolorach i różnych stopniach, ma układ 3-kartowy (wybiera się najlepszy); jeśli ktoś nie ma układu 4-kartowego lub 3-kartowego, prawdopodobnie ma układ 2-kartowy, ale jeśli nie, ma układ 1-kartowy.

• Jako taki najlepszy możliwy układ to układ 4-kartowy 4-3-2-A- najniższe karty poza rangą czterech różnych kolorów , często określane jako „numer 1”. Najsłabszym możliwym układem jest układ z jedną kartą Ki jest to możliwe tylko poprzez dokładne trzymanie Kc Kd Kh Ks.

• Zauważ, że nie4c 3h 2c As jest to „liczba-1”, ponieważ i mają ten sam kolor, ale jest najsilniejszy z 3-kartowych rąk, dobiera z innymi s (jak ) i bije wszystkie inne 3-kartowe ręce, ale przegrywa z wszystkimi 4 kartami (które mogą być tak słabe jak ). 4c2c3-2-A3-2-1Kh 3d 2s AhK-Q-J-T

  • Innym możliwym układem złożonym z 3 kart, który można wykonać, 4c 3h 2c Asjest 4-3-Ajednak słabszy (wyższy), więc nie został wybrany.

• Podobnie rozgrywane 8d 6h 3s 2hjest rozdanie z 3 kartami, ponieważ 8-3-2- istnieją dwie kombinacje poza rangą w kolorze 3 i 8-3-2są lepsze (niższe) niż 8-6-3ponieważ trzy (lub „trey”) są niższe niż sześć.

Porównywanie rąk ze sobą odbywa się zgodnie z tą samą logiką - każda karta 4 bije dowolną kartę 3, dowolna karta 3 bije dowolną kartę 2, a każda karta 2 bije dowolną kartę 1, a ręce tej samej liczby używanych kart są w porównaniu z najwyższą rangą do najniższej (na przykład: 8-4-2rytmy, 8-5-Aale żaden z nich 8-4-A, 8-3-2lub 7-6-5)

Wyzwanie:

Biorąc pod uwagę dwie nieuporządkowane kolekcje, każda z czterech kart, zidentyfikuj tę, która wygrywa showdown Badugi (zidentyfikuj obie, jeśli jest to remis).

Dane wejściowe mogą być cokolwiek rozsądnego:

• pojedynczy ciąg wszystkich ośmiu kart oznaczonych powyżej (ze spacjami lub bez), przy czym lewe cztery to jedna ręka, a prawa druga (z opcjonalnym separatorem); lub listę znaków w ten sam sposób
• lista dwóch ciągów - po jednym na rękę lub lista list znaków w ten sam sposób
• dwa oddzielne ciągi znaków lub dane wejściowe listy, po jednym na rękę
• karty w rękach też mogą być już rozdzielone (więc lista list jest w porządku)

Uwaga:

• karty nie mogą być ułożone w żadnej kolejności przed wprowadzeniem
• ... a kolory i stopnie są ustalone jako określone tutaj etykiety znaków - Jeśli twój język nie obsługuje takich konstrukcji, po prostu zasugeruj coś rozsądnego i zapytaj, czy jest to dopuszczalna alternatywa ze względu na ograniczenia językowe.

Wyjście powinno być albo

• sformatowane tak samo jak dane wejściowe lub ich wydrukowana reprezentacja; lub
• jednym z trzech odrębnych i spójne wyniki (na przykład: "left", "right", "both", i 1, 2, 3; itd.)

Naprawdę - dopóki jest jasne, które z dwóch identyfikowanych sygnałów wejściowych powinny być w porządku.

Przypadki testowe

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)

To jest golf-golf, więc najkrótszy kod w bajtach wygrywa w danym języku, a najkrótszy kod ogółem wygrywa. Nie pozwól, aby języki gry w golfa zniechęciły Cię do przesyłania w innych językach i ... baw się dobrze!

Perl 6 , 128 bajtów

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

Wypróbuj online!

Pobiera listę rąk (także więcej niż dwie), które są listami kart podobnych do strun Kc. Zwraca indeksy rąk o najniższym wyniku. W przypadku dwóch rozdań jest tak, (0)jeśli wygrywa pierwsza ręka, (1)jeśli wygrywa druga ręka, i (0, 1)w przypadku remisu.

Wyjaśnione:

{
    # 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 bajtów

Zaoszczędź 7 bajtów dzięki @Neil

Pobiera dane wejściowe jako tablicę tablic ciągów. Zwraca, truejeśli pierwsza ręka wygrywa, falsejeśli druga ręka wygrywa lub 2w przypadku remisu.

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)

Przypadki testowe

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)

W jaki sposób?

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
)

Galaretka , 36 bajtów

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

Monadyczny link zawierający listę dwóch list znaków
- każda z nich jest oddzieloną spacją reprezentacją ręki (np. "Ac 2d 4s 3h")
Zwraca listę dwóch liczb identyfikujących zwycięzcę (-ów) 1i każdego przegranego z 0
- tj. [1, 0]= Lewe wygrane; [0, 1]= prawo wygrywa; [1, 1]= remis

Wypróbuj online! lub zobacz zestaw testowy .

W jaki sposób?

ẎŒ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 bajtów

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]

Wypróbuj online!

Zaoszczędź 3 bajty dzięki Jonathanowi Frechowi

Zwraca, 1jeśli pierwsza ręka wygrywa, -1jeśli druga ręka wygrywa, 0aw przypadku remisu.

Funkcja hoblicza listę reprezentującą rękę.

Lambda porównuje dwa przedstawienia dłoni. Myślę, że można go skrócić, ale chciałem zwrócić tylko trzy wartości i nie znalazłem prostszego sposobu na porównanie.