^{Inspirado por este desafío y relacionado con este .}

Antecedentes

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

^{¡El evento de $ 1K de la Copa Mundial de Poker Poker de Pokerstars comienza en 3 horas y necesitaré saber qué tan buenas son mis manos!}

El juego utiliza una baraja estándar de 52 cartas de cuatro palos y trece rangos. Los trajes no están ordenados y deben estar etiquetados cdhs; los rangos, ordenados de mayor Ka menor A, son KQJT98765432A. Como tal, el mazo completo puede representarse de la siguiente manera (espacio separado):

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 cada jugador se le reparten cuatro cartas del mazo, hay cuatro rondas de apuestas con tres rondas de sorteo en el medio (un jugador siempre tiene cuatro cartas, tiene la opción de cambiar 0-4 de sus cartas con nuevas del crupier en cada una) de las tres rondas de dibujo).

Si más de un jugador sigue activo después de todas estas rondas, hay un enfrentamiento, con lo cual las manos más fuertes ganan las apuestas apostadas.

El juego se juega bajo, por lo que la mano más baja gana, y como se mencionó anteriormente A(as) es bajo. Además, el ranking de manos es diferente de otras formas de póker, y puede ser algo confuso para los principiantes.

La "mano" jugada es la combinación de menor puntaje hecha del mayor número de cartas "fuera de palo" (todos diferentes palos) y "fuera de rango" (todos los diferentes rangos) posibles (de las cuatro cartas retenidas ) Es decir: si uno tiene cuatro cartas de dos palos distintos y rangos distintos, tiene una mano de 4 cartas (llamada "badugi"); si uno no tiene una mano de 4 cartas pero tiene un conjunto o conjuntos de tres cartas de ambos palos distintos y rangos distintos, uno tiene una mano de 3 cartas (uno elige su mejor); si uno no tiene una mano de 4 cartas o una mano de 3 cartas, probablemente tenga una mano de 2 cartas, pero si no tiene una mano de 1 carta.

• Como tal, la mejor mano posible es la mano de 4 cartas 4-3-2-A: las cartas fuera de rango más bajas de cuatro palos diferentes , a menudo denominadas "número 1". La mano más débil posible sería la mano de 1 carta Ky solo es posible manteniendo exactamente Kc Kd Kh Ks.

• Tenga en cuenta que no4c 3h 2c As es un "número-1", ya que el y son del mismo palo, pero es la más fuerte de las manos de 3 cartas , empata con otras s (como ) y supera a todas las otras manos de 3 cartas pero pierde a todas las manos de 4 cartas (que podría ser tan débil como ). 4c2c3-2-A3-2-1Kh 3d 2s AhK-Q-J-T

  • La otra mano posible de 3 cartas que podría hacerse 4c 3h 2c Ases 4-3-A, pero que es más débil (más alta), por lo que no se elige.

• Del mismo modo, 8d 6h 3s 2hse juega una mano de 3 cartas, ya que 8-3-2hay dos combinaciones fuera de rango fuera del palo de tamaño 3 y 8-3-2es mejor (más bajo) que 8-6-3desde que las tres (o "trey") son más bajas que las seis.

La comparación de manos entre sí sigue la misma lógica: cualquier 4 cartas vence a cualquier 3 cartas, cualquier 3 cartas vence a cualquier 2 cartas y cualquier 2 cartas vence a cualquier 1 carta, mientras que las manos del mismo número de cartas usadas son comparado desde su rango más alto hasta su más bajo (por ejemplo: 8-4-2latidos 8-5-Apero ninguno de 8-4-A, 8-3-2o 7-6-5)

El reto:

Dadas dos colecciones desordenadas de cada una de las cuatro cartas, identifique las que ganen un enfrentamiento de Badugi (identifique ambas si es un empate).

La entrada puede ser cualquier cosa razonable:

• una sola cadena de las ocho cartas como se etiqueta arriba (con o sin espacios) con las cuatro izquierdas como una mano y la derecha como la otra (con un separador opcional); o una lista de personajes de la misma manera
• una lista de dos cadenas, una por mano, o una lista de listas de caracteres de la misma manera
• dos cadenas separadas o entradas de lista, una por mano
• las tarjetas dentro de las manos también pueden estar separadas (por lo que una lista de listas de listas está bien)

Nota, sin embargo:

• las tarjetas no pueden organizarse en ningún orden antes de la entrada
• ... y los trajes y los rangos se arreglan como las etiquetas de caracteres especificadas aquí: si su idioma no admite tales construcciones, simplemente sugiera algo razonable y pregunte si es una alternativa aceptable dadas las limitaciones de sus idiomas.

La salida debería ser

• formateado igual que la entrada, o una representación impresa de la misma; o
• ser uno de tres resultados distintos y coherentes (por ejemplo: "left", "right", "both", o 1, 2, 3, etc.)

Realmente, siempre que esté claro cuál de las dos entradas se está identificando, debería estar bien.

Casos de prueba

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)

Este es el código de golf , por lo que el código más corto en bytes gana por idioma, y ​​el código más corto en general gana. No deje que los idiomas de golf lo pospongan en otros idiomas y ... ¡diviértase!

Perl 6 , 128 bytes

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

Pruébalo en línea!

Toma una lista de manos (también más de dos) que son listas de cartas que son como cadenas Kc. Devuelve los índices de las manos con la puntuación más baja. Para dos manos esto es (0)si la primera mano gana, (1)si la segunda mano gana, y (0, 1)para un empate.

Explicado:

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

Guardado 7 bytes gracias a @Neil

Toma la entrada como una matriz de matrices de cadenas. Devuelve truesi gana la primera mano, falsesi gana la segunda mano o 2en caso de empate.

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)

Casos de prueba

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)

¿Cómo?

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
)

Jalea , 36 bytes

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

Un enlace monádico que toma una lista de dos listas de caracteres
, cada una de las cuales es una representación de la mano separada por espacios (p "Ac 2d 4s 3h". Ej. )
Que devuelve una lista de dos números que identifican al ganador o ganadores 1y a cualquier perdedor con 0
, es decir, la [1, 0]izquierda gana; [0, 1]= derecha gana; [1, 1]= dibujar.

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

ẎŒ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 , 207204 bytes

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]

Pruébalo en línea!

Guardado 3 bytes gracias a Jonathan Frech

Devuelve 1si gana la primera mano, -1si gana la segunda mano y 0en caso de empate.

La función hcalcula una lista que representa la mano.

La lambda compara dos representaciones de la mano. Creo que podría acortarse, pero quería devolver solo tres valores y no encontré una forma más simple de hacer una comparación.