मध्य शरद ऋतु महोत्सव जुआ खेल

Question

कल मध्य शरद ऋतु का त्योहार है, और उस छुट्टी की भावना में, मैं एक जुआ खेल शुरू करूँगा जिसे हम ( ज़ियामी लोग ) छुट्टी के दौरान खेलते हैं!

नियम

खेल छह 6-पक्षीय पासा के साथ खेला जाता है। संख्याओं के विभिन्न संयोजनों में अलग-अलग रैंक होते हैं, जिसमें चौकों और विशेष पर जोर होता है। आपका काम एक प्रोग्राम / फ़ंक्शन लिखना है जो हाथ को रैंक करेगा, 6 पासा का रोल दिया जाएगा। यहाँ रैंक हैं (मैंने नियमों को थोड़ा संशोधित / सरल किया है):

मुझे लगता है कि केवल चीनी लोग इस चुनौती को कर सकते हैं! ठीक है, ठीक है, यहाँ कुछ अंग्रेजी स्पष्टीकरण दिए गए हैं।

• 0: 4 चौके और 2 चौके।
• 1: 6 चौके।
• 2: 6 वाले।
• 4: 4 के अलावा किसी भी तरह का 6।
• 4: 5 चौके।
• 5: 4 के अलावा किसी भी तरह का 5।
• 6: 4 चौके।
• 7: सीधे। (1-6)
• 8: 3 चौके।
• 9: 4 को छोड़कर किसी भी तरह का 4।
• 10: 2 चौके।
• 11: 1 चार।
• 12: कुछ नहीं।

इनपुट

6 संख्या, 6 संख्याओं की एक सरणी या 6 संख्याओं की एक स्ट्रिंग जो 1-6 से 6 पासा रोल के मूल्यों का प्रतिनिधित्व करती है

उत्पादन

आपका कार्यक्रम / फ़ंक्शन रैंक को इंगित करने के लिए कुछ भी वापस कर सकता है / कर सकता है, जब तक कि प्रत्येक रैंक को एक आउटपुट द्वारा इंगित किया जाता है और इसके विपरीत। पूर्व। 0-12, 1-13 आदि संख्याओं का उपयोग करना।

उदाहरण (आउटपुट के रूप में 0-12 का उपयोग करते हुए)

[1,1,1,1,1,1]->2
[1,4,4,4,1,4]->0
[3,6,5,1,4,2]->7
[1,2,3,5,6,6]->12
[3,6,3,3,3,3]->5
[4,5,5,5,5,5]->5

यह कोड-गोल्फ है, इसलिए सबसे छोटी बाइट गिनती जीतती है!

Comments

(मैं इसे सैंडबॉक्स में डालूंगा, लेकिन मैं चाहता था कि समय सही हो। मैंने यथासंभव पूरी कोशिश की, कृपया मुझे बताएं कि क्या कोई स्पष्टीकरण आवश्यक है।)

— क्विंटेक

@ शिग्गी तो ओपी का कहना है कि आउटपुट 0-12 या 1-13 के बजाय

— शायरु असकोतो

@ शैग्गी जैसा कि मैंने सवाल में कहा है, आउटपुट के लिए जरूरी नहीं कि वह लेबल नंबर के साथ मेल खाए। छवि में छोड़ दी गई संख्या और यादृच्छिक अंतराल नियमों को थोड़ा सरल बनाने के लिए हैं - इस परंपरा के लिए वास्तव में निश्चित नियम नहीं हैं, यह सिर्फ मेरी व्याख्या है।

— क्विंटेक

यह नहीं होना चाहिए [1,2,3,5,6,6]->13??

— जे। सेप

@ J.Doe उदाहरण / परीक्षण-मामले मूल्यों के बजाय सूचकांकों का उपयोग करते हैं। मूल्यों के विपरीत, 10छोड़ नहीं है।

— केविन क्रूज़सेन

Answer 1

चारकोल , 55 बाइट्स

≡⌈Ｅθ№θι⁶Ｉ⁻²⌕14§θχ⁵Ｉ⁻⁵⁼⁵№θ4⁴⎇⁼№θ4⁴§60⁼№θ1²9¹7Ｉ⁻¹²⌊⊘Ｘ²№θ4

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नहीं छोड़ता है 10. स्पष्टीकरण:

