एक आइस भूलभुलैया का समाधान

Question

पोकेमोन गोल्ड और सिल्वर में पदार्पण के बाद से आइस मेज़ पोकेमॉन गेम्स के मेरे पसंदीदा स्टेपल्स में से एक रहा है । आपका कार्य एक ऐसा कार्यक्रम बनाना होगा जो इस प्रकार की समस्याओं को हल करे।

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

आपको मानों का एक दो आयामी कंटेनर मिलेगा, जैसे कि सूचियों की एक सूची या न्यूलाइन द्वारा अलग किए गए स्ट्रिंग, जिसमें 3 प्रकार के फ़र्श (आइस, सॉइल, और स्टोन) में से प्रत्येक के लिए 3 अलग-अलग मान हैं। आपको दो जोड़े (या अन्य समतुल्य दो मूल्य के कंटेनर) प्राप्त होंगे जो भूलभुलैया में एक शुरुआत और लक्ष्य समन्वय का संकेत देते हैं। ये शून्य या एक अनुक्रमित हो सकते हैं।

आपको चालों की एक सूची (4 अलग मानों के साथ N, E, S, W) पर आउटपुट करना होगा, जिससे खिलाड़ी को अंत में पहुंचने पर नुकसान होगा।

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

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

परीक्षण के मामलों

यहाँ .बर्फ ~का प्रतिनिधित्व करेगा, मिट्टी Oका प्रतिनिधित्व करेगा , और एक पत्थर का प्रतिनिधित्व करेगा। निर्देशांक 1 अनुक्रमित हैं। समाधान में प्रत्येक अक्षर उस अक्षर से शुरू होने वाली दिशा का प्रतिनिधित्व करता है (जैसे N= उत्तर)

---

इनपुट

OOOOO
OO.OO
O...O
OOOOO

Start : 3,3
End   : 3,2

उत्पादन

N

---

इनपुट

OOOOOOOOOOOOOOOOO
O........O.....OO
O...O..........OO
O.........O....OO
O.O............OO
OO.......O.....OO
O.............OOO
O......O.......~O
O..O...........~O
O.............OOO
O.......O......OO
O.....O...O....OO
O..............OO
OOOOOOOOOOOOOO~~O
OOOOOOOOOOOOOOOOO

Start : 15,12
End   : 16,8

उत्पादन

N,W,N,E,N,E,S,W,N,W,S,E,S,E,N,E,N

---

इनपुट

OOOOOOOOOOOOOOOO
O~~~~~OOOOO~~~~O
O~~O~OOOOOOO~~OO
O...O..........O
O........O.....O
O..............O
OO.............O
O.............OO
O....~....O....O
O..............O
O..............O
OOOOOOOOOOOOOOOO

Start : 2,2
End   : 14,3

उत्पादन

E,S,S,W,N,E,N

---

इनपुट

OOOOOOOOOOOOOOOOOOO
O~~~~~~~OOOOOOOOOOO
O~~~~...OOOOOOOOOOO
OO~O~..OOOOOOOOOOOO
O..OO.............O
O..............O..O
O....O............O
O.O............~..O
O........OOOO.....O
O.......OOOOO.....O
O.......O~~~O.....O
O.......~~~~~.....O
O.......~~~~~.....O
O..........O......O
O..O..~...........O
O...............O.O
O.....O...........O
O.................O
OOOOOOOOOOOOOOOOOOO

Start : 2,2
End   : 11,11

उत्पादन

E,E,E,E,E,S,S,E,N,W,S,E,N,N,N

Comments

क्या इनपुट में हमेशा कम से कम एक वैध समाधान होगा?

— पावेल

@ पीवल आप ऐसा मान सकते हैं।

— गेहूं जादूगर

क्या परीक्षण के मामले (पंक्ति, स्तंभ) या (स्तंभ, पंक्ति) हैं? 1 या 0 अनुक्रमित? क्या बोर्ड के किनारों को दीवारों के रूप में गिना जाता है?

— MildlyMilquetoast

सम्बंधित

— पीटर टेलर

@busukxuan आप स्थायी रूप से भूलभुलैया में फंस सकते हैं (देखें टेस्टकेस 1)

— गेहूं जादूगर

Answer 1

गणितज्ञ, 247 बाइट्स

