बडुगी, कौन जीता?

9

इस चुनौती से प्रेरित है और इस एक से संबंधित है ।

पृष्ठभूमि

बडुगी [bugduːɡiː] एक लो-बॉल ड्रा-पोकर संस्करण है।

ऑनलाइन पोकर $ 1K घटना का पोकरस्टार्स विश्व कप 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-कार्ड हाथ होता है (जिसे "बडुगी" कहा जाता है); यदि किसी के पास 4-कार्ड हाथ नहीं है, लेकिन उसके पास अलग-अलग सूट और अलग - अलग रैंक के तीन कार्डों के कुछ सेट या सेट हैं, तो एक में 3-कार्ड हाथ है (एक अपना सर्वश्रेष्ठ चुनता है); यदि किसी के पास न तो 4-कार्ड हाथ है और न ही 3-कार्ड हाथ है, तो शायद 2-कार्ड हाथ है, लेकिन यदि किसी के पास 1-कार्ड हाथ नहीं है।

  • जैसा कि सबसे अच्छा संभव हाथ 4-कार्ड हाथ है 4-3-2-A- चार अलग - अलग सूट के सबसे कम -रैंक वाले कार्ड , जिसे अक्सर "नंबर -1" कहा जाता है। सबसे कमजोर संभव हाथ 1-कार्ड हाथ होगा Kऔर केवल ठीक से पकड़कर संभव है Kc Kd Kh Ks।

  • ध्यान दें कि 4c 3h 2c Asहै नहीं एक "नंबर -1", के बाद से 4cऔर 2cएक ही सूट के हैं, लेकिन यह है 3-कार्ड हाथ के सबसे मजबूत, 3-2-Aहै, यह दूसरे के साथ ड्रॉ 3-2-1रों (तरह 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 के दो ऑफ-रैंक ऑफ-सूट संयोजन हैं और तीन (या "ट्रे") की तुलना में 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)

चुनौती:

चार कार्डों में से प्रत्येक को दो अव्यवस्थित-संग्रह को देखते हुए, एक (ओं) की पहचान करें, जो एक बदूगी तसलीम को जीतते हैं (दोनों की पहचान करें यदि यह एक ड्रॉ है)।

इनपुट कुछ भी उचित हो सकता है:

  • सभी आठ कार्डों की एक स्ट्रिंग के रूप में ऊपर के साथ (या रिक्त स्थान के बिना) बाएं चार एक हाथ और दूसरे के साथ दाईं ओर (एक वैकल्पिक विभाजक के साथ); या एक ही फैशन में पात्रों की एक सूची
  • दो तार की एक सूची - एक प्रति हाथ, या एक ही फैशन में पात्रों की सूची की एक सूची
  • दो अलग तार या सूची आदानों, एक हाथ प्रति
  • हाथों के कार्ड पहले से ही अलग हो सकते हैं (इसलिए सूचियों की सूची ठीक है)

नोट, हालांकि:

  • इनपुट से पहले कार्डों को किसी भी क्रम में व्यवस्थित नहीं किया जा सकता है
  • ... और सूट और रैंक यहां निर्दिष्ट वर्ण लेबल के रूप में तय किए गए हैं - यदि आपकी भाषा ऐसे निर्माणों का समर्थन नहीं करती है तो बस कुछ उचित सुझाव दें और पूछें कि क्या यह स्वीकार्य विकल्प है, जो आपकी भाषाओं में बाधा है।

आउटपुट या तो होना चाहिए

  • इनपुट के रूप में एक ही स्वरूपित किया गया, या उसके बाद एक मुद्रित प्रतिनिधित्व; या
  • के पास तीन अलग और संगत परिणामों में से एक हो (जैसे: "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)

ये है कोड गोल्फ, इसलिए बाइट्स में सबसे छोटा कोड प्रति भाषा जीतता है, और सबसे छोटा कोड समग्र जीतता है। गोल्फिंग भाषाओं को अन्य भाषाओं में सबमिट करने से न दें, और मज़े करें!

code-golf  string  decision-problem  game  card-games 
— जोनाथन एलन
स्रोत
क्या कुछ [['3c', '2s', '4d', 'Ah'], ['As', '3h', '2d', '4h']]उचित है?
— आउटगॉल्फ
@EriktheOutgolfer हां - मैं यह कहने जा रहा था कि मुझे लगता है कि आप बस Oसामने जोड़ सकते हैं ।
— जोनाथन एलन

जवाबों:

2

पर्ल 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
}
— nwellnhof
स्रोत
ब्याज से बाहर <...>अपने परीक्षण दोहन तार की एक सूची में अनुवाद कैसे करता है? क्या यह किसी प्रकार की चीनी है जो कहती है कि सामग्री को रिक्त स्थान पर विभाजित किया जाना चाहिए?
— जोनाथन एलन
@JonathanAllan यह पर्ल का शब्द है । पर्ल 6 पर्ल से 5 के <a b c>अलावा समर्थन करता है qw(a b c)।
— nwellnhof
खैर यह अपने आप में अच्छा और गोल्फ है :)
— जोनाथन एलन
2

जावास्क्रिप्ट (ईएस 6), 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)

परीक्षण के मामलों

कोड स्निपेट दिखाएं

कैसे?

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
)
— Arnauld
स्रोत
क्या आपको इसकी आवश्यकता है join?
— नील
1

जेली , 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)
— जोनाथन एलन
स्रोत
1

पायथन 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 बाइट्स धन्यवाद से बचाया

रिटर्न 1अगर पहले हाथ जीत, -1अगर दूसरा हाथ जीत और 0एक ड्रॉ के मामले में।

फ़ंक्शन hएक सूची की गणना करता है जो हाथ का प्रतिनिधित्व करता है।

लैम्ब्डा हाथ के दो अभ्यावेदन की तुलना करता है। मुझे लगता है कि इसे छोटा किया जा सकता है, लेकिन मैं केवल तीन मूल्यों को वापस करना चाहता था और तुलना करने का एक सरल तरीका नहीं मिला।

— jferard
स्रोत
आप L=lenके lenसाथ अन्य सभी घटनाओं को परिभाषित और प्रतिस्थापित करके दो बाइट्स बचा सकते हैं L।
— जोनाथन फ्रेच
इसके अलावा, आप शायद जगह ले सकता है s=set()के साथ s={0}और set(x)&s orसाथs&set(x)or
— जोनाथन frech
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.