^{Inspiriert von dieser Herausforderung und verwandt mit dieser .}

Hintergrund

Badugi [bæduːɡiː] ist eine Low-Ball Draw-Poker-Variante.

^{Der Pokerstars World Cup of Online Poker $ 1K Event beginnt innerhalb von 3 Stunden und ich muss wissen, wie gut meine Hände sind!}

Das Spiel verwendet ein Standardstapel von 52 Karten mit vier Farben und dreizehn Rängen. Die Anzüge sind ungeordnet und müssen gekennzeichnet sein cdhs; Die Ränge - vom höchsten Kzum niedrigsten geordnet A- sind KQJT98765432A. Als solches kann das gesamte Deck wie folgt dargestellt werden (durch Leerzeichen getrennt):

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 

Jeder Spieler erhält vier Karten aus dem Stapel, es gibt vier Wettrunden mit drei dazwischen liegenden Ziehungsrunden (ein Spieler hat immer vier Karten, er hat die Möglichkeit, 0-4 seiner Karten durch neue Karten des Dealers zu ersetzen der drei Ziehungsrunden).

Wenn nach all diesen Runden noch mehr als ein Spieler aktiv ist, gibt es einen Showdown, woraufhin die stärksten Hände die gesetzten Wetten gewinnen.

Das Spiel wird mit niedrigem Ball gespielt, so dass die niedrigste Hand gewinnt und wie oben erwähnt A(Ass) niedrig ist. Darüber hinaus unterscheidet sich das Handranking von anderen Pokerformen und kann für Anfänger etwas verwirrend sein.

Die gespielte "Hand" ist die Kombination mit dem niedrigsten Rang, die aus der höchsten Anzahl von möglichen "Off-Suit" -Karten (alle unterschiedlichen Farben) und "Off-Rank" -Karten (alle unterschiedlichen Ränge) (aus den vier gehaltenen Karten) besteht ). Das heißt: Wenn man vier Karten mit unterschiedlichen Farben und Rängen besitzt, hat man eine 4-Karten-Hand ("Badugi" genannt). Wenn man keine 4-Karten-Hand hat, aber einen Satz oder Sätze von drei Karten mit unterschiedlichen Farben und Rängen hat, hat man eine 3-Karten-Hand (man wählt das Beste aus). Wenn man weder eine 4-Karten-Hand noch eine 3-Karten-Hand hat, hat man wahrscheinlich eine 2-Karten-Hand, aber wenn nicht, hat man eine 1-Karten-Hand.

• Als solche ist die bestmögliche Hand die 4-Karten-Hand 4-3-2-A- die Karten mit dem niedrigsten Rang von vier verschiedenen Farben , die oft als "Nummer 1" bezeichnet werden. Die schwächste mögliche Hand wäre die 1-Karten-Hand Kund ist nur durch genaues Halten möglich Kc Kd Kh Ks.

• Beachten Sie, dass 4c 3h 2c Asist nicht eine „Nummer-1“, da die 4cund 2cvon der gleichen Farbe sind, aber es ist die stärkste der 3-Karten Hände, 3-2-Azieht er mit anderen 3-2-1s (wie Kh 3d 2s Ah) und übertrifft alle anderen 3-Karten Hände , aber verliert gegen alle 4-Karten-Hände (die so schwach sein können wie K-Q-J-T).

  • Die andere mögliche 3-Karten-Hand, aus der man machen könnte, 4c 3h 2c Asist 4-3-A, aber die ist schwächer (höher), also nicht gewählt.

• In ähnlicher Weise 8d 6h 3s 2hwird eine 3-Karten-Hand gespielt als 8-3-2- es gibt zwei Off-Sight-Off-Suit-Kombinationen der Größe 3, die 8-3-2besser (niedriger) sind als 8-6-3die drei (oder "trey") niedriger als die sechs.

Das Vergleichen von Händen untereinander folgt der gleichen Logik: Jede 4-Karte schlägt jede 3-Karte, jede 3-Karte schlägt jede 2-Karte und jede 2-Karte schlägt jede 1-Karte, während Hände mit der gleichen Anzahl gebrauchter Karten sind Vergleich von ihrem höchsten Rang nach unten auf die niedrigsten (zum Beispiel: 8-4-2Beats , 8-5-Aaber nicht alle 8-4-A, 8-3-2oder 7-6-5)

