क्रेप्स एक बहुत ही सरल पासा खेल है जो अक्सर केसिनो में खेला जाता है। भले ही आप एक जुआरी नहीं हैं (जो मैं नहीं हूं), यह अभी भी एक काफी दिलचस्प खेल है। यहाँ नियम हैं:

क्रेप्स के एक खेल की शुरुआत में वहाँ है जिसे आऊट -आउट दौर कहा जाता है । खिलाड़ी दो d6s (छह-पक्षीय मर) को रोल करता है और दो डाई रोल जोड़े जाते हैं। यदि परिणाम 7 या 11 है, तो व्यक्ति स्वचालित रूप से जीतता है (यह एक प्राकृतिक के रूप में जाना जाता है )। यदि परिणाम 2, 3 या 12 है, तो व्यक्ति स्वचालित रूप से खो देता है (इसे क्रैपिंग आउट के रूप में जाना जाता है )। अन्यथा, परिणाम बिंदु के रूप में सेट किया गया है बिंदु दौर के लिए ।

इसके बाद, बिंदु दौर शुरू होता है। पॉइंट राउंड के दौरान, खिलाड़ी को लगातार 2 d6 रोल करना चाहिए, जब तक कि व्यक्ति पिछले राउंड से 7 या उसके पॉइंट को रोल न कर दे। यदि व्यक्ति 7 रोल करता है, तो वे हार जाते हैं। अगर वे अपनी बात पर अमल करते हैं, तो वे जीत जाते हैं।

चुनौती

एक साधारण कार्यक्रम को लागू करें जो क्रेप्स के खेल को अनुकरण करता है। यदि व्यक्ति आने वाले दौर के दौरान एक प्राकृतिक या बकवास-बाहर रोल करता है, तो प्रोग्राम को "प्राकृतिक:" या "क्रैपिंग आउट:" का उत्पादन करना चाहिए और उसके बाद डाई-रोल से बाहर निकलें। अन्यथा, इसे "बिंदु:" बिंदु के बाद आउटपुट करना चाहिए। फिर, बिंदु दौर के दौरान, इसे 7 या बिंदु तक पहुंचने तक हर डाई-रोल का उत्पादन करना चाहिए। यदि व्यक्ति जीतता है, तो इसे आउटपुट करना चाहिए "Pass"; अगर वे इसे खो देते हैं तो इसका उत्पादन होना चाहिए "Don't Pass"।

संदर्भ कार्यान्वयन

ग्रूवी, 277 बाइट्स

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

इसे ऑनलाइन आज़माएं।

नमूना आउटपुट

Natural: 7

Crapping out: 3

Point: 9
4
8
11
9
Pass

तथा

Point: 5
3
7
Don't Pass

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

(अस्वीकरण: यह चुनौती किसी भी तरह से जुआ को बढ़ावा देने के उद्देश्य से नहीं है। याद रखें, घर हमेशा जीतता है।)

code-golf game random

— एक स्पैगेटो
स्रोत

You can't make your program shorter by picking a random number between 1 and 12 for the die roll; it must be two numbers picked between 1 and 6.

- [1, 6] में दो समान यादृच्छिक मूल्यों को जोड़ने के लिए समान वितरण से [1, 12] में यादृच्छिक मूल्य चुनने के बारे में क्या?

— मेगो

@ मेगो वाह, पुरानी चुनौती। हां यह ठीक रहेगा। मुझे लगता है कि चेतावनी केवल यह सुनिश्चित करने के लिए थी कि लोग यह महसूस करें कि [1, 12] के बीच एक समान वितरण 2d6 के समान नहीं है। मैं इसे फिर से लिखूंगा।

— एक स्पेगेटो

6

रूबी 164

बहुत सीधा। दिलचस्प विशेषताएं:

बाहर निकलने वाले मामलों को संक्षेप में प्रस्तुत किया जाता है r%12<4और शेष प्राकृतिक मामलों को संक्षेप में प्रस्तुत किया जाता हैr%4==3 ।

