^{Inspiré par ce défi et lié à celui-ci .}

Contexte

Badugi [bæduːɡiː] est une variante de poker à faible tirage.

^{L' événement Pokerstars World Cup Of Online Poker à 1 000 $ commence dans les 3 heures et je devrai savoir à quel point mes mains sont bonnes!}

Le jeu utilise un jeu standard de 52 cartes de quatre couleurs et treize rangs. Les combinaisons ne sont pas commandées et doivent être étiquetées cdhs; les rangs - classés du plus haut Kau plus bas A- sont KQJT98765432A. En tant que tel, le jeu complet peut être représenté comme suit (séparé par des espaces):

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 

Chaque joueur reçoit quatre cartes du jeu, il y a quatre tours d'enchères avec trois tours de tirage entre les deux (un joueur a toujours quatre cartes, ils ont la possibilité de changer 0-4 de leurs cartes avec de nouvelles du croupier sur chaque des trois tours de dessin).

Si plus d'un joueur est toujours actif après tous ces tours, il y a une confrontation, après quoi la ou les mains les plus fortes remportent les paris misés.

Le jeu se joue en low-ball, donc la main la plus basse gagne, et comme mentionné ci-dessus A(as) est faible. De plus, le classement des mains est différent des autres formes de poker et peut être quelque peu déroutant pour les débutants.

La "main" jouée est la combinaison la moins bien classée composée du nombre le plus élevé possible de cartes "hors-combinaison" (toutes les combinaisons différentes) et "hors-rang" (tous les grades différents) (parmi les quatre cartes détenues). ). C'est-à-dire: si l'on détient quatre cartes de couleurs et de rangs distincts, on a une main de 4 cartes (appelée "badugi"); si l'on n'a pas une main de 4 cartes mais a un ou plusieurs ensembles de trois cartes de couleurs et de rangs distincts, on a une main de 3 cartes (on choisit son meilleur); si l'on n'a ni main à 4 cartes ni main à 3 cartes, on a probablement une main à 2 cartes, mais sinon on n'a pas une main à 1 carte.

• En tant que telle, la meilleure main possible est la main à 4 cartes 4-3-2-A- les cartes hors rang les plus basses de quatre couleurs différentes , souvent appelées "numéro 1". La main la plus faible possible serait la main à 1 carte Ket n'est possible qu'en tenant exactement Kc Kd Kh Ks.

• Notez que 4c 3h 2c Asest pas un « numéro 1 », puisque la 4cet 2csont de la même couleur, mais il est le plus fort des mains de 3 cartes, 3-2-Ail dessine avec d' autres 3-2-1s (comme Kh 3d 2s Ah) et bat toutes les autres mains 3 cartes , mais perd à toutes les mains de 4 cartes (qui pourraient être aussi faibles que K-Q-J-T).

  • L'autre main de 3 cartes possible qui pourrait être fabriquée 4c 3h 2c Asest 4-3-A, mais elle est plus faible (plus élevée) donc elle n'est pas choisie.

• De même, 8d 6h 3s 2hune main à 3 cartes se joue comme 8-3-2- il y a deux combinaisons hors-rang de la taille 3 et 8-3-2est meilleure (inférieure) que 8-6-3puisque les trois (ou "trey") sont inférieures aux six.

La comparaison des mains les unes contre les autres suit la même logique - toute carte 4 bat n'importe quelle carte 3, toute carte 3 bat toute carte 2 et toute carte 2 bat toute carte 1, tandis que les mains du même nombre de cartes utilisées sont par rapport à leur rang le plus élevé au plus bas (par exemple: 8-4-2battements 8-5-Amais pas n'importe lequel 8-4-A, 8-3-2ou 7-6-5)

Le défi:

Étant donné deux collections non ordonnées chacune de quatre cartes, identifiez celle (s) qui remporte une épreuve de force Badugi (identifiez les deux s'il s'agit d'un tirage).

L'entrée peut être quelque chose de raisonnable:

• une seule chaîne des huit cartes comme indiqué ci-dessus (avec ou sans espaces), les quatre à gauche étant une main et l'autre à droite (avec un séparateur en option); ou une liste de personnages de la même façon
• une liste de deux chaînes - une par main, ou une liste de listes de caractères de la même manière
• deux chaînes distinctes ou entrées de liste, une par main
• les cartes entre les mains peuvent déjà être séparées (donc une liste de listes de listes est très bien)

Notez cependant:

• les cartes ne peuvent être rangées dans aucun ordre avant la saisie
• ... et les combinaisons et les rangs sont fixés comme les étiquettes de caractères spécifiées ici - Si votre langue ne prend pas en charge de telles constructions, suggérez simplement quelque chose de raisonnable et demandez si c'est une alternative acceptable compte tenu de vos contraintes de langues.

La sortie doit être soit

• formaté de la même manière que l'entrée, ou une représentation imprimée de celle-ci; ou
• être l' un des trois résultats distincts et cohérents (par exemple: "left", "right", "both", ou 1, 2, 3, etc.)

Vraiment - tant qu'il est clair laquelle des deux entrées est identifiée, cela devrait aller.

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

Il s'agit de code-golf , donc le code le plus court en octets gagne par langue, et le code le plus court gagne en général. Ne laissez pas les langues de golf vous décourager de soumettre dans d'autres langues, et ... amusez-vous!

Perl 6 , 128 octets

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

Essayez-le en ligne!

Prend une liste de mains (également plus de deux) qui sont des listes de cartes qui sont comme des chaînes Kc. Renvoie les indices des mains avec le score le plus bas. Pour deux mains, c'est (0)si la première main gagne, (1)si la seconde main gagne et (0, 1)pour un match nul.

Expliqué:

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

7 octets enregistrés grâce à @Neil

Prend l'entrée comme un tableau de tableaux de chaînes. Renvoie truesi la première main gagne, falsesi la seconde main gagne ou 2en cas d'égalité.

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)

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

Comment?

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
)

Gelée , 36 octets

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

Un lien monadique prenant une liste de deux listes de personnages
- chacun étant une représentation séparée par des espaces de la main (par exemple "Ac 2d 4s 3h")
renvoyant une liste de deux nombres identifiant le ou les gagnants avec 1et tout perdant avec 0
- c'est-à-dire [1, 0]= les gains à gauche; [0, 1]= victoires à droite; [1, 1]= dessiner.

Essayez-le en ligne! ou voir la suite de tests .

Comment?

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

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]

Essayez-le en ligne!

Enregistré 3 octets grâce à Jonathan Frech

Retourne 1si la première main gagne, -1si la seconde main gagne et 0en cas d'égalité.

La fonction hcalcule une liste qui représente la main.

Le lambda compare deux représentations de la main. Je pense que cela pourrait être raccourci, mais je voulais retourner seulement trois valeurs et je n'ai pas trouvé de moyen plus simple de faire une comparaison.