केवल एक समाधान के साथ एक बहु-स्तरीय 5x5x5 भूलभुलैया बनाएं

Question

इस चुनौती का उद्देश्य सबसे छोटा कोड बनाना है (वर्णों में) जो सफलतापूर्वक निम्नलिखित करते हैं:

विनिर्देशों :

• एक बनाना होगा 5x5x5 labyrinthबिल्कुल के साथ 1 possible solution(और नहीं, कम नहीं)
• भूलभुलैया बनाई जानी चाहिए randomly यदि वर्षों से चल रहा है तो यह हर मौजूदा समाधान को उत्पन्न करने में सक्षम होना चाहिए
• startऔर finishमें रखा जाना चाहिए*opposite corners
• मानचित्र outputको निम्न स्वरूपों में से एक में होना चाहिए:

विकल्प आउटपुट स्वरूप 1 strings, printed or alerted :

xxxxx,xxxxx,xxxxx,xxxxx,xxxxx/
xxxxx,xxxxx,xxxxx,xxxxx,xxxxx/
xxxxx,xxxxx,xxxxx,xxxxx,xxxxx/
xxxxx,xxxxx,xxxxx,xxxxx,xxxxx/
xxxxx,xxxxx,xxxxx,xxxxx,xxxxx

विकल्प आउटपुट स्वरूप 2 arrays :

[[xxxxx,xxxxx,xxxxx,xxxxx,xxxxx],
[xxxxx,xxxxx,xxxxx,xxxxx,xxxxx],
[xxxxx,xxxxx,xxxxx,xxxxx,xxxxx],
[xxxxx,xxxxx,xxxxx,xxxxx,xxxxx],
[xxxxx,xxxxx,xxxxx,xxxxx,xxxxx]]

आउटपुट नोट्स:

• के 0लिए emptyऔर के 1लिए उपयोग करेंsquares

• ब्रेक लाइनें आवश्यक नहीं हैं

• आप तय करते हैं indexकि क्या है, लेकिन इसे अच्छी तरह से समझाना सुनिश्चित करें

---

* यहाँ एक उदाहरण है कि मैं विपरीत कोनों से क्या मतलब है:

स्पष्टीकरण :

• कर सकते हैं नहीं में कदमdiagonal
• एक ही रास्ते पर दो बार नहीं जा सकते
• करने के बाद inaccessible areasअनुमति दी है
• आप go up/downएक पंक्ति में एक से अधिक स्तर कर सकते हैं

सुझाव:

• उन्हें दीवारों के रूप में न देखें, इसके बजाय उन्हें 5x5x5चौकों के ढेर के रूप में देखें कि उनमें से कुछ गायब हैं और आप लापता लोगों के माध्यम से जा सकते हैं

Comments

अगर कुछ स्पष्ट नहीं है, तो बस मुझसे पूछें :)

— ajax333221

हालाँकि, एक विवरण है जिस पर मैं स्पष्टीकरण चाहूंगा: क्या दीवारें वर्गों के बीच रखी गई हैं , या क्या एक दीवार पूरे वर्ग को भरती है?

— इल्मरी करोनें

आप कुछ स्थानों में 5x5 (एक 2D सरणी) कहते हैं, फिर भी कोड के नमूने और छवि 5x5x5 (एक 3D सरणी) का सुझाव देते हैं। मुझे लगता है कि 3D सरणी का मतलब क्या है?

— कै वेन्स

यह कैसे तय किया जाता है कि समाधान एक वैध भूलभुलैया है? मेरा मतलब है, यह सही रास्ता है कि offshoots की संख्या है? क्या यह 1s से 0 s के अनुपात के साथ कुछ करना है?

— कै वेन्स

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

— पीटर टेलर

Answer 1

C ++ C, लगभग 1000 670 643 395 297 248 वर्ण

नमूना उत्पादन:

00111,10011,10111,00110,11000,
11001,01010,00100,11011,10101,
10111,10101,10001,01010,00101,
11001,11110,11100,11110,10101,
11100,10010,11001,10101,00000,

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

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

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

#define M m[*p+1][p[1]][p[2]]
#define F(a,b)for(p[a]=5;p[a]--;putchar(b))
#define f for(i=3;i--;p[i]
p[]={4,4,4},h[3],m[7][6][6]={1};
main(i){
    for(M=2;h[1]^1||(M=1)^h[2];){
        f=rand()%5)
            h[i]=0;
        f++)
            p[i]++,
            h[M]++,
            p[i]-=2,
            h[M]++;
    }
    F(0,10)
        F(1,44)
            F(2,48+!M);
}

मैंने पठनीयता के लिए प्रदर्शित कोड में नई लिंक और इंडेंटेशन जोड़ दिया है।

Comments

मुझे लगता है कि आप इसे जीत

