गैर-संक्रामक पासा खेल


10

आप में से जिन्हें नंबरफाइल पसंद है, वे डॉ। जेम्स ग्रिम से परिचित होंगे, जिन्होंने अपने चैनल पर एक गैर-संक्रामक पासा खेल का वर्णन किया था

खेल तीन 6-सामना पासा के होते हैं:

  • डाई 1: 3,3,3,3,3,6
  • डाई 2: 2,2,2,5,5,5
  • डाई 3: 1,4,4,4,4,4

दो खिलाड़ी प्रत्येक का उपयोग करने के लिए एक डाई का चयन करते हैं। वे उन्हें रोल करते हैं और उच्चतर मर जीत, सर्वश्रेष्ठ-जो भी हो।

संभावित रूप से, मरने वाले 1 व्यक्ति की मृत्यु 2 के साथ> 50% की संभावना है। इसी तरह, 2 बीट डाई 3 मरें, और, दिलचस्प है, डाई 3 बीट्स डाई 1 मरना।

एक कार्यक्रम ले 1, 2या 3इनपुट के रूप में लिखें । यह इंगित करता है कि उपयोगकर्ता क्या मरता है। फिर प्रोग्राम उस डाई को चुनें जो उपयोगकर्ता को हराएगी और 21 रोल के परिणामों का उत्पादन करेगी, और " Computer/User wins with x points"

नियम

  • कोड-गोल्फ, टाईब्रेकर के रूप में वोट करता है
  • आपको वास्तव में पासा रोल का अनुकरण करने के लिए आरएनजी (या पसंद) का उपयोग करना चाहिए।
  • मैं आउटपुट फॉर्मेट पर बहुत सख्त नहीं हूं। यह ठीक है जब तक आप पासा दिखाते हैं, किसी तरह 21 रोल के बीच अलग हो जाते हैं (एक तरह से आप एक ही रोल में पासे को कैसे अलग करते हैं), और उस वाक्य को ऊपर आउटपुट करें।
  • इनपुट स्टड, कमांड लाइन तर्क, स्क्रीन आदि से हो सकता है।

उदाहरण

इनपुट

1

उत्पादन

4 3
4 3
4 3
4 3
4 3
4 3
4 3
4 3
4 3
4 6
1 3
4 3
4 3
1 3
4 3
1 3
4 3
4 3
4 3
4 3
4 6
 Computer wins with 16 points

यहाँ, उपयोगकर्ता चुनता है मर 1 और उसके रोल सही स्तंभ पर दिखाए जाते हैं। कार्यक्रम 3 चुनता है और उसे मारता है।

जवाबों:


1

गोल्फस्क्रिप्ट, 112 105 वर्ण

3,21*{..+6rand<3*+)}%3/\{)\.+-1%>2<.p~<}+,,"User
Computer"n/1$11<=" wins with "+\[.~22+]$1>~+" points"+

इसे ऑनलाइन चलाएं ।

स्क्रिप्ट एसटीडीआईएन पर इनपुट की उम्मीद करती है और फिर पासा रोल (पहला कॉलम कंप्यूटर, दूसरा उपयोगकर्ता) और अंतिम आँकड़े एसटीडीयूएस के परिणाम को प्रिंट करती है।


4

एपीएल ( 106 114)

'Computer' 'User'[1+X],'wins with','points',⍨|Z-21×X←11>Z←+/>/⎕←⍉↑{⍵[{?6}¨⍳21]}¨(↓5 6⍴545170074510753⊤⍨18⍴7)[⎕+⍳2]

स्पष्टीकरण:

  • (↓5 6⍴545170074510753⊤⍨18⍴7)[⎕+⍳2]: बड़ी संख्या पासा का एक आधार -7 प्रतिनिधित्व है। हम एक 6x5 मैट्रिक्स बनाते हैं जिसमें क्रम में पासा के मान होते हैं: 2 3 1 2 3. उपयोगकर्ता इनपुट के लिए पूछें और इसे वेक्टर में जोड़ें 1 2, और मैट्रिक्स से इन पंक्तियों का चयन करें। क्योंकि पासा की सूची को स्थानांतरित कर दिया गया है, उपयोगकर्ता को अब वह चुना जाता है जिसे उसने (दाईं ओर) चुना है और कंप्यूटर को मजबूत हो जाता है।
  • {⍵[{?6}¨⍳21]}¨: इन दो पासा में से प्रत्येक के लिए 21 रोल करें।
  • ⎕←⍉↑: रोल्स को मैट्रिक्स रूप में रखें और उन्हें आउटपुट करें।
  • Z←+/>/: कंप्यूटर का स्कोर प्राप्त करें (उपयोगकर्ता की तुलना में कंप्यूटर का मूल्य कितनी बार अधिक था)
  • X←11>Z: सेट Xकरें कि क्या उपयोगकर्ता जीता (यदि 11 कंप्यूटर के स्कोर से अधिक है)।
  • 'Computer' 'User'[1+X]Xउपयोगकर्ता जीता है या नहीं।
  • 'wins with','points',⍨|Z-21×X: Zकंप्यूटर का स्कोर है, इसलिए यदि कंप्यूटर ने डिस्प्ले जीता है Z, अन्यथा डिस्प्ले 21-Z

