मेरे लिए इस अलकेजर को सुलझाओ

39

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

  • एक बार दर्ज करें, एक बार छोड़ दें;
  • सभी वर्गों से गुजरें;
  • एक से अधिक बार एक वर्ग से न गुजरें

नीचे दी गई छवि एक अल्केजर बोर्ड का उदाहरण दिखाती है और इसके दाईं ओर, हल की गई पहेली (निश्चित रूप से यह एक आसान है):

नमूना अलकज़ार पहेली

आप http://www.theincrediblecompany.com/try-alcazar पर अधिक पहेलियाँ पा सकते हैं और PlayStore (PS: विज्ञापन नहीं) पर गेम डाउनलोड कर सकते हैं ।

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

बेशक, मैं किसी से भी छवि की व्याख्या करने के लिए छवि पढ़ने और पहेली को हल करने के लिए नहीं पूछ रहा हूँ (या मैं हूँ?)। इसलिए मैंने बॉक्स ड्रॉइंग पात्रों का उपयोग करके उपरोक्त पहेली को फिर से तैयार किया। पहेली और इसका समाधान इस तरह होगा:

╔═══════╗         ╔═══════╗
║▒ ▒ ▒ ▒║         ║┌─┐ ┌─┐║
║     ║ ║         ║│ │ │║│║
╣▒ ▒ ▒║▒╠         ╣│ └─┘║└╠
║ ══╦═╩═╣         ║│══╦═╩═╣
║▒ ▒║▒ ▒║         ║└─┐║┌─┐║
║   ║   ║   ==>   ║  │║│ │║
╣▒ ▒║▒ ▒║         ╣┐ │║│ │║
║ ║ ║   ║         ║│║│║│ │║
╣▒║▒ ▒ ▒║         ╣│║└─┘ │║
║ ║     ║         ║│║    │║
║▒ ▒ ▒ ▒║         ║└─────┘║
╚═══════╝         ╚═══════╝

ऊपर के बोर्ड में, ▒क्या कोशिकाएं भरी जानी हैं।

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

╔════╩╗         ═ ═ ╩ 
║▒ ▒ ▒║        ║▒ ▒ ▒║
║ ═══ ║           ═   
║▒ ▒ ▒║   ==   ║▒ ▒ ▒║
║     ║               
║▒ ▒ ▒║        ║▒ ▒ ▒║
╚╦════╝         ╦═ ══

यह भी समाधान के लिए मान्य है। यही है, यह कोशिकाओं को जोड़ने के लिए आवश्यक नहीं है:

╔════╩╗        ╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
║ ═══ ║        ║│═══ ║        ║ ═══ ║
║▒ ▒ ▒║   ==   ║└───┐║   =>   ║└ ─ ┐║
║     ║        ║    │║        ║     ║
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝        ╚╦════╝

ऊपर के उदाहरण में, दोनों समाधान समान हैं।

हाँ, परीक्षण के मामले। वे यहाँ हैं:

पहेली १

╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌ ─ ┘║
║ ═══ ║        ║ ═══ ║
║▒ ▒ ▒║   =>   ║└ ─ ┐║
║     ║        ║     ║
║▒ ▒ ▒║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝

पहेली २

╔═════╗        ╔═════╗
║▒ ▒ ▒║        ║┌ ─ ┐║
║   ║ ║        ║   ║ ║
╣▒ ▒║▒║        ╣└ ┐║│║
║ ║ ║ ║   =>   ║ ║ ║ ║
╣▒║▒ ▒╠        ╣┐║│ │╠
║ ║   ║        ║ ║   ║
║▒ ▒ ▒║        ║└ ┘ │║
╚════╦╝        ╚════╦╝

पहेली ३

