Jeu de dés non transitif

10

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.

TwiNight
la source

Réponses:

1

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.

Howard
la source
4

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.
marinus
la source
Le score n'est pas la différence des totaux (qui devrait être de 0 pour toutes les paires de dés), mais le gagnant de chacun des 21 lancers obtient 1 point. Dans l'exemple, l'utilisateur a 5 points (sur 5 rouleaux gagnés: 4-6, 1-3, 1-3, 1-3, 4-6) et l'ordinateur se repose les 16 points.
TwiNight
@TwiNight: corrigé
marinus
Points négatifs lorsque l'utilisateur gagne. Vous pouvez corriger |Z-21×Xce qui ne change pas le nombre de caractères
TwiNight
2

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
Geoff Reedy
la source
Vous pouvez remplacer summary.factorpar table, en enregistrant 9 caractères.
Brian Diggs
2

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]}}] &
Dr. belisarius
la source
Je pense que la sortie est censée énumérer les valeurs de chaque lancer de dés.
DavidC
@ mec ouais, je l'ai perdu pendant les tests. J'ai fait une correction rapide juste pour garder le ballon en marche. Je penserai plus tard comment l'améliorer.
Dr belisarius
Cela semble maintenant bien fonctionner.
DavidC
@dude Beaucoup mieux maintenant
Dr. belisarius
Vraiment sympa. +1
Mr.Wizard
1

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.

histocrate
la source
1

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]

résultats


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.

DavidC
la source
1

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.

a cessé de tourner dans le sens antihoraire
la source
Quelques conseils: for(c=51-getchar(p=0);, printf("%ser wins), réorganisez expression rpour commencer (et économiser de l' espace.
ugoren
Et plus: (c+1)%3-> -~c%3, rendre pstatique (initialisé à 0), supprimer {}après for( ;-> ,en leur sein), utiliser p<11?:deux fois à l'intérieur printfau lieu de l'attribuer p,q.
ugoren
Et vous pouvez définir s,qdans la boucle printf, et incrémenter pensuite, économisant ainsi les parenthèses. Modifiez également l' caffectation à utiliser %3ou %7, en donnant un ordre différent de 0,1,2.
ugoren
1

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.

Matthew Rolph
la source
0

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)
daniero
la source
0

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")
flodel
la source