Le Craps est un jeu de dés assez simple souvent joué dans les casinos. Même si vous n'êtes pas un joueur (ce que je ne suis pas), c'est toujours un jeu assez intéressant. Voici les règles:

Au début d'une partie de Craps, il y a ce qu'on appelle le round de sortie . Le joueur lance deux d6 (dé à six faces) et les deux jets de dé sont ajoutés. Si le résultat est 7 ou 11, la personne gagne automatiquement (c'est ce qu'on appelle un naturel ). Si le résultat est 2, 3 ou 12, la personne perd automatiquement (c'est ce qu'on appelle le crapping out ). Sinon, le résultat est défini comme le point pour le point rond.

Après cela, le tour de points commence. Pendant le tour de points, le joueur doit lancer en continu 2 d6s jusqu'à ce que la personne lance un 7 ou son point du tour précédent. Si la personne obtient un 7, elle perd. S'ils roulent leur point, ils gagnent.

Défi

Implémentez un programme simple qui simule un jeu de craps. Si la personne lance un naturel ou un crap-out pendant le round de come-out, le programme devrait sortir "Natural:" ou "Crapping out:" suivi du dé et puis quitter. Sinon, il devrait afficher "Point:" suivi du point. Ensuite, pendant le round de points, il devrait sortir chaque jet de dé jusqu'à ce qu'un 7 ou le point soit atteint. Si la personne gagne, elle devrait sortir "Pass"; s'ils perdent, il devrait sortir "Don't Pass".

Implémentation de référence

Groovy, 277 octets

def a={return Math.random()*6+1};int b=a()+a();(b<4||b==12)?{println"Crapping out: "+b}():{(b==7||b==11)?{println"Natural: "+b}():{println"Point: "+b;for(;;){int x=a()+a();println x;(x==7)?{println"Don't Pass";System.exit(0)}():{if(x==b){println"Pass";System.exit(0)}}()}}()}()

Essayez-le en ligne.

Exemples de sorties

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

et

Point: 5
3
7
Don't Pass

C'est le code-golf , donc le code le plus court l'emporte.

(AVERTISSEMENT: ce défi n'est pas destiné à promouvoir le jeu en aucune façon. N'oubliez pas, la maison gagne toujours.)

Rubis 164

Assez simple. Caractéristiques intéressantes:

Les cas de crapping out sont résumés comme r%12<4et les cas naturels restants sont résumés comme r%4==3.

La chaîne initiale est stockée dans cet les rouleaux suivants ne sont pris que si c'est plus tard alphabétiquement que la lettre unique ?P(qui ne se produit que pour Point.)

f=->{rand(6)+rand(6)+2}
s=0
r=f[]
print c=r%12<4?'Crapping out':r%4==3?'Natural':'Point',": #{r}
"
c>?P&&(until s==r||s==7
p s=f[]end
print s==7?"Don't ":"","Pass")

Python 3, 190 octets

from random import*
r=randrange
p=print
a=r(5)+r(5)+2
c=890145//3**a%3
p(['Point:','Crapping out:','Natural:'][c],a)
if c<1:
 while 7!=c!=a:c=r(5)+r(5)+2;p(c)
 p(['Pass',"Don't pass"][c==7])

Ceci est basé sur la réponse de Celeo ; J'ai remplacé de longs conditionnels par un nombre magique qui code une LUT pour chaque numéro, j'ai réutilisé une variable et fait quelques autres golfs divers. Encore de la place pour le golf; il est probablement possible d'obtenir moins de 170.

Je n'ai pas essayé d'utiliser Python 2, donc je ne sais pas si ce serait plus court.

C99, 366 312 293 277 octets

Ceci est mon premier post ici, donc je vais supposer que cela peut être amélioré de beaucoup.

#include<stdlib.h>
#include<time.h>
#define r rand()%6+1
#define p printf(
main(c,s){srand(time(0));s=r+r;int*a=s==7||s==11?"Natural:%d":2-s||3-s||12-s?0:"Crapping out:%d";if(a){p a,s);return 0;}p"Point:%d\n",c=s);do p"%d\n",s=r+r);while(7-s&&s-c);p(7-s)?"Pass":"Don't pass");}

Version étendue

#include<stdlib.h>
#include<time.h>
#define r rand()%6+1
#define p printf(
main(c,s){
    srand(time(0));
    s=r+r;
    int*a=s==7||s==11?"Natural:%d":2-s||3-s||12-s?0:"Crapping out:%d";
    if(a) {p a,s);return 0;}
    p"Point:%d\n",c=s);
    do p"%d\n",s=r+r);
    while(7-s&&s-c);
    p(7-s)?"Pass":"Don't pass");
}

Comme vous pouvez le voir, il existe ici une bonne redondance qui peut très probablement être supprimée.

Remerciements à @Mego pour avoir aidé à réduire ce nombre.

Python 2, 226 224 octets

Première passe et il y a beaucoup de code:

from random import*
r=randrange
a=r(5)+r(5)+2
if a in[7,11]:print'Natural:',a
elif a in[2,3,12]:print'Crapping out:',a
else:
 print'Point:',a
 b=0
 while b not in[7,a]:b=r(5)+r(5)+2;print b
 print'Pass'if b-7else"Don't pass"

Merci à Mego pour 2 octets!

PHP 230 228 218 199 192 188 octets

186 octets sans le <?

<?$a=rand(1,6)+rand(1,6);$a%4==3?die("Natural: $a"):$a%12<4?die("Crapping out: $a"):print"Point: $a
";while(1){($b=rand(1,6)+rand(1,6))==7?die("Don't Pass"):$b==$a?die("Pass"):print"$b
";}

