भूलभुलैया पीढ़ी [बंद]

Question

मुझे पता है कि इस ( यहाँ ) के समान एक (पुराना) धागा है , लेकिन मैं इसे कुछ संशोधनों के साथ रीबूट करना चाहूंगा।

लक्ष्य: अपनी पसंद के एल्गोरिथ्म का उपयोग करके एक यादृच्छिक दिखने वाला भूलभुलैया उत्पन्न करें, फिर भूलभुलैया को रेखांकन (प्रिंटिंग काउंट) से आउटपुट करें।

• चौड़ाई और ऊंचाई आपके द्वारा निर्धारित की जाती है।
• कम से कम एक प्रवेश द्वार से कम से कम एक निकास के लिए कम से कम एक रास्ता होना चाहिए।
• भूलभुलैया का प्रारूप (आप इसे कैसे प्रदर्शित करते हैं, प्रवेश द्वार (ओं) या निकास (ओं) को भी आप पर निर्भर है)
• प्रीटीयर, बेहतर।
• तुच्छ mazes (जैसे खाली mazes, जाली mazes, आकार 1x1 के mazes) हतोत्साहित किया जाता है।
• भूलभुलैया में चक्रों की अनुमति है और, प्रोत्साहित किया जाता है, अगर परिणाम उचित है।
• भाषा के दुरुपयोग को प्रोत्साहित किया।
• भूलभुलैया यथोचित यादृच्छिक होना चाहिए (लेकिन एक पूरी तरह से नियतात्मक (जैसे अराजक) एल्गोरिथ्म जो यह उत्पन्न करता है वह भी ठीक है)।

संपादित करें: यहां मुख्य ध्यान सबसे छोटा संभव कार्यान्वयन करने पर है। हालाँकि, मैं कुछ बाधाओं को दूर करने के लिए अनुमति देना चाहता हूं ताकि शिथिलता को बढ़ावा दिया जा सके। मैंने जान-बूझकर बिल्कुल वही छोड़ दिया है जो "सुविधाओं" भूलभुलैया को खुले-समाप्त किया गया है, लेकिन एक मोटे दिशानिर्देश के रूप में आपको कम से कम शाब्दिक रुपये में धमाके की सबसे अधिक मात्रा को पैक करने की कोशिश करनी चाहिए।

Comments

इसके अलावा "प्रीटियर, बेहतर" एक कोड-गोल्फ चुनौती के लिए शायद ही मूर्त (या बस अप्रासंगिक) लगता है। यदि आप सुंदर परिणामों में रुचि रखते हैं तो शायद एक लोकप्रियता प्रतियोगिता बेहतर विकल्प होगी।

— मार्टिन एंडर

तो क्या यह वास्तव में कोड-गोल्फ है या यह लोकप्रियता-प्रतियोगिता है?

— l0b0

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

— मार्टिन एंडर

मुझे लगता है कि प्रत्येक उत्तर में यह स्पष्ट करना चाहिए कि प्रत्येक भूलभुलैया में क्या प्रवेश द्वार और निकास हैं (साथ ही, क्या दीवार है और एक मार्ग क्या है), ताकि हम दूसरी बुलेट का मूल्यांकन कर सकें।

— लार्स

@Geobits मैं बहुत ज्यादा बुरा नहीं मानूंगा, लेकिन इसलिए मेरा सुझाव वास्तव में इसे कोड लंबाई और वोट से संयुक्त स्कोरिंग के साथ एक कोड-चुनौती बनाना है। ओपी जो चाहता है, वह वास्तव में प्रोत्साहित करेगा: दिलचस्प mazes के लिए संक्षिप्त कोड।

— मार्टिन एंडर

Answer 1

सी: 265 253 बाइट्स

#define f(v)for(v=0;v<k;++v)
#define d(q,n)case q:r(c+n,c+2*n);
z[4225],i,j,k=65;r(p,c){if(!z[c]){z[p]=z[c]=1;f(p)switch(rand()%4){d(0,-k)d(1,k)d(2,-1)d(3,1)}}}main(){f(i)z[i]=z[i+4160]=z[i*k]=z[i*k+64]=z[4157]=1;r(67,132);f(i)f(j)putchar(33-z[i*k+j]);}

(65-वर्ण टर्मिनल की आवश्यकता होती है) प्रवेश द्वार से बाहर निकलने के लिए एक गारंटी मार्ग के साथ अपेक्षाकृत यादृच्छिक 31x31 भूलभुलैया उत्पन्न करता है।