╔════╩══╗        ╔════╩══╗
║▒ ▒ ▒ ▒║        ║┌ ┐ └ ┐║
║ ║   ║ ║        ║ ║   ║ ║
╣▒║▒ ▒║▒╠        ╣┘║└ ┐║│╠
║ ╚══ ║ ║        ║ ╚══ ║ ║
║▒ ▒ ▒ ▒╠   =>   ║┌ ─ ┘ │╠
║   ═══ ║        ║   ═══ ║
║▒ ▒ ▒ ▒║        ║│ ┌ ┐ │║
║   ║   ║        ║   ║   ║
║▒ ▒║▒ ▒║        ║└ ┘║└ ┘║
╚═══╩═══╝        ╚═══╩═══╝

पहेली ४

╔═══════╗        ╔═══════╗
║▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐║
║     ║ ║        ║     ║ ║
╣▒ ▒ ▒║▒╠        ╣│ └ ┘║└╠
║ ══╦═╩═╣        ║ ══╦═╩═╣
║▒ ▒║▒ ▒║        ║└ ┐║┌ ┐║
║   ║   ║   =>   ║   ║   ║
╣▒ ▒║▒ ▒║        ╣┐ │║│ │║
║ ║ ║   ║        ║ ║ ║   ║
╣▒║▒ ▒ ▒║        ╣│║└ ┘ │║
║ ║     ║        ║ ║     ║
║▒ ▒ ▒ ▒║        ║└ ─ ─ ┘║
╚═══════╝        ╚═══════╝

पहेली ५

╔══╩══════╗        ╔══╩══════╗
║▒ ▒ ▒ ▒ ▒║        ║┌ ─ ┐ ┌ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ┘ │╠
║   ╠════ ║        ║   ╠════ ║
║▒ ▒║▒ ▒ ▒║   =>   ║┌ ┘║┌ ─ ┘║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ─ ─╠
║   ╠═════╣        ║   ╠═════╣
║▒ ▒║▒ ▒ ▒║        ║┌ ┘║┌ ─ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒ ▒ ▒ ▒║        ║└ ─ ┘ ┌ ┘║
╚══╦═══╦══╝        ╚══╦═══╦══╝

पहेली ६

╔═══════════╗        ╔═══════════╗
║▒ ▒ ▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐ ┌ ┐║
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ └ ┘ └ ┘ │║
║       ═══ ║        ║       ═══ ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┐ ┌ ─ ─ ┘║
║     ═══   ║        ║     ═══   ║
╣▒ ▒ ▒ ▒ ▒ ▒╠   =>   ╣┐ │ │ ┌ ┐ ┌╠
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ │ │ │ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒║▒ ▒║▒ ▒║        ║│ │║│ │║│ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┘ └ ┘ └ ┘║
╚═══════════╝        ╚═══════════╝

पहेली 7

╔════╩════════╦╩╗        ╔════╩════════╦╩╗
║▒ ▒ ▒ ▒ ▒ ▒ ▒║▒║        ║┌ ─ ─ ─ ─ ─ ┐║│║
║ ║       ║   ║ ║        ║ ║       ║   ║ ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ─ ─ ┐║┌ ┘ │║
║ ║ ║ ═══ ║     ║        ║ ║ ║ ═══ ║     ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠        ║│ │║┌ ─ ┘ └ ┐ │╠
║   ║           ║        ║   ║           ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ └ ┐ ┌ ┐ └ ┘║
║     ║ ║     ══╣        ║     ║ ║     ══╣
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║     ║ ║       ║        ║     ║ ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ ┌ ┘ │ └ ┐ ┌ ┘║
║           ║ ══╣   =>   ║           ║ ══╣
║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║        ║└ ┘ ┌ ┘ ┌ ┘║└ ┐║
╠══       ║ ╚══ ║        ╠══       ║ ╚══ ║
║▒ ▒ ▒ ▒ ▒║▒ ▒ ▒║        ║┌ ┐ └ ┐ │║┌ ─ ┘║
║     ║ ║ ║     ║        ║     ║ ║ ║     ║
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║ ║   ║ ║ ╔══   ║        ║ ║   ║ ║ ╔══   ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ┘ │ │║┌ ┐ │║
║ ║     ║ ║     ║        ║ ║     ║ ║     ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║        ║│ └ ─ ┘║└ ┘ │ │║
║       ╚══     ║        ║       ╚══     ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║└ ─ ─ ─ ─ ─ ┘ │║
╚════╦═╦═╦═════╦╝        ╚════╦═╦═╦═════╦╝

