জীবন একটি গোলকধাঁধা: আমরা হাঁটা শিখার আগে আমরা ভুল পথে চলি

30

ইনপুট:

অক্ষরগুলি সমন্বিত একটি গোলকধাঁধা:

  • -- (অনুভূমিক প্রাচীর);
  • | (উল্লম্ব প্রাচীর);
  • + (সংযোগ);
  • (হাঁটার জায়গা);
  • I (প্রবেশদ্বার);
  • U (প্রস্থান)।

অর্থাত একটি ইনপুট এর মতো দেখতে পারে:

 +--+--+--+--+--+--+--+--+--+--+ 
I               |     |        | 
 +  +--+--+--+  +  +  +  +--+  + 
 |           |     |  |  |     | 
 +--+--+--+  +--+--+  +  +  +--+ 
 |           |     |     |     | 
 +  +--+--+  +  +--+--+  +--+  + 
 |     |     |     |     |     | 
 +--+  +  +--+--+  +--+--+  +  + 
 |     |        |        |  |  | 
 +  +--+--+--+  +--+--+  +  +  + 
 |     |     |     |        |  | 
 +--+  +  +--+--+  +--+--+--+--+ 
 |  |  |                 |     | 
 +  +  +--+--+--+  +--+  +  +  + 
 |     |        |  |  |  |  |  | 
 +--+--+  +  +--+  +  +  +--+  + 
 |        |     |     |  |     | 
 +  +--+--+--+  +  +  +  +  +--+ 
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+

আউটপুট:

সবচেয়ে বেশি কার্যকরী পথ আপনি পদব্রজে ভ্রমণ করা উচিত ধাঁধা প্রদর্শন করে প্রস্থান (কিংকত্র্তব্যবিমূঢ় মাধ্যমে), অক্ষর দ্বারা নির্দেশিত প্রবেশদ্বার থেকে পেতে ইঙ্গিত, বাম ডান, আপ করুন এবং নিচে (অর্থাত >; <; ^; v)।

চ্যালেঞ্জ বিধি:

  • আপনি যে কোনও যুক্তিসঙ্গত বিন্যাসে ইনপুট নিতে পারেন। স্ট্রিং-অ্যারে, নতুন-লাইনগুলির সাথে একক স্ট্রিং, 2 ডি চর-অ্যারে ইত্যাদি সমস্ত সম্ভাব্য ইনপুট ফর্ম্যাট।
  • আউটপুটটিতে যে কোনও চারটি স্বতন্ত্র অক্ষর থাকতে পারে। অর্থাৎ ><^v; →←↑↓; ⇒⇐⇑⇓; RLUD; 0123; ABCD; ইত্যাদি)।
  • পছন্দসই হলে আপনাকে ফাঁকা স্থান বা আউটপুটে নতুন লাইনটি অনুসরণ করার অনুমতি দেওয়া হবে; এটি alচ্ছিক।
  • পদক্ষেপগুলি প্রতি বর্গক্ষেত্রে গণনা করা হয় ( +স্কোয়ারগুলির জন্য চারটি চিহ্ন ) দেখুন, এবং চরিত্র অনুসারে নয়।
  • গোলকধাঁধাঁটি 15x15 এর মাধ্যমে 5x5 আকারের হতে পারে এবং সর্বদা একটি বর্গক্ষেত্র হতে পারে (সুতরাং 5x10 ম্যাজগুলির জন্য কোনও পরীক্ষার কেস হবে না)।
  • আপনি ধরে নিতে পারেন যে প্রতিটি গোলকধাঁধায় শুরু থেকে শেষ পর্যন্ত এক বা একাধিক বৈধ পাথ রয়েছে এবং আপনি সর্বদা সংক্ষিপ্ততম আউটপুট পান (পরীক্ষার কেস 4 এবং 5 দেখুন)।
  • যদি একই দৈর্ঘ্যের একাধিক পাথ থাকে তবে আপনি কোনটিকে আউটপুট দিতে পারবেন তা বেছে নিতে পারেন (পরীক্ষার কেস see দেখুন)।
  • গোলকধাঁধার সীমানার বাইরে আপনি 'হাঁটাচলা' করতে পারবেন না (পরীক্ষার কেস test এবং ৮ দেখুন)।

সাধারাইওন রুল:

  • এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
    কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
  • স্ট্যান্ডার্ড নিয়মগুলি আপনার উত্তরের জন্য প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতিগুলি, সম্পূর্ণ প্রোগ্রামগুলির সাথে STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
  • ডিফল্ট লুফোলগুলি নিষিদ্ধ।
  • যদি সম্ভব হয় তবে আপনার কোডের জন্য একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন।
  • এছাড়াও, প্রয়োজনে একটি ব্যাখ্যা যোগ করুন।

পরীক্ষার কেস:

1. Input:
 +--+--+--+--+--+--+--+--+--+--+ 
I               |     |        | 
 +  +--+--+--+  +  +  +  +--+  + 
 |           |     |  |  |     | 
 +--+--+--+  +--+--+  +  +  +--+ 
 |           |     |     |     | 
 +  +--+--+  +  +--+--+  +--+  + 
 |     |     |     |     |     | 
 +--+  +  +--+--+  +--+--+  +  + 
 |     |        |        |  |  | 
 +  +--+--+--+  +--+--+  +  +  + 
 |     |     |     |        |  | 
 +--+  +  +--+--+  +--+--+--+--+ 
 |  |  |                 |     | 
 +  +  +--+--+--+  +--+  +  +  + 
 |     |        |  |  |  |  |  | 
 +--+--+  +  +--+  +  +  +--+  + 
 |        |     |     |  |     | 
 +  +--+--+--+  +  +  +  +  +--+ 
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+ 