प्रारंभिक स्ट्रिंग में संग्रहीत किया जाता है cऔर आगे रोल केवल तभी लिया जाता है यदि यह बाद में एकल अक्षर ?P(जो केवल इसके लिए होता है 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")

— स्तर नदी सेंट
स्रोत

जिस तरह से आप 2,3,7,11 या 12 सेपरेटली के बजाय शेष के लिए जांच करते हैं, उससे प्यार करें!

— जेरोएन

6

पायथन 3, 190 बाइट्स

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

यह पर आधारित है सेलेओ के जवाब ; मैंने एक जादुई संख्या के साथ कुछ लम्बी सशर्तियों को प्रतिस्थापित किया जो प्रत्येक संख्या के लिए एक LUT को एन्कोड करता है, एक चर का पुन: उपयोग करता है, और कुछ अन्य विविध गोल्फ करता है। अभी भी गोल्फ के लिए कमरा; यह संभवत: 170 से कम है।

मैंने पायथन 2 का उपयोग करने की कोशिश नहीं की, इसलिए मुझे नहीं पता कि यह छोटा होगा या नहीं।

— lirtosiast
स्रोत

1

यह समझाने की परवाह करें कि आपको वह जादू नंबर कैसे मिला और यह कैसे काम करता है?

— कार्ल नेफ

5

C99, 366 312 293 277 बाइट्स

यह मेरी पहली पोस्ट है, इसलिए मैं यह अनुमान लगाने जा रहा हूं कि इसमें बहुत सुधार किया जा सकता है।

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

विस्तारित संस्करण

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

जैसा कि आप देख सकते हैं, यहां अतिरेक की एक अच्छी मात्रा है जो सबसे अधिक संभावना के साथ दूर किया जा सकता है।

इसे छोटा बनाने में मदद के लिए @Mego को श्रेय।

— क्रिस लूनम
स्रोत

1

जब तक यह कहीं संकलित करता है, आप अच्छे हैं।

— lirtosiast

@Mego कि बाहर इंगित करने के लिए धन्यवाद, कि 19 बाइट्स से छुटकारा पाने में कामयाब रहे।

— बजे क्रिस लूनम

से छुटकारा पाने के लिए रवाना कुछ और समझे aऔर bऔर भी त्रिगुट ऑपरेटरों के साथ घटाव विधि का उपयोग कर।

— बजे क्रिस लूनम

5

पायथन 2, 226 224 बाइट्स

पहले पास और वहाँ बहुत कोड है:

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"

2 बाइट्स के लिए मीगो को धन्यवाद !

— Celeo
स्रोत

इसके साथ कुछ मुद्दे। यह "प्वाइंट:" प्रिंट नहीं करता है, यदि रोल प्राकृतिक या बकवास नहीं था, तो नंबर के बाद। इसके अलावा: और संख्या के बीच एक स्थान होना चाहिए।

— एक स्पेगेटो

ओह! फिक्स्ड प्रिंटिंग नहीं 'प्वाइंट: #'। आउटपुट में, एक स्थान है।

— सेलेओ

आह अच्छा। मैं अब पायथन का उपयोग नहीं करता हूं इसलिए मैं अनिश्चित था कि कैसे, एक काम करता है।

— एक स्पेगेटो

मैंने पायथन 3 में आपका कोड 198 तक घटा दिया, जो कि पायथन 2 में 192 है। क्या आप सुझाव चाहते हैं, या मुझे अपना जवाब पोस्ट करना चाहिए?

— २

@ThomasKwa यदि आप इसमें काम का एक गुच्छा रखते हैं, तो एक अलग उत्तर के रूप में पोस्ट करें ताकि आप इसके लिए कुछ प्रतिनिधि प्राप्त कर सकें।

— सेलेओ

3

पीएचपी 230 228 218 199 192 188 बाइट्स

186 बाइट बिना <?

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

कोड गोल्फ में पहला प्रयास! सुनिश्चित नहीं है कि अगर उपयोग करने </br>की अनुमति होगी, हालांकि? चूंकि यह कंसोल (नई लाइन के रूप में) में काम नहीं करेगा। मुझे बताएं कि क्या यह अनुमति नहीं है और मेरे कोड को बदल देगा।

EDIT (16-8-16): कोडगॉल्फ में बेहतर होने के बाद मैंने कुछ संभावित सुधारों पर ध्यान दिया। यह अभी भी कमांड लाइन इंटरफेस का उपयोग करके काम करता है। </br>एक हार्ड दर्ज के साथ प्रतिस्थापित ।

— जेरोन
स्रोत

प्राकृतिक "प्राकृतिक" वर्तनी है और "नेचरल" नहीं है।

— कृति लीथोस

उसे बदल दिया। धन्यवाद

— जेरोन

2

जावास्क्रिप्ट 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)}}