Première tentative de code golf! Vous ne savez pas si l'utilisation </br>serait autorisée? Comme cela ne fonctionnerait pas dans une console (comme une nouvelle ligne). Faites-moi savoir si cela n'est pas autorisé et modifiera mon code.

EDIT (16-8-16): Après m'être amélioré au codegolf, j'ai remarqué quelques améliorations possibles. Cela fonctionne toujours en utilisant l'interface de ligne de commande. Remplacé </br>par une entrée difficile.

Javascript 262

var r=(x=>Math.floor(Math.random()*6+1)),a=r()+r();if(a<4||a==12){alert("Crapping out: "+a)}else if(a==7||a==11){alert("Natural: "+a)}else{alert("Point: "+a);while(1){var b = r()+r();if(b==a){alert("pass");break}if(b==7){alert("dont't pass");break}alert(""+b)}}

Perl 5 , 140 octets

sub d{1+int rand 6}say$"=($p=&d+&d)%12<4?"Crapping out":$p%4-3?Point:Natural,": $p";if($"gt O){say$_=&d+&d until/7|$p/;say"Don't "x/7/,Pass}

Essayez-le en ligne!

PowerShell , 181 183 179 178 167 165 octets

^{-10 octets grâce à mazzy
-2 octets grâce à Xcali}

switch -r($z=&($x={(random 6)+(random 6)+2})){'7|11'{"Natural: $z"}'2|3'{"Crapping out: $z"}default{"Point: $z"
do{($m=&$x)}until($m-in7,$z)"Don't "*!($m-7)+'Pass'}}

Essayez-le en ligne!

Version déroulée:

#Switch using regex on $z which is...
#&($x={...}) first assigns $x to a scriptblock then calls it, saving the return to $z
switch -r($z=&($x={(random 6)+(random 6)+2})){
    '7|11' {"Natural: $z"}
    '2|3' {"Crapping out: $z"}
    default{
        "Point: $z"

        #Call the diceroll scriptblock until you Pass,
        #while pushing each roll to output
        do{($m=&$x)}
        until($m-in7,$z)
        "Don't "*!($m-7)+'Pass'
    }
}

Il y a quelques points de friction de moins maintenant que la logique de création de liste a été reconstruite dans un commutateur. Je pense que c'est toujours une bonne approche. +2 octets corrigeant un bogue.

R, 197 octets

 r=sum(sample(6,2,T));if(r%%12<4)cat("Crap Out",r)else if(r%%4==3)cat("Natural",r)else{cat("Point",r);while(T){cat("",q<-sum(sample(6,2,T)));if(q==7){cat(" Don't");break};if(q>r)break};cat(" Pass")}

Non golfé

r=sum(sample(6,2,T))
if (r%%12<4)  {
    cat("Crap Out",r) 
} else if (r%%4==3) {
    cat("Natural",r)
} else { 
    cat("Point",r)
    while (T) {
        q = sum(sample(6,2,T))
        cat("",q)
        if (q==7) {
            cat(" Don't")
            break
        }
        if (q>r) break
    }
    cat(" Pass")
}

Pyth , 108 octets

p|K?}J+OS6OS6,7 11"Natural"?}J[2 3 12)"Crapping out"k"Point"+": "JI!KW!}Z,7JIq7=Z
+OS6OS6=K"Don't "))+K"Pass

Essayez-le en ligne!

Premier passage, on peut sans doute trouver quelques économies.

Enchantements runiques , 151 octets

R}}6'RA6'RA2++{{B͍
00B:7=S:b={+?\"Natural: "@>
pping out: "@\:2=}:3=}:c={{++?/"Cra
{:}≠   ?\ 6?;$$k\/ak$00B:$:7≠?\
"Don't "R"Pass"a/\$:$" :tnioP"\

Essayez-le en ligne!

Après avoir corrigé un bug concernant les nombres aléatoires (il se réensemencait à chaque fois 'RA appel, et la graine était l'heure du système, ce qui entraînait des exécutions massives de valeurs répétées), cela fonctionne correctement.

Explication

L'entrée est sur la deuxième ligne, car la première ligne jusqu'à B͍est une fonction pour lancer deux dés et les additionner.

Flux de programme, avec quelques redirections enveloppantes et enroulées déroulées pour plus de lisibilité

   R}}6'RA6'RA2++{{B͍                      Roll 2, sum, return
   >00B:7=S:b={+?\                        Entry, make first roll, compare to 7 and 11.
                  "Natural: "@            If true, print "Natural: " and the value, else go down
                 \:2=}:3=}:c={{++?/       Compare to 2, 3, and 12.
"Crapping out: "@                         If true, print "Crapping out: " and the value, else go up
                     \$:$" :tnioP"\       Print "Point: " and value (IP is travelling RTL)
                     /ak$00B:$            Print newline, roll, print
:7≠?\                                     Compare to 7
    \"Don't "R"Pass"ak$$;                 If equal, print a newline and "Don't Pass"
     {:}≠   ?\                            Else compare to initial roll.
             R"Pass"ak$$;                 If equal, print a newline and "Pass"
              6?......ak$00B              Else return to roll loop by printing a newline
                                              and rolling again (. are skipped instructions)

Il n'y a que 4 instructions NOP ( {:}≠...?\.6?) qui seraient très difficiles à supprimer en raison de l'espace requis sur les autres lignes (à savoir la longueur de la "Don't "chaîne).