1. Output:
>v>>>vv<v>>v>v>>vvv>>>

2. Input:
 +--+--+--+--+--+ 
I   |        |  | 
 +  +--+--+  +  + 
 |        |  |  | 
 +  +--+  +  +  + 
 |  |  |     |  | 
 +  +  +--+  +  + 
 |        |     | 
 +--+  +  +--+--+ 
 |     |         U
 +--+--+--+--+--+ 

2. Output:
>vvv>>v>>>

3. Input:
 +--+--+--+--+--+ 
U      |        | 
 +  +  +--+--+  + 
 |  |     |     | 
 +--+--+  +  +--+ 
 |        |     | 
 +  +--+--+--+  + 
 |  |     |     | 
 +  +  +  +  +--+ 
 |     |         I
 +--+--+--+--+--+ 

3. Output:
<<<^<v<^^>>^<^<<

4. Input (test case with two valid paths):
 +--+--+--+--+--+ 
U      |        | 
 +  +  +--+--+  + 
 |  |           | 
 +--+--+  +  +--+ 
 |        |     | 
 +  +--+--+--+  + 
 |  |     |     | 
 +  +  +  +  +--+ 
 |     |         I
 +--+--+--+--+--+ 

4. Output:
<<^>^<^<<^<<     (<<<^<v<^^>>^<^<< is less efficient, and therefore not a valid output)

5. Input (test case with two valid paths):
                               I
+--+--+--+--+--+--+--+--+--+--+  +--+--+--+--+
|     |              |                    |  |
+  +  +  +--+--+--+  +  +--+--+  +--+--+  +  +
|  |     |        |     |        |     |     |
+--+--+--+  +--+  +  +--+--+--+--+  +--+--+--+
|     |  |  |  |     |     |           |     |
+  +  +  +  +  +--+  +  +  +  +--+--+  +--+  +
|  |        |        |  |     |        |     |
+  +--+--+--+  +--+--+  +  +--+  +--+--+  +--+
|  |     |     |        |  |     |     |     |
+  +--+  +  +--+  +--+--+  +--+--+  +  +--+  +
|  |     |        |     |           |        |
+  +  +--+--+--+--+  +  +--+--+--+  +--+  +--+
|     |     |        |        |  |     |     |
+--+--+--+  +  +--+--+  +--+  +  +--+  +--+  +
|              |     |     |        |  |  |  |
+  +--+--+--+--+  +  +  +--+--+--+  +  +  +  +
|     |  |     |  |  |        |        |  |  |
+--+  +  +  +  +  +  +--+--+  +  +  +--+  +  +
|     |     |  |  |  |           |  |     |  |
+--+  +--+--+  +  +  +  +--+--+--+  +  +  +  +
|     |        |  |  |     |        |  |  |  |
+  +--+  +--+--+  +  +--+--+  +  +--+  +  +  +
|        |     |  |     |     |  |     |  |  |
+--+--+--+  +  +  +--+  +  +--+--+  +--+  +  +
|  |        |        |     |        |     |  |
+  +  +--+--+--+--+  +--+--+  +--+--+  +--+  +
|  |              |              |     |     |
+  +  +  +--+--+--+--+--+--+--+--+  +--+  +--+
|     |                                |     |
+--+--+--+--+--+--+--+--+--+  +--+--+--+--+--+
                            U

5. Output:
v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv<^<v<<v>v>>>>>>>v     (v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv>v>>>^>>^>^^>vvv<v<v<<v is less efficient, and therefore not a valid output)

6. Input:
 +--+--+--+--+--+
I               |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |               U
 +--+--+--+--+--+

6. Output:
>>v>v>v>v> or >v>v>v>v>> or >>>>>vvvv> or etc. (all are equally efficient, so all 10-length outputs are valid)

7. Input:
 I  U
+  +  +--+--+--+
|  |        |  |
+  +--+--+  +  +
|     |     |  |
+--+  +  +--+  +
|        |  |  |
+  +--+  +  +  +
|     |        |
+--+  +--+--+  +
|     |        |
+--+--+--+--+--+

7. Output:
vv>v>^>^<<^

8. Input:
 +--+--+--+--+--+
 |     |        |
 +  +--+  +--+  +
I   |     |  |  |
 +  +  +--+  +  +
U   |     |  |  |
 +--+--+  +  +  +
 |     |     |  |
 +  +--+--+--+  +
 |               
 +--+--+--+--+--+

8. Output:
>v<

এই সরঞ্জামটি ব্যবহার করে তৈরি করা মজেস (এবং কিছু ক্ষেত্রে কিছুটা সংশোধন হয়েছে)।