Die Herausforderung:

Identifizieren Sie bei zwei ungeordneten Sammlungen mit jeweils vier Karten diejenige (n), die einen Badugi-Showdown gewinnen (identifizieren Sie beide, wenn es sich um ein Unentschieden handelt).

Die Eingabe kann alles Vernünftige sein:

• eine einzelne Zeichenfolge aller acht oben genannten Karten (mit oder ohne Leerzeichen), wobei die linken vier eine Hand und die rechte die andere sind (mit einem optionalen Trennzeichen); oder eine Liste von Zeichen auf die gleiche Weise
• eine Liste mit zwei Zeichenfolgen - eine pro Hand oder eine Liste mit Zeichenlisten auf dieselbe Weise
• zwei separate Zeichenfolgen oder Listeneingaben, eine pro Hand
• Die Karten in den Händen können auch schon getrennt sein (eine Liste von Listen von Listen ist also in Ordnung).

Beachten Sie jedoch:

• Die Karten dürfen vor der Eingabe nicht in beliebiger Reihenfolge angeordnet werden
• ... und die Farben und Ränge sind als die hier angegebenen Zeichenbezeichnungen festgelegt. - Wenn Ihre Sprache solche Konstrukte nicht unterstützt, schlagen Sie einfach etwas Vernünftiges vor und fragen Sie, ob es angesichts Ihrer sprachlichen Einschränkungen eine akzeptable Alternative ist.

Die Ausgabe sollte entweder sein

• das gleiche Format wie die Eingabe oder eine gedruckte Darstellung davon; oder
• sein , ein von drei unterschiedlichen und gleichbleibenden Ergebnissen (zB: "left", "right", "both", oder 1, 2, 3, etc.)

Wirklich - solange klar ist, welcher der beiden Eingänge identifiziert wird, sollte es in Ordnung sein.

Testfälle

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)

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes pro Sprache und der kürzeste Code insgesamt. Lassen Sie sich nicht von Golfsprachen davon abhalten, in anderen Sprachen einzureichen, und ... haben Sie Spaß!

Perl 6 , 128 Bytes

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

Probieren Sie es online aus!

Nimmt eine Liste von Händen (auch mehr als zwei), die Listen von Karten sind, die wie Strings sind Kc. Gibt die Indizes der Hände mit der niedrigsten Punktzahl zurück. Für zwei Hände ist dies, (0)wenn die erste Hand gewinnt, (1)wenn die zweite Hand gewinnt, und (0, 1)für ein Unentschieden.

Erklärt:

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

7 Bytes dank @Neil gespeichert

Nimmt die Eingabe als Array von Arrays von Strings auf. Gibt zurück, truewenn die erste Hand gewinnt, falsewenn die zweite Hand gewinnt oder 2bei einem Unentschieden.

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)

Testfälle

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)

Wie?

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
)

Gelee , 36 Bytes

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

Ein monadischer Link, der eine Liste von zwei Zeichenlisten enthält
- jede ist eine durch Leerzeichen getrennte Darstellung der Hand (z. B. "Ac 2d 4s 3h"),
die eine Liste von zwei Zahlen zurückgibt, die den / die Gewinner mit 1und jeden Verlierer mit 0
- dh [1, 0]= links gewinnt; [0, 1]= rechts gewinnt; [1, 1]= zeichnen.

Probieren Sie es online aus! oder sehen Sie sich die Testsuite an .

Wie?

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

Probieren Sie es online aus!

3 Bytes dank Jonathan Frech gespeichert

Gibt zurück, 1wenn die erste Hand gewinnt, -1wenn die zweite Hand gewinnt und 0im Falle eines Unentschieden.

Die Funktion hberechnet eine Liste, die die Hand darstellt.

Das Lambda vergleicht zwei Darstellungen von Hand. Ich denke, es könnte verkürzt werden, aber ich wollte nur drei Werte zurückgeben und fand keinen einfacheren Weg, um Vergleiche anzustellen.