≡⌈Ｅθ№θι

किसी भी अंक की उच्चतम आवृत्ति की गणना करें।

⁶Ｉ⁻²⌕14§θχ

यदि एक प्रकार का 6 है, तो 142 से स्ट्रिंग में अंक की स्थिति को घटाएं। 6 में से 1 में यह परिणाम 4 के लिए 2, 6 के लिए 2 और कुछ के 6 के लिए 3 है।

⁵Ｉ⁻⁵⁼⁵№θ4

यदि एक प्रकार का 5 है, तो परिणाम 5 है जब तक कि 5 डीएस नहीं हैं, जिस स्थिति में 1 घटाया जाता है।

⁴⎇⁼№θ4⁴§60⁼№θ1²9

यदि एक प्रकार का 4 है, तो यदि 4 4s हैं तो परिणाम 6 है जब तक कि 2 1s नहीं होते हैं जिसमें परिणाम 0 होता है, अन्यथा परिणाम 9 होता है।

¹7

यदि सभी अंक अलग-अलग हैं तो परिणाम 7 है।

Ｉ⁻¹²⌊⊘Ｘ²№θ4

अन्यथा परिणाम 12 है - (4 >> (3 - # of 4s))।

Comments

यह सबसे कम उत्तर को स्वीकार करने के लिए सबसे अच्छा अभ्यास प्रतीत होता है, इसलिए मैं यही करूँगा :) दुर्भाग्य से बहुत से लोगों ने आपके उत्तर को नहीं देखा और

— उत्थान किया

@ क्विंट एक समस्या नहीं है; लोगों को एल्गोरिथ्म या अन्य कारक की सरलता के आधार पर उत्तरों को उभारना चाहिए जो उन्हें उत्तर की सराहना करते हैं।

— नील

Answer 2

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

a=>a.map(o=n=>[x=o[n]=-~o[n],6,,,21,9,8^o[1]][a=x<a?a:x])[5]|[,1,4,5,o[1]&2|8,2,4][o[4]]

इसे ऑनलाइन आज़माएं! या सभी संभावित रोल का परीक्षण करें!

निम्नलिखित मानचित्रण के अनुसार एक पूर्णांक को आउटपुट करता है:

 Rank | Output       Rank | Output
------+--------     ------+--------
   0  |  31            7  |   7
   1  |  12            8  |   5
   2  |  14            9  |  21
   3  |   8           10  |   4
   4  |  11           11  |   1
   5  |   9           12  |   0
   6  |  29

कैसे?

तरीका

बिटवाइस या बीच में प्रदर्शन करके आउटपुट की गणना की जाती है:

• $F$
• $M$

अपवाद:

• $F=4$$4b$$4a$
• $M=6$$6b$$6a$

तालिका

$F$$M$

$$\begin{array}{c|c|cccccccc} &F&0&1&2&3&4a&4b&5&6\\ \hline M&\text{OR}&0&1&4&5&8&10&2&4\\ \hline 1&6&\color{grey}{6}&\color{blue}{\textbf{7}}&\color{grey}{6}&\color{grey}{7}&\color{grey}{14}&\color{grey}{14}&\color{grey}{6}&\color{grey}{6}\\ 2&0&\color{blue}{\textbf{0}}&\color{blue}{\textbf{1}}&\color{blue}{\textbf{4}}&\color{grey}{5}&\color{grey}{8}&\color{grey}{10}&\color{grey}{2}&\color{grey}{4}\\ 3&0&\color{blue}{\textbf{0}}&\color{blue}{\textbf{1}}&\color{blue}{\textbf{4}}&\color{blue}{\textbf{5}}&\color{grey}{8}&\color{grey}{10}&\color{grey}{2}&\color{grey}{4}\\ 4&21&\color{blue}{\textbf{21}}&\color{blue}{\textbf{21}}&\color{blue}{\textbf{21}}&\color{grey}{21}&\color{blue}{\textbf{29}}&\color{blue}{\textbf{31}}&\color{grey}{23}&\color{grey}{21}\\ 5&9&\color{blue}{\textbf{9}}&\color{blue}{\textbf{9}}&\color{grey}{13}&\color{grey}{13}&\color{grey}{9}&\color{grey}{11}&\color{blue}{\textbf{11}}&\color{grey}{13}\\ 6a&8&\color{blue}{\textbf{8}}&\color{grey}{9}&\color{grey}{12}&\color{grey}{13}&\color{grey}{8}&\color{grey}{10}&\color{grey}{10}&\color{blue}{\textbf{12}}\\ 6b&14&\color{blue}{\textbf{14}}&\color{grey}{15}&\color{grey}{14}&\color{grey}{15}&\color{grey}{14}&\color{grey}{14}&\color{grey}{14}&\color{grey}{14}\\ \end{array}$$

$M\ge3$$M\le3$$M$$F=3$

उदाहरण

$M=1$$F=1$

$$6 \text{ OR } 1 = 7$$

$7$$7$

टिप्पणी की गई

a =>                   // a[] = input array, reused as an integer to keep track of the
  a.map(               //       maximum number of occurrences of the same dice (M)
    o =                // o = object used to count the number of occurrences of each dice
    n =>               // for each dice n in a[]:
    [                  //   this is the lookup array for M-bitmasks:
      x =              //     x = o[n] = number of occurrences of the current dice
        o[n] = -~o[n], //     increment o[n] (we can't have M = 0, so this slot is not used)
      6,               //     M = 1 -> bitmask = 6
      ,                //     M = 2 -> bitmask = 0
      ,                //     M = 3 -> bitmask = 0
      21,              //     M = 4 -> bitmask = 21
      9,               //     M = 5 -> bitmask = 9
      8 ^ o[1]         //     M = 6 -> bitmask = 14 for six 1's, or 8 otherwise
    ][a =              //   take the entry corresponding to M (stored in a)
        x < a ? a : x] //   update a to max(a, x)
  )[5]                 // end of map(); keep the last value
  |                    // do a bitwise OR with the second bitmask
  [                    // this is the lookup array for F-bitmasks:
    ,                  //   F = 0 -> bitmask = 0
    1,                 //   F = 1 -> bitmask = 1
    4,                 //   F = 2 -> bitmask = 4
    5,                 //   F = 3 -> bitmask = 5
    o[1] & 2 | 8,      //   F = 4 -> bitmask = 10 if we also have two 1's, 8 otherwise
    2,                 //   F = 5 -> bitmask = 2
    4                  //   F = 6 -> bitmask = 4
  ][o[4]]              // take the entry corresponding to F (the number of 4's)

Answer 3

आर , 100 बाइट्स

अनुक्रमित सशर्तों के एक समूह के रूप में स्कोर को एनकोड करें। मेरे पहले कड़े-रेगेक्स दृष्टिकोण की तुलना में सरल।

संपादित करें- फिक्स्ड बग और अब सभी रोल रैंक।

function(d,s=sum(d<2))min(2[s>5],c(11,10,8,6-6*!s-2,4,1)[sum(d==4)],c(7,12,12,9,5,3)[max(table(d))])

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

Answer 4

जावास्क्रिप्ट (Node.js) , 169 बाइट्स

a=>-~"114444|123456".search(w=a.sort().join``,[l,t]=/(.)\1{3,}/.exec(w)||[0],l=l.length)||(l>5?3-"14".search(t):l>3?4+(5.5-l)*(t-4?4:2):[,13,12,11,9][w.split`4`.length])

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

रिटर्न 1..13

Answer 5

पायथन 2 ,  148  119 बाइट्स

-27 बाइट्स ओवेस के लिए धन्यवाद (1. उपयोग करने की .countअनुमति देने का mapउपयोग। 2. 0स्लाइस में निरर्थक को हटाने ; 3. एक के inबजाय का उपयोग max; 4. 4. को छोटा कर (F==4)*O==2दिया F==4>O==2[क्योंकि गोल्फ के लिए F>3>O>1]

C=map(input().count,range(1,7))
O,F=C[::3]
print[F>3>O>1,F>5,O>5,6in C,F>4,5in C,F>3,all(C),F>2,4in C,F>1,F,1].index(1)

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

Comments

@ ओव्स हेह .count> _ <अच्छा

— जोनाथन एलन

एक अंतिम सुझाव: जैसा dकि केवल एक की जरूरत है, यह एक पूर्ण कार्यक्रम के रूप में छोटा है ।

— 14:14 बजे अंडा

पायथन 3 संस्करण : 131 बाइट्स

— Adirio

@ovs - आपके सभी गोल्फ के लिए धन्यवाद। बूट करने के लिए एक और दो को बचाया।

— जोनाथन एलन

होगा प्यार अजगर सशर्त जंजीरों! इसके अलावा, कल्पना अब संख्या 10 नहीं

— छोड़ती है

Answer 6

अजगर, 60 बाइट्स

eS[@[ZhZ2 4*6hq2hJuXtHG1Qm0Q8hT)@J3*5hSJ*Tq6hJ*<3KeSJ@j937TK

नक्शे को उलटा रैंक, 0-12। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

पूर्ण मैपिंग का उपयोग निम्नानुसार है:

12: 4 fours and 2 ones.
11: 6 fours.
10: 6 ones.
 9: 6 of any kind except fours and ones.
 8: 5 fours.
 7: 5 of any kind except for fours.
 6: 4 fours.
 5: Straight. (1-6)
 4: 3 fours.
 3: 4 of any kind except 4.
 2: 2 fours.
 1: 1 four.
 0: Nothing.

यह पासा मानों को आवृत्तियों पर मैप करके काम करता है, फिर कई नियमों के मूल्य की गणना करता है, और सेट का अधिकतम लेता है।

Implicit: Q=eval(input()), Z=0, T=10

JuXtHG1Qm0Q   Input mapping
 u     Q      Reduce each element of the input, as H, ...
        m0Q   ...with initial value, G, as an array of 6 zeroes (map each roll to 0)
   tH           Decrement the dice roll
  X  G1         Add 1 to the frequency at that point
J             Store the result in J

@[ZhZ2 4*6hq2hJuXtHG1Qm0Q8hT)@J3   Rule 1 - Values for sets including 4
  Z                               *0
   hZ                             *1 (increment 0)
     2                            *2
       4                          *4
              JuXtHG1Qm0Q          Input mapping (as above)
             h                     First value of the above - i.e. number of 1's
           q2                      1 if the above is equal to 2, 0 otherwise
        *6h                       *Increment and multiply by 6
                                   Maps to 12 if there are 2 1's, 6 otherwise
                         8        *8
                          hT      *11 (increment 10)
 [                          )      Wrap the 7 starred results in an array
                             @J3   Get the 4th value of the input mapping - i.e. number of 4's
@                                  Get the value at that position in the array

*5hSJ   Rule 2 - Straight
  hSJ   Smallest frequency in input mapping (first, sort, J)
        For a straight, smallest value will be 1, 0 otherwise
*5      Multiply by 5

*Tq6hJ   Rule 3 - 6 1's
    hJ   Frequency of 1's (first value from input mapping)
  q6     1 if the above == 6, 0 otherwise
*T       Multiply by 10

*<3KeSJ@j937TK   Rule 4 - 4,5,6 of a kind, other than 4's
   KeSJ          Get the max frequency from input mapping, store in K
        j937T    [9,3,7]
       @     K   Get the element at K'th position in the above (modular indexing)
 <3K             1 if 3<K, 0 otherwise
*                Multiply the previous 2 results

eS[   Wrapping it all up!
  [   Wrap all the above rules in an array
eS    Take the max value of the above, implicit print

Answer 7

रेटिना , 137 126 बाइट्स

4
A
O`.
^11A+
0
1+$
2
^A+
1
(.)\1{5}
3
^.A+
4
.?(.)\1{4}.?
5
^..A+
6
12356A
7
.+AAA$
8
.*(.)\1{3}.*
9
.+AA$
10
.+A$
11
.{6}
12

-11 बाइट्स @ @ नील को धन्यवाद ।

आउटपुट 0-अनुक्रमित ( 0..12) है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

हर 4 को 'A' से बदलें:

4
A

सभी इनपुट-अंकों को क्रमबद्ध करें (A सबसे पीछे होगा):

O`.

हर दूसरी दो लाइनें इनपुट को अपेक्षित आउटपुट से बदल देती हैं:

Regex         Replacement  Explanation

^11A+         0            starts with "11", followed by any amount of A's
1+$           2            ends with any amount of 1s
^A+           1            starts with any amount of A's
(.)\1{5}      3            six of the same characters
^.A+          4            starts with any character, followed by any amount of A's
.?(.)\1{4}.?  5            five of the same characters,
                           with optionally a leading or trailing character
^..A+         6            starts with any two characters, followed by any amount of A's
12356A        7            literal "12356A" match
.+AAA$        8            any amount of leading characters, ending with three A's
.*(.)\1{3}.*  9            four of the same characters,
                           with optionally any amount of leading/trailing chars
.+AA$         10           any amount of leading characters, ending with two A's
.+A$          11           any amount of leading characters, ending with a A
.{6}          12           any six characters

Comments

बहुत चालाक है, लेकिन मुझे लगता है कि आप एक कदम आगे जा सकते हैं और 4सीमा के बाहर किसी चीज़ से प्रतिस्थापित कर सकते हैं 1-6ताकि इसे एक छोर पर स्वचालित रूप से प्राप्त किया जा सके (यह सुनिश्चित नहीं है कि इससे कोई फर्क पड़ता है कि आप किस तरह का अंत करते हैं)।

— नील

@ नील आह, वह भी चतुर है! धन्यवाद।

— केविन क्रूज़सेन

Answer 8

05AB1E , 57 55 बाइट्स

4¢4@U.M¢©5-Di14¹нk2αë>Di5X-ë>i9X3*-¹1¢2Ê*ë®i7ë¹4¢o;ï12α

पोर्ट ऑफ नोइल चारकोल उत्तर , क्योंकि मेरा प्रारंभिक दृष्टिकोण पहले से ही 60 बाइट्स पर था और मुझे अभी तक नहीं किया गया था। मेरे वर्तमान उत्तर को शायद कुछ और बताया जा सकता है, हालांकि।

अंकों की सूची के रूप में इनपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

4¢              # Count the amount of 4s in the (implicit) input-list
  4@            # Check if it's larger than or equal to 4
                # (results in 1 for truthy; 0 for falsey)
    U           # Pop and store that result in variable `X`
.M              # Push the most frequent number in the (implicit) input-list
  ¢             # Pop and push the count of that number in the (implicit) input-list
   ©            # Store it in the register (without popping)
5-Di            # If the maximum count - 5 is exactly 1 (so the maximum count is 6):
    14          #  Push 14
      ¹н        #  Push the first digit of the input-list
        k       #  Get its index in 14, resulting in -1, 0, or 1
         2α     #  Take the absolute difference with 2
                #  (This covers cases 1, 2, and 3)
ë>Di            # Else-if the maximum count - 5 + 1 is exactly 1 (so the maximum count is 5):
    5           #  Push 5
     X-         #  And subtract variable `X`
                #  (This covers cases 4 and 5)
ë>i             # Else-if the maximum count - 5 + 2 is exactly 1 (so the maximum count is 4):
   9            #  Push 9
    X3*         #  Multiply variable `X` by 3
       -        #  And subtract it from the 9
        ¹1¢     #  Count the amount of 1s in the input-list
           2Ê   #  Check if it's NOT equal to 2 (1 if truthy; 0 if falsey)
             *  #  Multiply it with the 9 or 6
                #  (This covers cases 0, 6, and 9)
ë®i             # Else-if the maximum count is 1:
   7            #  Push a 7
                #  (This covers case 7)
ë               # Else (maximum count is 2 or 3):
 ¹4¢            #  Count the amount of 4s in the input-list
    o           #  Take 2 to the power this count
     ;ï         #  Halve and floor it
       12α      #  And take the absolute difference with 12
                #  (This covers cases 8, 10, 11, and 12)
                # (Output the top of the stack implicitly as result)

Answer 9

रूबी , 100 बाइट्स

->a{%w(^2.*4$ 6$ ^6 6 5$ 5 4$ ^1*$ 3$ 4 2$ 1$ .).index{|b|/#{b}/=~([1,*a,4].map{|c|a.count(c)}*'')}}

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

यह काम किस प्रकार करता है:

सरणी में हर संख्या की घटनाओं की गणना करें, 1s की संख्या बढ़ाएं और 4s की संख्या जोड़ें।

उसके बाद, विभिन्न रेगेक्स पैटर्न के साथ मिलान करने का प्रयास करें।