(p=x#[[##&@@x]];m={c,v}Switch[p[c+v],0,m[c+v,v],1,c+v,_,c];g=Cases[Array[List,Dimensions@#],c_/;p@c<2,{2}];a=cm[c,#]&/@{{1,0},{-1,0},{0,1},{0,-1}};e=Flatten[Table[#->c,{c,a@#}]&/@g,1];Normalize/@Differences@FindPath[Graph[e],#2,#3][[1]])&

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

(
p=x#[[##&@@x]];
m={c,v}Switch[p[c+v],0,m[c+v,v],1,c+v,_,c];
g=Cases[Array[List,Dimensions@#],c_/;p@c<2,{2}];
a=cm[c,#]&/@{{1,0},{-1,0},{0,1},{0,-1}};
e=Flatten[Table[#->c,{c,a@#}]&/@g,1];
Normalize/@Differences@FindPath[Graph[e],#2,#3][[1]]
)&

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

पहला तर्क #एक 2 डी सरणी है जहां 0बर्फ का 1प्रतिनिधित्व करता है, मिट्टी का प्रतिनिधित्व करता है, और 2पत्थर का प्रतिनिधित्व करता है।

दूसरा तर्क #2और तीसरा तर्क #3क्रमशः फॉर्म में शुरू और समाप्त होने वाले बिंदु हैं {row,column}।

3 बाइट निजी उपयोग चरित्र का U+F4A1प्रतिनिधित्व करता है \[Function]।

व्याख्या

p=x#[[##&@@x]];

एक फ़ंक्शन को परिभाषित करता है pजो xफॉर्म {row,column}और आउटपुट की एक सूची लेता है #[[row,column]]; अर्थात, उस समन्वय पर बर्फ / मिट्टी / पत्थर का मूल्य।

m={c,v}Switch[p[c+v],0,m[c+v,v],1,c+v,_,c]

एक फ़ंक्शन को परिभाषित करता है mजो एक प्रारंभिक स्थिति cऔर दिशा वेक्टर लेता है vऔर पुनरावर्ती रूप से निर्धारित करता है कि आप कहां समाप्त होंगे। यदि c+vबर्फ है, तो हम उस बिंदु से फिसलना जारी रखते हैं, इसलिए यह वापस आ जाता है m[c+v,v]। अगर c+vमिट्टी है, तो हम आगे बढ़ते हैं c+vऔर रुकते हैं। अन्यथा (यदि c+vपत्थर है या सीमा से बाहर), तो आप नहीं चलते हैं। ध्यान दें कि यह केवल बर्फ या मिट्टी के पदों पर बुलाया जाना है।

g=Cases[Array[List,Dimensions@#],c_/;p@c<2,{2}];

gबर्फ और मिट्टी की स्थिति ( pमान से कम 2) की सूची को परिभाषित करता है ।

a=cm[c,#]&/@{{1,0},{-1,0},{0,1},{0,-1}}; 

एक समारोह को परिभाषित करता है aजो एक प्रारंभिक स्थिति लेता है cऔर रिटर्न में आगे बढ़ के परिणाम {1,0}, {-1,0}, {0,1}, और {0,-1}दिशाओं। कुछ अतिरेक हो सकता है। फिर, यह मानता है कि cबर्फ या मिट्टी से मेल खाती है।

e=Flatten[Table[#->c,{c,a@#}]&/@g,1];

eकानूनी चाल का प्रतिनिधित्व करने वाले निर्देशित किनारों की सूची को परिभाषित करता है। प्रत्येक स्थिति के लिए #में g, किनारों की मेज की गणना #->cप्रत्येक के लिए cमें a@#। तब से हम प्रत्येक स्थिति के लिए एक सूची के साथ समाप्त करेंगे #, मैं पहले स्तर को समतल करता हूं। कुछ छोर और कई किनारे हो सकते हैं।

Normalize/@Differences@FindPath[Graph[e],#2,#3][[1]]

Graph[e]वह ग्राफ है जहां नोड्स कानूनी स्थिति (बर्फ या मिट्टी) हैं और किनारों को कानूनी चाल का प्रतिनिधित्व करते हैं (संभवतः एक पत्थर में टकरा रहा है और नहीं चल रहा है)। इसके बाद हम FindPathसे एक रास्ता खोजने के लिए #2करने के लिए #3नोड्स की एक सूची के रूप में प्रतिनिधित्व। चूंकि FindPathएक से अधिक पथों को खोजने के लिए अतिरिक्त तर्क हो सकते हैं, परिणाम वास्तव में एक एकल पथ वाली सूची होगी, इसलिए मैं पहले तत्व का उपयोग कर लेता हूं [[1]]। फिर मैं Differencesनिर्देशकों और Normalizeउनके बीच लगातार काम करता हूं। इस प्रकार ऊपर है {-1,0}, नीचे है {1,0}, दाएं है {0,1}और बाएं है {0,-1}।

परीक्षण के मामलों

Answer 2

जावास्क्रिप्ट (ईएस 6) 180 183

(m,[x,y],[t,u],o=~m.search`
`,s=[[x-y*o,[]]],k=[])=>eval("for(i=0;[p,l]=s[i++],k[p]=t-u*o-p;)[-1,o,1,-o].map(d=>k[q=(M=p=>+m[p+=d]?m[p]<8?M(p):p:p-d)(p)]||s.push([q,[...l,d]]));l")

एक बीएफएस का उपयोग करना , जैसे मैंने इस संबंधित चुनौती को हल करने के लिए किया था

इनपुट
भूलभुलैया नक्शा एक बहुस्तरीय स्ट्रिंग है, जो मिट्टी के लिए Oया 0पत्थर के लिए, 8बर्फ के लिए 8 या उससे कम किसी भी गैर-अंकीय अंक ( 7अच्छी दिखती है) के लिए है।
प्रारंभ और समाप्ति की स्थिति शून्य आधारित है।

आउटपुट
ऑफ़ ऑफ़ लिस्ट, जहां -1 है W, 1 है E, -1 नकारात्मक है , -1 से कम है Nऔर 1 से अधिक सकारात्मक हैS

कम गोल्फ वाला

(m,[x,y],[t,u])=>{
  o=~m.search`\n`
  s=[[x-y*o,[]]]
  k=[]
  for(i=0; [p,l]=s[i++], k[p]=1, t-u*o != p;)
  {
    [-1,o,1,-o].map(d=>(
      M=p=>+m[p+=d] ? m[p]<8 ? M(p) : p : p-d,
      q=M(p),
      k[q]||s.push([q,[...l,d]])
    ))
  }
  return l
}

परीक्षा

Solve=
(m,[x,y],[t,u],o=~m.search`
`,s=[[x-y*o,[]]],k=[])=>eval("for(i=0;[p,l]=s[i++],k[p]=t-u*o-p;)[-1,o,1,-o].map(d=>k[q=(M=p=>+m[p+=d]?m[p]<8?M(p):p:p-d)(p)]||s.push([q,[...l,d]]));l")

function Go(maze) {
  var map = maze.textContent;
  var [sx,sy, dx,dy] = map.match(/\d+/g)
  --sx, --sy // zero based
  --dx, --dy // zero based
  map = map.split('\n').slice(1).join('\n') // remove first line
  var result = Solve(map.replace(/\./g, 7).replace(/~/g, 8), [sx,sy], [dx,dy])
  S.textContent = result
  Animate(maze, map, result, sx, sy)
}

function Display(maze, map, pos) {
  var row0 = maze.textContent.split('\n')[0]
  map = [...map]
  map[pos] = '☻'
  maze.textContent = row0+'\n'+map.join('')
}

function Animate(maze, map, moves, x, y) {
  console.log('A',moves)
  var offset = map.search('\n')+1
  var curPos = x + offset * y
  var curMove = 0
  var step = _ => {
    Display(maze, map, curPos)
    if (curMove < moves.length) 
    {
      curPos += moves[curMove]
      if (map[curPos] == 'O')
      {
        curPos -= moves[curMove]
        ++curMove
      }  
      else 
      {
        if (map[curPos] == '~') {
          ++curMove
        }
      }
      setTimeout(step, 100)
    }
    else
      setTimeout(_=>Display(maze,map,-1),500)
  }
  step()
}

td { 
  border: 1px solid #888;
}

Select maze<pre id=S></pre>
<table cellspacing=5><tr>
<td valign=top><input type=radio name=R onclick='Go(M1)'><br>
<pre id=M1>3,3 to 3,2  
OOOOO
OO.OO
O...O
OOOOO</pre></td>
<td valign=top><input type=radio name=R onclick='Go(M2)'><br>
<pre id=M2>15,12 to 16,8
OOOOOOOOOOOOOOOOO
O........O.....OO
O...O..........OO
O.........O....OO
O.O............OO
OO.......O.....OO
O.............OOO
O......O.......~O
O..O...........~O
O.............OOO
O.......O......OO
O.....O...O....OO
O..............OO
OOOOOOOOOOOOOO~~O
OOOOOOOOOOOOOOOOO</pre></td>
<td valign=top><input type=radio name=R onclick='Go(M3)'><br>
<pre id=M3>2,2 to 14,3
OOOOOOOOOOOOOOOO
O~~~~~OOOOO~~~~O
O~~O~OOOOOOO~~OO
O...O..........O
O........O.....O
O..............O
OO.............O
O.............OO
O....~....O....O
O..............O
O..............O
OOOOOOOOOOOOOOOO</pre></td>
<td valign=top><input type=radio name=R onclick='Go(M4)'><br>
<pre id=M4>2,2 to 11,11
OOOOOOOOOOOOOOOOOOO
O~~~~~~~OOOOOOOOOOO
O~~~~...OOOOOOOOOOO
OO~O~..OOOOOOOOOOOO
O..OO.............O
O..............O..O
O....O............O
O.O............~..O
O........OOOO.....O
O.......OOOOO.....O
O.......O~~~O.....O
O.......~~~~~.....O
O.......~~~~~.....O
O..........O......O
O..O..~...........O
O...............O.O
O.....O...........O
O.................O
OOOOOOOOOOOOOOOOOOO</pre></td>
</tr></table>