^{この課題に触発され、これに関連しています。}

バックグラウンド

Badugi [bæduːɡiː]はローボールドローポーカーバリアントです。

^{Pokerstarsワールドカップオブオンラインポーカーの$ 1Kイベントは3時間以内に始まります。ハンドがどれだけ優れているかを知る必要があります。}

ゲームは、4つのスーツと13のランクの52枚のカードの標準デッキを使用します。スーツは順不同であり、ラベルが付けられcdhsます。ランクは、最高Kから最低の順に並べられAていKQJT98765432Aます。そのため、デッキ全体は次のように表されます（スペースで区切られています）。

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 

各プレイヤーにはデッキから4枚のカードが配られ、その間に4つの賭けラウンドがあり、その間に3つの抽選ラウンドがあります（プレイヤーは常に4枚のカードを持っています。 3つの描画ラウンドの）。

これらのすべてのラウンドの後に複数のプレーヤーがまだアクティブである場合、ショーダウンがあり、最強のハンドが賭けられた賭けに勝ちます。

ゲームはローボールでプレーされるため、最低のハンドが勝ち、前述のように A（エース）は低くなります。さらに、ハンドランキングは他の形式のポーカーとは異なり、初心者には多少混乱する可能性があります。

プレイされた「ハンド」は、「オフスーツ」（すべて異なるスーツ）と「オフランク」（すべて異なるランク）の両方のカード（保持されている4枚のカード）の最大数から作成された最低ランクの組み合わせです。 ）。つまり、異なるスーツと異なるランクの4枚のカードを持っている場合、4枚のカードの手（「badugi」と呼ばれます）を持っています。4枚のカードの手は持っていないが、異なるスーツとランクの両方の3枚のカードのセットがある場合は、3枚のカードの手があります（1つがベストを選択します）。4カードハンドも3カードハンドもない場合は、おそらく2カードハンドを持っていますが、そうでない場合は1カードハンドを持っています。

• そのため、可能な限り最高のハンドは4カードハンドです。4つの異なるスーツ4-3-2-Aの中で最もランクの低いカードで、「ナンバー1」と呼ばれることがよくあります。最も弱いハンドは1カードハンドであり、正確にホールドすることによってのみ可能です。KKc Kd Kh Ks

• 注意4c 3h 2c Asされていないことから、「数1」4cと2c同じスーツであるが、それはある 3枚のカードの手の最強、3-2-Aそれは他に描く3-2-1S（のようなKh 3d 2s Ah）および他のすべての3枚のカードの手を打つが、すべての4カードの手に負けます（これはと同じくらい弱い場合がありますK-Q-J-T）。

  • から作成できる他の3枚のカードの手 4c 3h 2c Asはですが4-3-A、それは弱い（高い）ため、選択されません。

• 同様8d 6h 3s 2hに、3枚のカードの手札は次のようにプレーされ8-3-2ます。サイズ3には2つのオフランクオフスーツの組み合わせがあり、3つ（または「トレイ」）が6つよりも低いので、8-3-2より優れています（低い）8-6-3。

ハンドを相互に比較すると、同じロジックに従います。4枚のカードは3枚のカードに勝ち、3枚のカードは2枚のカードに勝ち、2枚のカードは1枚のカードに勝ちます。 （：例えば最安値に彼らの最高ランクダウンから比べ8-4-2ビート8-5-Aではなく、いずれかの8-4-A、8-3-2または7-6-5）

チャレンジ：

4枚のカードのそれぞれに2つの順序付けられていないコレクションがある場合、Badugi対決に勝ったカードを特定します（引き分けの場合は両方を特定します）。

入力は妥当なものである可能性があります。

• 上記のラベルの付いた8枚すべてのカードの単一の文字列（スペースありまたはなし）、左の4枚が片手で右が（オプションのセパレーター付き）。または同じ方法で文字のリスト
• 2つの文字列のリスト-手ごとに1つ、または同じ方法で文字のリストのリスト
• 2つの個別の文字列またはリスト入力（片手に1つ）
• 手の中のカードもすでに分離されている可能性があります（したがって、リストのリストのリストは問題ありません）

ただし、次の点に注意してください。

• 入力前にカードを任意の順序で配置することはできません
• ...そしてスーツとランクはここで指定された文字ラベルとして固定されます-言語がそのような構成をサポートしていない場合は、妥当なものを提案し、言語の制約を考慮して、それが許容できる代替案かどうか尋ねてください。

出力は

• 入力またはその印刷表現と同じフォーマット または
• （：例えば、3つのはっきりと一貫性のある結果の一つである"left"、"right"、"both"、または1、2、3、等）

本当に-2つの入力のどちらが識別されているかが明らかである限り、問題はありません。

テストケース

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)

これはcode-golfなので、バイト単位の最短コードが言語ごとに勝ち、最短コード全体が勝ちます。ゴルフ言語が他の言語での提出を先送りにすることを許さないでください、そして...楽しんでください！

Perl 6、128バイト

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

オンラインでお試しください！

のような文字列のカードのリストであるハンドのリスト（2つ以上）を取りますKc。最も低いスコアを持つ手のインデックスを返します。両手では(0)、これは最初の手が勝った(1)場合、2番目の手が勝った場合、および(0, 1)引き分けの場合です。

説明：

{
    # 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バイト

@Neilのおかげで7バイト節約

文字列の配列の配列として入力を受け取ります。true最初のハンドが勝ったfalse場合、2番目のハンドが勝った場合、または2引き分けの場合に戻ります。

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)

テストケース

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)

どうやって？

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
)

ゼリー、36 バイト

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

文字の二つのリストのリストを取ってモナドリンク
-それぞれのスペースであることは、（例えば、手の表現を分離"Ac 2d 4s 3h"）
勝者（複数可）を特定する2つの数のリストを返すと1して持つ任意の敗者0
-つまりは[1, 0]、左の勝利を=。[0, 1]=正しい勝利。[1, 1]=ドロー。

オンラインでお試しください！またはテストスイートを参照してください。

どうやって？

ẎŒ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バイト

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]

オンラインでお試しください！

Jonathan Frechのおかげで3バイト節約

1最初のハンドが勝った-1場合、2番目のハンドが勝っ0た場合、および引き分けの場合に戻ります。

この関数hは、手を表すリストを計算します。

ラムダは2つの手の表現を比較します。短くなるかもしれませんが、3つの値のみを返す必要があり、比較を行う簡単な方法が見つかりませんでした。