^{Lấy cảm hứng từ thử thách này và liên quan đến cái này .}

Lý lịch

Badugi [bæduːɡiː] là một biến thể rút bóng thấp.

^{Sự kiện $ 1K Poker trực tuyến World Cup của Pokerstars bắt đầu trong vòng 3 giờ và tôi sẽ cần phải biết tay của mình tốt như thế nào!}

Trò chơi sử dụng một bộ bài tiêu chuẩn gồm 52 lá bài gồm bốn bộ đồ và mười ba cấp bậc. Các bộ quần áo không có thứ tự và sẽ được dán nhãn cdhs; các cấp bậc - được sắp xếp từ cao nhất Kđến thấp nhất A- là KQJT98765432A. Do đó, toàn bộ boong có thể được biểu diễn như sau (không gian được phân tách):

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 

Mỗi người chơi được chia bốn thẻ từ bộ bài, có bốn vòng đặt cược với ba vòng rút ở giữa (một người chơi luôn có bốn thẻ, họ có tùy chọn đổi 0-4 thẻ của mình bằng thẻ mới từ mỗi người chia bài của ba vòng vẽ).

Nếu có nhiều hơn một người chơi vẫn còn hoạt động sau tất cả các vòng đấu đó, sẽ có một trận đấu, trong đó tay bài mạnh nhất sẽ thắng các cược đặt cược.

Trò chơi được chơi bóng thấp, do đó tay thấp nhất sẽ thắng, và như đã đề cập ở trên A(ace) là thấp. Hơn nữa, xếp hạng tay khác với các hình thức poker khác, và có thể hơi khó hiểu cho người mới bắt đầu.

"Tay" đã chơi là sự kết hợp xếp hạng thấp nhất được tạo từ số lượng cao nhất của cả hai thẻ "off-suit" (tất cả các bộ khác nhau) và "off-rank" (tất cả các cấp bậc khác nhau) có thể (từ bốn thẻ được giữ ). Đó là: nếu một người giữ bốn thẻ gồm cả hai bộ quần áo riêng biệt và cấp bậc riêng biệt thì một người có một tay 4 thẻ (được gọi là "badugi"); nếu một người không có tay 4 thẻ nhưng có một số bộ hoặc ba thẻ gồm cả hai bộ quần áo riêng biệt và cấp bậc riêng biệt thì một người có một tay 3 thẻ (một người chọn tốt nhất); nếu một người không có tay 4 thẻ hoặc tay 3 thẻ thì có thể có tay 2 thẻ, nhưng nếu không có tay 1 thẻ.

• Như vậy, tay tốt nhất có thể là tay 4 thẻ - thẻ giảm hạng4-3-2-A thấp nhất trong bốn bộ đồ khác nhau , thường được gọi là "số 1". Tay yếu nhất có thể là tay 1 thẻ và chỉ có thể bằng cách cầm chính xác .KKc Kd Kh Ks

• Lưu ý rằng 4c 3h 2c Aslà không một "số 1", kể từ khi 4cvà 2clà những bộ đồ giống nhau, nhưng nó là mạnh nhất của bàn tay 3 thẻ, 3-2-A, nó thu hút với khác 3-2-1s (như Kh 3d 2s Ah) và đánh bại tất cả các tay 3 thẻ khác nhưng thua tất cả các tay bài 4 lá (có thể yếu như K-Q-J-T).

  • Tay 3 thẻ khác có thể được tạo ra 4c 3h 2c Aslà 4-3-A, nhưng nó yếu hơn (cao hơn) nên không được chọn.

• Tương tự 8d 6h 3s 2hlà một tay bài 3 lá được chơi như 8-3-2- có hai kết hợp ngoài bộ đồ ngoài cỡ 3 và 8-3-2tốt hơn (thấp hơn) so với 8-6-3ba (hoặc "trey") thấp hơn sáu.

Việc so sánh các tay bài với nhau theo cùng một logic - bất kỳ 4 thẻ nào cũng đánh bại 3 thẻ bất kỳ, bất kỳ 3 thẻ nào cũng đánh bại 2 thẻ và bất kỳ 2 thẻ nào đánh bại bất kỳ 1 thẻ nào, trong khi các tay có cùng số thẻ được sử dụng là được so sánh từ thứ hạng cao nhất của họ xuống mức thấp nhất của họ (ví dụ: 8-4-2nhịp 8-5-Anhưng không phải bất kỳ 8-4-A, 8-3-2hoặc 7-6-5)