code-golf  path-finding  maze 
— কেভিন ক্রুইজসেন
সূত্র
10
আমি তৃতীয় পরীক্ষার মামলার একটি সংক্ষিপ্ত সমাধান খুঁজে পেয়েছি! v<<<<<<^^^^^(সর্বদা বাক্সের বাইরে ভাবুন)
— লিও
2
যদি কেউ প্রমাণ করতে পারে যে তাদের কোডটি যথেষ্ট সময় এবং মেমরির প্রদত্ত সংক্ষিপ্ততম সমাধান দেবে, তবে এটি কি প্রতিযোগিতা করে? এমনকি সত্যিই দীর্ঘ সময় চলার ক্ষেত্রে (মহাবিশ্বের ফ্যাশনের শেষ)?
— Yytsi
1
@ জ্যাকবেটস এটি একটি রসিকতা। তিনি আক্ষরিক অর্থে প্রস্থান করতে বাক্সের চারপাশে হাঁটেন: ডি
— ইয়াতসি
1
আমি মনে করি প্রথম পরীক্ষার মামলাটি ভুল, এটি হওয়া উচিত >v>>>vv<v>>v>v>>vvv>>>।
— স্মুথ
1
@ কেভিন ক্রুজসেন উদাহরণস্বরূপ, এমন একটি সমাধান যা গোলকধাঁধায় থাকা খালি বাক্সগুলির পরিমাণ পর্যন্ত দৈর্ঘ্যের জন্য "ভি ^ <>" এর প্রতিটি সংমিশ্রণ পরীক্ষা করে। সঠিক সমাধানটি হবে তবে গণনা করতে জ্যোতির্বিদ্যার সময় লাগে takes
— Yytsi

উত্তর:

7

রেটিনা , 338 281 275 273 261 বাইট