उदाहरण आउटपुट (सिम्युलेटेड 65-कैरेक्टर टर्मिनल के साथ):

 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
 !     !       !   !       !     !           !             !   ! 
 !!!!! !!! !!! ! !!! ! !!! ! !!! !!!!!!! !!! !!!!!!!!! !!! ! ! ! 
 !   !   !   ! !     ! ! ! ! ! ! !       !   !         !   ! ! ! 
 ! !!!!! !!! ! !!!!!!! ! ! ! ! ! ! !!!!!!! !!! ! !!!!!!! !!! ! ! 
 !     !     !         ! !   !   !     !   !   ! !     !   ! ! ! 
 ! !!! !!!!!!!!!!!!!!!!! !!!!! !!! !!! !!! ! ! !!! !!! !!! !!! ! 
 !   !         !     !   !     !     !   ! ! ! !     !   !   ! ! 
 !!!!!!!!!!! ! ! !!! !!! ! !!!!!!!!!!!!! ! !!! ! !!!!!!! !!! ! ! 
 !           !   !       ! !             !   !     !     !     ! 
 ! !!!!!!! !!!!!!! !!!!!!! ! !!!!!!!!!!!!!!! !!!!!!! !!!!!!!!!!! 
 ! !     ! !   !     !   ! !           !   !       ! !         ! 
 ! !!! ! ! ! ! !!!!!!! ! ! ! !!!!!!!!! ! ! !!!!!!! ! ! !!!!!!! ! 
 !   ! !   ! !       ! !   ! !         ! !       ! ! !   !   ! ! 
 !!! ! !!!!! !!!!!!! ! !!!!!!! !!!!!!!!! !!! !!!!! ! !!! ! !!! ! 
 !   !   ! ! !       !   !     !   !     ! !           ! !   ! ! 
 ! !!!!! ! ! ! !!!!!!!!! ! !!!!! !!! !!!!! !!!!!!!!!!! ! ! ! ! ! 
 ! !       ! !   !   !   ! !       ! !       !   !     ! ! ! ! ! 
 ! !!!!!!!!! !!! ! ! ! !!! !!!!!!! ! !!!!!!! ! ! !!!!!!! !!! ! ! 
 !             !   ! !   !       ! !     !   ! !             ! ! 
 !!!!!!!!!!!!!!!!!!! !!! !!!!!!! ! !!!!! ! !!! !!!!!!!!!!!!!!! ! 
 !               !   !   !       !         !   !     !   !     ! 
 ! !!!!!!!!!!!!! ! ! ! !!! !!!!!!! !!!!!!!!! !!! !!! !!! ! !!! ! 
 ! !   !       !   ! ! ! !     ! ! ! !     !     !   !   !   ! ! 
 ! ! ! !!!!! !!!!!!! ! ! ! !!! ! ! ! ! !!! !!!!!!! !!! !!!!! !!! 
 !   ! !   !       ! ! !     ! !     ! ! !     !   !       !   ! 
 !!!!! ! ! !!! !!! ! ! !!!!!!! !!!!!!! ! ! !!! ! !!!!!!!!! !!! ! 
 !     ! !   !   !   !       !       ! ! ! !   !   !         ! ! 
 ! !!!!! !!! !!! !!!!!!!!!!! !!!!!!! ! ! ! !!!!!!! ! !!!!!!! ! ! 
 !         ! !           !   !       ! ! !     !   ! !       ! ! 
 !!!!!!!!!!! !!!!!!!!!!! ! !!! !!!!!!! ! !!!!! ! !!! !!!!!!!!! ! 
 !         !     !     ! ! !       !   !     ! !     !         ! 
 ! !!!!!!! !!!!! ! !!! !!! !!!!!!! ! !!!!! ! ! !!!!! ! !!!!!!!!! 
 ! !     !     !   ! !   !       ! !       ! !       !         ! 
 ! ! !!! !!!!! ! !!! !!! !!!!!!! ! !!!!!!!!! !!!!!!!!!!!!!!!!! ! 
 !     !     ! !   !   ! !     ! !       !   ! !     !         ! 
 !!!!!!!!!!! ! !!! !!! ! ! ! !!! ! ! !!!!! !!! ! !!! ! !!!!!!! ! 
 !           ! !       !   ! !   ! !       !   ! ! ! !     !   ! 
 ! !!!!!!!!!!! !!!!!!!!!!!!! ! !!! !!!!!!!!!!! ! ! ! ! !!! ! !!! 
 !       !   !             ! ! ! !   !         ! !   !   ! ! ! ! 
 !!!!!!! !!! !!!!!!!!!!!!! ! ! ! !!! ! !!!!!!! ! !!! !!!!! ! ! ! 
 !       !         !     ! ! ! !   !   !     ! !   !       !   ! 
 ! !!!!!!! !!!!!!! ! !!!!! ! ! !!! !!!!!!! ! ! !!! !!!!!!!!!!!!! 
 !   !         ! !   !       ! !           ! !   !             ! 
 ! ! ! !!!!!!! ! ! !!! !!!!!!! ! !!!!!!!!!!! ! !!!!!!!!!!!!!!! ! 
 ! ! ! !     ! !   !   ! !     !   !   !     ! !               ! 
 ! ! !!! !!! ! !!!!! !!! ! !!!!! ! ! ! !!!!!!! ! !!!!!!!!!!!!! ! 
 ! !   !   ! !   !       !   !   !   !         ! !         !   ! 
 !!!!! !!! ! !!! ! !!!!!!!!! !!!!!!! !!!!!!!!!!! !!!!! !!!!! !!! 
 !     !   !   !   !       !       !       !   !     !       ! ! 
 ! !!!!! !!!!! !!!!! !!!!! !!!!!!! !!!!!!!!! ! !!!!! !!!!!!! ! ! 
 !           !     ! !   !   !   !           !   !   !     !   ! 
 ! !!!!!!!!! !!!!! ! !!! ! !!! ! !!!!!!!!!!!!!!! ! !!! !!! !!! ! 
 ! !     !       ! !     !     !     !         ! !       !   ! ! 
 !!! !!! !!!!!!!!! !!!!! !!!!!!!!! ! !!!!!!! !!! ! !!!!!!!!! ! ! 
 !   !     !   !   !   ! !       ! !         !   ! !         ! ! 
 ! !!!!!!! ! ! ! ! !!! ! !!!!!!! ! !!!!!!!!! ! !!!!! !!!!!!!!! ! 
 !       !   !   ! !   !         !   ! !   ! ! !     !       ! ! 
 ! !!!!! !!!!!!!!! ! !!!!!!!!!!! !!! ! ! ! ! ! ! !!!!! !!!!! ! ! 
 ! !     !           !         ! ! ! !   !   ! !   !   !     ! ! 
 ! ! !!!!!!!!!!!!!!!!! !!! !!!!! ! ! !!!!!!!!! !!! ! !!!!!!!!! ! 
 ! !                     !         !               !           ! 
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! 