— user902383
स्रोत

1

पर्ल 5 , 140 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

पॉवरशेल , 181 183 179 178 167 165 बाइट्स

^{-10 बाइट्स धन्यवाद mazzy}
^{-2 बाइट्स एक्सकली के लिए धन्यवाद}

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

इसे ऑनलाइन आज़माएं!

अनियंत्रित संस्करण:

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

अब कुछ कम चिपके हुए बिंदु हैं कि सूची-निर्माण तर्क को एक स्विच में फिर से बनाया गया है। मुझे लगता है कि यह अभी भी एक बहुत ठीक दृष्टिकोण है। +2 बाइट्स बग फिक्स करना।

— Veskah
स्रोत

1

बहुत बढ़िया! इसे 178 बाइट

— mazzy

मुझे लगता है कि हालत -notin (7,$z)प्रासंगिक नहीं है नियम नियम During the point round, the player must continuously roll ... the previous round। अब लूप पूरा होने $mपर 7या पहले राउंड के बराबर होता है ।

— माज़ी

1

@mazzy यह सवाल में एक मुद्दा है। केवल दो राउंड है। आपने केवल एक बार Come-outराउंड में पॉइंट सेट किया है और पूरे Pointराउंड के लिए आपका टारगेट नंबर है । दौर का previous roundउल्लेख हैCome-out

— Veskah

1

धन्यवाद। 168 बाइट्स

— माज़ी

2

आपको 1?अपने क्रेप्स रेगेक्स से हटाकर दो और लेने में सक्षम होना चाहिए ।

— Xcali

0

आर, 197 बाइट्स

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

— user5957401
स्रोत

0

अजगर , 108 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पहली पास, शायद कुछ बचत पा सकते हैं।

— सोक
स्रोत

0

रूनिक एनचेंमेंट्स , 151 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यादृच्छिक संख्याओं के बारे में एक बग को ठीक करने के बाद (यह हर बार फिर से बोया गया था 'RA गया था, और बीज प्रणाली समय था, जिसके परिणामस्वरूप दोहराया मूल्यों के बड़े पैमाने पर रन) यह सही ढंग से काम करता है।

व्याख्या

दूसरी पंक्ति में प्रवेश पहली पंक्ति के रूप में होता है B͍ है कि दो पासा को रोल करने और उन्हें समेटने के लिए एक फ़ंक्शन नहीं है।

कार्यक्रम प्रवाह, कुछ बढ़त-लपेटकर और पठनीयता के लिए घुमावदार पुनर्निर्देशन के साथ

   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)

केवल 4 एनओपी निर्देश ( {:}≠...?\.6?) हैं जिन्हें अन्य लाइनों (आवश्यक रूप से लंबाई की लंबाई "Don't ") पर आवश्यक स्थान के कारण निकालना बहुत मुश्किल होगा ।

— Draco18s को अब SE पर भरोसा नहीं है
स्रोत

क्रेप्स का एक खेल अनुकरण

चुनौती

संदर्भ कार्यान्वयन

नमूना आउटपुट

रूबी 164

पायथन 3, 190 बाइट्स

C99, 366 312 293 277 बाइट्स

विस्तारित संस्करण

पायथन 2, 226 224 बाइट्स

पीएचपी 230 228 218 199 192 188 बाइट्स

जावास्क्रिप्ट 262

पर्ल 5 , 140 बाइट्स

पॉवरशेल , 181 183 179 178 167 165 बाइट्स

आर, 197 बाइट्स

अजगर , 108 बाइट्स

रूनिक एनचेंमेंट्स , 151 बाइट्स

व्याख्या