स्कोर कुल योग (जो पासा के सभी जोड़े के लिए 0 होने की उम्मीद है) का अंतर नहीं है, इसके बजाय, 21 रोल में से प्रत्येक के विजेता को 1 अंक मिलता है। उदाहरण में, उपयोगकर्ता के 5 अंक हैं (5 रोल जीतने से: 4-6, 1-3, 1-3, 1-3, 4-6) और कंप्यूटर को 16 अंक बाकी मिलते हैं।
22

@TwiNight: इसे ठीक कर दिया
marinus

जब उपयोगकर्ता जीतता है तो नकारात्मक अंक। आप ठीक कर सकते हैं |Z-21×Xजिसके द्वारा चार गिनती में बदलाव नहीं होता है
ट्विन नाइट

2

आर - 228

d=matrix(rep(c(rep(3,5),6,2,2,2,5,5,5,1,rep(4,5)),2),6)
x=scan()
r=expand.grid(Computer=d[,x+2],User=d[,x])[sample(36,21,T),]
print(r)
s=summary.factor(names(r)[max.col(r)])
cat(names(which.max(s)),"wins with",max(s),"points\n")

उदाहरण रन:

> source('ntd.R')
1: 2
2: 
Read 1 item
     Computer User
28          3    5
31          3    5
36          6    5
18          6    2
11          3    2
31.1        3    5
14          3    2
8           3    2
9           3    2
17          3    2
2           3    2
29          3    5
3           3    2
16          3    2
4           3    2
21          3    5
14.1        3    2
23          3    5
16.1        3    2
17.1        3    2
19          3    5
Computer wins with 14 points

आप बदल सकते हैं summary.factorके साथ table, 9 पात्रों की बचत।
ब्रायन डिग्स

2

गणितज्ञ 208 172 166 159

स्पष्टता के लिए रिक्त स्थान जोड़े गए