— लेते हैं;;

मैं वास्तव में प्रतियोगिता का आनंद ले रहा था :-) मुझे थोड़ा आश्चर्य है कि हम अभी भी एकमात्र उत्तर हैं, मुझे उम्मीद थी कि गोल्फ ट्रिक या इसी तरह हम दोनों को अब तक हरा देंगे।

— १

किसी भी तरह, बिना कांटे या निर्णय नोड के साथ एक सरल मार्ग, एक सच्चे भूलभुलैया के रूप में अर्हता प्राप्त करने के लिए प्रतीत नहीं होता है। कुछ अंधे गलियों को जोड़ने की कोशिश करें।

— DavidC

@ डेविड कारहर एल्गोरिथ्म नमूना में दिखाए गए अनुसार डेड एंड ब्रांचिंग पथ उत्पन्न करता है। पहले से मौजूद दो शाखाओं को जोड़ने के लिए एक नए बिंदु की अनुमति नहीं देना बस भूलभुलैया में कई समाधानों या चक्रों को रोकता है।

— १३:३५ पर सर_गागलोट

@Sir_Lagsalot स्पष्टीकरण के लिए धन्यवाद

— डेविड 55

Answer 2

जावास्क्रिप्ट, 874 816 788 686 682 668 637 वर्ण

नमूना उत्पादन:

00000,10111,10111,01010,11000
01011,01000,01010,01111,00011
00100,11010,00111,10111,11010
01111,10001,01110,01010,01000
00000,11110,00001,10101,10110

यह एक बिंदु से शुरू करके काम करता है [0,0,0] और बेतरतीब ढंग से जोड़ते हुए 0 के आगे एक 0 जोड़ देना जहाँ कहीं भी अनुमति दी जाती है (अनुमति == नया 0 किसी भी अन्य 0 के बगल में नहीं है, मूल को छोड़कर) तब तक नहीं है जब तक कि कोई और न हो। संभव अतिरिक्त।

यदि कोई नया 0 निकास बिंदु (x * y * z == 48) के बगल में है, तो हम बाहर निकलने को खोलते हैं।

golfed

b=[]
I=Math.random
for(i=5;i--;)for(j=5,b[i]=[];j--;)b[i][j]=[1,1,1,1,1]
b[0][0][0]=0
k=[[0,0,0]]
function q(x,y,z){J=b[x]
if(x<0||y<0||z<0||x>4||y>4||z>4||!J[y][z])return 
n=6-!x||b[x-1][y][z]
n-=!y||J[y-1][z]
n-=!z||J[y][z-1]
n-=x==4||b[x+1][y][z]
n-=y==4||J[y+1][z]
n-=z==4||J[y][z+1]
n==1&&v.push([x,y,z])}while(I){F=k.length
B=k[C=0|I(v=[])*F]
x=B[0]
q(x-1,y=B[1],z=B[2])
q(x,y-1,z)
q(x,y,z-1)
q(x+1,y,z)
q(x,y+1,z)
q(x,y,z+1)
if(D=v.length){k.push(A=v[0|I()*D])
b[A[0]][A[1]][A[2]]=0
if(A[0]*A[1]*A[2]==48)b[4][4][4]=I=0}else{for(E=[];F--;)F^C&&E.push(k[F])
k=E}}for(i=25;i--;)b[H=0|i/5][i%5]=b[H][i%5].join('')
alert(b.join("\n"))

मूल

window.map=[];
for (i=0;i<5;++i) {
  map[i]=[];
  for (j=0;j<5;++j) {
    map[i][j]=[1,1,1,1,1];
  } 
} 
points=[[0,0,0]];
map[0][0][0]=0;
function spaces(x,y,z) {
  var n=6;
  if (x<0 || y<0 || z<0) return 0;
  if (x>4 || y>4 || z>4) return 0;
  if (!map[x][y][z]) return 0;
  if (!x || map[x-1][y][z]) n--;
  if (!y || map[x][y-1][z]) n--;
  if (!z || map[x][y][z-1]) n--;
  if (x==4 || map[x+1][y][z]) n--;
  if (y==4 || map[x][y+1][z]) n--;
  if (z==4 || map[x][y][z+1]) n--;
  return n;
} 
do {
  var index=Math.floor(Math.random()*points.length);
  point=points[index];
  v=[];
  x=point[0];
  y=point[1];
  z=point[2];
  spaces(x-1,y,z)==1 && v.push([x-1,y,z]);
  spaces(x,y-1,z)==1 && v.push([x,y-1,z]);
  spaces(x,y,z-1)==1 && v.push([x,y,z-1]);
  spaces(x+1,y,z)==1 && v.push([x+1,y,z]);
  spaces(x,y+1,z)==1 && v.push([x,y+1,z]);
  spaces(x,y,z+1)==1 && v.push([x,y,z+1]);
  if (v.length) {
    var point=v[Math.floor(Math.random()*v.length)];
    points.push(point);
    map[point[0]][point[1]][point[2]]=0;
    if (point[0]*point[1]*point[2]==48) {
      map[4][4][4]=0;
    } 
  } 
  else {
    var np=[];
    for (var i=0;i<points.length;++i) {
      i!=index && np.push(points[i]); 
    } 
    points=np;
  } 
} while(points.length);
for (i=0;i<5;++i) {
  for (j=0;j<5;++j) {
    map[i][j]=map[i][j].join('');
  } 
  map[i]=map[i].join();
} 
alert(map.join("\n"));

