एक दुबला, मतलब बीन मशीन

Question

एक असतत संभाव्यता वितरण की अवधारणा से लोगों को परिचित कराने का एक उत्कृष्ट उदाहरण है बीन मशीन । इस मशीन के शीर्ष पर एक संकीर्ण मार्ग से बड़ी मात्रा में पत्थर गिरते हैं, जिसके बाद वे परस्पर पिन की पंक्तियों को मारते हैं, जहां प्रत्येक पिन पर संगमरमर हिट होता है यह पिन के बाईं या दाईं ओर गिर सकता है। अंत में, पिन को मशीन के निचले भाग में लंबवत डिब्बे में एकत्र किया जाता है। इस मशीन का एक सरल आरेख इस तरह दिखता है:

|     O     |
|     ^     |
|    ^ ^    |
|   ^ ^ ^   |
|  ^ ^ ^ ^  |
| ^ ^ ^ ^ ^ |
|_|_|_|_|_|_|

इस आरेख में, उस Oस्थान को इंगित करता है जहां से पत्थर गिरते हैं। प्रत्येक ^एक पिन होता है, जिस पर संगमरमर को बाईं ओर या पिन के दाईं ओर वर्ग में ले जाने का 50% मौका होता है। मार्बल्स तब उपकरण के तल पर डिब्बे में इकट्ठा होते हैं, और बड़ी संख्या में मार्बल्स के लिए, डिब्बे में संगमरमर के ढेर की ऊंचाई एक असतत द्विपद वितरण के समान होगी।

चुनौती

इस चुनौती के लिए, आप ऊपर की तरह आरेखों के आधार पर बीन मशीनों के परिणामी संभाव्यता वितरण की गणना करेंगे। आरेखों की व्याख्या एक दो-आयामी 'कार्यक्रम' के रूप में की जाती है, जो मार्बल्स से होकर गुजरती है, या तो खेतों की ओर या वर्तमान क्षेत्र के नीचे के क्षेत्रों की ओर। जब मार्बल्स मशीन के निचले हिस्से में पहुंचते हैं तो उन्हें संभाव्यता वितरण के लिए गिना जाता है। इसे दिलचस्प बनाए रखने के लिए, इन आरेखों में साधारण स्रोत और पिनों की तुलना में कुछ अधिक फ़ील्ड होंगे। एक उदाहरण आरेख है:

|     O     |
|     ^     |
|    ^ /    |
|   ^ | ^   |
|  <^- =  v |
| ^ ^ ^ ^ ^ |

इसके अलावा, अब प्रत्येक के पास एक रोटेशन दिशा है। यह दिशा कुछ क्षेत्रों द्वारा निर्धारित की जाती है और यह निर्धारित करती है कि किस क्षेत्र में संगमरमर कई अन्य क्षेत्रों में चलता है।

निम्नलिखित क्षेत्रों को परिभाषित किया गया है:

• O: स्रोत इसके नीचे सीधे पत्थर दिखाई देते हैं। इन मार्बल्स की दिशा 50% बाएं, 50% दाईं ओर है। प्रत्येक स्रोत समान मात्रा में पत्थर का उत्पादन करता है।
• U: सिंक। इस क्षेत्र में प्रवेश करने वाले किसी भी पत्थर को बीन मशीन से हटा दिया जाता है।
• : खाली जगह। यदि कोई संगमरमर इस क्षेत्र में आता है, तो यह नीचे के क्षेत्र में चला जाएगा।
• -: मंज़िल। यदि कोई संगमरमर इस क्षेत्र में आता है, तो वह अपनी वर्तमान दिशा के आधार पर या तो बाईं ओर या दाईं ओर फ़ील्ड में स्थानांतरित हो जाएगा।
• ^: फाड़नेवाला। यदि कोई संगमरमर इस क्षेत्र में आता है, तो यह 50% क्षेत्र को दाईं ओर या फ़ील्ड को बाईं ओर से अलग करता है। यह भी संगमरमर की दिशा निर्धारित करता है।
• v: सम्मिलित हों। यदि कोई संगमरमर इस क्षेत्र में आता है, तो यह नीचे के क्षेत्र में चला जाएगा।
• /: धीमा पैड। यदि कोई संगमरमर इस क्षेत्र में आता है, तो यह संगमरमर की दिशा निर्धारित करते हुए, पैड के बाईं ओर स्थित क्षेत्र में चला जाएगा।
• \: पिछले के समान, लेकिन दाईं ओर।
• |: परावर्तक। यदि कोई संगमरमर इस क्षेत्र में आता है, तो यह संगमरमर की दिशा को उलट देगा, और इस उलट दिशा के आधार पर संगमरमर को दाएं या बाएं क्षेत्र में ले जाएगा।
• =: तोप। यदि कोई संगमरमर इस क्षेत्र में आता है, तो वह इसे वर्तमान दिशा में दाईं या बाईं ओर ले जाएगा, जब तक कि संगमरमर एक क्षेत्र का सामना नहीं करता है , -या नहीं O।
• <: पिछले की तरह ही, लेकिन हमेशा दिशा निर्धारित करेगा और बाईं ओर बढ़ेगा।
• >: पिछले के समान, लेकिन दाईं ओर।