पहेली 8 (क्षमा करें, मेरे पास वास्तव में इसका समाधान नहीं है)

╔══╩╦══╩═══╩═╩═╩═══╩╗
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ║               ║
╣▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ╚══ ╔══     ╔═══╣
╣▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒╠
║       ║   ╔══ ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║           ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒╠
║           ║       ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║   ╔═══╗   ╚══     ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║
║   ║   ║           ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠
║ ══╝   ║       ╔══ ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒║
║   ══╗ ╚══ ╔══ ║   ║
╣▒ ▒ ▒║▒ ▒ ▒║▒ ▒ ▒ ▒╠
║     ║     ║   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║
║   ═══   ══╗   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
╠══ ║       ║   ╔══ ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒╠
║   ╚══ ║   ║   ║   ║
╣▒ ▒ ▒ ▒║▒ ▒║▒ ▒ ▒ ▒╠
║       ║   ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
╚══╦═══╦═══╦═╦═╦═╦═╦╝

इनपुट

जब तक यह इन नियमों का पालन करता है आपके कोड के इनपुट में कोई भी प्रतिनिधित्व हो सकता है:

  1. यह एक ग्राफिकल इनपुट होना चाहिए। इसलिए, उदाहरण के लिए, एक समन्वय सूची को पढ़ना संभव नहीं है।

  2. क्षैतिज दीवारें, ऊर्ध्वाधर दीवारें, और दरवाजे अलग-अलग होने चाहिए, और उन्हें एक दृश्य चरित्र (कोई रिक्त वर्ण नहीं) से बना होना चाहिए।

  3. ▒कारतूस द्वारा प्रतिस्थापित किया जा सकता है। मैंने उन्हें उजागर करने के लिए एक अलग चरित्र का उपयोग किया।

उत्पादन

जब तक यह इन नियमों का पालन करता है तब तक आउटपुट का कोई भी प्रतिनिधित्व हो सकता है:

  1. यह एक ग्राफिकल आउटपुट होना चाहिए। अर्थात व्यक्ति जिसको देखकर रास्ता बना सकता है।

  2. नियम नंबर एक का अर्थ है कि पथ के चरित्र भिन्न हैं। यही है, कम से कम 6 पथ वर्ण होने जा रहे हैं; क्षैतिज, ऊर्ध्वाधर और कोने।

  3. मान्य होने के उत्तर के लिए, आउटपुट को सभी सेल (मेरे प्रतिनिधित्व में) के साथ इनपुट (स्पष्ट रूप से) के समान बोर्ड होना चाहिए ▒। कोशिकाओं के बीच अंतराल भरना वैकल्पिक है।

स्कोरिंग

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

1 अलकज़ार के कुछ स्तर हैं जिनमें वैकल्पिक कोशिकाएँ और सुरंगें हैं। इन पर विचार नहीं किया जाएगा।

2 कुछ ऐलज़र बोर्ड हैं जो असंभव हैं।

code-golf  ascii-art  puzzle-solver 
— फ्लीप ओलेनिक
स्रोत
2
मेरे कार्यक्रम में पहेली 8 का हल नहीं है। क्या आपको यकीन है कि यह हल करने योग्य है? शायद कुछ टाइपो?
— edc65
1
@ यहाँ edc65 वही - # 8 के लिए कोई हल नहीं
— ngn

जवाबों:

5

पायथन 3 , 809 728 723 714 693 688 684 663 657 641 639 627 610 571 569 बाइट्स

संपादित करें: @ बेली नार्डी बतिस्ता के लिए 55 बाइट्स धन्यवाद सहेजा गया