b=Boole;{#, Row@{
         If[# > 10, "Play", "Comput"], "er wins with ",
         Max[#, 21 - #], " points"} &@ Total[b[#1 > #2] & @@@ #]} &@
   Table[1 + i + 3 b[6 Random[] > 2 i + 1],{21}, {i, {#, Mod[# + 1, 3]}}] &

मुझे लगता है कि आउटपुट को पासा के प्रत्येक रोल के मूल्यों को सूचीबद्ध करना है।
डेविड जेएन

@ यदु हां, मैंने परीक्षण के दौरान इसे खो दिया। मैंने बस गेंद को चालू रखने के लिए एक त्वरित फिक्सअप किया। मैं बाद में सोचूंगा कि इसे कैसे सुधारना है।
डॉ। बेलीजरियस

अब यह ठीक काम करने लगता है।
डेविड जेएन

@ अब बहुत बेहतर है
डॉ। बेलिसरियस

बहुत अच्छे। +1
मि। छिपकली

1

रूबी 1.8, 165

i,s,*d=getc,21,[4]*5<<1,[3]*5<<6,[2,5]*3
puts"#{s.times{p r=[i,i-1].map{|o|d[o%3][rand 6]};s+=r[0]<=>r[1]}>s?"Human":"Computer"} wins with #{[s/=2,21-s].max} points"

getc इनपुट की ascii मान (रूबी 1.8 केवल) है, जो खुशी से अपने पूर्णांक मान के लिए 3 modulo अनुरूप है।

s21 पर शुरू होता है, इसलिए 21 बार s.times{code}निष्पादित होता है codeऔर 21 पर वापस लौटता है। प्रत्येक पुनरावृत्ति पर, लूप या तो जोड़ता है या जो कि जीतता है, उसके आधार पर एस से 1 घटाता है, इसलिए हम देख सकते हैं कि कौन जीता है जो s21 से नीचे समाप्त हो गया है। , लेकिन फिर मुझे [s/=2,21-s].maxअंक की वास्तविक संख्या निकालने के लिए अनाड़ी अभिव्यक्ति की आवश्यकता है । मैं लंबे समय से वापसी मूल्य के साथ अंकगणित करना चाहता था <=>, इसलिए मैं वैसे भी खुश हूं।


1

गणितज्ञ 234 247

कोड

g@n_ := {t = RandomChoice[{{5, 25, 1, 5}/36 -> {{3, 1}, {3, 4}, {6, 1}, {6, 4}}, 
         {5, 1, 5, 1}/12 -> {{2, 3}, {2, 6}, {5, 3}, {5, 6}},
         {1, 1, 5, 5}/12 -> {{1, 2}, {1, 5}, {4, 2}, {4, 5}}}[[n]], 21], 
         Row[{If[(c = Count[t, {x_, y_} /; y > x]) > 10, "Computer ", "Player "], 
         "wins with ", If[c > 10, c, 21 - c], " points"}]}

प्रयोग

{खिलाड़ी का रोल, कंप्यूटर का रोल}

g[1]
g[2]
g[3]

परिणाम


व्याख्या

nनंबर 1, 2 या 3 है जो खिलाड़ी की मृत्यु से मेल खाता है। क्योंकि n भी कंप्यूटर की मृत्यु को निर्धारित करता है (लेकिन बराबर नहीं करता है), हम n = 1, n = 2, n = 3 होने पर पासा के सभी संभावित रोल तैयार कर सकते हैं। हम उनकी संबंधित संभावनाओं को भी निर्धारित कर सकते हैं।

सही होने पर डेटा की जाँच करें RandomChoice:

{५, २५, १, ५} / ३६ -> {{३, १}, {३, ४}, {६, १}, {६, ४}}

यदि खिलाड़ी ड्रॉ 1 मरता है, तो केवल संभावित परिणाम निम्नलिखित 4 जोड़े हैं

{{3, 1}, {3, 4}, {6, 1}, {6, 4}}

इन जोड़ियों की संबंधित संभावनाएँ हैं

{5, 25, 1, 5}/36, अर्थात्,

{5/36, 25/36, 1/36, 5/36}

RandomChoice[<data>, 21] दो पासा के 21 रोल का आउटपुट।


1

सी, 205 191

p;r(c){return 1+c+3*(rand()%6>2*c);}main(i,c,q,s){for(c=51-getchar();++i<23;printf("%u %u\n",q,s))q=r(c),p+=(s=r(-~c%3))<q;printf("%ser wins with %u points",p<11?"Comput":"Us",p<11?21-p:p);}

स्टड से उपयोगकर्ता की पसंद को पढ़ता है।


कुछ युक्तियां: for(c=51-getchar(p=0);, printf("%ser wins), में पुन: व्यवस्थित करें अभिव्यक्ति rके साथ शुरू करने के लिए (और अंतरिक्ष को बचाने।
बदसूरत

और अधिक: (c+1)%3-> -~c%3, मेकअप pस्थिर (0 को प्रारंभ), हटाने {}के बाद for( ;-> ,उन्हें अंदर), उपयोग p<11?:दो बार के भीतर printfबजाय देने की p,q
बदसूरत

और आप s,qलूप में सेट कर सकते हैं printf, और pबाद में वेतन वृद्धि , इस प्रकार कोष्ठक को बचा सकते हैं। ०,१,२ का एक अलग आदेश देते हुए, cउपयोग करने के लिए असाइनमेंट को बदलें %3या %7
ugoren

1

फ़ैक्टर

के साथ शामिल हैं: 388

बिना: 300

USING: arrays formatting io kernel math math.parser prettyprint random sequences ;
IN: N
CONSTANT: d { { 3 3 3 3 3 6 } { 2 2 2 5 5 5 } { 1 4 4 4 4 4 } }
: p ( -- ) 1 read string>number [ 3 mod 1 + ] keep [ 1 - d nth ] bi@ 2array 21 iota [ drop first2 [ random ] bi@ [ 2array . ] 2keep < ] with map [ ] count [ 11 > "Comput" "Play" ? ] [ "er wins with %d points" sprintf ] bi append print ;

हाँ, जब फैक्टरिंग का उपयोग करने के लिए फैक्टर वास्तव में भाषा नहीं है, लेकिन यह अच्छा है।


0

अजगर 182

from random import*
u=2+input()
r=[eval("int(choice(`0x1d67e987c0e17c9`[i%3::3])),"*21)for i in(u,u-1)]
U,C=map(sum,r)
print r,['Us','Comput'][U<C]+'er wins with %d points'%abs(U-C)

0

आर 206

u=scan()
D=list(c(rep(3,5),6),c(2,5),c(1,rep(4,5)))
S=sample
U=S(D[[u]],21,T)
C=S(D[[(u+1)%%3+1]],21,T)
print(cbind(U,C))
W=sum(U>C)
I=(W>10)+1
cat(c("Computer","User")[I],"wins with",c(21-W,W)[I],"points")
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.