Craps to dość prosta gra w kości, często grana w kasynach. Nawet jeśli nie jesteś hazardzistą (a ja nie jestem), wciąż jest to dość interesująca gra. Oto zasady:

Na początku gry w Craps jest tak zwana runda come-out . Gracz rzuca dwoma k6 (sześciościenna kość) i dodaje dwa rzuty. Jeśli wynik to 7 lub 11, osoba automatycznie wygrywa (jest to znane jako naturalne ). Jeśli wynik wynosi 2, 3 lub 12, osoba automatycznie przegrywa (to się nazywa wyniszczenie ). W przeciwnym razie, wynik jest ustawiony jako punkt za punkt rundzie.

Następnie rozpoczyna się runda punktowa . Podczas rundy punktowej gracz musi nieprzerwanie rzucać 2 k6s, aż osoba rzuci 7 lub swój punkt z poprzedniej rundy. Jeśli osoba wyrzuci 7, przegrywa. Jeśli wyrzucą punkt, wygrywają.

Wyzwanie

Zaimplementuj prosty program symulujący grę w kości. Jeśli dana osoba wyrzuci naturalny lub bzdury podczas rundy come-out, program powinien wypisać „Natural:” lub „Crapping out:”, a następnie rzut i następnie wyjść. W przeciwnym razie powinien wypisać „Punkt:”, a następnie punkt. Następnie, podczas rundy punktowej, powinien generować każdy rzut kością, aż do 7 lub punktu. Jeśli dana osoba wygra, powinna wyjść "Pass"; jeśli przegrają, powinien wyjść "Don't Pass".

Realizacja referencji

Groovy, 277 bajtów

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

Wypróbuj online.

Przykładowe wyniki

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

i

Point: 5
3
7
Don't Pass

To jest golf golfowy , więc wygrywa najkrótszy kod.

(OŚWIADCZENIE: To wyzwanie nie ma na celu promowania hazardu w jakikolwiek sposób. Pamiętaj, że dom zawsze wygrywa.)

Ruby 164

Całkiem proste. Ciekawe funkcje:

Przypadki odrzucania są podsumowane jako, r%12<4a pozostałe przypadki naturalne są podsumowane jako r%4==3.

Początkowy ciąg jest przechowywany w, ca kolejne rolki są pobierane tylko wtedy, gdy jest to później alfabetycznie niż pojedyncza litera ?P(co występuje tylko dla 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 bajtów

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

Jest to oparte na odpowiedzi Celeo ; Kilka długich warunkowych zastąpiłem magiczną liczbą, która koduje LUT dla każdej liczby, ponownie użyłem zmiennej i zrobiłem kilka innych golfów. Jeszcze miejsce na golfa; prawdopodobnie można uzyskać mniej niż 170.

Nie próbowałem używać Pythona 2, więc nie wiem, czy byłby krótszy.

C99, 366 312 293 277 bajtów

To jest mój pierwszy post tutaj, więc zgaduję, że można to znacznie poprawić.

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

Wersja rozszerzona

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

Jak widać, istnieje tutaj duża ilość nadmiarowości, którą najprawdopodobniej można wyeliminować.

Podziękowania dla @Mego za pomoc w zmniejszeniu tego.

Python 2, 226 224 bajty

Pierwsze przejście i jest tam dużo kodu:

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"

Dzięki Mego za 2 bajty!

PHP 230 228 218 199 192 188 bajtów

186 bajtów bez <?

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

Pierwsza próba golfa kodowego! Nie </br>jesteś pewien, czy użycie byłoby dozwolone? Ponieważ nie działałoby to w konsoli (jako nowa linia). Daj mi znać, jeśli nie jest to dozwolone i zmieni mój kod.

EDYCJA (16-8-16): Po poprawie umiejętności gry w codegolf zauważyłem kilka możliwych ulepszeń. To nadal działa przy użyciu interfejsu wiersza polecenia. Zastąpiony </br>trudnym wejściem.

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 bajtów

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}

Wypróbuj online!

PowerShell , 181 183 179 178 167 165 bajtów

^{-10 bajtów dzięki mazzy
-2 bajty dzięki 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'}}

Wypróbuj online!

Wersja rozwinięta:

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

Teraz jest kilka mniej istotnych punktów, gdy logika tworzenia listy została przebudowana na przełącznik. Myślę, że nadal jest to całkiem w porządku podejście. +2 bajty naprawiające błąd.

R 197 bajtów

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

Bez golfa

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 bajtów

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

Wypróbuj online!

Pierwsze przejście, prawdopodobnie znajdziesz kilka oszczędności.

Runiczne Zaklęcia , 151 bajtów

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

Wypróbuj online!

Po naprawieniu błędu dotyczącego liczb losowych (za każdym razem 'RAwywoływano ponowne inicjowanie , a czas początkowy był czasem systemowym, co powodowało masowe uruchamianie powtarzanych wartości), działa to poprawnie.

Wyjaśnienie

Wejście znajduje się w drugiej linii, ponieważ pierwsza linia do góry B͍jest funkcją rzucania dwiema kostkami i ich sumowania.

Przebieg programu, z pewnymi zawijanymi krawędziami i zwiniętymi przekierowaniami dla czytelności

   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)

Są tylko 4 instrukcje NOP ( {:}≠...?\.6?), które byłyby bardzo trudne do usunięcia ze względu na wymaganą przestrzeń w innych wierszach (mianowicie długość "Don't "łańcucha).