^{受到这一挑战的启发并与此相关。}

背景

Badugi [bæduːɡiː]是低球平局扑克变种。

^{Pokerstars世界杯在线扑克$ 1K赛事在3小时内开始，我需要知道我的手牌有多好！}

该游戏使用52张标准卡组，其中包含四张西服和13张等级。西服是无序的，应加标签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 

每位玩家从牌组中获得四张纸牌，中间进行四次下注回合，其中四次下注回合（一位玩家始终拥有四张纸牌，他们可以选择将0-4张纸牌更换为每张庄家的新纸牌三个回合中的一个）。

如果在所有这些回合之后仍然有多个玩家处于活跃状态，则将出现对决，然后最强的手赢得下注赌注。

这场比赛是低球比赛，因此最低手数获胜，并且如上所述 A（ace）低。此外，手牌等级不同于其他形式的扑克，对于初学者而言可能有些混乱。

所打出的“手牌”是由尽可能多的“副手”（全副牌）和“副手”（全异手）牌（从四张持牌中）组成的最低等级组合）。也就是说：如果一个人拥有四张同时具有不同花色和等级的卡，则有人拥有四张手（称为“ badugi”）；如果一个人没有四张牌，但是确实有一组或三组，每张牌都有不同的花色和不同的等级，那么一个人有三张牌（最好选择一张）；如果一个人既没有四手牌，也没有三手牌，则可能有两手牌，但如果没有，则只有一手牌。

• 这样，最好的一手牌是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）。

  • 可以使用的另一张可能的三张牌 4c 3h 2c As是4-3-A，但是较弱（较高），所以未选择。

• 类似地，三张8d 6h 3s 2h牌的游戏方式为8-3-2-有两个大小为3的等级不合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）

挑战：

给定四张卡中的每张，有两个无序集合，找出赢得Badugi摊牌的那张（如果是平局，则同时识别两张）。

输入可以是任何合理的：

• 如上标记的所有八张卡的单个字符串（带或不带空格），左四只手为一只手，右手另一只手（具有可选的分隔符）；或以相同方式列出的字符
• 两个字符串的列表-每只手一个，或相同方式的字符列表
• 两个单独的字符串或列表输入，每只手一个
• 手中的牌可能也已经分开了（所以列表列表很好）

但是请注意：

• 在输入之前，卡片可能没有按照任何顺序排列
• ...并且西服和军衔被固定为此处指定的字符标签-如果您的语言不支持这种结构，请提出合理的建议，并在您的语言限制下询问是否可以接受。

输出应该是

• 格式与输入或其打印的表示相同；要么
• 是三个不同的和一致的结果的一个（例如："left"，"right"，"both"，或1，2，3等等）

确实-只要可以清楚识别出两个输入中的哪个，就可以了。

测试用例

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)

这是 代码高尔夫球，因此以语言为单位的最短代码以每种语言获胜，而总体上最短的代码以获胜。不要让打高尔夫球的语言让您推迟使用其他语言提交的内容，并且……玩得开心！

Perl 6、128字节

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

在线尝试！

拿出一手牌（也要多于两手），这些牌是像的字符串牌Kc。返回得分最低的手的索引。对于两只手，这是(0)如果第一手获胜，(1)如果第二手获胜，(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在平局的情况下。

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"），
返回两个数字的列表，分别标识获胜者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第二手获胜以及0平局，则返回。

该函数h计算代表手的列表。

Lambda比较手的两种表示。我认为它可能会缩短，但是我只想返回三个值，却没有找到一种更简单的比较方法。