Craps es un juego de dados bastante simple que a menudo se juega en los casinos. Incluso si no eres un jugador (que yo no soy), sigue siendo un juego bastante interesante. Aquí están las reglas:

Al comienzo de un juego de dados no es lo que se llama el de Salida ronda. El jugador tira dos d6s (dado de seis lados) y se suman las dos tiradas de dado. Si el resultado es 7 u 11, la persona gana automáticamente (esto se conoce como natural ). Si el resultado es 2, 3 o 12, la persona pierde automáticamente (esto se conoce como basura ). De lo contrario, el resultado se establece como el punto para la ronda de puntos.

Después de esto, comienza la ronda de puntos . Durante la ronda de puntos, el jugador debe tirar continuamente 2 d6s hasta que la persona saque un 7 o su punto de la ronda anterior. Si la persona saca un 7, pierde. Si sacan su punto, ganan.

Desafío

Implemente un programa simple que simule un juego de dados. Si la persona lanza un natural o una basura durante la ronda de salida, el programa debería mostrar "Natural:" o "Recorte:" seguido por la tirada del dado y luego salir. De lo contrario, debería mostrar "Punto:" seguido del punto. Luego, durante la ronda de puntos, debería generar cada tirada hasta que se alcance un 7 o el punto. Si la persona gana, debería salir "Pass"; si lo pierden debería salir "Don't Pass".

Implementación de referencia

Groovy, 277 bytes

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

Pruébalo en línea.

Resultados de muestra

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

y

Point: 5
3
7
Don't Pass

Este es el código de golf , por lo que gana el código más corto.

(DESCARGO DE RESPONSABILIDAD: Este desafío no pretende promover el juego de ninguna manera. Recuerde, la casa siempre gana).

Rubí 164

Muy claro. Características interesantes:

Los casos de eliminación se resumen como r%12<4y los casos naturales restantes se resumen como r%4==3.

La cadena inicial se almacena cy se toman rollos adicionales solo si esto es posterior alfabéticamente a la letra única ?P(que solo ocurre para 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 bytes

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

Esto se basa en la respuesta de Celeo ; Reemplacé algunos condicionales largos con un número mágico que codifica un LUT para cada número, reutilicé una variable e hice algunos otros campos de golf diversos. Todavía hay espacio para el golf; Probablemente sea posible llegar a menos de 170.

No intenté usar Python 2, así que no sé si sería más corto.

C99 366 312 293 277 bytes

Esta es mi primera publicación aquí, así que supongo que esto se puede mejorar mucho.

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

Versión ampliada

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

Como puede ver, aquí hay una buena cantidad de redundancia que probablemente se pueda eliminar.

Créditos a @Mego por ayudar a hacer esto más pequeño.

Python 2, 226 224 bytes

Primer pase y hay mucho código allí:

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"

¡Gracias a Mego por 2 bytes!

PHP 230 228 218 199 192 188 bytes

186 bytes sin el <?

<?$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
";}

Primer intento de código de golf! Sin </br>embargo, ¿ no está seguro si se permitiría usar ? Como esto no funcionaría en una consola (como una nueva línea). Avíseme si esto no está permitido y alterará mi código.

EDITAR (16-8-16): Después de mejorar en codegolf noté algunas posibles mejoras. Esto todavía funciona usando la interfaz de línea de comando. Reemplazado </br>con una entrada difícil.

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 bytes

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}

Pruébalo en línea!

PowerShell , 181 183 179 178 167 165 bytes

^{-10 bytes gracias a mazzy
-2 bytes gracias a 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'}}

Pruébalo en línea!

Versión desenrollada:

#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'
    }
}

Hay algunos puntos menos problemáticos ahora que la lógica de creación de listas se ha reconstruido en un interruptor. Creo que sigue siendo un enfoque bastante bueno. +2 bytes arreglando un error.

R, 197 bytes

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

Sin 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 bytes

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

Pruébalo en línea!

Primer pase, probablemente pueda encontrar algunos ahorros.

Encantamientos rúnicos , 151 bytes

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

Pruébalo en línea!

Después de corregir un error con respecto a los números aleatorios (se volvía a sembrar cada vez que 'RAse llamaba, y la semilla era la hora del sistema, lo que resulta en ejecuciones masivas de valores repetidos) esto funciona correctamente.

Explicación

La entrada está en la segunda línea, ya que la primera línea hasta B͍es una función para tirar dos dados y sumarlos.

Flujo de programa, con algunas envolturas de bordes y redirecciones curvadas desenrolladas para facilitar la lectura.

   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)

Solo hay 4 instrucciones NOP ( {:}≠...?\.6?) que serían muy difíciles de eliminar debido al espacio requerido en otras líneas (es decir, la longitud de la "Don't "cadena).