บรรดาผู้ที่ชอบ Numberphile จะคุ้นเคยกับดร. เจมส์ Grime ที่อธิบายเกมลูกเต๋าที่ไม่ใช่สกรรมกริยาในช่องทางของเขา

เกมนี้ประกอบไปด้วยลูกเต๋า 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"

กฎระเบียบ

• รหัส - กอล์ฟคะแนนเป็น tiebreaker
• คุณต้องใช้ RNG (หรือไลค์) เพื่อจำลองการทอยลูกเต๋า
• ฉันไม่เข้มงวดกับรูปแบบผลลัพธ์ ไม่เป็นไรตราบใดที่คุณแสดงลูกเต๋าแยกจากกันระหว่าง 21 ม้วน (ในวิธีที่แตกต่างจากวิธีที่คุณแยกลูกเต๋าในม้วนเดียวกัน) และส่งออกประโยคข้างต้น
• อินพุตสามารถเป็น stdin, อาร์กิวเมนต์บรรทัดคำสั่ง, จากหน้าจอ ฯลฯ

ตัวอย่าง

อินพุต

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 ตายและเต้นเขา

GolfScript 112 112ตัวละคร

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

เรียกใช้งานออนไลน์

สคริปต์คาดว่าอินพุตใน STDIN จากนั้นพิมพ์ผลลัพธ์ของการทอยลูกเต๋า (คอมพิวเตอร์คอลัมน์แรกผู้ใช้คนที่สอง) และสถิติสุดท้ายไปยัง STDOUT

APL ( 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ปรากฏขึ้น

R - 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

Mathematica 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.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 ของอินพุต (ruby 1.8 เท่านั้น) ซึ่งเป็นโมดูลัส 3 ที่สอดคล้องกับค่าจำนวนเต็ม

sเริ่มต้นที่ 21 ดังนั้นs.times{code}จะดำเนินการcode21 ครั้งและส่งคืน 21 ในแต่ละรอบการวนซ้ำเพิ่มหรือลบ 1 จาก s ขึ้นอยู่กับผู้ชนะดังนั้นเราสามารถดูว่าใครชนะโดยดูว่าsจบลงต่ำกว่า 21 หรือไม่ แต่ฉันต้องการนิพจน์ที่เงอะงะ[s/=2,21-s].maxเพื่อแยกจำนวนจริง ฉันอยากทำเลขคณิตด้วยค่าที่ส่งคืนมานาน<=>แล้วดังนั้นฉันจึงมีความสุขอยู่ดี

Mathematica 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:

{5, 25, 1, 5} / 36 -> {{3, 1}, {3, 4}, {6, 1}, {6, 4}}

หากผู้เล่นเสมอกัน 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 ม้วนของลูกเต๋าสองลูก

ค, 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);}

อ่านตัวเลือกของผู้ใช้จาก stdin

ปัจจัย

รวมถึง: 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 ;

ใช่ปัจจัยไม่ใช่ภาษาที่ใช้ในการเล่นกอล์ฟ แต่มันก็ดี

Python 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)

R 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")