भूलभुलैया को हल किया जा सकता है?

20

पहेली

  • 0 प्रिंट करें यदि एक भूलभुलैया n * m हल नहीं किया जा सकता है
  • 1 प्रिंट करें यदि भूलभुलैया n * m हल किया जा सकता है (1 या अधिक तरीकों से)

(इसलिए मैं रास्तों के लिए नहीं कह रहा हूँ लेकिन अगर हल करना संभव है !!!

इनपुट सरणी (2d): 

[[0,0,0,0,0,0,1],[0,0,0,0,0,1,0],[0,0,0,0,1,0,0],[1,0,0,0,0,0,0]]

XXXXXXXXX
XS     XX
X     X X
X    X  X
XX     FX
XXXXXXXXX

0 = can pass through
1 = can not pass trough
[0][n] is the last block of the first line
[m][0] is the first block of the last line

नियम प्रारंभ स्थिति 0,0 है और अंतिम स्थिति n है, m आप केवल क्षैतिज और लंबवत रूप से सबसे छोटा कोड जीत सकते हैं

code-golf  decision-problem  graph-theory  path-finding  maze 
— Dwana
स्रोत
क्या इनपुट एक स्ट्रिंग या एक सरणी होना चाहिए?
— अप्सराएँ
3
यदि 1 (दीवार) पर (n, m) कोड 0 है?
— त्रिकोप्लक्स
3
(वही (0,0 पर एक दीवार के लिए?)
— मार्टिन एंडर
3
आप कहते हैं कि यह एक × m भूलभुलैया है, लेकिन आपके अनुक्रमण का अर्थ है कि यह एक (n + 1) × (m + 1) भूलभुलैया है।
— निक मैट्टो
3
मैं रेगेक्स समाधान के लिए आगे देख रहा हूँ =)
— दोष

जवाबों:

7

CJam, 42 41 39 36 35 बाइट्स

Wq3>~_s,{{[{_2$+0<{e<_}*}*]}%z}*sW=

इस उत्तर में विचारों के आधार पर ।

4 बाइट्स ऑप्टिमाइज़र के लिए धन्यवाद।

इनपुट प्रारूप:

[[0 0 0 0 0 0 1] [0 0 0 0 0 1 0] [0 0 0 0 1 0 0] [1 0 0 0 0 0 0]]
— jimmy23013
स्रोत
@ ऑप्टिमाइज़र इसके लिए धन्यवाद। लेकिन फिर मुझे एक छोटा रास्ता मिला ...
— jimmy23013
1
q2Wts~_s,{{[{_2$+0<{e<_}*}*]}%z}*sW=- 36. हालाँकि यह मानता है कि इनपुट के पहले तीन अक्षर होंगे[[0
— ऑप्टिमाइज़र
7

दिल्लोग एपीएल, 27 अक्षर

⊃⌽∨.∧⍨⍣≡1≥+/¨|∘.-⍨,(~×⍳∘⍴)⎕

⎕मूल्यांकन किया गया इनपुट। APL एक मैट्रिक्स और वैक्टर के एक वेक्टर के बीच अंतर करता है। यह प्रोग्राम मानता है कि इनपुट एक मैट्रिक्स है।

(~×⍳∘⍴)Aके बराबर कांटा है (~A) × ⍳⍴A। ⎕दो बार उल्लेख करने या एक चर को प्रस्तुत करने से बचने की आवश्यकता है ।

⍴Aका आकार है A। 4-बाय -7 मैट्रिक्स के लिए आकार है 4 7।

⍳सूचकांक जनरेटर है। ⍳4है 1 2 3 4। ⍳4 7वैक्टर (1 1)(1 2)...(4 7)4-बाय -7 मैट्रिक्स में व्यवस्थित है।

~Aके टुकड़े झपटते हैं A।

×⍳⍴Aफ़्लिप बिट्स द्वारा गुणा करके, हम सभी मुक्त कोशिकाओं के निर्देशांक को संरक्षित करते हैं और सभी दीवारों को चालू करते हैं 0 0।

,समन्वय जोड़े के मैट्रिक्स को उठाता है, अर्थात इसे एक वेक्टर में रैखिक करता है। इस मामले में वेक्टर में जोड़े शामिल होंगे।

∘.-⍨Aया जोड़ो के A∘.-Aतत्वों को घटाता है A। ध्यान दें कि यहां तत्व Aस्वयं जोड़े हैं।

| निरपेक्ष मूल्य

+/¨प्रत्येक जोड़ी को पूर्ण मूल्यों के योग। यह हमें भूलभुलैया में हर जोड़ी कोशिकाओं के बीच ग्रिड की दूरी देता है, दीवारों के लिए बचाते हैं।

1≥हम केवल 1 से अधिक की दूरी पर पड़ोसियों में घुसपैठ कर रहे हैं, यह दीवारों को भी बाहर निकालता है। अब हमारे पास एक ग्राफ है आसन्न मैट्रिक्स।

∨.∧⍨⍣≡ फ्लोयड - वॉरहॉल का सकर्मक क्लोजर एल्गोरिथम

(f⍣n)A(यहां इस्तेमाल नहीं किया गया) जहां nएक पूर्णांक है, बिजली ऑपरेटर है। यह लागू होता है fकरने के लिए A nबार: f f ... f A।

(f⍣g)Aजहां gएक फ़ंक्शन है, निश्चित बिंदु ऑपरेटर है, उर्फ ​​"पावर लिमिट"। यह श्रृंखला कंप्यूटिंग रहती है A, f A, f f A, ... जब तक ((f⍣i)A) g ((f⍣(i+1))A)कुछ के लिए सच रिटर्न i। इस मामले में हम मिलान ( ≡) का उपयोग करते हैं g।

∨.∧⍨Aया A∨.∧Aफ़्लॉइड के एल्गोरिथ्म में एक कदम है। f.gआव्यूह गुणन (का सामान्यीकरण है +.×), यहाँ हम संयोजन (का उपयोग ∧) और अलगाव ( ∨के स्थान पर) +और ×।

⊃⌽⍣≡चरण को पर्याप्त बार लागू करने और स्थिर स्थिति तक पहुंचने के बाद , हमें परिणाम प्राप्त करने के लिए मैट्रिक्स के शीर्ष-दाएं कोने को देखना चाहिए, इसलिए हम इसे फ्लिप करते हैं ( ⌽) और पहले, शीर्ष-बाएं आइटम ( ⊃) लें।

विज़ुअलाइज़ेशन के ⍣≡कदम

— NGN
स्रोत
5

पायथन, 164 बाइट्स

def s(a):
 d=[(0,0)]
 while d:i,j=d.pop();a[i][j]=2;d+=[(x,y)for x,y in[(i-1,j),(i,j-1),(i+1,j),(i,j+1)]if len(a[0])>y>-1<x<len(a)and a[x][y]<1]
 return a[-1][-1]>1

मैं इसे पोस्ट करने के लिए अनिच्छुक था क्योंकि यह व्यावहारिक रूप से है कि मैं सामान्य रूप से बाढ़ भरण कैसे करूंगा, बस हल्के से गोल्फ। लेकिन यहाँ यह वैसे भी है।

— Sp3000
स्रोत
4

पर्ल, 73 बाइट्स

69 बाइट्स कोड + 4 बाइट्स के लिए -n0E(यह सुनिश्चित नहीं है कि 2014 में जहां टैग गिने गए थे, इसलिए मैंने उन्हें 2 के बजाय 4 के लिए गिना, लेकिन यह बहुत मायने नहीं रखता है)।

/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0

इसे ऑनलाइन आज़माएं! (और यदि आप 1111011लाइन को बदलते हैं 1111111, तो भूलभुलैया अब हल नहीं है, और आउटपुट 0इसके बजाय होगा 1: इसे ऑनलाइन आज़माएं! )

स्पष्टीकरण:

यह कोड भूलभुलैया के हर पुनः प्राप्य सेल (और उन्हें A) के साथ चिह्नित करेगा : यदि कोई सेल एक के साथ चिह्नित सेल को छूता है A, तो यह पहुंच योग्य है और हम इसे Aभी चिह्नित करते हैं; और हम फिर से ऐसा करते हैं ( redo)। यह दो रेगेक्स के लिए किया जाता है: s/(^0|A)(.{@{+}})?0/A$2A/sजाँच करता है कि कोई स्थान दाईं ओर है या किसी तल के नीचे है A, जबकि s/0(.{@{+}})?A/A$1A/sजाँच करता है कि कोई स्थान बाईं ओर है या किसी शीर्ष पर A। अंत में, अगर अंतिम सेल में Aयह पहुंच योग्य है, अन्यथा यह नहीं है (कि क्या say/A$/+0जाँच करता है; +0यहाँ यह सुनिश्चित करने के लिए है कि परिणाम खाली स्ट्रिंग के बजाय 0या होगा ) और । ध्यान दें कि एक पूरी लाइन से मेल खाएगा, इस प्रकार सेटिंग11
/.*/@+पहली पंक्ति के अंत का सूचकांक, जो एक पंक्ति के आकार का होता है, जो उपयोग करने के लिए उपयोग .{@{+}}करते हैं ठीक उसी तरह से जैसे कि एक पंक्ति में हैं। ( @{+}के बराबर है @+, लेकिन केवल पूर्व regex में इस्तेमाल किया जा सकता है)

— बापू
स्रोत
के लिए इस परीक्षण का मामला , अपने कोड व्याख्या करने योग्य अंतिम स्थिति है, भले ही भूलभुलैया समझता है 1।
— जितासे
@ जीत अच्छा कैच। दरअसल, ऐसा इसलिए था क्योंकि TIO लिंक सही कोड का उपयोग नहीं कर रहे थे (मुझे लगता है कि यह कुछ पहले वाला संस्करण था और मैंने इसे स्पॉट नहीं किया था)। उत्तर अभी भी मान्य है, और मैंने TIO लिंक को अपडेट किया है। आपका उदाहरण तब ठीक काम करता है: इसे ऑनलाइन आज़माएं!
— दादा
अरे हाँ! स्पष्टीकरण के लिए धन्यवाद, मुझे यह दृष्टिकोण पसंद है।
— जितसेव
@ धन्यवाद धन्यवाद, यह मेरे पसंदीदा गोल्फों में से एक है :)
— दादा
3

रूबी, 133 130 129 वर्ण

a=eval gets
f=->x,y{a[x][y]=1
[[-1,0],[1,0],[0,-1],[0,1]].map{|o|d,e=x+o[0],y+o[1]
f[d,e]if a[d]&&a[d][e]==0}}
f[0,0]
p a[-1][-1]

STDIN, आउटपुट 1या 0STDOUT पर इनपुट ।

अनायास लंबा। यह बस की बाढ़ भरण करता है 1से रों (0, 0)कि क्या "अंत" वर्ग एक है देखने के लिए, और फिर जाँच करता है 1।

— Doorknob
स्रोत
यदि यह पहले से ही 1 (n, m) सम्‍मिलित है तो क्या यह भूलभुलैया को विलेय मान लेगा?
— ट्राइकोप्लाक्स
2

जावा, 418 बाइट्स

import java.util.Scanner;public class Solvable{static int w,h;public static void main(String[] a){String[]i=new Scanner(System.in).nextLine().split(";");h=i.length+2;w=i[0].length()+2;int[]m=new int[w * h];for(int x=1;x<w-1;x++)for(int y=1;y<h-1;y++)m[y*w+x]=i[y-1].charAt(x-1)<'.'?0:1;f(m,w+1);System.out.println(m[w*h-w-2]>0?0:1);}static void f(int[]m,int i){if(m[i]>0){m[i]--;f(m,i-1);f(m,i+1);f(m,i-w);f(m,i+w);}}}

मेरा पहला कोड गोल्फ। मुझे नहीं पता कि मैंने जावा को क्यों चुना - यह गोल्फिंग एक्सडी के लिए बहुत बुरा है

उदाहरण भूलभुलैया को स्टड के माध्यम से इस तरह इनपुट किया जाएगा: 

......#;.....#.;....#..;#......
— bace1000
स्रोत
1
प्रो टिप: अपने वर्ग कुछ एक वर्ण लंबा नाम, के बीच की जगह खाई String[]और aहै, और बजाय stdin, जो अनुमति दी है की तुलना में आदेश पंक्ति तर्क से इनपुट ले लो।
— पावेल
1

अजगर 184 188

def f(a,x=0,y=0,h=[]):s=h+[[x,y]];X,Y=len(a[0]),len(a);return([x,y]in h)==(x>=X)==(y>=Y)==(x<0)==(y<0)==a[y][x]<(x==X-1and y==Y-1or f(a,x-1,y,s)|f(a,x+1,y,s)|f(a,x,y-1,s)|f(a,x,y+1,s))

यह जितना मैंने सोचा था कि इससे अधिक लंबा हो गया :( वैसे भी, मैं एक स्पष्टीकरण जोड़ दूंगा एक बार मैं इसे अब और नहीं गोल्फ सकता हूं।

— FryAmTheEggman
स्रोत
1

जे, 75 चर

आसन्न मैट्रिक्स की शक्ति (बहुत समय और स्मृति अक्षम)। (इसे अंग्रेजी में पॉवरिंग कहा जाता है?)

   ({.@{:@(+./ .*.^:_~)@(+:/~@,*2>(>@[+/@:|@:->@])"0/~@,@(i.@#<@,"0/i.@#@|:)))

कुछ परीक्षण मामले:

   m1=. 0 0 0 0 0 0 1,. 0 0 0 0 0 1 0,.  0 0 0 0 1 0 0,. 1 0 0 0 0 0 0
   m2=. 0 1 1 ,. 0 0 0
   m3=. 0 1 0 ,. 1 1 0
   m4=. 0 1 1 0 ,. 0 0 1 0
   ({.@{:@(+./ .*.^:_~)@(+:/~@,*2>(>@[+/@:|@:->@])"0/~@,@(i.@#<@,"0/i.@#@|:))) every m1;m2;m3;m4
1 1 0 0
— randomra
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.