टीआईओ पर 60 सेकंड में अंतिम परीक्षण मामला नहीं चलता है, लेकिन फिर भी सही ढंग से काम करना चाहिए। पथ के लिए निर्देशांक की एक सूची देता है। कुछ 400 बाइट्स का उपयोग I / O से डेटा सूचियों को प्राप्त करने के लिए किया जाता है।

A=enumerate
I,J="═║"
B=range
L=len
K=-1
Z=1,0
X=0,1
C=K,0
V=0,K
E=lambda a,b,p:(((a,b)in d)*L(p)==H*h)*p or max([E(q+a,w+b,p+[(q+a,w+b)])for q,w in y[a][b]if~-((q+a,w+b)in p)*-h>w+b>K<q+a<H]+[[]])
x=input().split("\n")
h=L(x[0])//2
H=L(x)//2
y=[[{C,Z,V,X}for i in B(h)]for j in B(H)]
d=[]
exec('d+=[(%s,i)for i,a in A(x[%s][1::2])if I<a]\nfor i,u in A(x[%s:%s:2]):\n d+=[(i,0)]*(J<u[0])+[(i,h-1)]*(J<u[K])\n for j,w in A(u[%s:%s:2]):\n  if"%s"==w:y[i][j]-={%s};y[i+%s][j+%s]-={%s}\n'*2%(0,*X,"",2,K,J,X,*X,V,H-1,K,2,K,1,"",I,Z,*Z,C))
print(max(E(*D,[D])for D in d))

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

— हलवार्ड वुल्फ
स्रोत
@HalvardHummel खैर, चुनौती के ख़राब सूत्रीकरण के लिए खेद है। इसलिए मैं निम्नलिखित प्रस्ताव करता हूं। रन टाइम द्वारा बाइट काउंट को गुणा करके स्कोर की गणना की जाएगी, इसलिए रन टाइम और बाइट काउंट दोनों को पुरस्कृत किया जाएगा। तुम क्या सोचते हो?
— फेल्प ओलेनिक
1
@PhelypeOleinik मुझे नहीं लगता कि यह बहुत अच्छा स्कोरिंग सिस्टम है। कोएड गोल्फ में इसे रखना एक बेहतर उपाय है, लेकिन अगर आप वास्तव में एक समाधान की तलाश में हैं तो मुझे यकीन है कि इसे और अधिक कुशल बनाने के लिए संशोधित किया जा सकता है।
— caird coinheringaahing
@cairdcoinheringaahing मैं समझता हूं कि सबसे सुरुचिपूर्ण समाधान जैसा है वैसा ही रखना है। लेकिन एक 8x12 पहेली बोर्ड को हल करने के लिए "दिन या महीने" लगने वाला एल्गोरिदम किसी भी तरह अक्षम है, क्या आपको नहीं लगता? जिस तरह से मैं इसे देखता हूं, एक एल्गोरिथ्म जो समस्या को कम समय में हल करता है, उसे पुरस्कृत किया जाना चाहिए, भले ही यह थोड़ा लंबा हो।
— फेलेप ओलेनिक
3
@PhelypeOleinik कोड की "दक्षता" अप्रासंगिक है। आपने हमें लघु कोड लिखने की चुनौती दी है, और यह आपकी चुनौती का आधार है। जिस गति से प्रोग्राम मिक्स पर चलता है उसे जोड़ने से केवल अनावश्यक रूप से चीजों को उलझाया जाता है और हास्यास्पद स्कोर के लिए भी शोषण किया जा सकता है। कस्टम स्कोरिंग सिस्टम काम नहीं करते हैं। यदि आप लघु कोड चाहते हैं, तो एक कोड-गोल्फ प्रश्न बनाएं। यदि आप तेज़ कोड चाहते हैं, तो सबसे तेज़-कोड प्रश्न बनाएं। उन्हें एक साथ मिलाने की कोशिश करना अच्छा विचार नहीं है।
— LyricLy
आपकी exec(...)स्ट्रिंग में पाँच नई रेखाएँ हैं, जिनका प्रतिनिधित्व \n5 * 2 = 10 बाइट्स के रूप में किया जाता है। ट्रिपल-उद्धृत स्ट्रिंग का उपयोग करके 4 बाइट्स ( ...''...''...) जोड़े जाएंगे, लेकिन फिर 5 बाइट्स निकाल देंगे , क्योंकि वास्तविक नई लाइन वर्णों का उपयोग किया जा सकता है। कुल मिलाकर यह एक बाइट बचा सकता है।
— जोनाथन फ्रीच
5