Answer 3

गणित: सच्चा भूलभुलैया (827 वर्ण)

मूल रूप से, मैंने {1,1,1} से {5,5,5} तक का रास्ता तैयार किया, लेकिन क्योंकि इसमें कोई संभावित गलत मोड़ नहीं थे, इसलिए मैंने कांटे या "निर्णय बिंदु" (डिग्री का वर्जन> 2) पेश किया, जहां किसी को यह तय करने की आवश्यकता होगी कि किस रास्ते पर जाना है। परिणाम एक सच्चे भूलभुलैया या भूलभुलैया है।

"अंधा गलियों" को एक सरल, सीधा रास्ता खोजने की तुलना में हल करना अधिक चुनौतीपूर्ण था। सबसे चुनौतीपूर्ण बात यह थी कि समाधान पथ से साइकिल को अनुमति देते समय पथ के भीतर चक्रों को समाप्त करना।

कोड की निम्नलिखित दो पंक्तियाँ केवल खींचे गए ग्राफ़ को प्रस्तुत करने के लिए उपयोग की जाती हैं, इसलिए कोड की गणना नहीं की जाती है, क्योंकि यह समाधान में नियोजित नहीं है।

o = Sequence[VertexLabels -> "Name", ImagePadding -> 10, GraphHighlightStyle -> "Thick", 
    ImageSize -> 600];

o2 = Sequence[ImagePadding -> 10, GraphHighlightStyle -> "Thick", ImageSize -> 600];

उपयोग किया गया कोड:

e[c_] := Cases[EdgeList[GridGraph[ConstantArray[5, 3]]], j_ \[UndirectedEdge] k_ /; (MemberQ[c, j] && MemberQ[c, k])]