Các thách thức:

Cho hai bộ sưu tập không có thứ tự mỗi bốn thẻ, xác định một trong số đó giành chiến thắng trong trận đấu Badugi (xác định cả hai nếu đó là một trận hòa).

Đầu vào có thể là bất cứ điều gì hợp lý:

• một chuỗi gồm tất cả tám thẻ như được dán nhãn ở trên (có hoặc không có dấu cách) với bốn bên trái là một tay và bên phải (với một dấu tách tùy chọn); hoặc một danh sách các nhân vật trong cùng một thời trang
• một danh sách hai chuỗi - mỗi chuỗi một tay hoặc danh sách các danh sách các ký tự theo cùng một kiểu
• hai chuỗi riêng biệt hoặc danh sách đầu vào, mỗi đầu một
• các thẻ trong tay cũng có thể được tách ra (vì vậy một danh sách các danh sách là tốt)

Lưu ý, tuy nhiên:

• các thẻ có thể không được sắp xếp theo bất kỳ thứ tự nào trước khi nhập
• ... và các bộ quần áo và cấp bậc được cố định là nhãn ký tự được chỉ định ở đây - Nếu ngôn ngữ của bạn không hỗ trợ các cấu trúc như vậy, chỉ đề xuất một cái gì đó hợp lý và hỏi xem đó có phải là một sự thay thế chấp nhận được với các ràng buộc ngôn ngữ của bạn không.

Đầu ra phải là

• được định dạng giống như đầu vào, hoặc một đại diện được in; hoặc là
• là một trong ba kết quả khác biệt và phù hợp (ví dụ như: "left", "right", "both", hoặc 1, 2, 3, vv)

Thực sự - miễn là rõ ràng cái nào trong hai đầu vào đang được xác định thì nó sẽ ổn.

Các trường hợp thử nghiệm

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)

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte sẽ thắng trên mỗi ngôn ngữ và mã ngắn nhất sẽ thắng chung. Đừng để ngôn ngữ chơi gôn khiến bạn không thể gửi bằng các ngôn ngữ khác và ... vui chơi!

Perl 6 , 128 byte

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

Hãy thử trực tuyến!

Có một danh sách các tay (cũng nhiều hơn hai) là danh sách các thẻ có chuỗi như thế nào Kc. Trả về các chỉ số của tay với số điểm thấp nhất. Đối với hai tay thì đây là (0)nếu ván thứ nhất thắng, (1)nếu ván thứ hai thắng và (0, 1)cho một trận hòa.

Giải thích:

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

Đã lưu 7 byte nhờ @Neil

Đưa đầu vào như một mảng các chuỗi của chuỗi. Trả về truenếu ván thứ nhất thắng, falsenếu ván thứ hai thắng hoặc 2trong trường hợp hòa.

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)

Các trường hợp thử nghiệm

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)

Làm sao?

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
)

Thạch , 36 byte

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

Một liên kết đơn thể lấy một danh sách gồm hai danh sách các ký tự
- mỗi danh sách là một đại diện được phân tách bằng dấu cách (ví dụ "Ac 2d 4s 3h")
trả về một danh sách gồm hai số xác định (các) người chiến thắng với 1và bất kỳ người thua nào có 0
- tức là [1, 0]= thắng trái; [0, 1]= thắng đúng; [1, 1]= vẽ.

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm .

Làm sao?

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

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]

Hãy thử trực tuyến!

Đã lưu 3 byte nhờ Jonathan Frech

Trả về 1nếu ván thứ nhất thắng, -1nếu ván thứ hai thắng và 0trong trường hợp hòa.

Hàm htính toán một danh sách đại diện cho bàn tay.

Lambda so sánh hai đại diện của bàn tay. Tôi nghĩ rằng nó có thể được rút ngắn, nhưng tôi chỉ muốn trả về ba giá trị và không tìm thấy một cách đơn giản hơn để so sánh.