लाठी बस्ट कैलकुलेटर

12

लाठी , जिसे इक्कीस के रूप में भी जाना जाता है, अपने और एक डीलर के बीच तुलना कार्ड गेम है, जहां प्रत्येक खिलाड़ी डीलर के खिलाफ प्रतिस्पर्धा करता है, लेकिन खिलाड़ी एक दूसरे के खिलाफ नहीं खेलते हैं।

प्ले निम्नानुसार है, डीलर आपको एक कार्ड प्रदान करता है। डीलर फिर उन्हें डील करता है-एक कार्ड, नीचे चेहरा। डीलर तब आपको दूसरा कार्ड प्रदान करता है। फिर अंत में, डीलर उन्हें सामना करता है-एक कार्ड, फेस-अप।

चुनौती

आपकी चुनौती एक प्रोग्राम (या फ़ंक्शन) लिखना है जिसे चलाने (या कॉल करने), आउटपुट (या रिटर्न) की संभावना है कि अगले कार्ड जो डीलर आपको देता है वह आपको बस्ट कर देगा, जिसका अर्थ है आपके हाथ में कार्ड का संचयी स्कोर डीलर आपको एक और कार्ड देता है जो 21 से अधिक है।

इनपुट

खेलने में तीन दिखाई देने वाले कार्ड। वे दो कार्ड हैं जो आपके हाथ में हैं, और एक चेहरा कार्ड आप डीलरों के हाथ में देख सकते हैं। यह आपके आवेदन के लिए उपयुक्त जो भी प्रारूप में हो सकता है।

एक डेक में 52 कार्ड हैं (नीचे प्रत्येक कार्ड में से 4)। कार्ड का मूल्य इस प्रकार है:

Symbol(Case Insensitive)  Name     Value
2                         Two      2
3                         Three    3
4                         Four     4
5                         Five     5
6                         Six      6
7                         Seven    7
8                         Eight    8
9                         Nine     9
T                         Ten      10
J                         Jack     10
Q                         Queen    10
K                         King     10
A or 1                    Ace      1

लाठी में, एक इक्का 1 या 11 के रूप में गिना जा सकता है। हमारी चुनौती में, इसे केवल 1 के रूप में गिना जा सकता है

उत्पादन

संभावना, एक अनुपात या प्रतिशत प्रारूप में, कि अगला कार्ड जो हमें आकर्षित करेगा वह हमें बस्ट करेगा।

आप प्रतिशत, अंश या अंश के मात्रक का उत्पादन कर सकते हैं।

उदाहरण

इस उदाहरण में, पहले दो कार्ड हमारे हाथ में हैं, तीसरा कार्ड डीलरों का दिखाई देने वाला कार्ड है

 Input          ->       Output

 A 2 Q          ->       0.00%  or  0/49 or 0
 A 2 3          ->       0.00%  or  0/49 or 0
 T T T          ->       91.84% or 45/49 or 91.84 
 T J K          ->       91.84% or 45/49 or 45
 9 7 3          ->       61.22% or 30/49 ...
 9 7 Q          ->       59.18% or 29/49 ...

नियम

मानक खामियों की अनुमति नहीं है।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf  card-games 
— DevelopingDeveloper
स्रोत
2
क्या हमें इक्का 1 के रूप में लेने की अनुमति है और 10 के रूप में कार्ड का सामना करना पड़ता है, या क्या यह इनपुट प्रारूप को बहुत दूर तक ले जाएगा?
तो, हम 10 के रूप में चेहरे कार्ड ले सकते हैं?
— '15
1
@Arnauld आपको पकड़ने के लिए धन्यवाद। मैंने अनुपात को अद्यतन किया लेकिन संभावनाओं को नहीं। आपके आउटपुट प्रश्न के लिए जैसा कि ठीक है। आपको प्रत्येक उत्तर पर / 49 नहीं जोड़ना है।
— विकासशील
1
"TJK -> 91.84% या 45/49 या 45 या आदि ..." - तो हम बस अंश का उत्पादन कर सकते हैं? यदि ऐसा है तो आप इसे पाठ में बता सकते हैं?
— जोनाथन एलन
1
@JonathanAllan अपडेट किया गया
— विकासशील

जवाबों:

7

जेली ,  26  24 बाइट्स

O%48«⁵µ13R«⁵ẋ4œ-+ṖS$>21S

एक monadic लिंक वर्ण (या तो लोअर केस विकल्प या साथ अपर-केस विकल्प का उपयोग करने की एक सूची को स्वीकार करने 1के लिए A) जो गणक (49 की संख्या रिटर्न वीं में है) [0,49]।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