m[] :=
Module[{d = 5, v = {1, 125}},
   While[\[Not] MatchQ[FindShortestPath[Graph[e[v]], 1, 125], {1, __, 125}],

v = Join[v, RandomSample[Complement[Range[125], v], 1]]];
   Graph[e[Select[ConnectedComponents[Graph[e[v]]], MemberQ[#, 1] &][[1]]]]]

w[gr_, p_] := EdgeDelete[gr, EdgeList[PathGraph[p]]]

y[p_, u_] := Select[Intersection[#, p] & /@ ConnectedComponents[u], Length[#] > 1 &]

g = HighlightGraph[lab = m[],  PathGraph[s = FindShortestPath[lab, 1, 125]],o]
u = w[g, s]
q = y[s, u]

While[y[s, u] != {}, u =  EdgeDelete[u, Take[FindShortestPath[u,  q[[1, r = RandomInteger[Length@q[[1]] - 2] + 1]], 
  q[[1, r + 1]]], 2] /. {{a_, b_} :> a \[UndirectedEdge] b}];

q = y[s, u]]

g = EdgeAdd[u, EdgeList@PathGraph[s]];

Partition[StringJoin /@ Partition[ReplacePart[Table["x", {125}], 
Transpose[{VertexList[g], Table["o", {Length[VertexList@g]}]}]/. {{a_, b_} :>  a -> b}], {5}], 5]

नमूना उत्पादन

{{"oxooo", "xxooo", "xoxxo", "xoxxo", "xxoox"}, {"ooxoo", "xoooo", "ooxox", "ooxox", "xooxx"}, {"oooxx", "ooxxo", "ooxox", "xoxoo", "xxxoo"}, {"oxxxx", "oooox", "xooox", "xoxxx", "ooxox" "}, {" xxxxx "," ooxox "," ooxox " "," xoxoo "," oooxo "}}

हुड के नीचे

नीचे दी गई तस्वीर भूलभुलैया या भूलभुलैया को दर्शाती है ({{"ooxoo",...}}जो ऊपर दिखाए गए समाधान से मेल खाती है :

यहाँ एक ही भूलभुलैया 5x5x5 में डाला गया है GridGraph। गिने हुए कोने भूलभुलैया से बाहर सबसे छोटे मार्ग पर स्थित हैं। 34, 64 और 114 पर कांटे या निर्णय बिंदुओं पर ध्यान दें। मैं ग्राफ के प्रतिपादन के लिए उपयोग किए जाने वाले कोड को शामिल करूंगा, हालांकि यह समाधान का हिस्सा नहीं है:

HighlightGraph[gg = GridGraph[ConstantArray[5, 3]], g,  
 GraphHighlightStyle ->"DehighlightFade", 
 VertexLabels -> Rule @@@ Transpose[{s, s}] ]

और यह ग्राफ केवल भूलभुलैया के समाधान को दर्शाता है:

HighlightGraph[gg = GridGraph[ConstantArray[5, 3]], 
   Join[s, e[s]], GraphHighlightStyle -> "DehighlightFade", VertexLabels -> Rule @@@    Transpose[{s, s}] ]

अंत में, कुछ परिभाषाएँ जो कोड को पढ़ने में मदद कर सकती हैं:

---

मूल समाधान (432 चार, एक रास्ता बनाया गया था, लेकिन सही भूलभुलैया या भूलभुलैया नहीं)

एक 5x5x5 बड़े ठोस घन की कल्पना करें जो अलग-अलग यूनिट क्यूब्स से बना हो। निम्नलिखित यूनिट क्यूब्स के बिना {1,1,1} और {5,5,5} पर शुरू होती है, क्योंकि हम जानते हैं कि उन्हें समाधान का हिस्सा होना चाहिए। तब यह यादृच्छिक क्यूब्स को हटा देता है जब तक कि {1,1,1} से {5,5,5} तक का एक अनपेक्षित मार्ग न हो।

"भूलभुलैया" सबसे छोटा रास्ता है (यदि एक से अधिक संभव है) इकाई क्यूब्स को हटा दिया गया है।

d=5
v={1,d^3}
edges[g_,c_]:=Cases[g,j_\[UndirectedEdge] k_/;(MemberQ[c,j]&&MemberQ[c,k])]

g:=Graph[v,edges[EdgeList[GridGraph[ConstantArray[d,d]]],v]];

While[\[Not]FindShortestPath[g,1,d^3]!={},
    v=Join[v,RandomSample[Complement[Range[d^3],v],1]]]

Partition[Partition[ReplacePart[
   Table["x",{d^3}],Transpose[{FindShortestPath[g,1,d^3],Table["o",{Length[s]}]}]
      /.{{a_,b_}:>  a->b}],{d}]/.{a_,b_,c_,d_,e_}:>  StringJoin[a,b,c,d,e],5]

उदाहरण:

{{"ooxxx", "xxxxx", "xxxxx", "xxxxx", "xxxxx"}, 
 {"xoxxx", "xoooo", "xxxxo", "xxxxo", "xxxxo"}, 
 {"xxxxx", "xxxxx", "xxxxx", "xxxxx", "xxxxo"}, 
 {"xxxxx", "xxxxx", "xxxxx", "xxxxx", "xxxxo"}, 
 {"xxxxx", "xxxxx", "xxxxx", "xxxxx", "xxxxo"}}

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

दिनचर्या वास्तव में एक भूलभुलैया बना देती है, लेकिन मैंने सभी खाली स्थानों को प्लग किया जो साइकिल को जन्म दे सकते थे। अगर मुझे साइकिल निकालने का कोई रास्ता मिल जाए तो मैं यहाँ उस कोड को शामिल करूँगा।

Comments

अच्छा अद्यतन, मुझे यह पसंद है कि आपका अद्यतन समाधान गैर-समाधान पथों पर चक्रों की अनुमति देता है, यह अधिक भ्रामक भूलभुलैया के लिए बनाता है।

— सर_गागलोट

धन्यवाद। मैं अब भी यही चाहूंगा कि समाधान मार्ग समय-समय पर अंतिम नोड से दूर रहने की अधिक संभावना है। यह वर्तमान में हतोत्साहित किया गया है (लेकिन पूरी तरह से रोका नहीं गया है) FindShortestPath।

— 15

मैं matlab से बहुत परिचित नहीं हूं, लेकिन क्या आप FindShortestPath जैसा कुछ कर सकते हैं, प्रत्येक नोड के खिलाफ सबसे छोटे पथ में एक पूर्वाग्रह जोड़ सकते हैं, और फिर FindShortestPath को फिर से पूर्वाग्रह को ध्यान में रखते हुए चलाएंगे ताकि यह सबसे छोटे समाधान में नोड्स से बच जाए? यह भी किया जा सकता है। मुझे यह देखने में दिलचस्पी होगी कि किस तरह का रास्ता बनेगा।

— १३:१३ पर सर_जगलोट

@Sir_Lagsalot मैंने इसे यहाँ Mathematica SE समूह के लिए एक प्रश्न के रूप में पोस्ट किया है ( mathematica.stackexchange.com/questions/4084/… )

— DavidC