एपीएल (डायलॉग क्लासिक) , 319 बाइट्स

i←N⍴j←⍳1+n←×/N←⌊2÷⍨⍴a←⎕⋄e←↑⊃,/{(,~'#='∊⍨a[(⍵⌽⍳2)∘+¨2×⍳N+⍵=⍳2])/,2,/[⍵]⊃,[⍵]/n i n}¨⍳2
r←{e g c←⍵⋄d←+/j∘.=∊g⋄e⌿⍨←(≠/c[e])∧2>⌈/d[e]⋄n≡≢g:g⍪j/⍨d=1⋄0≡≢e:0⋄2>⌊/d+D←+/j∘.=,e:0⋄u←,¯1↑e←e[⍒⌊/D[e];]⋄e↓⍨←¯1⋄0≢r←∇e(g⍪u)(c-(-/c[u])×c=c[⊃u]):r⋄∇e g c}e(0↑e)j
a[1+2×⍳N]←' ??┌?─┐┬?└│├┘┴┤┼'[2⊥(↑(⊂i),¨¨{⊖∘⍉⍣⍵⊢n⍪¯1↓⌽∘⍉⍣⍵⊢i}¨⍳4)∊↓r⍪⌽r]
a

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

क्लासिक चारसेट में फिट होने के =#F7LJ<>^v.बजाय इनपुट का उपयोग होता है ।═║╔╗╚╝╣╠╩╦▒

कुछ ही सेकंड में अंतिम एक को छोड़कर सभी परीक्षण मामले।

अंतिम परीक्षा में मेरे कंप्यूटर पर 47 मिनट लगते हैं और कोई हल नहीं निकलता है।

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

— NGN
स्रोत
बहुत अच्छा! यदि मैं पूछ सकता हूं कि आपके कोड को हल करने के लिए कौन सा दृष्टिकोण उपयोग करता है? व्यापक खोज या कुछ और अधिक सुरुचिपूर्ण? इसके अलावा, जैसा कि मैंने कहा, मैंने अंतिम पहेली को हाथ से हल नहीं किया। इसका कोई स्पष्ट चरण-दर-चरण समाधान नहीं है और आवश्यकता होती है, यहां तक ​​कि जब हाथ से हल करते हैं, तो कुछ उत्तरों को खोजने के लिए एक अनुमान। यह पहेली मूल खेल में शामिल है, लेकिन इसका कोई हल नहीं हो सकता है, इसलिए शायद इसे ध्यान में नहीं रखा जाना चाहिए।
— फेलेप ओलेनिक
1
@PhelypeOleinik हाँ, यह एक नहीं बल्कि परिष्कृत खोजपूर्ण खोज है। इसका कारण यह है कि यह मौजूदा समाधानों को जल्दी से ढूंढता है, यह पहले से अधिक संभावना वाले मामले की कोशिश करता है (बनाम ग्राफ में एक निश्चित बढ़त के बिना - मेरी उत्तराधिकारियों को दो कोने की डिग्री का न्यूनतम है, कम संभावना है)। अंतिम मामले में यह बहुत ही खराब है क्योंकि यह सभी संभावनाओं का परीक्षण करता है और स्पष्ट विरोधाभासों पर ही पुनरावृत्ति करता है। बाउंड-डिग्री (s4 पड़ोसी) ग्राफ़ के विशेष मामले के लिए भी अच्छा हैमिल्टन-पथ एल्गोरिदम नहीं मालूम पड़ता है।
— ngn
3

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