ध्यान दें कि लोअर-केस का उपयोग करके न्यूनतम 10 और ऑर्डिनल्स मोडुलो 48 से कार्ड मान देता है। एक ही अपर-केस के लिए रखती है T, J, Q, Kऔर 1एक इक्का के लिए, दाईं ओर दिखाई देता है (लेकिन एक अपर-केस के रूप में Aकाम नहीं करता है):

     card:   a   2   3   4   5   6   7   8   9   t   j   q   k   |   1   T   J   Q   K
  ordinal:  97  50  51  52  53  54  55  56  57 116 106 113 107   |  49  84  74  81  75
   mod 48:   1   2   3   4   5   6   7   8   9  20  10  17  11   |   1  36  26  33  27
min(_,10):   1   2   3   4   5   6   7   8   9  10  10  10  10   |   1  10  10  10  10


O%48«⁵µ13R«⁵ẋ4œ-+ṖS$>21S - Link: list of characters   e.g. "q3a"
O                        - ordinals (of the input list)    [113, 51, 97]
 %48                     - modulo by 48                    [17,3,1]
     ⁵                   - ten
    «                    - minimum                         [10,3,1]
      µ                  - start a new monadic chain
       13R               - range of 13                     [1,2,3,4,5,6,7,8,9,10,11,12,13]
           ⁵             - ten                             10
          «              - minimum                         [1,2,3,4,5,6,7,8,9,10,10,10,10]
            ẋ4           - repeat four times               [1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10]
              œ-         - multi-set difference            [1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10,1,2,3,4,5,6,7,8,9,10,10,10,10  ,2  ,4,5,6,7,8,9   ,10,10,10]
                   $     - last two links as a monad:
                 Ṗ       -   pop                           [10,3]
                  S      -   sum                           13
                +        - add (vectorises)                [14,15,16,17,18,19,20,21,22,23,23,23,23,14,15,16,17,18,19,20,21,22,23,23,23,23,14,15,16,17,18,19,20,21,22,23,23,23,23,15,17,18,19,20,21,22,23,23,23]
                    >21  - greater than 21?                [0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1]
                       S - sum                             19
— जोनाथन एलन
स्रोत
फ्लैट-आउट चोरी करने का प्रलोभन mod-48 तकनीक को बढ़ाता है
— मैजिक ऑक्टोपस Urn
अगर मैं अंत में 48-mod का उपयोग करके एक उत्तर बनाता हूं तो मैं आपको महाकाव्य अवलोकन के लिए 200 का इनाम दे रहा हूं।
— मैजिक ऑक्टोपस Urn
4

जावास्क्रिप्ट (ईएस 6), 73 62 बाइट्स

1इक्के के लिए 3 वर्णों के एक सरणी के रूप में इनपुट लेता है । पूर्णांक X का प्रतिनिधित्व करता है जो कि संभावित X / 49 का प्रतिनिधित्व करता है ।

a=>([b,c]=a.map(v=>v*4||40)).map(n=>b-=n+b>52,b+=c-32)|b>12&&b

इसे ऑनलाइन आज़माएं!

थकावट का परीक्षण

गोल्फ का फॉर्मूला बहुत सहज नहीं है। तो, इसकी स्थिरता को साबित करने का सबसे आसान तरीका शायद एक मूल असंबद्ध कार्यान्वयन द्वारा प्रदान किए गए लोगों के खिलाफ सभी संभावित आउटपुट की तुलना करना है:

