Craps ist ein ziemlich einfaches Würfelspiel, das oft in Casinos gespielt wird. Auch wenn Sie kein Spieler sind (was ich nicht bin), ist es immer noch ein ziemlich interessantes Spiel. Hier sind die Regeln:

Zu Beginn eines Craps-Spiels gibt es eine sogenannte Come-out- Runde. Der Spieler würfelt mit zwei Würfeln (sechsseitiger Würfel) und die beiden Würfelwürfe werden addiert. Wenn das Ergebnis 7 oder 11 ist, gewinnt die Person automatisch (dies wird als natürlich bezeichnet ). Wenn das Ergebnis 2, 3 oder 12 ist, verliert die Person automatisch (dies wird als Ausscheißen bezeichnet ). Andernfalls wird das Ergebnis als Punkt für die Punktrunde festgelegt.

Danach beginnt die Punkterunde . Während der Punkterunde muss der Spieler kontinuierlich 2 W6 würfeln, bis die Person eine 7 oder ihren Punkt aus der vorherigen Runde würfelt. Wenn die Person eine 7 würfelt, verliert sie. Wenn sie ihren Punkt rollen, gewinnen sie.

Herausforderung

Implementieren Sie ein einfaches Programm, das ein Würfelspiel simuliert. Wenn die Person während der Come-Out-Runde ein Natural oder Crap-Out würfelt, sollte das Programm "Natural:" oder "Crapping out:" ausgeben, gefolgt vom Würfelwurf und dann beenden. Andernfalls sollte "Point:" gefolgt von dem Punkt ausgegeben werden. Dann sollte es während der Punktrunde jeden Würfelwurf ausgeben, bis eine 7 oder der Punkt erreicht ist. Wenn die Person gewinnt, sollte sie ausgeben "Pass"; Wenn sie verlieren, sollte es ausgegeben werden "Don't Pass".

Referenzimplementierung

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

Probieren Sie es online aus.

Beispielausgaben

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

und

Point: 5
3
7
Don't Pass

Das ist Code-Golf , also gewinnt der kürzeste Code.

(HAFTUNGSAUSSCHLUSS: Diese Herausforderung soll das Glücksspiel in keiner Weise fördern. Denken Sie daran, dass das Haus immer gewinnt.)

Ruby 164

Ziemlich einfach. Interessante Funktionen:

Die Ausscheidungsfälle werden wie folgt zusammengefasst r%12<4und die übrigen natürlichen Fälle werden wie folgt zusammengefasst r%4==3.

Die Anfangszeichenfolge wird in gespeichert cund weitere Rollen werden nur dann genommen, wenn dies alphabetisch später ist als der einzelne Buchstabe ?P(der nur für Point. Vorkommt).

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

Dies basiert auf Celeos Antwort ; Ich habe einige langwierige Bedingungen durch eine magische Zahl ersetzt, die eine LUT für jede Zahl codiert, eine Variable wiederverwendet und ein paar andere verschiedene Golfspiele durchgeführt. Noch Platz zum Golfen; es ist wahrscheinlich möglich, unter 170 zu bekommen.

Ich habe nicht versucht, Python 2 zu verwenden, daher weiß ich nicht, ob es kürzer sein würde.

C99, 366 312 293 277 Bytes

Dies ist mein erster Beitrag hier, also werde ich vermuten, dass dies um einiges verbessert werden kann.

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

Erweiterte Version

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

Wie Sie sehen, gibt es hier eine Menge Redundanz, die höchstwahrscheinlich beseitigt werden kann.

Wir danken @Mego für ihre Hilfe bei der Verkleinerung.

Python 2, 226 224 Bytes

Erster Durchgang und da ist viel 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"

Danke an Mego für 2 Bytes!

PHP 230 228 218 199 192 188 Bytes

186 Bytes ohne die <?

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

Erster Versuch, Code Golf zu spielen! Sie sind sich nicht sicher, ob die Verwendung </br>zulässig wäre? Da dies in einer Konsole nicht funktionieren würde (als neue Zeile). Lassen Sie mich wissen, wenn dies nicht erlaubt ist und meinen Code ändern wird.

EDIT (16-8-16): Nachdem ich mich im Codegolf verbessert hatte, bemerkte ich einige mögliche Verbesserungen. Dies funktioniert immer noch über die Befehlszeilenschnittstelle. Ersetzt </br>mit einem harten Enter.

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}

Probieren Sie es online!

PowerShell , 181 183 179 178 167 165 Byte

^{-10 Bytes dank mazzy
-2 Bytes dank 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'}}

Probieren Sie es online!

Abgerollte Version:

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

Es gibt jetzt ein paar Punkte weniger, da die Listenerstellungslogik in einen Schalter umgebaut wurde. Ich denke, es ist immer noch ein ziemlich guter Ansatz. +2 Bytes, die einen Fehler beheben.

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

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

Probieren Sie es online!

Erster Durchgang, kann wahrscheinlich ein paar Einsparungen finden.

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

Probieren Sie es online!

Nachdem ein Fehler in Bezug auf Zufallszahlen behoben wurde (es wurde jedes Mal 'RAneu gesetzt, und der Startwert war die Systemzeit, was zu massiven Läufen wiederholter Werte führte), funktioniert dies korrekt.

Erläuterung

Die Eingabe erfolgt in der zweiten Zeile, als erste Zeile bis B͍ eine Funktion zum Würfeln und Summieren von zwei Würfeln ist.

Programmablauf, wobei einige Kantenumbrüche und gekräuselte Umleitungen zur besseren Lesbarkeit entfernt wurden

   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)

Es gibt nur 4 NOP-Anweisungen ( {:}≠...?\.6?), die aufgrund des in anderen Zeilen erforderlichen Platzes (dh der Länge der "Don't "Zeichenfolge) nur sehr schwer zu entfernen wären .