Comments

तुम भी जरूरत नहीं है int p,int c। p,cपर्याप्त है ...

— चुबाकुएनो

आह, यह इंगित करने के लिए धन्यवाद

— डेंड्रोबियम

Answer 2

मैथेमेटिका, 144 132 बाइट्स

स्थापना के बाद से, हम सभी भूलभुलैया को आकर्षित करने का सबसे कुशल तरीका जानते हैं ।

c=0;Graphics@Most[Join@@{Circle[{0,0},i,{a=c-(r=Random[](d=2Pi-1/i)&)[],a+d}],Line[{{i},{i+1}}.{{Cos[c=a+r[]],Sin@c}}]}~Table~{i,9}]

Ungolfed और उदाहरण आउटपुट:

बेशक, लाइनें दीवारें हैं। आप केंद्र में शुरू होने वाले मिनोटौर हैं और बाहर निकलने की जरूरत है।

Comments

यह सुंदर है, और कोड छोटा है, लेकिन मैं कहूंगा कि यह स्पेक्ट्रम के "तुच्छ भूलभुलैया" अंत की ओर है।

— लार्स

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

— लार्स

@ लार्स हां, हम उस पर सहमत हैं। इसलिए मैंने कहा कि यह भूलभुलैया को खींचने का सबसे "कुशल" तरीका है, सबसे "प्रभावी" नहीं। ;) फिर भी, यह सरल हो सकता है, लेकिन मुझे नहीं लगता कि यह "खाली" या "1x1" जैसे शासित लोगों के साथ एक श्रेणी में आता है। बेशक, यह ओपी के विवेक पर है कि वह अपनी सादगी के लिए इस सबमिशन को अयोग्य घोषित कर दे, लेकिन जब तक वह ऐसा नहीं करता है या चुनौती के प्रकार को बदलता है, मुझे इसे और अधिक जटिल / दिलचस्प बनाने के लिए प्रोत्साहन नहीं दिखता है।

— मार्टिन एंडर

@ लार्स ने कहा कि, मुझे यकीन नहीं है कि यह उनके एल्गोरिदम या उनके द्वारा पोस्ट किए गए विशेष उदाहरणों की एक विशेषता के कारण है, लेकिन उनके जवाबों में से किसी को भी गहराई से परे "1" की आवश्यकता नहीं है। इसलिए जब तक उनमें बहुत अधिक जटिलता नहीं होती है, यह उन सभी रास्तों पर है जो वैसे भी अप्रासंगिक हैं।

— मार्टिन एंडर

यह भूलभुलैया तुच्छ नहीं है, मेरी राय में, भले ही यह आसान हो (और नीचे मेरी परिपत्र भूलभुलैया और भी अधिक तुच्छ है)। मैं वास्तव में सिर्फ खाली-कैनवास / आकार -1 / आदि को रोकना चाहता था। "भूलभुलैया" एस।

— imallett

Answer 3

C: 364 बाइट्स

#define I int
m[1600],i=0,r;f(I x,I y,I l){m[80*y+x]|=l;I d[]={x-1,y,2,1,x+1,y,1,2,x,y-1,8,4,x,y+1,4,8},
s[]={5,5,5,5},j=0;for(;j<4;){L:r=rand()%4;for(I k=0;k<4;)if(s[k++]==r)goto L;s[j]=r;I*p=d+
4*s[j++],X=p[0],Y=p[1];if(!(X<0|X>79|Y<0|Y>19|m[80*Y+X])){f(X,Y,p[2]);m[80*y+x]|=p[3];}}}
main(){f(0,0,4);m[9]|=4;for(;i<1600;)putchar("#5FMP<HJR;IK:9LN"[m[i++]]+128);}

नोट: उपरोक्त में, मैंने इसे पृष्ठ पर फिट करने के लिए नई कड़ियाँ जोड़ीं। अपेक्षित आउटपुट (80-वर्ण टर्मिनल पर) (नोट शुरू और अंत बाईं ओर):

Comments

बचाव के लिए @bwoebi MSPaint! छवि

— छत पर गेको

ध्यान दें कि मेरा इरादा पथों के अंदर होने का था (जैसा कि यहां) ।

— इमललेट

@IanMallett मुझे लगता है कि सीलिंग गेको को इस बात की जानकारी थी, लेकिन बाईं दीवार को एक रंग से भर देने से आपको बाईं दीवार के साथ एक (गैर-इष्टतम) मार्ग मिल जाता है जब तक कि आपको बाहर निकलने का पता नहीं चलता। ;)

— मार्टिन एंडर

यदि आपके पास समय है, तो मैं इस कोड के अन-गोल्‍डेड संस्करण को देखने का इच्छुक हूं।

— लार्स

जब आपने लिखा था कि आप एक भूलभुलैया-आईएनजी कोडर थे।

— टटिमेडली

Answer 4

गणितज्ञ, १३४ १३० वर्ण