g = a => {
  deck = [...'123456789TJQK'.repeat(4)];
  a.forEach(card => deck.splice(deck.indexOf(card), 1));

  return deck.filter(card =>
    (+a[0] || 10) +
    (+a[1] || 10) +
    (+card || 10) > 21
  ).length;
}

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
.map(n=>b-=n+b>52,b+=c-32)सामान्य तौर पर क्या करता है? मैं जेएस से बहुत परिचित नहीं हूं .mapऔर यह समझने की कोशिश कर रहा हूं कि कॉमा यहां क्या करती है .. शुरू में मुझे हालांकि यह छोटा रूप है .map(n=>{b-=n+b>52;b+=c-32})या कुछ और .. मुझे पता है कि यह a=>([b,c]=a.map(v=>v*4||40))धर्मान्तरित ['1','2','Q']है [ 4, 8, 40 ], और फिर यह इन तीन मूल्यों से अधिक है, जहां bपहला मूल्य है , और cदूसरा है (यदि मैं सही ढंग से समझता हूं)। लेकिन मैं थोड़ा उलझन में हूँ .map(n=>b+=(n+b<53)-1,b+=c-32)(अगर पहली बार b-=बदला है b+=) बनाम .map(n=>b+=(n+b<53)-33+c)..
— केविन क्रूज़सेन
हम्म, या यह वास्तव में b= पहला मूल्य, c= दूसरा मूल्य है [4, 8, 40], और साथ ही साथ यदि यह दूसरा पुनरावृत्ति है, तो क्या यह b-=n+b>52संशोधित होता है c? किस मामले में b-=और b+=एकल b+=(या b-=) दोनों के संयोजन के कारण काम नहीं करेगा?
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन b+=c-32इसका (अप्रयुक्त) पैरामीटर है map()और पहले पुनरावृत्ति से पहले केवल एक बार मूल्यांकन किया जाता है। n=>b-=n+b>52कॉलबैक फ़ंक्शन (1 पैरामीटर का map()) है और इसे प्रत्येक पुनरावृत्ति पर बुलाया जाता है। तकनीकी रूप से, map()दूसरा पैरामीटर स्वीकार करता है (जिसे इसआर्ग कहा जाता है ), लेकिन यह यहां अप्रासंगिक है: हम बस चाहते हैं कि लूप शुरू होने से पहले इस कोड को निष्पादित किया जाए।
— अरनुलद
1
@ केविनक्रूजसेन यहाँ कुछ कोड दिखा रहा है कि क्या चल रहा है।
— अरनौलद
आह ठीक है, अब यह सब समझ में आता है। धन्यवाद!
— केविन क्रूज़सेन
2

पायथ, 35 बाइट्स

Jm?}dGTsdQclf>T-21sPJ.-*4+ST*3]TJ49

वर्णों की सूची (या स्ट्रिंग के रूप में) के रूप में इनपुट लेता है।
इसे यहाँ आज़माएँ

व्याख्या

Jm?}dGTsdQclf>T-21sPJ.-*4+ST*3]TJ49
Jm?}dGTsdQ                            Convert each input to the appropriate number.
                     .-*4+ST*3]TJ     Remove each from the deck.
           lf>T-21sPJ                 Count how many remaining cards bust.
          c                      49   Get the probability.
1

पायथन 2 , 97 96 बाइट्स

def f(s):C=[min(int(c,36),10)for c in s];D=C[0]+C[1];return(4*D-35+sum(v+D<22for v in C))*(D>11)

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में एक 3-वर्ण स्ट्रिंग लेता है, जिसमें '1' का उपयोग ऐस के रूप में किया जाता है। अंश लौटाता है।

— चास ब्राउन
स्रोत
1

जावा 8, 109 बाइट्स

a->{int r=3;for(;r-->0;a[r]=a[r]<59?a[r]*4-192:40);r=a[0]+a[1]-32;for(int v:a)r-=v+r>52?1:0;return r>12?r:0;}

पोर्ट @Arnauld का जावास्क्रिप्ट (ES6) उत्तर ।
तीन मूल्यों के साथ चरित्र-सरणी के रूप में इनपुट, इक्के के रूप में '1'; उत्पादन में संभावना pहै p/49।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

a->{                   // Method with integer-array as parameter and integer return-type
  int r=3;for(;r-->0;  //  Loop over the array
    a[r]=a[r]<59?      //   If the current item is a digit:
          a[r]*4-192   //    Multiply it by 4
         :             //   Else:
          40);         //    Change it to 40
  r=a[0]+a[1]-32;      //  Set `r` to the first value, plus the second value, minus 32
  for(int v:a)         //  Loop over the now modified array again
    r-=v+r>52?         //   If the current value plus `r` is larger than 52
        1              //    Decrease the result-integer by 1
       :0;             //   Else: Leave the result-integer the same
  return r>12?         //  If the result-integer is larger than 12
          r            //   Return the result-integer
         :             //  Else:
          0;}          //   Return 0
— केविन क्रूज़सेन
स्रोत
1

05AB1E , 23 22 21 बाइट्स

AST:4-D¨OÐ4@*4*Š+T@O-

इसे ऑनलाइन आज़माएं!

AST:                   # replace all letters in the input with 10
    4-                 # subtract 4 from each card value
      D                # duplicate
       ¨               # drop the last element
        O              # sum (hand value of the player - 8)
         Ð             # triplicate that
          4@*          # set to 0 if it's less than 4
             4*        # multiply by 4
               Š       # 3-way swap
                +      # add the player's hand value to each card value
                 T@O   # count how many are >= 10
                    -  # subtract
— ग्रिमी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.