Diejenigen unter Ihnen, die Numberphile mögen, kennen Dr. James Grime, der auf seinem Kanal ein nicht-transitives Würfelspiel beschrieben hat .

Das Spiel besteht aus drei Würfeln mit 6 Gesichtern:

• Die 1: 3,3,3,3,3,6
• Die 2: 2,2,2,5,5,5
• Die 3: 1,4,4,4,4,4

Jeweils zwei Spieler wählen einen Würfel aus. Sie würfeln sie und der höhere Würfel gewinnt, das Beste von allem.

Wahrscheinlich schlägt Würfel 1 Würfel 2 mit einer Chance von> 50%. In ähnlicher Weise schlägt die 2 die 3 und interessanterweise die 3 die 1.

Schreiben Sie ein Programm Mitnahmen 1, 2oder 3als Eingabe. Dies zeigt den Würfel an, den der Benutzer auswählt. Das Programm wählt dann den Würfel, der den Benutzer schlagen würde, und gibt die Ergebnisse von 21 Würfeln aus, und " Computer/User wins with x points"

Regeln

• Code-Golf, Stimmen als Tiebreaker
• Sie müssen RNG (oder ähnliches) verwenden, um die Würfelwürfe tatsächlich zu simulieren.
• Ich bin nicht zu streng im Ausgabeformat. Es ist in Ordnung, solange Sie die Würfel zeigen, sich irgendwie zwischen den 21 Würfeln trennen (anders als Sie die Würfel in demselben Wurf trennen) und den obigen Satz ausgeben.
• Die Eingabe kann stdin, Befehlszeilenargument, vom Bildschirm usw. sein.

Beispiel

Eingang

1

Ausgabe

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

Hier wählt der Benutzer Würfel 1 und seine Rollen werden in der rechten Spalte angezeigt. Das Programm wählt Würfel 3 und schlägt ihn.

GolfScript, 112 105 Zeichen

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

Führen Sie es online aus .

Das Skript erwartet die Eingabe auf STDIN und druckt dann das Ergebnis der Würfelwürfe (Computer der ersten Spalte, zweiter Benutzer) und die endgültigen Statistiken an STDOUT.

APL ( 106 114)

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

Erläuterung:

• (↓5 6⍴545170074510753⊤⍨18⍴7)[⎕+⍳2]: Die große Zahl ist eine Basis-7-Darstellung der Würfel. Wir erstellen eine 6x5-Matrix, die die Werte der Würfel in der folgenden Reihenfolge enthält: 2 3 1 2 3. Bitten Sie um Benutzereingaben, fügen Sie diese dem Vektor hinzu 1 2und wählen Sie diese Linien aus der Matrix aus. Da die Liste der Würfel verschoben wird, erhält der Benutzer jetzt die von ihm ausgewählte (rechts) und der Computer die stärkere.
• {⍵[{?6}¨⍳21]}¨: 21 Würfe für jeden dieser beiden Würfel.
• ⎕←⍉↑: Legen Sie die Rollen in Matrixform und geben Sie sie aus.
• Z←+/>/: Ermittelt die Punktzahl des Computers (wie oft der Wert des Computers höher war als der des Benutzers)
• X←11>Z: Legen Sie fest X, ob der Benutzer gewonnen hat (wenn 11 höher ist als die Punktzahl des Computers).
• 'Computer' 'User'[1+X]. Xist, ob der Benutzer gewonnen hat.
• 'wins with','points',⍨|Z-21×X: Zist die Punktzahl des Computers. Wenn der Computer also die Anzeige gewonnen hat Z, wird sie ansonsten angezeigt 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")

Beispiellauf:

> 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

Zur Verdeutlichung hinzugefügte Leerzeichen

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]}}] &

Ruby 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 Ruft den ASCII-Wert der Eingabe ab (nur Ruby 1.8), der glücklicherweise Modulo 3 zu seinem ganzzahligen Wert kongruent ist.

sBeginnt bei 21, s.times{code}wird also code21 Mal ausgeführt und gibt 21 zurück. Bei jeder Iteration addiert oder subtrahiert die Schleife 1 von s, je nachdem, wer gewinnt. Wir können also sehen, wer gewonnen hat, indem wir sehen, ob ses unter 21 gelandet ist , aber dann brauche ich den ungeschickten Ausdruck [s/=2,21-s].max, um die tatsächliche Anzahl von Punkten zu extrahieren. Ich wollte schon lange mit dem Rückgabewert von rechnen <=>, also bin ich trotzdem glücklich.

Mathematica 234 247

Code

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"}]}

Verwendungszweck

{Spielerwurf, Computerwurf}

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

Erläuterung

nist die Zahl 1, 2 oder 3, die dem Würfel des Spielers entspricht. Da n auch den Würfel des Computers bestimmt (aber nicht gleich ist), können wir alle möglichen Würfelwürfe erzeugen, wenn n = 1, n = 2, n = 3. Wir können auch ihre jeweiligen Wahrscheinlichkeiten bestimmen.

Untersuchen Sie die Daten direkt nach RandomChoice:

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

Wenn der Spieler Würfel 1 zieht, sind die folgenden 4 Paare die einzig möglichen Ergebnisse

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

Die jeweiligen Wahrscheinlichkeiten dieser Paare sind

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

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

RandomChoice[<data>, 21] gibt 21 Würfe der beiden Würfel aus.

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

Liest die Auswahl des Benutzers von stdin.

Faktor

Mit enthält: 388

Ohne: 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 ;

Ja, Factor ist nicht wirklich die Sprache, die man beim Golfen verwenden sollte, aber es ist schön.

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