Graph[Range@273,Reap[Do[c@n/._c:>#0[Sow[#<->n];n],{n,RandomSample@AdjacencyList[g=GridGraph@{13,21},c@#=#]}]&@1][[2,1]],Options@g]

---

वास्तव में, हम इस एल्गोरिथ्म का उपयोग किसी भी (अप्रत्यक्ष) ग्राफ से भूलभुलैया उत्पन्न करने के लिए कर सकते हैं।

उदाहरण के लिए, 8 * 8 नाइट के टूर ग्राफ ( KnightTourGraph[8,8]) से एक भूलभुलैया उत्पन्न करें :

Graph[Range@64,Reap[Do[c@n/._c:>#0[Sow[#<->n];n],{n,RandomSample@AdjacencyList[g=KnightTourGraph[8,8],c@#=#]}]&@1][[2,1]],Options@g]

Comments

अच्छा भूलभुलैया ... लेकिन मुझे कोई प्रवेश नहीं दिखता है जो एक निकास से जुड़ा है ...?

— बुवबी

मेरा मानना ​​है कि प्रवेश के रूप में एक यादृच्छिक नोड (जैसे कि ऊपरी बाएं) को चुनना और दूसरे (नीचे दाएं) को बाहर निकालना है। गणितज्ञ यह सुनिश्चित करता है कि सभी नोड्स अन्य सभी नोड्स के साथ जुड़े हुए हैं, लेकिन - विशेष रूप से दूसरे भूलभुलैया में - यह पता लगाना कि वे कैसे जुड़े हैं सबसे कठिन हिस्सा है।

— ईगलवी_अट्टनम

क्या रेखाओं (ग्राफ किनारों) को भूलभुलैया की दीवारें या मार्ग माना जाता है? मुझे लगा कि मुझे पता है, लेकिन अब मुझे यकीन नहीं है।

— लार्स

@ लार्स वे मार्ग हैं।

— एलेफल्फा

@ लार्स ग्राफ जुड़ा हुआ है, इसलिए आप केवल दो मनमाना नोड्स ले सकते हैं, एक प्रवेश द्वार के रूप में, दूसरा बाहर निकलने के रूप में।

— एलेफ़लफा

Answer 5

बैश, 53 बाइट्स

w=(╱ ╲);while true;do echo -n ${w[RANDOM%2]};done

C64 कोड के समान विचार। स्लैश के रूप में यूनिकोड के पात्रों का उपयोग करता है क्योंकि वे एक टर्मिनल में बहुत अच्छे लगते हैं जो यूनिकोड का समर्थन करता है। ओएस एक्स टर्मिनल (मेनलो फ़ॉन्ट) पर नमूना आउटपुट:

Comments

मैं एक बार यह पता लगा yes 'c=(╱ ╲);printf ${c[RANDOM%2]}'|bash:। इस पोस्ट को

— gniourf_gniourf

यह एक एल्गोरिथ्म पर आधारित है जो खुद को हल करने की गारंटी नहीं दे सकता है, जो कि कई साल पुराना है।

— इसियाह मीडोज

Answer 6

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

यह भूलभुलैया का बिल्डर है जिसे मैंने इस अन्य चुनौती में इस्तेमाल किया था , बस गोल्फ था। यह 2 मापदंडों वाला एक फ़ंक्शन है: पंक्तियाँ और स्तंभ। भूलभुलैया पूरी तरह से बिना छोरों के साथ जुड़ा हुआ है, इसलिए कोई भी स्थान शुरुआती या समाप्ति बिंदु हो सकता है।

(r,c,o=2*c+2,i=2*r*o+o,z=[],F=(p,i=Math.random()*4)=>[o,1,-o,-1].map((s,j,d)=>z[s=p+2*d[j+i&3]]>0&&(z[s]=z[(p+s)/2]=' ',F(s))))=>{for(;i--;)z[i]=i%o?8:`\n`;F(o+2);return''+z}

उदाहरण

f(7,10)

उत्पादन

,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
,8, , , ,8, , , , , ,8, , , , , , , , , ,8,
,8, ,8, ,8,8,8, ,8, ,8,8,8,8,8,8,8, ,8, ,8,
,8, , , ,8, , , ,8, , , ,8, , , , , ,8, ,8,
,8, ,8,8,8, ,8,8,8,8,8, ,8, ,8,8,8,8,8, ,8,
,8, ,8, , , , , ,8, ,8, ,8, ,8, , , , , ,8,
,8, ,8, ,8,8,8, ,8, ,8, ,8, ,8, ,8,8,8,8,8,
,8, ,8, ,8, , , ,8, , , , , ,8, ,8, , , ,8,
,8, ,8, ,8, ,8,8,8,8,8,8,8,8,8, ,8, ,8,8,8,
,8, ,8, ,8, , , , , , , ,8, , , ,8, , , ,8,
,8, ,8, ,8,8,8,8,8,8,8, ,8,8,8, ,8,8,8, ,8,
,8, ,8, , , , , , , ,8, , , ,8, , , , , ,8,
,8, ,8,8,8,8,8,8,8,8,8,8,8, ,8,8,8,8,8, ,8,
,8, , , , , , , , , , , , , ,8, , , , , ,8,
,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8

परीक्षा

f=
(r,c,o=2*c+2,i=2*r*o+o,z=[],F=(p,i=Math.random()*4)=>[o,1,-o,-1].map((s,j,d)=>z[s=p+2*d[j+i&3]]>0&&(z[s]=z[(p+s)/2]=' ',F(s))))=>{for(;i--;)z[i]=i%o?8:`\n`;F(o+2);return''+z}
    
function update() {    
  O.textContent='';
  [r,c]=I.value.match(/\d+/g)
  O.textContent=f(r,c)
}  

update()

pre { line-height: 0.8em }

Rows,Columns <input id=I oninput='update()' value='8,12'>
<pre id=O></pre>

Comments

मुझे यकीन नहीं है ... प्रकाश या अंधेरे क्षेत्र भूलभुलैया है? यदि अंधेरा है, तो इसका एक बड़ा लूप है और कोई भी बाहर जाने पर तभी रह सकता है जब किसी भी बिंदु को प्रवेश / निकास बिंदु के रूप में चुना जाए। यदि प्रकाश, तो आपको निकास / प्रविष्टि को जोड़ना चाहिए।

— पाओलो एबरमन

@ Pa @loEbermann यह निश्चित रूप से प्रकाश है, अंधेरे क्षेत्र की दीवारें हैं। खुद को दोहराते हुए: भूलभुलैया पूरी तरह से बिना छोरों के साथ जुड़ा हुआ है, इसलिए कोई भी स्थान शुरुआती या समाप्ति बिंदु हो सकता है

— edc65

वाह यह आश्चर्यजनक है! कुछ बाइट्स को शेव किया और इसे 133 बाइट्स तक नीचे कर दिया: twitter.com/aemkei/status/889587308894326785 लेकिन सभी क्रेडिट आपको जाना चाहिए!

— ऐमकेई

@aemkei 8 '#' के बजाय, मुझे विश्वास नहीं हो रहा है कि मैं उस समय चूक गया था

— edc65

Answer 7

ZX बेसिक - 54 अक्षर

a$="/\":for i=1 to 24*32:print a$(1+int(rnd*2));:next

यहाँ एक मार्ग के माध्यम से रास्ता दिखा रहा है (लाइनों के बीच रिक्त स्थान)

और जब मैंने पहली बार (कई साल पहले) एक छोटा सा स्निपेट बनाया, और बेहतर ग्राफिक्स करने में थोड़ा समय बिताया।

Comments

हम्म, चीकू। ^ ^ शुरुआत क्या है और वहाँ अंत क्या है? और क्या स्लैश पथ या दीवारें हैं? और न्यूनतम अंतर आकार क्या है जिससे मैं गुजर सकता हूं?

— मार्टिन एंडर

"कम से कम एक प्रवेश द्वार से कम से कम एक निकास के लिए कम से कम एक रास्ता होना चाहिए।" मुझे ऐसा कोई संकेत नहीं दिखता कि यह मानदंड पूरा हो। यादृच्छिक दीवारों जरूरी एक भूलभुलैया नहीं बनाते हैं।

— लार्स

@ m.buettner: मैं अनुमान लगा रहा हूं कि स्लैश दीवारें हैं, और हम इसे कल्पना करने वाले हैं जैसे कि पंक्तियों के बीच और स्तंभों के बीच शून्य स्थान था। तो नीचे-बाएँ 2x2 वर्ण पूरी तरह से बंद हीरे (चौकोर) आकार बनाते हैं।

— लार्स

@ लार्स हाँ मुझे ऐसा लगा। यह सिर्फ ओपी के सवाल पर आपके मामले के लिए एक और बात करता है कि लोगों को संकेत देना चाहिए कि क्या शुरू और खत्म होता है। इसके अलावा, यह योजना जंक्शनों के लिए भी अनुमति नहीं देती है। आपके पास केवल उन बंद वर्ग या मार्ग पथ हो सकते हैं (जो बंद लूप भी हो सकते हैं)।

— मार्टिन एंडर

बेहतर ग्राफिक्स और मार्ग दिखाने के लिए +1। मुझे लगता है कि इतने सारे संभावित प्रवेश और निकास दिए गए हैं, "कम से कम एक प्रवेश द्वार से कम से कम एक निकास से कम से कम एक रास्ता" होने की संभावना बहुत अधिक है!

— लार्स

Answer 8

बीबीसी बेसिक, 18 बाइट्स

@Nneonneo द्वारा 23-बाइट C64 अनंत लूप संस्करण पर लंबाई में सुधार। VDU VDU नियंत्रक को एक एकल वर्ण भेजता है: या तो 2 + 1 * 45 = ASCII 47 /या 2 + 2 * 45 = ASCII 92\

  VDU2+RND(2)*45:RUN

बीबीसी बेसिक, 35 बाइट्स / 107 95 बाइट्स

35 बाइट्स केवल अंतिम पंक्ति के लिए है, जो 40 कॉलम लेआउट में 25 पंक्ति भूलभुलैया देता है। MODE1 यह सुनिश्चित करता है कि लाइनों के बीच कोई अतिरिक्त स्थान नहीं बचा है। कार्यक्रम का शेष वैकल्पिक है और स्वरूपण में सुधार करता है। VDU23 कथन 47 और 92 वर्णों के लिए फ़ॉन्ट को फिर से परिभाषित करता है (8x8 बिटमैप बनाने वाले 8 बाइट्स।) मैं सीधे रनों को चुटकी में बंद करने के लिए सभी चार कोनों में एक हल्का पिक्सेल शामिल करता हूं। इसका दुष्प्रभाव यह है कि खाली हीरे में एक बिंदु दिखाई देता है। 2 न्यूलाइन सहित कुल 107 बाइट्स।

  VDU23,47,131,7,14,28,56,112,224,193
  VDU23,92,193,224,112,56,28,14,7,131
  MODE9FORa=0TO999VDU2+RND(2)*45:NEXT

इस कार्यक्रम को संपादित करें , 8 बिट VDU कोड में से कुछ को 16 बिट छोटे एंडियन मान (कुछ अल्पविराम के बजाय एक अर्धविराम द्वारा चिह्नित) में एन्कोड करके 95 बाइट्स तक छोटा किया जा सकता है और VOD कोड की एक जोड़ी के रूप में MODE कथन का प्रतिनिधित्व करता है, निम्नानुसार है। ।

VDU23,47,1923;7182;28728;49632;23,92,57537;14448;3612;33543;22,9:FORa=0TO999VDU2+RND(2)*45:NEXT

उत्पादन

Bbcbasic.co.uk से विंडोज के लिए बीबीसी बेसिक का उपयोग करना

केवल अंतिम पंक्ति, 35 बाइट्स

पूरे कार्यक्रम, 107 95 बाइट्स

जैसा कि मैंने @ ब्रायन के उत्तर पर टिप्पणी की है, स्लैश ने स्क्वायर को 2 डार्क त्रिकोण में विभाजित किया है, जिनमें से प्रत्येक में बिल्कुल 2 प्रवेश द्वार / निकास हैं। यह भूलभुलैया के किनारे पर किसी भी बिंदु पर भूलभुलैया के किनारे पर किसी भी बिंदु से एक (तुच्छ, असहनीय) मार्ग की गारंटी देता है। इनमें से कई बहुत कम हैं, लेकिन हमेशा कुछ लंबे लगते हैं। बेशक, भूलभुलैया के बीच में कुछ लूप भी हैं।

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

नीचे दिए गए उदाहरण में, आप मेरे कार्यक्रम से कच्चे आउटपुट (मोनोक्रोम) देख सकते हैं। उसके नीचे (विंडोज पेंट का उपयोग करके) मैंने दो सबसे लंबे अंधेरे क्षेत्रों को नीले रंग में रंग दिया है। फिर मैंने पीले रंग में सबसे बड़े प्रकाश क्षेत्र को रंग दिया, और दो क्षेत्रों को लाल और हरे रंग में नीला कर दिया। पीले, हरे (और यहां तक ​​कि लाल) mazes काफी दिलचस्प और nontrivial हैं।

EDIT - mazes का स्वत: चयन और प्रारंभ / समाप्ति का चयन

एक और रेखा (59 वर्णों) के लिए, प्रोग्राम स्वचालित रूप से 6 mazes तक वर्गों को चुनकर यादृच्छिक और बाढ़ को लाल, हरे, पीले, नीले, मैजेंटा और सियान में भर सकता है। यह हमेशा एक पूर्ण 6 नहीं पाता है, क्योंकि यदि यह एक यादृच्छिक वर्ग चुनता है जो पहले से ही रंगीन है तो यह कुछ भी नहीं करता है।

नीचे दिए गए बाकी कोड प्रत्येक रंग के लिए प्रत्येक कॉलम को ऊपर से नीचे और दाएं से बाएं स्कैन करके प्रारंभ करते हैं, और पहले वर्ग को उठाते हुए उसका सामना करते हैं। यह विपरीत दिशा में स्कैन करके समाप्त होता है।

यह रंगीन, intertwined mazes का एक सेट पैदा करता है। कभी-कभी वे इतने गूंथे हुए होते हैं कि ऐसा लगता है कि मज़ारों को कहीं पार कर जाना चाहिए। लेकिन निश्चित रूप से, वे नहीं!

अतिरिक्त कोड और आउटपुट 59 + 187 = 246 अतिरिक्त अक्षर मूल कार्यक्रम के अंत में जोड़ा जाना है (प्रश्न युक्ति से परे वृद्धि के लिए)।

  GCOL135FORa=1TO6GCOLa FILLRND(40)*32-16,RND(25)*32+208:NEXT   :REM set background to grey so fill can identify. For each colour 1 to 6, pick a point in the centre of a character and flood fill (characters are logically 32x32 although they are physically only 8x8 pixels.)
  f=126:g=126                                                   :REM flags 1111110 to indicate which starts and ends have not been allocated yet
  FORx=0TO39FORy=0TO24                                          :REM maze is 40x25. There is some blank space at the bottom of the screen (32 rows total)
  p=POINT(x*32+16,1008-y*32)                                    :REM check start point. Text origin is at top of screen, Graphics origin is at bottom, 1280x1024 logical. therefore y offset is 1024-32/2=1008.
  IFf AND2^p f=f-2^p:VDU31,x,y,17,p,79                          :REM if start for colour P has not been allocated yet, allocate it now. VDU31,X,Y go to that square. VDU 17,p select text colour. VDU 79 print an "O"                 
  p=POINT(1264-x*32,240+y*32)                                   :REM check end point
  IFg AND2^p g=g-2^p:VDU31,39-x,24-y,17,p,79                    :REM if end for colour P has not been allocated yet, allocate it now.
  NEXT:NEXT
  VDU31;26                                                      :REM get the cursor off the board. Move to (0,26). Semicolon used instead of comma here indicating that 31 is a 16 bit small endian value, equivalent to VDU31,0,26 or PRINTTAB(0,26)

Answer 9

सी: 235 बाइट्स

#define P(X,Y)M[(Y+40)*80+X+40]=rand()%49/6;
#define B(X,Y)P(X,Y)P(Y,X)
M[6400],r,i;main(){for(i=0;i<40;i+=2){int x=i,y=0,e=1-x;while(x>=y)
{B(x,y)B(-x,y)B(-x,-y)B(x,-y)++y;e+=e<0?2*y+1:2*(y-x--);}}for(i=0;
i<6400;)putchar(64>>!M[i++]);}

नोट: उपरोक्त में, मैंने इसे पृष्ठ पर फिट करने के लिए नई कड़ियाँ जोड़ीं। अपेक्षित उत्पादन (80-वर्ण टर्मिनल पर):

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

Comments

यह देखना थोड़ा कठिन है कि आप कहां से गुजर सकते हैं और कहां नहीं। मुझे कहना है, मैंने पाइपों को प्राथमिकता दी;) (यह और मेरी परिपत्र प्रस्तुत दोनों के लिए)।

— मार्टिन एंडर

@ m.buettner: मैं वास्तव में सहमत हूं। आप को बदलते हैं i+=2करने के लिए i+=3, इसे और अधिक स्पष्ट क्या हो रहा है हो सकता है।

— imallett

Answer 10

मैंने अपने बच्चे को ऐसा करने में मदद की, थोड़ी प्रोग्रामिंग सीखने के लिए: http://jsfiddle.net/fs2000/4KLUC/34/ आपको यह कैसे पसंद है?

Comments

यदि आप अपने कोड को पोस्ट में फिट कर सकते हैं, तो ऐसा करें। इसके अलावा, #Language (s) जैसे हेडर शामिल करें - बायटेकाउंट। यदि आपने अपने कोड में केवल ASCII वर्णों का उपयोग किया है, तो आप यहां एक अच्छा बायटेकाउंट प्राप्त कर सकते हैं । आपका कोड क्या करता है, इसका कोई सारांश, जो आपके पास हो सकता है, या आपके द्वारा किया गया कोई भी चतुर काम आपके पोस्ट के लिए एक अच्छा जोड़ हो सकता है। वैसे, डार्थ वाडर कुछ लाइनों को देखना बहुत कठिन बनाता है। अंत में, गोल्फ में आपका स्वागत है!

— रेनबोल्ट

आपने अपने बच्चों के साथ थोड़ी प्रोग्रामिंग सीखी और मैंने थोड़ी बहुत गोल्फ सीखी। यह मेरी पहली गोल्फ है और परिणाम अभी भी लंबा है। बाइट गिनती: मूल: 55 + 6822 = 6877। थोड़ा सा पुनर्गठित : 39 + 3131 = 3170 गोल्फ : 39 + 1593 = 1632

— बार्टेकहोम जूल

Answer 11

कमोडोर 64 बुनियादी - 38 बाइट्स

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

यह मेरा आविष्कार नहीं है, मैं पिछले दिनों से बहुत सुंदर और संक्षिप्त कार्यक्रम दोहरा रहा हूं। वास्तव में, 10 PRINT CHR$(205.5+RND(1)); : GOTO 10कोड के इस टुकड़े को मनाने के नाम पर एक पूरी किताब है !

आप इस YouTube वीडियो पर आउटपुट देख सकते हैं ; यहाँ एक पेंच है:

यहाँ इस StackOverflow सवाल पर इस भूलभुलैया जनरेटर कार्यक्रम के अधिक कार्यान्वयन कर रहे हैं। कार्यक्रम का सबसे छोटा कार्यान्वयन निम्नलिखित 23-बाइट C64 का मूल प्रोग्राम है जो उस प्रश्न के लेखक द्वारा पोस्ट किया गया है:

1?cH(109.5+rN(1));:gO1

जहाँ लोअरकेस अक्षर को इस प्रकार प्रविष्ट किया जाता है, और Shift कुंजी का उपयोग करके अपरकेस अक्षर दर्ज किए जाते हैं (ये वास्तविक C64 स्क्रीन पर अलग-अलग दिखते हैं)।

Comments

क्या यह ठीक उसी ब्रायन की अधीनता नहीं है? (बस थोड़ा सा) और तो क्या आपका बैश जवाब है? फिर यहाँ सवाल यह भी है कि क्या बिना जंक्शन के भूलभुलैया अभी भी भूलभुलैया है?

— मार्टिन एंडर

nneonneo, इस महान विचार के उचित और ईमानदार अटेंशन के लिए +1। @ m.buettner जैसा कि आप बताते हैं कि अनियंत्रित क्षेत्र अनियंत्रित लेबिरिंथ पैदा करता है। हालाँकि, और मुझे आश्चर्य है कि किसी और ने इसे अभी तक नहीं दिखाया है) मुद्रित क्षेत्र कुछ दिलचस्प, गैर-तुच्छ, शाखित माज़े बनाता है (मेरा उत्तर देखें।) मैं आपके भूलभुलैया को भी बढ़ा रहा हूं क्योंकि इसमें सबसे अच्छी शुरुआत और अंत है। । इन विकर्ण mazes पर शुरू और अंत को परिभाषित करना आसान नहीं है।

— लेवल रिवर सेंट

@ m.buettner 1. x86 बाइनरी अपने सबसे छोटे पर केवल 10 बाइट्स है। 2. यह एक अच्छी तरह से सम्मानित एल्गोरिथ्म है, और यह बिल्कुल भी मूल नहीं है, और न ही इसका उद्देश्य सॉल्वेबल भूलभुलैया बनाना था।

— इसियाह मीडोज

Answer 12

जावा: 700

यहाँ एक पुनरावर्ती दीवार योजक है। एल्गोरिथ्म इस साइट पर उल्लिखित है :

public class Z{int i,j,u=20,v=u,g[][]=new int[v][u];public static void main(String[]a){new Z().d(0,0,20,20,0).p();}int q(int m){return(int)(Math.random()*m);}<T>void z(T m){System.out.print(m);}void p(){for(i=0;i++<u*2;z("_"));for(i=0;i<v;i++){z("\n|");for(j=0;j<u;j++){boolean b=i+2>v,s=g[i][j]%2>0||b;z(s?"_":" ");z(g[i][j]>1||j+2>u?"|":s&(j+1<u&&g[i][j+1]%2>0||b)?"_":" ");}}}Z d(int x,int y,int w,int h,int o){int a=x,b=y,c=a,d=b,e,f;boolean t=o<1;if(t){b+=q(h-2);c+=q(w);}else{a+=q(w-2);d+=q(h);}for(i=t?w:h;i-->0;j=t?a++:b++)if(a!=c&&b!=d)g[b][a]|=t?1:2;e=t?w:a-x+1;f=t?b-y+1:h;if(e>2&&f>2)d(x,y,e,f,e<f?0:1);e=t?w:x+w-a-1;f=t?y+h-b-1:h;if(e>2&&f>2)d(t?x:a+1,t?b+1:y,e,f,e<f?0:1);return this;}}

मूल रूप से, यह प्रत्येक आयत को एक दीवार (और मार्ग) के साथ दो में विभाजित करता है, फिर उन दो में विभाजित करता है, आदि। यह एक "पूर्ण" भूलभुलैया उत्पन्न करता है - जिसमें कोई चक्र नहीं है - जिसमें हर बिंदु से हर दूसरे बिंदु तक एक रास्ता है। बहुत सारे मृत समाप्त होते हैं, इसलिए यह बड़े माज़ों के लिए किसी भी मायने में "तुच्छ" नहीं है।

तो, प्रवेश और निकास मनमाने ढंग से तय किया जा सकता है। अगर मुझे किसी एक को चुनना है, तो यह सिर्फ शीर्ष / बाएं और नीचे / दायां कहेगा।

यदि आप किसी भी आकार में से एक कर रहे हैं, तो यह डबल-चौड़ाई की एससीआई में खींचा गया है, इसलिए किसी फाइल को आउटपुट करना एक अच्छा विचार है। यहाँ 20x20 कंसोल में है:

और नोटपैड ++ में 100x100 (मुझे सभी को प्राप्त करने के लिए ज़ूम आउट करना पड़ा, इसलिए यह कुछ हद तक ... छोटा है ):

लाइन ब्रेक के साथ कोड:

public class Z{
    int i,j,u=20,v=u,g[][]=new int[v][u];
    public static void main(String[]a){
        new Z().d(0,0,20,20,0).p();
    }

    int q(int m){return(int)(Math.random()*m);}
    <T>void z(T m){System.out.print(m);}

    void p(){
        for(i=0;i++<u*2;z("_"));
        for(i=0;i<v;i++){
            z("\n|");
            for(j=0;j<u;j++){
                boolean b=i+2>v,s=g[i][j]%2>0||b;
                z(s?"_":" ");
                z(g[i][j]>1||j+2>u?"|":s&(j+1<u&&g[i][j+1]%2>0||b)?"_":" ");
            }
        }
    }

    Z d(int x,int y,int w,int h,int o){
        int a=x,b=y,c=a,d=b,e,f;
        boolean t=o<1;
        if(t){
            b+=q(h-2);
            c+=q(w);
            }
        else{
            a+=q(w-2);
            d+=q(h);
        }

        for(i=t?w:h;i-->0;j=t?a++:b++)
            if(a!=c&&b!=d)
                g[b][a]|=t?1:2;

        e=t?w:a-x+1;f=t?b-y+1:h;
        if(e>2&&f>2)d(x,y,e,f,e<f?0:1);
        e=t?w:x+w-a-1;f=t?y+h-b-1:h;
        if(e>2&&f>2)d(t?x:a+1,t?b+1:y,e,f,e<f?0:1);
        return this;
    }
}

Answer 13

ZX बेसिक - 281 अक्षर

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

"::" एक पाठ फ़ाइल में स्पेक्ट्रम ग्राफिक वर्णों को दर्ज करने का ZXB का तरीका है, एक बेचा ब्लॉक चरित्र के बराबर है।

randomize:border 1:paper 1:ink 6:cls
for x=0 to 30 step 2
 for y=0 to 20 step 2
  r=1+int(rnd*2)
  if x=30 and r=1 then 
   r=2
  end if
  if y=20 and r=2 then
   r=1
  end if
  print at y,x;"\::"
  print at y+(r=2),x+(r=1);"\::"
 next
next
print inverse 1;at 0,0;"S";at 20,31;"E"

Comments

नहीं, मेरा वास्तव में मतलब था कि आपको शुरुआत और अंत (शुरुआत नीचे दाएं, अंत शीर्ष बाएं) स्वैप करना चाहिए। जैसा कि यह अपनी तुच्छता रखता है, क्योंकि नियमों के कारण आपको अंत तक पहुंचने के लिए हर समय नीचे जाना होगा और सही करना होगा।

— मार्टिन एंडर

भले ही शुरू और अंत उलट हो, भूलभुलैया में (शायद दिलचस्प) संपत्ति है कि सही रास्ता केवल ऊपर और बाएं जाएगा। भूलभुलैया अब तुच्छ नहीं है, हालांकि, क्योंकि कई बिंदु हैं जिन पर आप दो में से एक तरीके से जा सकते हैं।

— केविन -

Answer 14

सी- 244

#include <unistd.h>
#include <windows.h>
int main(i,j,rv,rs){srand( time(0));for (i = 0; i < 80; i++)for (j = 0; j <50 ; j++){rv = rand() %10;rs = rand() %100;if(rs < 10 || rs  > 90)continue;if(rv<4){gotoxy(i,j);printf("%c", '#');}}return 0;}

यहाँ है कि यह कैसा दिखता है:

नोट: यह समाधान जंगल में अविश्वसनीय खेल स्तर 8: से प्रेरित है ।