आरेख के संबंध में निम्नलिखित गारंटी दी गई है।

• प्रत्येक इनपुट पंक्ति में फ़ील्ड्स की लंबाई समान होगी।
• प्रत्येक पंक्ति का सबसे बाएँ और दाएँ क्षेत्र हमेशा एक होगा |।
• आरेख में कोई भी संभावित पथ नहीं होगा, जिसके माध्यम से मशीन पुनरावृत्तियों की अनिश्चित मात्रा के लिए मशीन में अटक सकती है, जैसे \/या ^^।
• आरेख में केवल उपर्युक्त क्षेत्र होंगे।
• एक या अधिक स्रोत हैं

परिणाम

आपका कार्य प्रायिकता वितरण का 16-लाइन लंबा ASCII बार ग्राफ उत्पन्न करना होगा, जिसमें मार्बल ग्राफ़ के नीचे की ओर से बाहर निकलता है, इसलिए सबसे बड़ी प्रायिकता सभी 16 वर्णों को कवर करती है। तो निम्नलिखित समस्या के लिए:

|     O     |
|     ^     |
|    ^ ^    |
|   ^ ^ ^   |
|  ^ ^ ^ ^  |
| ^ ^ ^ ^ ^ |

आपके कार्यक्रम को निम्नलिखित समाधान का उत्पादन करना चाहिए (ध्यान दें कि इसमें इनपुट प्रोग्राम के समान चौड़ाई होनी चाहिए, जिसमें पाइप शामिल हैं:

     # #     
     # #     
     # #     
     # #     
     # #     
     # #     
     # #     
     # #     
   # # # #  
   # # # #  
   # # # #  
   # # # #  
   # # # #  
   # # # #  
 # # # # # #
 # # # # # # 

उदाहरण

निम्नलिखित एक उदाहरण है जो सभी विभिन्न प्रकारों की कार्यक्षमता का परीक्षण करना चाहिए:

|     O     O         |
|  O  ^ /  <^\\\      |
|    ^ >            ^ |
|   ^ ^ ^            =|
|  ^ ^ | ^    <^   O  |
| ^ > ^ | ^   O ^> v  |
||  ^U  ^  |  =    ^\ |
|  ^ ^ ^ ^U ^\ ---^   |
| = ^   ^     =    v  |

इसका परिणाम निम्न आउटपुट में होना चाहिए:

                     # 
                     # 
                     # 
                     # 
                   # # 
                   # # 
                   # # 
       # #         # # 
       # #         # # 
       # #         # # 
       # #         # # 
      ## #         # # 
      ## # #       # # 
   # ### # #       # # 
 # # ### # #       # # 
 # # ### # #       # # 

नियम

दोनों कार्य और पूर्ण कार्यक्रम इस चुनौती के लिए मान्य उत्तर देते हैं। आप आरेख को एक नईलाइन-पृथक स्ट्रिंग के रूप में प्राप्त करेंगे, और आपको दिए गए प्रारूप में आउटपुट ग्राफ को वापस करना चाहिए। डिफ़ॉल्ट इनपुट / आउटपुट नियम लागू होते हैं। आउटपुट में अनुगामी और अग्रणी न्यूलाइन्स की अनुमति होती है, प्रत्येक पंक्ति में इनपुट के समान चौड़ाई होनी चाहिए।

जैसा कि अधिक रचनात्मक समाधानों की अनुमति देने के लिए, केवल यह आवश्यक है कि आपका कार्यक्रम उसी आरेख के लिए 90% से अधिक समय के सही परिणाम का उत्पादन करे। यह सब के बाद एक संभावना सिमुलेशन है।

स्कोरिंग

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

Comments

बहुत सरल लेकिन संबंधित ।

— पीटर टेलर

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

तो v= [space]?

— l4m2

@ l4m2 vऔर [space]तोपों के आसपास कैसे बातचीत करते हैं, इसमें अंतर है।

— CensoredUsername

Answer 1

पायथन 3 , 431 429 410 बाइट्स

def t(a):e=enumerate;p=a.split("\n");o=[0]*len(p[0]);{m(i,j,p,o,1):m(i,j,p,o,-1)for i,r in e(p)for j,c in e(r)if"O"==c};[print("".join(" #"[round(16*r/max(o)+i)>15]for r in o))for i in range(16)]
def m(r,k,p,o,l,x=1):
 while r<len(p):
  c=p[r][k]
  if"^"==c:x/=2;m(r,k-l,p,o,l,x)
  if"U"==c:return
  if c in" vO":r+=1;continue
  l=[1,l,-1,l,-l,1][ord(c)%6];k-=l
  while";"<c<"?"and p[r][k]in" O-":k-=l
 o[k]+=x

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

यह उत्तर गेहूं के जादूगर और सेंसरडॉउसरनाम के बीच एक सहयोगी प्रयास है। संदर्भ के लिए, यह अनलॉल्फ एल्गोरिथ्म है।

श्री एक्सकोडर से -2 बाइट्स

-19 CensoredUsername से बाइट्स

Comments

-2 बाइट्स यदि आप पायथन 2 (प्रिंट स्टेटमेंट) पर जाते हैं?

— caird coinheringaahing

इसमें से कहा गया था: but I can confirm it's doable in 519 characters of python 3 code ;) I don't think I can golf mine much more- CensoredUsername

— स्टीफन

जब मैंने कहा कि मैं बहुत भोली थी। उस ने कहा, गोल्फ प्रतियोगिता सुनिश्चित करना काफी मनोरंजक था। इसके अलावा @cairdcoinheringaahing, python 2 का प्रिंट स्टेटमेंट एक स्टेटमेंट है, न कि एक एक्सप्रेशन। और इसलिए इसे लिस्ट कॉम्प्रिहेंशन में इस्तेमाल नहीं किया जा सकता है। इसका मतलब यह होगा कि शीर्ष पर स्थित एलाइनर को कई इंडेंटेड लाइनों में विभाजित किया जाना है, जो 2 बाइट को शून्य से हटाने में मदद करेगा।

— CensoredUsername

Answer 2

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

i=raw_input
l=i()
c=[]
while l:c,l=c+[l],i()
p=[[0]*len(l)for l in c]+[[0]*max(map(len,c))]
S=lambda r,C,p:r>=0and C>=0and r<len(p)and C<len(p[r])
def U(r,C,P,D,N=0):
 if S(r,C,p):p[r][C]+=P
 if S(r,C,c):
	K=c[r][C]
	if K in' O':U(r+1-N,C+D*N,P,D,N)
	elif'v'==K:U(r+1,C,P,D)
	elif'-'==K:U(r,C+D,P,D,N)
	elif'^'==K:U(r,C-1,P/2,-1);U(r,C+1,P/2,1)
	elif'/'==K:U(r,C-1,P,-1)
	elif'\\'==K:U(r,C+1,P,1)
	elif'='==K:U(r,C+D,P,D,1)
	elif'>'==K:U(r,C+1,P,1,1)
	elif'<'==K:U(r,C-1,P,-1,1)
	elif'|'==K:U(r,C-D,P,-D)
for r in range(len(c)):
 for C in range(len(c[r])):
	if'O'==c[r][C]:U(r+1,C,1.,1);U(r+1,C,1.,-1)
p=p[-1][::-1]
s=16/max(p)
f=['#'*min(int(n*s),16)+' '*min(int(16-n*s),16)for n in p]
print('\n'.join(map(''.join,zip(*f)))[::-1])

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

-17 बाइट्स के लिए धन्यवाद caird coinheringaahing

-12 बाइट्स नाथन शेरीनी को धन्यवाद

-56 बाइट्स मिश्रित इंडेंटेशन पर स्विच करके (पायथन 2)

-28 CensoredUsername के लिए धन्यवाद क्योंकि संभावनाएं अंत में सामान्यीकृत होती हैं, इसलिए यह आवश्यक नहीं है कि अंतिम संभावनाएं हमेशा 1 तक जोड़ दें।

-7 बाइट्स कम अंत elifकथन का उपयोग करके कैलकुलेटर फ़लाइन के लिए धन्यवाद ।

-218 बाइट्स दो कार्यों को मर्ज करके

Comments

1052 बाइट्स

— caird coinheringaahing

@cairdcoinheringaahing अधिकार, धन्यवाद।

— हाइपरनेत्रिनो

कॉल Rऔर Lलाइक R(r+1-N,C+N,P,N=N)(पहली कॉल R) को, आपको N=अंत में आवश्यकता नहीं है ; इसके R(r+1-N,C+N,P,N)बजाय होना चाहिए ।

— नाथन.इलिशा शिरनी

@NathanShiraini राइट, धन्यवाद।

— हाइपरन्यूट्रिनो

... आप कुछ भूल गए। दोनों के अंतिम 2 लाइन Lऔर R^^ इसके अलावा, खरोज के अपने दूसरे स्तर 4 स्थानों हर जगह है, मुझे लगता है कि आप इसे 2. बना सकता है

— Nathan.Eilisha Shiraini

Answer 3

सी, 569 568 556 बाइट्स

golfed

#define A s[1]
#define c(i,j,k) break;case i:x=j;y=k;
w,S,i,j,d,x,y,z;main(int*a,char**s){w=strchr(&A[1],'|')+2-A;a=calloc(w,4);for(;i++<'~~';j=0){for(;A[j];){if(A[z=j++]==79){d=rand()%2;x=4;y=7;z+=w;for(;z<strlen(A);){z+=x%3-1+(y%3-1)*w;switch(A[z]){case 85:goto e;c(32,x/3*(3+1),y/3*(3+1))c(45,d*2+3,7)c(94,(d=rand()%2)*2+3,7)c(118,4,8)c(47,3,7)d=0;c(92,5,7)d=1;c(124,(d=!d)*2+3,7)c(60,x,y)case 62:d=A[z]/2%2;case 61:x=d*8;y=4;}}a[z%w]++;e:;}}}for(i=-1;++i<w;S=a[i]>S?a[i]:S);for(j=17;j-->1;puts(""))for(i=0;i<w-1;printf("%c",a[i++]*16./S+0.6<j?32:35));}

Ungolfed

//Variable Definitions
//direction - marbles current direction, 0 -> left, 1-> right
//arrwidth - width of array
//x - change in x of marble in base 3 - 0 -> Left, 1 -> stay, 2-> right
//y - change in y of marble in base 3 - 0 -> Up, 1 -> stay, 2-> Down
//z - position of marble
//i - iterator on runs of program
//j - iterator on string
//k - iterator on outputstring
//argc - array holding all buckets

#define c(i,j,k) break;case i:x=j;y=k;

arrwidth,scale,i,j,direction,x,y,z;

main(int *argc, char**argv){
  arrwidth=strchr(&A[1],'|')+2 - A; //get width
  argc=calloc(arrwidth,4);
  for(;i++<'~~';j=0){
    for(;A[j];){
      if(A[z=j++] == 79){ //if it finds an O, start sim
        direction=rand()%2;
        x=4;
        y=7;
        z+=arrwidth;
        for(;z<strlen(A);){
          z+=x%3-1 + (y%3-1)*arrwidth;
          switch (A[z]){
            case 85://marble dies dont record
              goto e;
            c(32,x/3*(3+1),y/3*(3+1)) //case ' '
            c(45,direction*2+3,7)    //case -
            c(94,(direction=rand()%2)*2+3,7)    //case ^
            c(118,4,8)    //case v
            c(47,3,7)    //case /
              direction=0;
            c(92,5,7)   //case '\'
              direction=1;
            c(124,(direction=!direction)*2+3,7)
            c(60,x,y)    //case <
            case 62:    //case >
              direction=A[z]/2%2;
            case 61:  //case =
              x=direction*8;
              y=4;
          }
        }
        argc[z%arrwidth]++;
        e:;
      }
    }
  }
  //get output answer in terms of '#'
  for(i=-1;++i<arrwidth;scale=argc[i]>scale?argc[i]:scale);
  for(j=17;j-->1;puts(""))
    for(i=0; i < arrwidth-1;printf("%c",argc[i++]*16./scale+0.6<j?32:35));
}

संपादित करता

मेरा मामला मैक्रो बदलकर 12 बाइट्स सहेजे गए।

टिप्पणियाँ

मेरा कोड यह निर्धारित करने के लिए आधार 3 पूर्णांक की एक प्रणाली का उपयोग करता है जहां संगमरमर का नेतृत्व किया जाता है और बाद में (तोपों और सामान के लिए) नेतृत्व किया जाएगा।

मैंने कोशिश की थी कि अजगर समाधान को हरा दे, मैंने वास्तव में किया।

Comments

मैं 568 बाइट्स गिनता हूं; हो सकता है कि आपने अनुगामी न्यूलाइन गिना हो? और मुझे बुरा लगता है; सी द्वारा पायथन में आउटगोइंग?

— जीज़

आप सही हैं, मैंने फ़ाइल में एक नया अनुगामी छोड़ दिया। धन्यवाद!

— dj0wns