¶U
¶&
+`·(\w.+)$
|$1
((.)+I.+¶.+¶(?<-2>.)+)·
$1v
+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6
·v
-v
G`1
·U
&
{`\B·\d+.(\w+)
$1K$&
(\w+)·\d+.\B
$&$1r
(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v
)`\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A
^.+\d·(\w+)
&$1A
M!`&\w+
I|&

এটি অনলাইন চেষ্টা করুন!

নোট

  • উল্লেখযোগ্য শ্বেত স্পেসের কারণে, সমস্ত স্পেস ( 0x20) ইন্টারপান্টের সাথে প্রতিস্থাপিত হয় (· উত্তর ) এই উত্তর এবং টিআইও লিঙ্ক উভয়ই ) । স্পেসগুলি পুনরুদ্ধার করা হলে প্রোগ্রামটি ঠিকঠাক কাজ করে।
  • AvKrযথাক্রমে উপর, নীচে, বাম এবং ডান জন্য ব্যবহার করে। এগুলি বাদে যে কোনও অক্ষর দিয়ে প্রতিস্থাপন করা যেতে পারে I।
  • 15 × 15 পরীক্ষার ক্ষেত্রে টিআইওতে প্রায় 40s লাগে। ধৈর্য্য ধারন করুন. একবার পথটি প্রস্থান করার সময় সংক্ষিপ্ততম পথটি সন্ধান করার জন্য অংশটি পুনরায় কাজ করেছিল। দেখা যাচ্ছে যে অনেক সময় নিচ্ছিল।
  • 66 বা ততোধিক কোষের প্রশস্ত মেজেগুলিকে সম্পূর্ণরূপে ভেঙে ফেলতে পারে তবে নির্বিচার উচ্চতার ম্যাজগুলি পরিচালনা করতে পারে। যথেচ্ছ প্রস্থের জন্য একটি স্থিরতা +1 বাইট নেয়।

ব্যাখ্যা

প্রোগ্রামটি 3 টি পর্যায় নিয়ে গঠিত:

  • একটি নির্মাণ পর্বগোলকধাঁটিকে একটি কমপ্যাক্ট ফর্ম্যাটে রূপান্তর করতে যা এর সাথে কাজ করা সহজ (নীচে বিস্তারিত)।
  • বন্যার ভরাট অ্যালগরিদম ব্যবহার করে গোলকধাঁধাটি সমাধান করার জন্য একটি পূরণের পর্ব ।
  • প্রস্থান করার সময় সংক্ষিপ্ততম পথে ফিরে আসার জন্য একটি ফিরতি পর্যায় ।

বিন্যাস

যেহেতু মূল গোলকধাঁধা বিন্যাসটি বেশ অযৌক্তিক, তাই প্রোগ্রামের প্রথম অংশ এটিকে অন্য ফর্ম্যাটে রূপান্তরিত করে।

সেল

মূল ফর্ম্যাটে, প্রতিটি ঘর 2 × 3 অঞ্চল হিসাবে উপস্থাপিত হয়:

+               <top wall>      <top wall>
<left wall>     <data/space>    <space>

যেহেতু ডান কলামে কোনও তথ্য নেই, প্রোগ্রামটি কোষগুলিকে +উপরের-বামে একটি 2 × 2 অঞ্চল হিসাবে চিহ্নিত করে ।

এটি আমাদের 3 ধরণের কোষ সহ ছেড়ে দেয়:

  • আই সেলস : কোষগুলি ধাঁধার ভিতরে সঠিকভাবে রয়েছে।
  • আর সেলগুলি : কোষগুলি যে ধাঁধাটির ডানদিকে রয়েছে। এগুলি প্রবেশ বা প্রস্থান করার জন্য ব্যবহৃত প্যাডিংয়ের মাধ্যমে তৈরি করা হয় are উদাহরণস্বরূপ, প্রস্থানU পরীক্ষার ক্ষেত্রে 1 একটি আর-সেল হয়।
  • বি সেল : গোলকোষের নিচে থাকা ঘরগুলি। আর-সেলগুলির মতো এগুলি প্যাডিংয়ের মাধ্যমে তৈরি করা হয়।

নতুন ফর্ম্যাটে, ঘরগুলি একটি চলক-দৈর্ঘ্যের স্ট্রিং হিসাবে উপস্থাপিত হয়:

<left wall> <column number> <top wall/exit marker> <path>

বাম এবং উপরের প্রাচীরটি মূল ফর্ম্যাট থেকে অনুলিপি করা হয়েছে। কলাম নম্বরটি ঘরের অনুভূমিক অবস্থানের উপর ভিত্তি করে এবং প্রান্তিককরণের জন্য ব্যবহৃত হয় (একে অপরের উপরে / নীচে সরাসরি সেলগুলি চিহ্নিত করতে)। পথটি একটি বর্ণানুক্রমিক স্ট্রিং যা সেই ঘরে পৌঁছানোর জন্য সবচেয়ে সংক্ষিপ্ত পথটি সংরক্ষণ করতে পূরণের পর্যায়ে ব্যবহৃত হয়। পথ এবং প্রস্থান মার্কার আরও ব্যাখ্যা করা হবে।

হাফ-কোষ

যদিও গোলকধাঁধার বেশিরভাগটি কোষ, তবে গোলকধাঁধার এমন অঞ্চল রয়েছে যা কোষ নয়:

  • অর্ধকোষ : যদি কোনও ডান প্যাডিং না +থাকে তবে ডান প্রাচীর বরাবর গুলি শেষ কলামে থাকার কারণে সেগুলি গঠন করে না।
  • এল হাফ-সেল : যদি বাম প্যাডিং থাকে তবে কোষগুলি সেখানে গঠন করতে পারে না কারণ +তাদের বাম দিকের কোনও অংশ নেই । উদাহরণস্বরূপ, Iপরীক্ষার ক্ষেত্রে 1 প্রবেশদ্বারটি একটি এল হাফ-কোষে।

প্রযুক্তিগতভাবে, গোলকধাঁটির উপরে টি হাফ-কোষ রয়েছে (যখন শীর্ষ প্যাডিং থাকে) এবং বি অর্ধ-কোষ (নীচের প্যাডিংয়ের নীচে যখন প্রাচীর থাকে না) তবে সেগুলিকে নতুন ফর্ম্যাটে উপস্থাপন করা হয় না।

অর্ধকোষের শীর্ষ সারিটি একই সারিতে সম্পূর্ণ ঘর তৈরির অংশ হিসাবে সরিয়ে ফেলা হবে, সুতরাং অর্ধেকটি কক্ষগুলি নতুন বিন্যাসে উপস্থাপিত হবে

<wall/exit marker>? <path>

একটি আর হাফ-সেল ঠিক আছে |। একটি এল হাফ-কোষের ঠিক Iযেমন পথ, কেবল প্রস্থান মার্কার এবং একটি খালি পথ, বা কেবল একটি খালি প্রাচীর রয়েছে।

প্রবেশ এবং প্রস্থান

যদি প্রবেশদ্বারটি বাম, ডান বা গোলকধাঁধার নীচে থাকে, তবে প্রবেশদ্বারটি Iস্বাভাবিকভাবেই (অর্ধ) কক্ষে অন্তর্ভুক্ত হবে পথ হিসাবে, যা চূড়ান্ত পথে ফেরার সময় সরানো যেতে পারে।

প্রবেশপথটি গোলকধাঁধারের উপরে থাকলে, টির অর্ধ-কোষগুলি নির্মাণের সময় সরানো হওয়ায় নির্মাণের পর্যায়ে প্রথম (নীচের দিকে) পদক্ষেপ নেওয়া হয়। এটি একটি পূর্ণ কোষে কার্যক্ষম পথে রাখে। উপরের প্রাচীরটি পরে বন্ধ রয়েছে।

প্রস্থানটি যদি গোলকাহাঁটির বাম, ডান বা নীচে Uথাকে তবে স্বাভাবিকভাবেই (অর্ধ) কক্ষে অন্তর্ভুক্ত হবে। পথ হিসাবে ভুল হওয়া এড়াতে, অ-আলফানামের প্রস্থান চিহ্নিতকারীটির &পরিবর্তে ব্যবহৃত হয়U । প্রস্থান মার্কারটি কোনও ঘর বা অর্ধ-কক্ষে এমবেড করা থাকে (উপরে বর্ণিত হিসাবে)।

প্রস্থানটি যদি গোলকধাঁধারের উপরে থাকে, তবে এটি কেবলমাত্র একমাত্র গর্ত হবে যা কোষের শীর্ষ সারির উপরে যেতে পারে (যেহেতু প্রবেশদ্বারটির জন্য এটি ইতিমধ্যে বন্ধ হয়ে থাকবে)। যে গর্তে পৌঁছানো যে কোনও পথই wardর্ধ্বমুখী পদক্ষেপ নিয়ে ধাঁধাঁ থেকে বেরিয়ে যেতে পারে।

শেষ অবধি, প্রবেশদ্বার বা প্রস্থান সহ যে কোনও বি সেলকে বি কোষগুলির সাথে হাঁটাচলা করে "সমাধান" করা রোধ করার জন্য তার বাম প্রাচীরটি বন্ধ করতে হবে। আর সেল বা এল হাফ-কোষগুলিতে প্রবেশ ও প্রস্থানগুলি আর প্রক্রিয়াকরণের দরকার নেই যেহেতু বন্যা ভরাট অ্যালগরিদম তাদের / থেকে ভার্টিকাল চলাচলের অনুমতি দেয় না।

উদাহরণ

উদাহরণস্বরূপ, প্রথম পরীক্ষার কেস

·+--+--+--+--+--+--+--+--+--+--+·
I···············|·····|········|·
·+··+--+--+--+··+··+··+··+--+··+·
·|···········|·····|··|··|·····|·
·+--+--+--+··+--+--+··+··+··+--+·
·|···········|·····|·····|·····|·
·+··+--+--+··+··+--+--+··+--+··+·
·|·····|·····|·····|·····|·····|·
·+--+··+··+--+--+··+--+--+··+··+·
·|·····|········|········|··|··|·
·+··+--+--+--+··+--+--+··+··+··+·
·|·····|·····|·····|········|··|·
·+--+··+··+--+--+··+--+--+--+--+·
·|··|··|·················|·····|·
·+··+··+--+--+--+··+--+··+··+··+·
·|·····|········|··|··|··|··|··|·
·+--+--+··+··+--+··+··+··+--+··+·
·|········|·····|·····|··|·····|·
·+··+--+--+--+··+··+··+··+··+--+·
·|···········|·····|··|·········U
·+--+--+--+--+--+--+--+--+--+--+·

হয়

I·3-·6-·9-·12-·15-|18-·21-|24-·27-·30-|33·
·|3··6-·9-·12-|15··18·|21·|24·|27-·30·|33·
·|3-·6-·9-·12·|15-·18-|21··24·|27··30-|33·
·|3··6-|9-·12·|15··18-|21-·24·|27-·30·|33·
·|3-·6·|9··12-·15-|18··21-·24-|27·|30·|33·
·|3··6-|9-·12-|15··18-|21-·24··27·|30·|33·
·|3-|6·|9··12-·15-·18··21-·24-|27-·30-|33·
·|3··6·|9-·12-·15-|18·|21-|24·|27·|30·|33·
·|3-·6-·9·|12··15-|18··21·|24·|27-·30·|33·
·|3··6-·9-·12-|15··18·|21·|24··27··30-·33&

নতুন বিন্যাসে। আপনি এখানে অন্যান্য ম্যাজগুলিকে রূপান্তর করতে পারেন ।

নির্মাণ পর্ব

নির্মাণের পর্বটি প্রোগ্রামের প্রথম 13 লাইন তৈরি করে।

¶U
¶&

এল হাফ-সেল-এ প্রস্থানটি চিহ্নিতকারীকে প্রস্থান করতে রূপান্তর করে

+`·(\w.+)$
|$1

প্রবেশদ্বারের বামে দেয়াল যুক্ত করে এবং বি কোষে প্রস্থান করুন

((.)+I.+¶.+¶(?<-2>.)+)·
$1v

প্রবেশপথটি গোলকধাঁধারের উপরে থাকলে প্রথম পদক্ষেপ নেয়

+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6

প্রকৃত রূপান্তর সম্পাদন করে

·v
-v

উপরের প্রবেশদ্বারটির গর্তটি বন্ধ করে দেয়

G`1

একটি দিয়ে কেবল রেখাগুলি রাখে 1। যেহেতু ম্যাজগুলি কমপক্ষে 5 টি কোষ প্রশস্ত এবং কলাম সংখ্যা 3 টি বর্ধিত হয়, তাই নতুন বিন্যাসের কক্ষগুলির সাথে একটি লাইনে একটি কলাম নম্বর 10 এবং 19 এর মধ্যে থাকতে হবে।

·U
&

আর সেল বা বি সেলে প্রস্থান থেকে চিহ্নিতকারীকে প্রস্থান করতে রূপান্তর করে

ভরাট পর্ব

পূরণের পর্যায়ে প্রোগ্রামটির পরবর্তী 8 টি লাইন তৈরি হয়। প্রবেশদ্বার থেকে সেখানে পৌঁছানোর জন্য সবচেয়ে ছোটতম পথ সহ সমস্ত ঘর পূরণ করতে এটি বন্যার ফিল অ্যালগরিদম ব্যবহার করে।

{`

পুরো ধাঁধাটি পূরণ করতে পুরো ফিল ফেজটি একটি লুপে রাখে।

\B·\d+.(\w+)
$1K$&

বাম স্থানান্তর করতে সক্ষম প্রতিটি ঘর এটি করে। একটি ঘর যদি বাম দিকে সরানো সক্ষম হয়

  1. এটি একটি খালি খালি পথ আছে
  2. এটি একটি খালি বাম প্রাচীর আছে; এবং
  3. তার বাম দিকে ঘর বা এল অর্ধ-কক্ষের খালি পথ রয়েছে
(\w+)·\d+.\B
$&$1r

তারপরে, ডান স্থানান্তর করতে সক্ষম প্রতিটি কক্ষ এটি করে। একটি ঘর ডানদিকে যেতে সক্ষম হয় যদি

  1. এটি একটি খালি খালি পথ আছে
  2. তার ডানদিকে ঘরের একটি খালি বাম প্রাচীর রয়েছে; এবং
  3. এর ডানদিকে ঘরের একটি ফাঁকা পথ রয়েছে
(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v

তারপরে, নীচে সরতে সক্ষম প্রতিটি ঘর এটি করে। একটি ঘর নিচে যেতে সক্ষম যদি

  1. এটি একটি খালি খালি পথ আছে
  2. এর ডানদিকে কমপক্ষে একটি সেল বা অর্ধ-কক্ষ রয়েছে (যেমন এটি কোনও আর সেল নয়)
  3. এর নীচের কক্ষটি (যেমন একই কলাম নম্বরযুক্ত পরবর্তী লাইনের ঘর) এর খালি শীর্ষ প্রাচীর রয়েছে বা প্রস্থান চিহ্ন রয়েছে; এবং
  4. এর নীচের কক্ষে একটি ফাঁকা পথ রয়েছে

নোট করুন যে এল হাফ-সেলগুলি কলাম নম্বর না থাকায় তারা নামতে পারবেন না।

\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A

তারপরে, প্রতিটি ঘর উপরে উঠতে সক্ষম এমনটি করে। একটি ঘর যদি উপরে যেতে সক্ষম হয়

  1. এটি একটি খালি খালি পথ আছে
  2. এটি একটি খালি উপরে প্রাচীর আছে
  3. তার উপরের কক্ষটির ডানদিকে কমপক্ষে একটি ঘর বা অর্ধকক্ষ রয়েছে; এবং
  4. এটির উপরের ঘরে একটি ফাঁকা পথ রয়েছে

ফেরার পর্ব

রিটার্ন পর্বটি প্রোগ্রামটির শেষ 5 টি লাইন তৈরি করে। এই ধাপটি প্রস্থান কক্ষে ভরা পথটি অনুসন্ধান করে এবং ফিরে দেয়।

প্রস্থান করার সময় পথের ধরণটি প্রস্থানটি কোথায় রয়েছে তার উপর নির্ভর করে:

  1. যদি প্রস্থানটি একটি এল হাফ-কোষে থাকে, তবে সেই অর্ধকোষটি হবে & <path>
  2. যদি প্রস্থানটি কোনও আর সেল বা বি কোষে থাকে তবে সেই ঘরটি হবে <left wall> <column number> & <path>
  3. প্রস্থানটি যদি কোনও টি হাফ-কোষে থাকে, তবে উপরে উল্লিখিত হিসাবে, প্রস্থানটির দিকে পরিচালিত আই সেলটি <left wall> <column number> · <path>এবং শীর্ষ সারিতে থাকবে।
^.+\d·(\w+)
&$1A

উপরের লাইনে একটি ফাঁকা শীর্ষ দেয়াল এবং একটি খালি নয় পাথ সহ একটি ঘর সন্ধান করে। এটি সর্বশেষ পদক্ষেপ এবং প্রস্থান মার্কার যুক্ত করে সর্বশেষ কেসের যত্ন নেয়।

M!`&\w+

একটি প্রস্থান চিহ্নিতকারীকে অনুসরণ করে একটি খালি নয় খালি পথটি ম্যাচ করে এবং ফেরত দেয়।

I|&

প্রস্থান চিহ্ন এবং Iপথের উপসর্গ সরিয়ে দেয় ।

— TwiNight
সূত্র
কেন AvKr? আপনার স্থানীয় ভাষার উপরে, নীচে, বাম এবং ডানদিকে সংক্ষিপ্তসারগুলির কী অর্থ আছে / নাকি আপনি এই নির্দিষ্ট অক্ষরগুলি বেছে নেওয়ার কারণেই অন্য কোনও কারণ রয়েছে?
— কেভিন ক্রুইজসেন
@ কেভিনিক্রুজসেন কেবলমাত্র কারণ আমি অবশ্যই অক্ষর অক্ষর এবং ব্যবহার করব use AvKr are the closest thing to arrows in alphanum.
— TwiNight
12

Perl 6, 259 295 bytes

{my \a=S:g/(.)$0+/{$0 x($/.comb+.5)*2/3}/;sub f (\c,\v,*@p) {with (c ne any v)&&a.lines».comb[+c[0];+c[1]] ->$_ {for (/\s/??10011221!!/I/??a~~/^\N*I|I\N*$/??2101!!1012!!'').comb X-1 {f [c Z+$^a,$^b],(|v,c),@p,chr 8592+$++}
take @p if /U/}}
[~] (gather f a~~/(\N+\n)*(.)*I/,[]).min(+*)[1,3...*]}

How it works

  1. my \a = S:g/ (.) $0+ /{ $0 x ($/.chars + .5) * 2/3 }/;

এটি গোলকধাঁধাটিকে আটকায় যাতে প্রতিটি ঘরের অভ্যন্তর 2x1 স্পেস অক্ষরের পরিবর্তে 1x1 হয়:

 + - + - + - + - + - + - + - + - + - + - + 
I   |        |  |            I  |     | | 
 + + - + - + + + + + + + + + + + 
 | | | | | | | |
 + + - + + + + + + + + + + + + 
 | | | | | -> | | | | |
 + + + + + + + + + + + + + + 
 | | | | | |
 + - + + + - + + + + + + + + + + + 
 | | ইউ | | ইউ
 + - + - + - + - + - + - + - + - + - + - +

  1. sub f (\c,\v,*@p) {
    with (c ne any v) &&                   # If the coordinate wasn't visited yet
         lines».comb[+c[0];+c[1]] -> $_ {  # and a character exists there...
        for (                          # For each vector...
             /\s/ ?? 10011221 !!       #  from a cell: (0,-1), (-1,0), (0,1), (1,0)
             /I/  ?? a~~/^\N*I|I\N*$/
                      ?? 2101          #  from a top/bottom entrance: (1,0), (-1,0)
                      !! 1012          #  from a left/right entrance: (0,-1), (0,1)
                  !! ''                #  otherwise: none
            ).comb X-1 {
            f                       #   Recurse with arguments:
                [c Z+ $^a, $^b],    #     c plus the vector
                (|v, c),            #     v with c appended
                @p, chr 8592 + $++  #     p with the correct Unicode arrow appended
        }
        take @p if /U/
    }
}

এটি পুনরাবৃত্তির পথ অনুসন্ধানের ফাংশন। এটি তিনটি প্যারামিটার লাগে: বর্তমান স্থানাঙ্ক c=(y,x), ইতিমধ্যে পরিদর্শন করা স্থানাঙ্কগুলির তালিকা vএবং pএখনও পর্যন্ত নেওয়া পথ (তীর অক্ষরের তালিকা হিসাবে)।

বর্তমান স্থানাঙ্কে অক্ষরটি যদি একটি স্থান হয় তবে এটি তার চারটি প্রতিবেশীর কাছে পুনরাবৃত্তি করে।
যদি বর্তমান স্থানাঙ্কে চরিত্রটি একটি হয় I, তবে এটি দুটি প্রতিবেশী যে "প্রান্তে বরাবর" নয়, তাদের পুনরাবৃত্তি করে, সমাধানটিকে চারপাশে নয়, গোলকধাঁধার মধ্য দিয়ে যেতে বাধ্য করতে।
বর্তমান স্থানাঙ্কে অক্ষরটি যদি একটি হয় তবে এটি সঞ্চিত পাথ স্ট্রিংকে Uকল takeকরে।

  1. [~] (gather f a ~~ /(\N+\n)*(.)*I/, []).min(+*)[1,3...*]

পুনরাবৃত্ত ফাংশনটি প্রথমে চিঠির স্থানাঙ্কের সাথে ডাকা হয় I, যা একটি রেজেক্স ব্যবহার করে পাওয়া যায়।

দ্য gather keyword collects all values on which take was called inside the function, i.e. all valid non-cyclical paths through the maze.

সংক্ষিপ্ততম পথটি বেছে নেওয়া হয়েছে, প্রতিটি দ্বিতীয় তীরটি এই অ্যাকাউন্টে ফেলে দেওয়া হয় যে একটি কক্ষ থেকে অন্য কোষে দু'টি অভিন্ন চলন প্রয়োজন, এবং বাকী তীরগুলি ল্যাম্বডা থেকে ফিরে আসা স্ট্রিং গঠনের জন্য একত্রিত হয়।

— smls
সূত্র
First of all great job on being the first to complete my challenge! :) Smart how you've changed the two spaces to one to ease the actual movement/counting. +1 from me. Anyway, after some comments two new test cases were added. Could you verify these work with your solution as well? (Also, does Perl 6 have a TIO or other online compiler that you could add a link to?)
— Kevin Cruijssen
@KevinCruijssen: It went around the maze in the new test-cases. :( I fixed the code now. tio.run supports Perl 6, but for some reason, this doesn't work there... maybe it has a too old Perl 6 version?
— smls
Great job fixing the code. Sorry for specifying the rule of having to go through the maze after you've already posted your answer, but chapeau for fixing it so fast. And regarding the TIO version I have no idea. Not really my expertise..
— Kevin Cruijssen
Since you were the first to answer my challenge four months ago, I gave the bounty to you. :) And the Accept is for the slightly shorter Retina answer.
— Kevin Cruijssen
5

Python 2: 302 bytes

from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1]
z=',l)for l in s]'
def f(s,b=1,o=0,n=0):
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z+"s=r([sub(' I ','+I+'%s);"%z*4)*b+"t=[sub('I  ','@@I'"+z
 if'I U'in`s`or n>3:return`o%4`+n/4*`s`
 return min(`o%4`+f(t,0,o,4*(t==s)),f(r(s),0,o+1,n+1),key=len)

Takes input as an array of strings all with the same length. Prints 0 for right, 1 for down, 2 for left, and 3 for up.

Explanation

I took a different approach than the other answers. General idea: recursively search by finding the shortest path between going straight forward and rotating the board 90 degrees.

from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1] #Rotates the board counterclockwise
z=',l)for l in s]'    #Suffix for hacky exec golfing
def f(s,b=1,o=0,n=0): #b is 1 on initial call, 0 on every recursion
                      #o is orientation
                      #n is number of rotations
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z  #Squeeze the maze
      +"s=r([sub(' I ','+I+'%s);"%z*4)   #Add walls around the I to keep it in the maze
      *b                                 #Only if b is 1
      +"t=[sub('I  ','@@I'"+z            #Attempt to move right

 if'I U'in`s`or n>3:return`o%4`+n/4*`s`  #If the I is next to the U, return the orientation
                                         #If there were 4 rotations, return a long string
 return min(                             #Return the path with the shortest length:
            `o%4`+f(t,0,o,4*(t==s)),       #Moving forward if possible
            f(r(s),0,o+1,n+1),             #Rotating the board
        key=len)

Try it online!

— deltaepsilon3
সূত্র
3
Welcome to PPCG! This is a great first answer, and I'm impressed you decided to do a pretty tough challenge as your first. Also smart how you've put walls around the I to prevent the path from going outside the maze. Enjoy your stay, and +1 from me. :)
— Kevin Cruijssen
2

JavaScript (ES6), 356 bytes

a=>(a=a.map(s=>s.filter((_,i)=>!i|i%3)),g=([x,y])=>a[y]&&a[y][x],o=[],c=([x,y],m="",v=[])=>[[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(p=[x+j,y+k],!m&(!y|y>a[l="length"]-2)==i%2|v.includes(""+p)||(g(p)<"!"?c(p,m+"v>^<"[i],[...v,""+p]):g(p)=="U"?o.push(m.replace(/(.)\1/g,"$1")):0))),a.map((h,i)=>h.map((k,j)=>k=="I"&&c([j,i]))),o.sort((a,b)=>a[l]-b[l])[0])

Takes input as a 2D array of characters. Each line must be left-padded by one space and have no trailing space, no matter where the start/end points are.

Uses smls's idea of squishing the maze to make each cell 1x1 and removing repeated arrows from the output.

Ungolfed and Explained

a=>(
    a=a.map(s=>s.filter((_,i)=>!i|i%3)),    // squish the maze to 1x1 cells
    g=([x,y])=>a[y]&&a[y][x],               // helper func to get maze value
    o=[],                                   // resulting movesets
    c=([x,y], m="", v=[]) =>                // recursive func to search
                                            // takes current point, moves, and visited spots
        [[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(// for each direction
            p=[x+j,y+k],
            !m & (!y | y>a[l="length"]-2) == i%2 |  // if first move, prevent moving out of maze
                v.includes(""+p) || (               // also prevent if already visited
                    g(p)<"!" ?                      // is this a space?
                        c(p, m+"v>^<"[i], [...v,""+p]) // check this spot recursively
                    : g(p)=="U" ?                   // if this the end?
                        o.push(                     // add moves to moveset
                            m.replace(/(.)\1/g,"$1")) // with double arrows removed
                    : 0
                )
        )),

    a.map((h,i)=>h.map((k,j)=>      // find the starting "I" and
        k=="I" && c([j,i])          // begin recursion at that point
    )),

    o.sort((a,b)=>a[l]-b[l])[0]     // get shortest path
)

Test Snippet

Show code snippet

— Justin Mariner
সূত্র
1

Retina, 416 bytes

T` `+`^.*| ?¶.|.*$
I
#
{+` (\w)
d$1
+`(\w) 
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!))) 
$1w
^
w¶
w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1
{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2# 
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6 
s`U.*

(a|d)\1\1?
$1
ss
s
ww
w

Try it online! Had I seen this question when it was originally posted, this is probably the answer I would have given, so I'm posting it anyway, even though there's a much better answer in Retina. Explanation:

T` `+`^.*| ?¶.|.*$

Fill in the border. This avoids walking around the outside of the maze (e.g. for test case 7).

I
#

Place a non-alphabetic marker at the entrance.

{+` (\w)
d$1
+`(\w) 
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!))) 
$1w

