^{แรงบันดาลใจจากความท้าทายนี้และที่เกี่ยวข้องกับคนนี้}

พื้นหลัง

Badugi [bæduːɡiː] เป็นตัวแปรโป๊กเกอร์วาดต่ำ

^{เหตุการณ์$ 1K Pokerstars World Cup Of Online Poker เริ่มต้นภายใน3ชั่วโมงและฉันต้องรู้ว่ามือของฉันดีแค่ไหน!}

เกมนี้ใช้สำรับมาตรฐาน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 

ผู้เล่นแต่ละคนจะแจกไพ่สี่ใบจากเด็คมีสี่รอบเดิมพันกับสามรอบในระหว่าง (ผู้เล่นมักมีไพ่สี่ใบพวกเขามีตัวเลือกในการเปลี่ยน 0-4 ของไพ่ของพวกเขาด้วยดีลเลอร์ใหม่จากแต่ละคน ของสามรอบการวาดภาพ)

หากผู้เล่นมากกว่าหนึ่งคนยังคงทำงานหลังจากรอบนี้มีการเปิดไพ่ดังนั้นมือที่แข็งแกร่งที่สุดชนะการเดิมพันแบบวางเดิมพัน

เกมนี้เล่นบอลต่ำดังนั้นมือที่ต่ำที่สุดชนะและตามที่กล่าวไว้ข้างต้น A(เอซ) ต่ำ นอกจากนี้การจัดอันดับมือแตกต่างจากโป๊กเกอร์รูปแบบอื่น ๆ และอาจสร้างความสับสนสำหรับผู้เริ่มต้น

"มือ" ที่เล่นเป็นชุดที่มีอันดับต่ำที่สุดที่ทำจากจำนวนสูงสุดของทั้ง "ชุดสูท" (ชุดที่แตกต่างกันทั้งหมด) และ "ชุดชั้นนอก" (ไพ่ชุดที่แตกต่างกันทั้งหมด) ที่เป็นไปได้ ) นั่นคือ: หากมีไพ่สี่ใบที่มีทั้งชุดที่แตกต่างกันและอันดับที่แตกต่างอย่างใดอย่างหนึ่งจะมีมือไพ่ 4 ใบ (เรียกว่า "badugi"); ถ้าไม่มีไพ่ 4 ใบ แต่มีชุดไพ่หรือชุดไพ่สามใบทั้งชุดที่แตกต่างกันและชุดที่แตกต่างกันอย่างใดอย่างหนึ่งมีไพ่ 3 ใบ (หนึ่งใบเลือกได้ดีที่สุด); ถ้าใครไม่มีไพ่ 4 ใบหรือไพ่ 3 ใบอย่างใดอย่างหนึ่งอาจมีมือ 2 ใบ แต่ถ้าไม่มีใครมีมือ 1 ใบ

• ดังนั้นไพ่ที่ดีที่สุดที่เป็นไปได้คือไพ่ 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- มีสองชุด off-rank off-suit ชุดขนาด 3 และ8-3-2ดีกว่า (ต่ำ) กว่า8-6-3ตั้งแต่สาม (หรือ "แต้ม") ต่ำกว่าหก

การเปรียบเทียบมือกันคือตรรกะเดียวกัน - ไพ่ 4 ใบใด ๆ ที่มีไพ่ 3 ใบใด ๆ ที่มีไพ่ 3 ใบจะมีไพ่ 2 ใบใด ๆ ที่มี 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 ไบต์

บันทึกแล้ว 7 ไบต์ขอบคุณ @Neil

รับอินพุตเป็นอาร์เรย์ของอาร์เรย์ของสตริง ผลตอบแทน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Ç€ṢṪµ€⁼€Ṁ$

ลิงก์แบบ monadic ที่รับรายการของตัวละครสองรายการ
- แต่ละอันเป็นช่องว่างคั่นด้วยมือ (เช่น"Ac 2d 4s 3h")
คืนรายการหมายเลขสองหมายเลขที่ระบุผู้ชนะด้วย1และผู้แพ้ที่มี0
- ie [1, 0]= left wins; [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]

ลองออนไลน์!

บันทึกแล้ว 3 ไบต์ขอบคุณ Jonathan Frech

ผลตอบแทน1ถ้ามือแรกชนะ-1ถ้ามือที่สองชนะและ0ในกรณีที่เสมอ

ฟังก์ชันhคำนวณรายการที่แสดงถึงมือ

แลมบ์ดาเปรียบเทียบมือสองภาพ ฉันคิดว่ามันอาจสั้นลง แต่ฉันต้องการคืนค่าสามค่าเท่านั้นและไม่พบวิธีที่ง่ายกว่าในการเปรียบเทียบ