Craps è un gioco di dadi abbastanza semplice spesso giocato nei casinò. Anche se non sei un giocatore d'azzardo (cosa che non sono), è comunque un gioco abbastanza interessante. Ecco le regole:

All'inizio di una partita di Craps c'è quello che viene chiamato il round uscente . Il giocatore lancia due d6 (dado a sei facce) e vengono aggiunti i due tiri di dado. Se il risultato è 7 o 11, la persona vince automaticamente (questo è noto come naturale ). Se il risultato è 2, 3 o 12 la persona perde automaticamente (questo è noto come crapping out ). Altrimenti, il risultato viene impostato come punto per il punto rotondo.

Successivamente, inizia il punto circolare. Durante il round di punti, il giocatore deve tirare continuamente 2 d6s fino a quando la persona ottiene un 7 o il suo punto dal round precedente. Se la persona ottiene un 7, perde. Se ottengono il loro punto, vincono.

Sfida

Implementa un semplice programma che simula un gioco di craps. Se la persona tira un naturale o uno schifo durante il round di lancio, il programma dovrebbe produrre "Natural:" o "Crapping out:" seguito dal lancio del dado e quindi uscire. Altrimenti, dovrebbe essere visualizzato "Punto:" seguito dal punto. Quindi, durante il round di punti, dovrebbe emettere ogni tiro di dado fino a raggiungere un 7 o il punto. Se la persona vince, dovrebbe produrre "Pass"; se lo perdono dovrebbe essere prodotto "Don't Pass".

Implementazione di riferimento

Groovy, 277 byte

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

Provalo online.

Output di esempio

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

e

Point: 5
3
7
Don't Pass

Questo è code-golf , quindi vince il codice più corto.

(ESCLUSIONE DI RESPONSABILITÀ: questa sfida non ha lo scopo di promuovere il gioco d'azzardo in alcun modo. Ricorda, la casa vince sempre.)

Ruby 164

Abbastanza diretto. Caratteristiche interessanti:

I casi di crapping sono riassunti come r%12<4e i rimanenti casi naturali sono riassunti come r%4==3.

La stringa iniziale viene archiviata ce vengono eseguiti ulteriori tiri solo se questa è successiva in ordine alfabetico rispetto alla singola lettera ?P(che si verifica solo per 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 byte

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

Questo si basa sulla risposta di Celeo ; Ho sostituito alcuni lunghi condizionali con un numero magico che codifica una LUT per ciascun numero, riutilizzato una variabile e fatto alcuni altri golf vari. Ancora spazio per il golf; è probabilmente possibile ottenere meno di 170.

Non ho provato ad usare Python 2, quindi non so se sarebbe più corto.

C99, 366 312 293 277 byte

Questo è il mio primo post qui, quindi indovinerò che questo può essere migliorato di molto.

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

Versione estesa

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

Come puoi vedere, c'è una buona quantità di ridondanza qui che molto probabilmente può essere eliminata.

Ringraziamo @Mego per aver contribuito a ridurlo.

Python 2, 226 224 byte

Primo passaggio e c'è molto codice lì:

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"

Grazie a Mego per 2 byte!

PHP 230 228 218 199 192 188 byte

186 byte senza il <?

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

Primo tentativo di code golf! Non sei sicuro se l'utilizzo </br>sarebbe consentito però? Poiché ciò non funzionerebbe in una console (come una nuova linea). Fammi sapere se questo non è permesso e cambierà il mio codice.

EDIT (16-8-16): Dopo essere migliorato con codegolf ho notato alcuni possibili miglioramenti. Funziona ancora usando l'interfaccia della riga di comando. sostituito</br> con un duro invio.

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 byte

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}

Provalo online!

PowerShell , 181 183 179 178 167 165 byte

^{-10 byte grazie a
-2 byte smaglianti grazie 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'}}

Provalo online!

Versione non srotolata:

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

Ci sono alcuni punti critici in meno ora che la logica di costruzione dell'elenco è stata ricostruita in uno switch. Penso che sia ancora un approccio abbastanza valido. +2 byte che risolvono un bug.

R, 197 byte

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

Ungolfed

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 byte

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

Provalo online!

Primo passaggio, probabilmente può trovare qualche risparmio.

Incantesimi runici , 151 byte

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

Provalo online!

Dopo aver corretto un bug relativo ai numeri casuali (veniva re-seeding ogni volta 'RA veniva chiamato, e il seed era tempo di sistema, con conseguenti massicce sequenze di valori ripetuti), questo funzionava correttamente.

Spiegazione

L'ingresso è sulla seconda riga, poiché la prima riga fino a quando B͍è una funzione per tirare due dadi e sommarli.

Flusso del programma, con alcuni reindirizzamenti arricciati e arricciati per la lettura

   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)

Ci sono solo 4 istruzioni NOP ( {:}≠...?\.6?) che sarebbe molto difficile da rimuovere a causa dello spazio richiesto su altre linee (vale a dire la lunghezza della "Don't "stringa).