Ceux d'entre vous qui aiment Numberphile connaissent bien le Dr James Grime, qui a décrit un jeu de dés non transitif sur sa chaîne .

Le jeu se compose de trois dés à 6 faces:

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

Deux joueurs choisissent chacun un dé à utiliser. Ils les lancent et le dé supérieur gagne, le meilleur de tout.

Probablement, le dé 1 bat le dé 2 avec> 50% de chances. De même, le dé 2 bat le dé 3 et, fait intéressant, le dé 3 bat le dé 1.

Ecrire un programme de prise 1, 2ou 3en entrée. Cela indique le dé choisi par l'utilisateur. Le programme choisit ensuite le dé qui battrait l'utilisateur et produirait les résultats de 21 lancers, et " Computer/User wins with x points"

Règles

• Code-golf, vote comme bris d'égalité
• Vous devez utiliser RNG (ou des likes) pour simuler réellement les jets de dés.
• Je ne suis pas trop strict sur le format de sortie. Ce n'est pas grave tant que vous montrez les dés, séparés d'une manière ou d'une autre entre les 21 rouleaux (d'une manière différente de la façon dont vous séparez les dés dans le même rouleau), et sortez cette phrase ci-dessus.
• L'entrée peut être stdin, argument de ligne de commande, à partir de l'écran, etc.

Exemple

Contribution

1

Production

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

Ici, l'utilisateur choisit le dé 1 et ses jets sont affichés dans la colonne de droite. Le programme choisit le dé 3 et le bat.

GolfScript, 112 105 caractères

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

Exécutez-le en ligne .

Le script attend l'entrée sur STDIN et imprime ensuite le résultat des lancers de dés (ordinateur de la première colonne, deuxième utilisateur) et les statistiques finales sur STDOUT.

APL ( 106 114)

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

Explication:

• (↓5 6⍴545170074510753⊤⍨18⍴7)[⎕+⍳2]: Le grand nombre est une représentation en base 7 des dés. Nous faisons une matrice 6x5 contenant les valeurs des dés dans l'ordre: 2 3 1 2 3. Demandez l'entrée de l'utilisateur et ajoutez-la au vecteur 1 2, puis sélectionnez ces lignes dans la matrice. Parce que la liste des dés est décalée, l'utilisateur obtient maintenant celui qu'il a sélectionné (à droite) et l'ordinateur obtient le plus fort.
• {⍵[{?6}¨⍳21]}¨: effectuez 21 lancers pour chacun de ces deux dés.
• ⎕←⍉↑: mettre les rouleaux sous forme matricielle et les sortir.
• Z←+/>/: obtenir le score de l'ordinateur (nombre de fois où la valeur de l'ordinateur était supérieure à celle de l'utilisateur)
• X←11>Z: définir Xsi l'utilisateur a gagné (si 11 est supérieur au score de l'ordinateur).
• 'Computer' 'User'[1+X]. Xest de savoir si l'utilisateur a gagné.
• 'wins with','points',⍨|Z-21×X: Zest le score de l'ordinateur, donc si l'ordinateur a gagné l'affichage Z, sinon afficher 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")

Exemple d'exécution:

> 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

Espaces ajoutés pour plus de clarté

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

Rubis 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 obtient la valeur ascii de l'entrée (ruby 1.8 uniquement), qui est heureusement modulo 3 congru à sa valeur entière.

scommence à 21, donc s.times{code}s'exécutera code21 fois et retournera 21. À chaque itération, la boucle ajoute ou soustrait 1 de s en fonction de qui gagne, afin que nous puissions voir qui a gagné en voyant s'il ss'est retrouvé en dessous de 21. Neat jusqu'ici , mais j'ai besoin de l'expression maladroite [s/=2,21-s].maxpour extraire le nombre réel de points. J'ai longtemps voulu faire de l'arithmétique avec la valeur de retour de <=>, donc je suis quand même content.

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

Usage

{Tableau du joueur, Tableau de l'ordinateur}

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

Explication

nest le nombre 1, 2 ou 3 qui correspond au dé du joueur. Parce que n détermine également (mais n'est pas égal) le dé de l'ordinateur, nous pouvons générer tous les lancers de dés possibles lorsque n = 1, n = 2, n = 3. Nous pouvons également déterminer leurs probabilités respectives.

Examinez les données juste après RandomChoice:

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

Si le joueur tire le dé 1, les seuls résultats possibles sont les 4 paires suivantes

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

Les probabilités respectives de ces paires sont

{5, 25, 1, 5}/36, C'est,

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

RandomChoice[<data>, 21] sort 21 lancers des deux dés.

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

Lit le choix de l'utilisateur depuis stdin.

Facteur

Avec comprend: 388

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

Ouais, Factor n'est pas vraiment le langage à utiliser pour jouer au golf, mais c'est sympa.

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