Flood fill from the exit to the entrance. At each step, use a letter to indicate the best direction to go (wasd - this might be familiar to gamers; I had also considered hjkl but I found it too confusing). Additionally, prefer to repeat the same direction; this avoids going left/right in between two vertically adjacent cells.

^
w¶

Assume the first step is down.

w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1

But if there's a letter above, left or right of the entrance, change that to the first step.

{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2# 
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6

Move the marker in the direction of the last move, reading the direction of the next move from the square that the marker is moving to, and add that to the list of directions. This repeats until the U is reached.

s`U.*

Delete everything after the directions as it's not needed any more.

(a|d)\1\1?
$1
ss
s
ww
w

The original grid is on a 3×2 layout. While moving vertically if we zig-zag horizontally the flood fill will optimise the movement and only move 3n-1 characters horizontally, so when dividing by three, we need to round up. Vertically we just divide by 2.

I also investigated a true square grid solution i.e where the character matrix is itself square rather than being a 3×2 layout with an optional border. While probably nonconforming to the question, the ability to transpose reduced the byte count to 350: Try it online!

— Neil
সূত্র
Nice answer, +1! I do see in your TIO link you've added two - around both the entrance and exit characters. Since the challenge is mainly about going through the maze I guess it's fine, but I'm curious: what were the issues when you hadn't placed those walls above/below the I and U? Also, could you verify this works for test case 7 with the I and U at the top instead of sides? TIO exceeds the 60 second limit, so I'm unable to test it myself. Although reading your explanation of first trying to go down by default, I assume it should work fine.
— Kevin Cruijssen
@KevinCruijssen The "secondary" answer works for test case 7 but requires extra characters: Try it online! continued...
— Neil
@KevinCruijssen The "main" answer had a bug whereby it couldn't cope with the exit on the top line at all. It also has a similar bug to the "secondary" answer whereby it prefers to walk around the outside of the maze if it can. (Also, I didn't get anywhere near the 60 second limit.)
— Neil
Actually, I could fix both answers by filling in the border. I'll do that later when I have time.
— Neil
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.