^{Ispirato da questa sfida e correlato a questa .}

sfondo

Badugi [bæduːɡiː] è una variante di draw-poker low-ball.

^{L' evento $ 1K di Pokerstars World Cup Of Online Poker inizia entro 3 ore e dovrò sapere quanto sono buone le mie mani!}

Il gioco utilizza un mazzo standard di 52 carte di quattro semi e tredici gradi. Le tute non sono ordinate e devono essere etichettate cdhs; i gradi - ordinati dal più alto Kal più basso A- sono KQJT98765432A. Pertanto, l'intero mazzo può essere rappresentato come segue (spazio separato):

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 

A ogni giocatore vengono distribuite quattro carte dal mazzo, ci sono quattro giri di puntate con tre giri di pesca tra di loro (un giocatore ha sempre quattro carte, hanno la possibilità di cambiare 0-4 delle loro carte con nuove del banco su ciascuna dei tre round di disegno).

Se dopo tutti questi round è ancora attivo più di un giocatore, c'è uno showdown, al termine del quale le mani più forti vincono le scommesse puntate.

Il gioco si gioca con la palla bassa, quindi vince la mano più bassa e, come detto sopra, l' Aasso è basso. Inoltre, la classifica delle mani è diversa dalle altre forme di poker e può essere un po 'confusa per i principianti.

La "mano" giocata è la combinazione più bassa classificata fatta dal numero più alto possibile di carte sia "fuori seme" (semi tutti diversi) sia "fuori rango" (gradi tutti diversi) (tra le quattro carte possedute ). Cioè: se si possiedono quattro carte di semi e semi distinti e si ha una mano di 4 carte (chiamata "badugi"); se uno non ha una mano di 4 carte ma ha una serie o tre serie di tre carte di semi e gradi distinti, ha una mano di 3 carte (si sceglie il meglio); se uno non ha né una mano da 4 carte né una mano da 3 carte, probabilmente ha una mano da 2 carte, ma in caso contrario ha una mano da 1 carta.

• Pertanto la migliore mano possibile è la mano di 4 carte 4-3-2-A- le carte fuori rango più basse di quattro semi diversi , spesso definite "numero 1". La mano più debole possibile sarebbe la mano di 1 carta Ked è possibile solo tenendo esattamente Kc Kd Kh Ks.

• Nota che non4c 3h 2c As è un "numero 1", poiché i e sono dello stesso seme, ma è la più forte delle mani di 3 carte , pesca con altre s (come ) e batte tutte le altre mani di 3 carte ma perde in tutte le mani di 4 carte (che potrebbero essere deboli come ). 4c2c3-2-A3-2-1Kh 3d 2s AhK-Q-J-T

  • L'altra possibile mano di 3 carte che potrebbe essere fatta 4c 3h 2c Asè 4-3-A, ma che è più debole (più alta), quindi non scelta.

• Allo stesso modo 8d 6h 3s 2hsi gioca una mano di 3 carte come 8-3-2: ci sono due combinazioni fuori seme di valore 3 di dimensione 3 ed 8-3-2è migliore (inferiore) rispetto a 8-6-3quando le tre (o "trey") sono inferiori alle sei.

Confrontare le mani l'una con l'altra segue la stessa logica: ogni 4 carte batte qualsiasi 3 carte, ogni 3 carte batte qualsiasi 2 carte e ogni 2 carte batte qualsiasi 1 carta, mentre le mani dello stesso numero di carte usate sono confrontato dal loro rango più alto al più basso (ad esempio: 8-4-2battiti 8-5-Ama nessuno dei 8-4-A, 8-3-2o 7-6-5)

La sfida:

Date due raccolte non ordinate ciascuna di quattro carte, identifica quella (e) che vincono una resa dei conti Badugi (identifica entrambe se si tratta di un pareggio).

L'input può essere qualcosa di ragionevole:

• una singola stringa di tutte e otto le carte come indicato sopra (con o senza spazi) con i quattro a sinistra che sono una mano e l'altra a destra (con un separatore opzionale); o un elenco di personaggi nello stesso modo
• un elenco di due stringhe: una per mano o un elenco di elenchi di caratteri nello stesso modo
• due stringhe o input di elenco separati, uno per mano
• anche le carte nelle mani potrebbero essere già separate (quindi un elenco di liste di liste va bene)

Nota, tuttavia:

• le carte non possono essere disposte in alcun ordine prima dell'immissione
• ... e semi e gradi sono fissi come le etichette dei personaggi qui specificate - Se la tua lingua non supporta tali costrutti, suggerisci qualcosa di ragionevole e chiedi se è un'alternativa accettabile dati i tuoi vincoli linguistici.

L'output dovrebbe essere

• formattato come l'input o una sua rappresentazione stampata; o
• uno dei tre risultati distinti e costanti (es: "left", "right", "both", o 1, 2, 3, etc.)

Davvero - fintanto che è chiaro quale dei due input viene identificato, dovrebbe andare bene.

Casi test

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)

Si tratta di code-golf , quindi vince il codice più breve in byte per lingua e vince il codice più corto complessivo. Non lasciare che le lingue del golf ti scoraggino a presentare in altre lingue e ... divertiti!

Perl 6 , 128 byte

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

Provalo online!

Prende un elenco di mani (anche più di due) che sono elenchi di carte simili a stringhe Kc. Restituisce gli indici delle mani con il punteggio più basso. Per due mani questo è (0)se la prima mano vince, (1)se la seconda mano vince e (0, 1)per un pareggio.

Ha spiegato:

{
    # 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

Salvato 7 byte grazie a @Neil

Accetta input come una matrice di array di stringhe. Restituisce truese vince la prima mano, falsese vince la seconda mano o 2in caso di pareggio.

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)

Casi test

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)

Come?

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
)

Gelatina , 36 byte

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

Un collegamento monadico che prende un elenco di due elenchi di caratteri
- ognuno dei quali è una rappresentazione della mano separata dallo spazio (ad es. "Ac 2d 4s 3h") Che
restituisce un elenco di due numeri che identificano il / i vincitore / i 1e qualsiasi perdente con 0
- cioè [1, 0]= vittorie a sinistra; [0, 1]= vince a destra; [1, 1]= pareggio.

Provalo online! o vedi la suite di test .

Come?

ẎŒ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]

Provalo online!

Salvato 3 byte grazie a Jonathan Frech

Restituisce 1se la prima mano vince, -1se la seconda mano vince e 0in caso di pareggio.

La funzione hcalcola un elenco che rappresenta la mano.

La lambda confronta due rappresentazioni della mano. Penso che potrebbe essere abbreviato, ma volevo restituire solo tre valori e non ho trovato un modo più semplice per fare un confronto.