मल्टीलाइन स्ट्रिंग के रूप में इनपुट, प्रत्येक पंक्ति एक नई लाइन वर्ण के साथ समाप्त हो जाती है। दरवाजे '2' वर्ण से चिह्नित हैं

चरित्र '1' द्वारा चिह्नित पथ के साथ एक बहुस्तरीय स्ट्रिंग के रूप में आउटपुट, बहुत आसानी से विचार करने योग्य है।

यह एक गहराई से पहली खोज है , जब अटक जाने पर सभी पथ और बैकट्रैकिंग की कोशिश की जाती है। यह बिल्कुल भी कुशल नहीं है, लेकिन 1 मिनट से कम समय में 1 .. 6 पहेली को हल कर सकता है।

z=>(w=z.search`
`+1,t=(w-2)*(z.length/w-1)/4,z=[...z],R=(p,l,q)=>[1,-1,w,-w].some(d=>l<t?z[q=p+d]<1&z[q+d]<1&&(R(q+d,++z[q]+l)||--z[q]):z[p+d]>1&&--z[p+d],++z[p])||--z[p],z.some((c,i)=>-c&&(x=i%w,R(i<w?i+w:x?x>w-3?i-1:i-w:i+1,--z[i])||++z[i]*0))&&z.join``.replace(/0/g,' '))

कम गोल्फ वाला

z => (
  w = z.search`\n`+1, // board width and offset to next row
  t = (w-2)*(z.length/w-1)/4, // total size of board, number of cells that must be filled
  z = [...z], // convert string to array
  d = [1, -1, w, -w], // delta to next position in all directions
  // recursive search
  // given a current position, try to move in all directions
  // if the board is not full, look for an emoty cell
  // if the board is full, look for a door
  R = (p, // current position
       l, // fill level
       q  // parameter used as a local variable
      ) => (
        ++z[p], // mark current position
        // .some will terminate early if the called function returns true
        // in case of return true the recursive function returns all way up leaving the path marked
        // in case of return false we need to unmark path and backtrack
        d.some( d => // for each direction, offset in d
          l < t // check if board is full
          ? z[q=p+d] < 1 & z[q+d] < 1 // not full, try to advance 
            && (++z[q], // mark intermediate cell
                R(q+d, 1+l) // recursive call incrementing fill level
                || --z[q] // if R return false, backtrack: unmark intermediate cell
               )
          : z[p+d] > 1 && --z[p+d]
        ) // full, ok only if I find a door nearby
        || --z[p], // if some returns false, unmark and backtrak
  // look for doors and for each door call R 
  // when R returns true, stop and return the marked board
  // if R returns false for each door, no solution, return false
  z.some((c,i) => 
   -c && // if numeric and != 0
    (x = i%w,
     z[i]=1, // marking starting position (door)
     R(i<w ? i+w : x ? x > w-3 ? i-1 : i-w : i+1, 1)
     || (z[i] = 2, false) // if R returned false, unmark a return false
    ) 
  ) && z.join``.replace(/0/g,' ') 
)

परीक्षण स्निपेट के अंदर कुछ अवरोध के साथ DFS का उपयोग करके एक समाधान है जो एक मिनट से भी कम समय में (मेरे पीसी पर) पहेली को हल करता है। पहेली 8 का कोई हल नहीं है। प्रतिबंध:

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

परीक्षा

खबरदार, पहेली 7 किसी भी ब्राउज़र में जावास्क्रिप्ट निष्पादन के लिए समय से परे है (शॉर्ट और स्लो सॉल्वर का उपयोग करके)

कोड स्निपेट दिखाएं

— edc65
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.