भूलभुलैया एक लाइनर पैदा कर रहा है

Question

प्रसिद्ध C64 बुनियादी एक लाइनर

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

स्लैश और बैकस्लैश के भूलभुलैया को प्रिंट करता है।

\\/\\\//\/\////\\/\/
\/\///\\///////\//\/
/\\\//\//\////\\//\\
\////\//\//\/\\\\\\/
/\/\\///\\\\/\\\\/\\
\/\//\\\\\\//\/\////
/\//\\///\/\///\////
\/\\\//\\/\\\//\\/\/
//////\\/\\/\/\/\///
\\/\/\\////\/\/\\/\/

स्टड से विकर्ण दीवारों से बने ऐसे भूलभुलैया में पढ़ें और दीवार के चरित्र से युक्त क्षैतिज और ऊर्ध्वाधर दीवारों के साथ एक ही भूलभुलैया को प्रिंट करें # "

उदाहरण के लिए छोटा भूलभुलैया

/\\
\\/
///

में अनुवाद करता है

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

     #####    

सटीक होने के लिए, प्रत्येक पृथक दीवार खंड में पांच वर्णों की लंबाई होती है, आसन्न दीवार खंड एक कोने को साझा करते हैं। स्लैश और बैकस्लैश के मैट्रिक्स में एक चरित्र को दाएं / बाएं / ऊपर / नीचे ले जाना, ऊर्ध्वाधर और 2 वर्णों द्वारा तिरछे अनुवाद में क्षैतिज दिशा में # -मेट्रिक्स में 2 वर्णों से मेल खाता है।

Comments

एक और आउटपुट उदाहरण शायद उपयोगी होगा। और मुझे उम्मीद है कि शीर्षक "एक लाइनर" होना चाहिए।

— केल्विन के शौक

क्या इनपुट भूलभुलैया हमेशा एक आयत होगी? क्या आपको एक बड़ा उदाहरण देना चाहिए ताकि हम रिक्ति देख सकें?

— xnor

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है! पहली बड़ी चुनौती, लेकिन कुछ चीजें: इनपुट / आउटपुट STDIN / STDOUT के अलावा कुछ हो सकता है (उदाहरण के लिए एक फ़ंक्शन तर्क और वापसी मान के रूप में)? क्या लाइनों को नए वर्णों के अलावा किसी चरित्र के माध्यम से अलग किया जा सकता है?

— दरवाज़े

यदि संभव हो तो स्टड और स्टडआउट का उपयोग करना अनिवार्य है, अन्यथा "निकटतम समकक्ष।" क्या न्यूलाइन-धारणा को कमजोर करने के कारण हैं?

— मिसेच्योर

संबंधित: codegolf.stackexchange.com/q/37390/194 , codegolf.stackexchange.com/q/21730/194

— पीटर टेलर

Answer 1

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

मेरा पहला पायथन गोल्फ, इसलिए शायद बहुत उप-इष्टतम। यह व्हाट्सएप के पूरे बहुत सारे उत्पादन करता है, लेकिन इससे पहले की कोई नई कहानी नहीं है, और अधिकांश दो पूर्ववर्ती स्थानों पर। इनपुट को कमांड लाइन से हाथ से देने की आवश्यकता है (शायद कोई पायथन में मल्टीलाइन इनपुट प्राप्त करने का एक छोटा तरीका जानता है ...)।

e,z,s=enumerate,'0',list(iter(input,""))
p=''.join(s)*5
r=[len(p)*[' ']for _ in p]
for y,l in e(s):
 for x,c in e(l):
  for i in range(-2,3):r[2*(x+y+(s>[z]))+i*(c>z)][2*(x+len(s)-y)+i*(c<z)]='#'
for l in r:print(''.join(l))

विचार अंतरिक्ष के एक विशाल सरणी को आरंभीकृत करना है r, फिर इनपुट के माध्यम से पुनरावृत्त करें और #आवश्यकतानुसार रिक्त स्थान को बदलें , और अंत में पूरे सरणी को प्रिंट करें। एक चाल मैं प्रयोग किया जाता करने के लिए पात्रों की तुलना करना है z = '0'करने के लिए समानता के परीक्षण के बजाय '/'या '\', जो बाइट्स की एक गुच्छा बचाता है।

Answer 2

जूलिया, 258 बाइट्स

एक कार्यात्मक समाधान ...

A=split(readall(STDIN))
q(i,j)=fld(i-1,j)
n,^ =A[].(3),q
f(i,j)=try A[1+i^5][1+j^5]<'0'?(i+j)%5==1:(i-j)%5==0catch 0end
h(i,j)=f(i+i^4,j)|f(i+(i-1)^4,j)
g(i,j)=h(i,j+j^4)|h(i,j+(j-1)^4)
for i=1:6length(A),j=-n-5:2n;print(" #"[1+g(i-j,i+j)],j==2n?"\n":"")end

उपस्थिति के क्रम में: fअपने 5 * 5 बिट पैटर्स द्वारा '/' और '\' को कवर किया जाता है, hहर पांचवें और निम्नलिखित लाइन को एक ही लाइन में गुना करता है (याद रखें "आसन्न दीवार खंड एक कोने को साझा gकरता है ") और स्तंभों के लिए भी ऐसा ही करता है। अंत में, i-j,i+jचित्र को घुमाता है।

Answer 3

जावास्क्रिप्ट (ईएस 6), 258

पैरामीटर के रूप में भूलभुलैया के साथ एक फ़ंक्शन, आउटपुट लौटाता है।

इनपुट / आउटपुट नियमों के कारण यदि यह वैध है, तो अनिश्चित करें (यह वैसे भी मजेदार था)

f=m=>([...m].map(c=>{if(c<' ')x=sx-=2,y=sy+=2;else for(x+=2,y+=2,d=c>'0',i=y-3*d,j=x-3*!d,c=5;c--;)o[i+=d][j+=!d]='#';},w=m.search`
`,h=m.match(/\n/g).length,sy=y=0,sx=x=h*2,o=Array(z=(w+h+1)*2).fill(' ').map(x=>Array(z).fill(x))),o.map(r=>r.join``).join`
`)

// LESS GOLFED

U=m=>(
  w=m.search`\n`,
  h=m.match(/\n/g).length,
  o=Array(z=(w+h+1)*2).fill(' ').map(x=>Array(z).fill(x)),
  sy=y=0,
  sx=x=h*2,
  [...m].forEach(c=>{
    if(c<' ')x=sx-=2,y=sy+=2
    else for(x+=2,y+=2,d=c>'0',i=y-3*d,j=x-3*!d,c=5;c--;)o[i+=d][j+=!d]='#';
  }),
  o.map(r=>r.join``).join`\n`  
)

// TEST
out=x=>O.innerHTML+=x+'\n'

test=`\\\\/\\\\\\//\\/\\////\\\\/\\/
\\/\\///\\\\///////\\//\\/
/\\\\\\//\\//\\////\\\\//\\\\
\\////\\//\\//\\/\\\\\\\\\\\\/
/\\/\\\\///\\\\\\\\/\\\\\\\\/\\\\
\\/\\//\\\\\\\\\\\\//\\/\\////
/\\//\\\\///\\/\\///\\////
\\/\\\\\\//\\\\/\\\\\\//\\\\/\\/
//////\\\\/\\\\/\\/\\/\\///
\\\\/\\/\\\\////\\/\\/\\\\/\\/`
out(test),out(f(test))

<pre id=O></pre>