ষড়ভুজ ধাঁধা সময়!

Question

অন্য ধাঁধা চ্যালেঞ্জের জন্য সময়, কিন্তু আপনি এটি জানেন হিসাবে না।

এই চ্যালেঞ্জের নিয়মগুলি বেশিরভাগ ধাঁধা চ্যালেঞ্জগুলির চেয়ে কিছুটা আলাদা। টাইল প্রকারগুলি নীচে হিসাবে সংজ্ঞায়িত করা হয়:

• S: আপনি যে ধাঁধাটি দিয়ে শুরু করেছেন তার অবস্থান
• E: আপনি যে অবস্থানটিতে যাওয়ার চেষ্টা করছেন
• 0: দেয়াল যে আপনি পার করতে পারবেন না
• +: আপনি যে তলটি পার হতে পারেন

আপনি ছয়টি দিকের একটিতে ভ্রমণ করতে পারেন: উপর-বাম, উপরে-ডান, বাম, ডান, নীচে-বাম, বা নীচে-ডান।

\ /
-S-
/ \

গোলকধাঁধা জড়ান না। লক্ষ্যটি হল পৌঁছনোর জন্য সংক্ষিপ্ততম স্ট্রিংয়ের সন্ধান Sকরা E।

ইনপুট:

ইনপুটটি ম্যাজগুলি দেখানোর মতো স্থান বিভাজিত লাইন। কোনও চলার স্থান কোনও লাইন অনুসরণ করবে না।

আউটপুট:

একটি স্ট্রিংয়ের R, Lএবং Fযেখানে

• R আপনাকে 60 ডিগ্রি ডানদিকে ঘড়ায় wise
• L আপনাকে বামে ঘোরাবে (ঘড়ির কাঁটার বিপরীতে) 60 ডিগ্রি
• F আপনি যে দিকে নির্দেশ করছেন সেদিকে আপনাকে একটি স্থান সরিয়ে দেয়

আপনি ইশারা শুরু left-up

সংক্ষিপ্ততম পথটি উত্পাদিত স্ট্রিংয়ের দৈর্ঘ্যের দ্বারা গণনা করা হয়েছে, পরিদর্শন করা অবস্থানগুলির সংখ্যা নয়। আপনার প্রোগ্রামটি সমাধান হিসাবে সবচেয়ে সংক্ষিপ্ত পথটি মুদ্রণ করতে হবে।

গোলকধাঁটি অবিশ্বাস্য হলে আপনার আউটপুট করা উচিত Invalid maze!।

( >>>আউটপুট হয়)

     0 0 0 0
    0 + 0 + 0
   0 0 0 + + 0
  0 + 0 + 0 + 0
 0 0 + + 0 0 + 0
0 0 + 0 + 0 0 + 0
 E 0 + 0 0 + + 0 
  + + 0 + 0 + 0
   0 0 0 0 0 +
    + 0 + + +
     0 S 0 0

>>>RFRFFLFLFRFFLFFFLFLFFRFLFLFRFRFRF

  + 0 0 0 0 0 0
 0 0 0 0 0 + + 0
0 0 E 0 + 0 0 + 0
 0 0 0 0 0 0 0 +
  0 + 0 0 + + +
   0 0 + + 0 0
    S + 0 0 0

>>>Invalid maze!

0 E S

>>>LF


 E + 0
0 + + +
 0 0 S
  + +

>>>FFLF

  E
 0 +
0 + +
 0 +
  S

>>>RFFLFF

 0 E + 0 0
0 + 0 0 + +
 + 0 + + + 0
  + 0 + 0 + 0
   + + + 0 S

>>>FFLFLFFRFRFFRFF

 E 0 + + 0
0 + 0 + + 0
 + + + 0 + 0
  + 0 0 0 0 0
   + + + + 0
    + 0 S 0

>>>FLFFRFFRFLF

(দ্রষ্টব্য যে কয়েকটি মেজেদের অন্যান্য সমাধান রয়েছে যা একই দৈর্ঘ্যের তবে এখানে তালিকাভুক্ত নয়)

Comments

হেক্সাগনি সমাধানের আশা করছি ...

— বেকুল

আমি একটি হেক্সাগোনি সমাধানে 500 পয়েন্টের অনুদান প্রদান করব।

— lirtosiast

@ lirtosiast2 বছর পরে, আমি মনে করি হেক্সাগনি এই সমস্যার জন্য একটি প্রসারিত হতে পারে;)

— জে আটকিন

আরও কয়েক বছরের জন্য অপেক্ষা করা যাক।

— ব্যবহারকারী 202729 10

ট্রেলিং নিউলাইন কি থাকতে পারে?

— ব্যবহারকারী 202729

Answer 1

পাইথন 2, 291 বাইট

def f(M):
 Y=map(max,M).index("S");X=M[Y].find("S");V={()};Q=[(0,0,0,1,"")]
 while Q:
    try:x,y,u,v,p=s=Q.pop(0);c=(Y>=y<=X-2*x)*ord(M[Y-y][X-2*x-y])
    except:c=0
    if c==69:return p
    if{c%2*s[:4]}-V:V|={s[:4]};Q+=(x+u,y+v,u,v,p+"F"),(x,y,-v,u+v,p+"R"),(x,y,u+v,-u,p+"L")
 return"Invalid maze!"

একটি ক্রিয়াকলাপ, fগোলকধাঁটিকে সারিগুলির তালিকা হিসাবে নিয়ে যাওয়া, এবং যদি উপস্থিত থাকে তবে কোনও সমাধান ফেরত দেওয়া।

ব্যাখ্যা

সঞ্চালিত একটি পানা-প্রথম স্থান / দিক যুগলের গ্রাফে অনুসন্ধান থেকে সবচেয়ে কম পথ খুঁজে পেতে Sকরার E।

আকর্ষণীয় হ'ল হেক্সাগোনাল গ্রিডে অবস্থান এবং দিকনির্দেশের একটি কমপ্যাক্ট উপায় সন্ধান করা, এটি সাধারণ "পদক্ষেপ" (অর্থাত্ একটি নির্দিষ্ট দিকে অগ্রসর হওয়া) এবং ঘূর্ণনকে স্বীকার করে। এখানে জটিল সংখ্যার ব্যবহার করতে, "বাস্তব" ষড়ভুজ গ্রিডের স্থানাঙ্কগুলির প্রতিনিধিত্ব করার জন্য এটি লোভনীয়, তবে এটি বেশ কয়েকটি কারণের জন্য খুব ভাল ধারণা নয়, যার মধ্যে সবচেয়ে গুরুতর বিষয়টি হল যে আমাদের একটি in3 প্লাগ ইন করতে হবে fact এটি কোথাও কাজ করার জন্য (পাপ 60 ° = √3 / 2), যা ভাসমান-পয়েন্ট সংখ্যাগুলি ব্যবহার করার সময়, আমাদের যদি নির্ভুল নির্ভুলতার প্রয়োজন হয় তবে (যেমন, আমরা ইতিমধ্যে যে রাজ্যগুলিতে পরিদর্শন করেছি রাষ্ট্রগুলি ট্র্যাক করার জন্য;) আপনি নিজের জাভাস্ক্রিপ্ট কনসোল এবং টাইপিং চেষ্টা করে Math.sqrt(3)*Math.sqrt(3) == 3দেখতে পারেন এবং নিজের জন্য দেখতে পারেন।

তবে, আমরা একটু কৌশল ব্যবহার করতে পারি! জটিল সংখ্যার ব্যবহার করার পরিবর্তে, এর সংজ্ঞায়িত করি ষড়্ভুজাকার সংখ্যার , একই শিরা মধ্যে বাস্তব সংখ্যার একটি জুড়ি হিসাবে একটি + + BH , যেখানে জ কাল্পনিক একটি অনুরূপ ভূমিকা পালন করে আমি যখন জটিল সংখ্যার সঙ্গে তার আচরণ। জটিল সংখ্যার মতো আমরাও জোড় ( ক , খ ) বিমানের একটি বিন্দুর সাথে সংযুক্ত করতে পারি , যেখানে আসল অক্ষটি ডানদিকে, কাল্পনিক অক্ষটি °০ points উপরে পয়েন্ট করে এবং তারা উভয়ই ইউনিটকে নিয়মিত ষড়্ভুটি ছেদ করে যখন আসল এবং কাল্পনিক অংশগুলি যথাক্রমে 1 সমান। গোলকধাঁধার কোষগুলিতে এই সমন্বয় ব্যবস্থাটি ম্যাপিং তুচ্ছ।

I এর বিপরীতে , ধ্রুবক এইচটিকে h ² = h - 1 ( h এর কিছু অন্তর্দৃষ্টি প্রকাশ করতে পারে)) এবং এটিই! উপরের সম্পর্কটি ব্যবহার করে ষড়ভুজ সংখ্যাগুলি অনেকগুলি জটিল সংখ্যার মতো যুক্ত এবং গুণিত করা যেতে পারে: ( a + bh ) + ( c + dh ) = ( a + c ) + ( b + d ) h , এবং ( a + bh )) ( সি + ডিএইচ ) = ( এসি - বিডি) জন্য সমাধান করা ) + ( বিজ্ঞাপন + বিসি + বিডি ) h দ্বারা সম্পর্ক দ্বারা সংজ্ঞায়িত করা হয়
। এই ক্রিয়াকলাপগুলিতে তাদের জটিল অংশগুলির মতো একই জ্যামিতিক ব্যাখ্যা রয়েছে: সংযোজনটি ভেক্টর সংযোজন এবং গুণকটি স্কেলিং এবং আবর্তন। বিশেষত, ষড়যন্ত্র সংখ্যাটি 60 ° ঘড়ির কাঁটার বিপরীতে ঘোরার জন্য, আমরা এটিকে h :
( a + bh ) · h = - b + ( a + b ) h দিয়ে গুণ করি এবং একই সংখ্যা 60 ° ঘড়ির কাঁটার দিকে ঘোরানোর জন্য, আমরা বিভক্ত করি দ্বারা h :
( a + bh ) / h = ( a +)BH ) · (1 - জ ) = (ক + খ) - অই । উদাহরণস্বরূপ, আমরা ইশারা ইউনিট ষড়্ভুজাকার সংখ্যা নিতে পারেন ঠিক আছে, 1 = (1, 0) একটি পূর্ণ বৃত্ত, ঘড়ির কাঁটার বিপরীতে গিয়ে দ্বারা এটি গুন দ্বারা জ ছয় বার:
(1, 0) · জ = (0, 1 ); (0, 1) · এইচ = (-1, 1); (-1, 1) · এইচ = (-1, 0); (-1, 0) · এইচ = (0, -1); (0, -1) · এইচ = (1, -1);
(1, -1) · এইচ = (1, 0)

গোলকধাঁধার বর্তমান অবস্থান এবং বর্তমান দিকনির্দেশ, নির্দিষ্ট দিকে অগ্রসর হতে এবং বাঁদিকে এবং ডানে দিকটি ঘোরানোর জন্য প্রোগ্রামটি এই ফ্যাশনে ষড়ভুজ সংখ্যাগুলি ব্যবহার করে।

Answer 2

হেক্সাগনি , 2437 বাইট

দীর্ঘ প্রতীক্ষিত প্রোগ্রামটি এখানে:

(.=$>({{{({}}{\>6'%={}{?4=$/./\_><./,{}}{<$<\?{&P'_("'"#<".>........_..\></</(\.|/<>}{0/'$.}_.....><>)<.$)).><$./$\))'"<$_.)><.>%'2{/_.>(/)|_>}{{}./..>#/|}.'/$|\})'%.<>{=\$_.\<$))<>(|\4?<.{.%.|/</{=....$/<>/...'..._.>'"'_/<}....({{>%'))}/.><.$./{}{\>$\|$(<><$?..\\<.}_>=<._..\(/.//..\}\.)))))<...2/|$\){}/{..><>).../_$..$_>{0#{{((((/|#.}><..>.<_.\(//$>))<(/.\.\})'"#4?#\_=_-..=.>(<...(..>(/\")<((.\=}}}\>{}{?<,|{>/...(...>($>{)<.>{=P&/(>//(_.)\}=#=\4#|)__.>"'()'\.'..".(\&P'&</'&\$_></}{)<\<0|\<.}.\"\.(.(.(/(\..{.>}=P/|><.(...(..."/<.{"_{{=..)..>})<|><$}}/\}}&P<\(/._...>\$'/.>}/{}}{)..|/(\'.<(\''"")$/{{}})<..'...}}>3#./\$<}|.}|..$.><${{}/>.}}{{<>(""''/..>){<}\?=}{\._=/$/=_>)\{_\._..>)</{\=._.....>(($>}}<.>5#.\/}>)<>-/(.....{\<>}}{{/)\$>=}}}))<...=...(\?{{{?<\<._...}.><..\}}/..>'P&//(\......(..\})"'/./&P'&P{}}&P'<{}\{{{({{{(.\&P=<.><$"&1}(./'"?&'&"\.|>}{?&"?&'P&/|{/&P''</(\..>P&{/&/}{}&'&},/"&P'&?<.|\}{&?"&P'&P'<._.>"&}\(>))<\=}{}<.{/}&?"&"&/"&"?&}\.|>?&"?&{{}}?&//x'&{((<._\($|(}.\/}{/>=&'P&"&/".{3?<.|\"&P'&P}{}&P'<.>&{}}?&"&'P&\=}}<.}/2?".?''5?"/?1{(}\."..../{},<../&//&"&P'&P'&"&"</{}}{{/>"?1''?.'({/}}{}<..>?&"?&}}$>)|P/<.>"&'P&'P&"&"&{/........._/"\$#1}/._.........|,($<'"}'?/_$P#"$0'${)$})$)|........(>/\.#1?<$<|.....>?&}$>=?&"?&/1$..>I;n;v;a;l;i;d;P0;m;a\|\"(}}({=/..$_...\"&P=},}}&P'<.|><....................;...>1"(}}){=/_....>'P&'P&}}_?&/#.>}?4'%\/<...@;1P;e;z<._><>"))'?=<.$$=..\&P}{&</\"><_'|/'&=}<.>{{.<.........|>(/>3")}}){=/=/_.>}P&"?/"<).}_.>?4{=:<.|_...........\$\2$'>4")}}({/."\{&P'&?/><.?|>P...."/=(>(/./(}{{\..>(<>(<>?5'"((..'/...#,</,}{{\.......;.F>..\(...}....._.._..._..._........__..'$......\.<R..$.>))<$}{{&P'&?}<.\$$.\...................$\.<>L\.\(('_"\>}P&"?&{/__/=(.(<.>_)..<...>....\..._.<.....&?=\}=&?"&<.."'>.\>))<.|>))\.|$.>&"?&{{}=P&}?&=}/{\.>&{{P/{">)<|\{<(|\(_(<>\_\?"&P'&P}{{{&<=_.>\&\?"&?<|'{/(/>{{/_>.{/=/\\.>'P&"?&"?&"?/._(\)\\>?&"/_|.>/.$/|$..\\><..\&?}{{}&P'&<}.._>{<|\{}<._$>-")<.>_)<|{)$|..>}=P&"?&"?/...{"./>'P&/=_\{?(/>(<>\(|)__.\&?}}{}&P<}.$.\&P'&P'&<\})))&=<\)<'.'_,><.>"?&'P&'/.|>?&{{}?&"?/>&"?&"?&}}<.".(\\\&?={&P<{..\"&?"&P'&<.?....|.$'\$/\"/.,.>{}{}=/..>&'P&}{{}P/\{}&P{(&?"&?"<'.(\&?"&<}..\?"&?"&<.>P&={}}?&}}P&'P&/.'.>&"?/..>P&}}{{P/\}&P'&?={&?<$}=\"."\P'<{..\'&P'&<....>'P&{}P&"?&{{<\\..>&/$.>}{?&"?/|'$&.P&$P\$'&P={(/..\P\\.\{&?"&?\...\?{{}=<$&P'&P<.,./<?\...{}=P\"&<.>=P&""'?&'P&'/$.#1.>{?1#=$\&'P/\}&P'&?={(,}<._?_&\&?{=&{*=}4<.>P&"?&"?&'P&/1_$>}?&}}=?&){?/\{}&P'&?={&?#<$

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

"পাঠযোগ্য" সংস্করণ:

                             ( . = $ > ( { { { ( { } } { \ > 6 ' % = { } { ? 4 = $ / .
                            / \ _ > < . / , { } } { < $ < \ ? { & P ' _ ( " ' " # < " .
                           > . . . . . . . . _ . . \ > < / < / ( \ . | / < > } { 0 / ' $
                          . } _ . . . . . > < > ) < . $ ) ) . > < $ . / $ \ ) ) ' " < $ _
                         . ) > < . > % ' 2 { / _ . > ( / ) | _ > } { { } . / . . > # / | }
                        . ' / $ | \ } ) ' % . < > { = \ $ _ . \ < $ ) ) < > ( | \ 4 ? < . {
                       . % . | / < / { = . . . . $ / < > / . . . ' . . . _ . > ' " ' _ / < }
                      . . . . ( { { > % ' ) ) } / . > < . $ . / { } { \ > $ \ | $ ( < > < $ ?
                     . . \ \ < . } _ > = < . _ . . \ ( / . / / . . \ } \ . ) ) ) ) ) < . . . 2
                    / | $ \ ) { } / { . . > < > ) . . . / _ $ . . $ _ > { 0 # { { ( ( ( ( / | #
                   . } > < . . > . < _ . \ ( / / $ > ) ) < ( / . \ . \ } ) ' " # 4 ? # \ _ = _ -
                  . . = . > ( < . . . ( . . > ( / \ " ) < ( ( . \ = } } } \ > { } { ? < , | { > /
                 . . . ( . . . > ( $ > { ) < . > { = P & / ( > / / ( _ . ) \ } = # = \ 4 # | ) _ _
                . > " ' ( ) ' \ . ' . . " . ( \ & P ' & < / ' & \ $ _ > < / } { ) < \ < 0 | \ < . }
               . \ " \ . ( . ( . ( / ( \ . . { . > } = P / | > < . ( . . . ( . . . " / < . { " _ { {
              = . . ) . . > } ) < | > < $ } } / \ } } & P < \ ( / . _ . . . > \ $ ' / . > } / { } } {
             ) . . | / ( \ ' . < ( \ ' ' " " ) $ / { { } } ) < . . ' . . . } } > 3 # . / \ $ < } | . }
            | . . $ . > < $ { { } / > . } } { { < > ( " " ' ' / . . > ) { < } \ ? = } { \ . _ = / $ / =
           _ > ) \ { _ \ . _ . . > ) < / { \ = . _ . . . . . > ( ( $ > } } < . > 5 # . \ / } > ) < > - /
          ( . . . . . { \ < > } } { { / ) \ $ > = } } } ) ) < . . . = . . . ( \ ? { { { ? < \ < . _ . . .
         } . > < . . \ } } / . . > ' P & / / ( \ . . . . . . ( . . \ } ) " ' / . / & P ' & P { } } & P ' <
        { } \ { { { ( { { { ( . \ & P = < . > < $ " & 1 } ( . / ' " ? & ' & " \ . | > } { ? & " ? & ' P & /
       | { / & P ' ' < / ( \ . . > P & { / & / } { } & ' & } , / " & P ' & ? < . | \ } { & ? " & P ' & P ' <
      . _ . > " & } \ ( > ) ) < \ = } { } < . { / } & ? " & " & / " & " ? & } \ . | > ? & " ? & { { } } ? & /
     / x ' & { ( ( < . _ \ ( $ | ( } . \ / } { / > = & ' P & " & / " . { 3 ? < . | \ " & P ' & P } { } & P ' <
    . > & { } } ? & " & ' P & \ = } } < . } / 2 ? " . ? ' ' 5 ? " / ? 1 { ( } \ . " . . . . / { } , < . . / & /
   / & " & P ' & P ' & " & " < / { } } { { / > " ? 1 ' ' ? . ' ( { / } } { } < . . > ? & " ? & } } $ > ) | P / <
  . > " & ' P & ' P & " & " & { / . . . . . . . . . _ / " \ $ # 1 } / . _ . . . . . . . . . | , ( $ < ' " } ' ? /
 _ $ P # " $ 0 ' $ { ) $ } ) $ ) | . . . . . . . . ( > / \ . # 1 ? < $ < | . . . . . > ? & } $ > = ? & " ? & / 1 $
  . . > I ; n ; v ; a ; l ; i ; d ; P 0 ; m ; a \ | \ " ( } } ( { = / . . $ _ . . . \ " & P = } , } } & P ' < . |
   > < . . . . . . . . . . . . . . . . . . . . ; . . . > 1 " ( } } ) { = / _ . . . . > ' P & ' P & } } _ ? & / #
    . > } ? 4 ' % \ / < . . . @ ; 1 P ; e ; z < . _ > < > " ) ) ' ? = < . $ $ = . . \ & P } { & < / \ " > < _ '
     | / ' & = } < . > { { . < . . . . . . . . . | > ( / > 3 " ) } } ) { = / = / _ . > } P & " ? / " < ) . } _
      . > ? 4 { = : < . | _ . . . . . . . . . . . \ $ \ 2 $ ' > 4 " ) } } ( { / . " \ { & P ' & ? / > < . ? |
       > P . . . . " / = ( > ( / . / ( } { { \ . . > ( < > ( < > ? 5 ' " ( ( . . ' / . . . # , < / , } { { \
        . . . . . . . ; . F > . . \ ( . . . } . . . . . _ . . _ . . . _ . . . _ . . . . . . . . _ _ . . ' $
         . . . . . . \ . < R . . $ . > ) ) < $ } { { & P ' & ? } < . \ $ $ . \ . . . . . . . . . . . . . .
          . . . . . $ \ . < > L \ . \ ( ( ' _ " \ > } P & " ? & { / _ _ / = ( . ( < . > _ ) . . < . . . >
           . . . . \ . . . _ . < . . . . . & ? = \ } = & ? " & < . . " ' > . \ > ) ) < . | > ) ) \ . | $
            . > & " ? & { { } = P & } ? & = } / { \ . > & { { P / { " > ) < | \ { < ( | \ ( _ ( < > \ _
             \ ? " & P ' & P } { { { & < = _ . > \ & \ ? " & ? < | ' { / ( / > { { / _ > . { / = / \ \
              . > ' P & " ? & " ? & " ? / . _ ( \ ) \ \ > ? & " / _ | . > / . $ / | $ . . \ \ > < . .
               \ & ? } { { } & P ' & < } . . _ > { < | \ { } < . _ $ > - " ) < . > _ ) < | { ) $ | .
                . > } = P & " ? & " ? / . . . { " . / > ' P & / = _ \ { ? ( / > ( < > \ ( | ) _ _ .
                 \ & ? } } { } & P < } . $ . \ & P ' & P ' & < \ } ) ) ) & = < \ ) < ' . ' _ , > <
                  . > " ? & ' P & ' / . | > ? & { { } ? & " ? / > & " ? & " ? & } } < . " . ( \ \
                   \ & ? = { & P < { . . \ " & ? " & P ' & < . ? . . . . | . $ ' \ $ / \ " / . ,
                    . > { } { } = / . . > & ' P & } { { } P / \ { } & P { ( & ? " & ? " < ' . (
                     \ & ? " & < } . . \ ? " & ? " & < . > P & = { } } ? & } } P & ' P & / . '
                      . > & " ? / . . > P & } } { { P / \ } & P ' & ? = { & ? < $ } = \ " . "
                       \ P ' < { . . \ ' & P ' & < . . . . > ' P & { } P & " ? & { { < \ \ .
                        . > & / $ . > } { ? & " ? / | ' $ & . P & $ P \ $ ' & P = { ( / . .
                         \ P \ \ . \ { & ? " & ? \ . . . \ ? { { } = < $ & P ' & P < . , .
                          / < ? \ . . . { } = P \ " & < . > = P & " " ' ? & ' P & ' / $ .
                           # 1 . > { ? 1 # = $ \ & ' P / \ } & P ' & ? = { ( , } < . _ ?
                            _ & \ & ? { = & { * = } 4 < . > P & " ? & " ? & ' P & / 1 _
                             $ > } ? & } } = ? & ) { ? / \ { } & P ' & ? = { & ? # < $

এসোটেরিক আইডিতে পরীক্ষিত: টিআইওর কিছু বৃহত্তর পরীক্ষার ক্ষেত্রে সময় শেষ হতে পারে তবে সমস্ত যাচাই করা আছে। টিমউয়িকে অনেক ধন্যবাদ, আইডিই ছাড়া এটি সম্ভব হত না।

এখানে বেশ কিছুটা খালি জায়গা রয়েছে, তাই আমি সম্ভবত এটি একটি পাশের দৈর্ঘ্যের 28 ষড়্ভুজ (পার্শ্ব-দৈর্ঘ্যের 29 এর পরিবর্তে) এর উপর ফিট করতে সক্ষম হয়েছি তবে এটি একটি বিশাল কাজ হবে তাই আমি সম্ভবত এটি চেষ্টা করতে যাচ্ছি না।

বেসিক ব্যাখ্যা

আরও বড় এবং আরও বিশদ সংস্করণের জন্য চিত্রগুলিতে ক্লিক করুন।

ক্রিয়াকলাপ

_{দ্রষ্টব্য: বিভাগগুলি সাধারণত সঠিক তবে মাঝেমধ্যে মোটামুটি অনুমান হতে পারে।}

এই কোডটি বেশ "কার্যকরী" - হেক্সাগনি যতটা অনুমতি দেয়। উপরের চিত্রটিতে লেবেলযুক্ত এই কোডটিতে আটটি প্রধান ফাংশন রয়েছে, যার সাথে তারা কল করা সংখ্যার নামকরণ করা হয় (সুতরাং তাদের নির্দেশিকা নির্দেশকের সংখ্যাগুলি সেই সংখ্যাটি মোড 6)। (মোটামুটি) কল করার ক্রমে এগুলি (উদ্ধৃত নামগুলি মেমরির অবস্থান যা পরে ব্যাখ্যা করা হবে):

• এস: সূচনা ফাংশন - ইনপুট পড়ে এবং "রেফারেন্স অ্যারে" সেট আপ করে, তারপরে তিনটি পথ দিয়ে "পাথ স্ট্যাক" শুরু করে F,R এবং Lপ্রধান প্রক্রিয়াকরণের জন্য প্রস্তুত। নির্দেশিকা পয়েন্টার 0 0 কার্যকর করতে সঞ্চালিত হয় যখন এক্সিকিউশন 1 কার্যকর হয়।
• 1 (-11): মূল ফাংশন - একটি পাথ পেতে 2 টি ব্যবহার করে, এর বৈধতা পরীক্ষা করতে 3 টি ব্যবহার করে এবং যদি বৈধ হয়ে যায় -110 / -10 দুবার এবং তারপরে 4 বার তিনবার নতুন পাথগুলি "পাথের অনুলিপি করতে" স্ট্যাক ", নিজেই ফিরে এসে সমাপ্তি। পাথটি শেষের স্থানে থাকলে 5 ফাংশন কল করতে পারে।
• 2: প্রসেসিংয়ের জন্য প্রস্তুত "পাথ স্ট্যাক" এর পরবর্তী পথটি পায়, স্ট্যাকের কোনও পাথ না থাকলে ফাংশন -1 কল করে। ফাংশন 1 এ ফিরে আসে।
• 3: চলন সংখ্যাটির পাশাপাশি মানগুলির একটি জোড়া লাগে এবং বর্তমান পথটি কোনও বৈধ স্থানে শেষ হয়েছে কিনা তা দেখতে "রেফারেন্স অ্যারে" পরীক্ষা করে। একটি বৈধ অবস্থান হয় হয় প্রথম 3 পদক্ষেপের মধ্যেই শুরু, বা +এর প্রথম দিকে পৌঁছানোর 2 টি মুভের মধ্যে কোনও । ফাংশন 1 এ ফিরে আসে।
• -10 / -110: বর্তমান পথ অনুলিপি করে। ফাংশন 1 এ ফিরে আসে।
• 0: এর সাথে চলাচলের দিক পরিচালনা করতে 1 ক্রিয়ায় সহায়তা করে F । ফাংশন 1 এ ফিরে আসে।
• 4: বর্তমান পথ একটি কপি লাগে এবং 1 পরিবর্তনগুলি এটির সাথে একই পথে পারেন ফাংশন সুত্রে বেঁধে F, Rবা Lযোগ করা। ফাংশন 1 এ ফিরে আসে।
• 5: পথ নেয় এবং সঠিক পথটি প্রিন্ট করে (উদাঃ FFLF), তারপর প্রোগ্রামটি সমাপ্ত করে।
• -1: প্রিন্ট Invalid maze!এবং সমাপ্তি।
• (ডাবল তীর): স্থানের অভাবে, ফাংশন 1 / -11 ফাংশন -1 এর উপরের স্পেসে যেতে হয়েছিল।

স্মৃতি

_{দ্রষ্টব্য: ডায়াগ্রামের জন্য আবার এসোটেরিক আইডিই ধন্যবাদ}

স্মৃতি তিনটি প্রধান অংশ নিয়ে গঠিত:

• রেফারেন্স অ্যারে: গ্রিডটি প্রতিটি ধাপে একটি মান সহ 2 টি কলাম বাদে কলাম সংরক্ষণ করা হয়:
  • 0 হয় একটি প্রতিনিধিত্ব করে ,0 বা কোনও বৈধ স্থানের যা কোনও দিক থেকে স্থান থেকে বেরিয়ে আসার প্রয়োজনের চেয়ে বেশি পদক্ষেপে অ্যাক্সেস করা হয়েছিল।
  • 1 +এমন একটি প্রতিনিধিত্ব করে যা এখনও পৌঁছায় নি।
  • (উচ্চতর সংখ্যা) সরানো নম্বরটি উপস্থাপন করে যেখানে কোনও দিক থেকে স্থানটি বাইরে বেরোনোর ​​জন্য যথেষ্ট পদক্ষেপ থাকবে।
  • 10 এছাড়াও একটি নতুন লাইনের প্রতিনিধিত্ব করে: এগুলি ধরেই নেওয়া হয় না যে তারা অবিলম্বে শেষ অ-সাদা-স্থানের অক্ষরটি অনুসরণ করে।
• রেল: বামে -1একটি একক -2নিয়ে গঠিত , মেমরি পয়েন্টারটি মূল প্রসেসিং এরিয়ায় দ্রুত ফিরে যেতে দেয়।
• পাথ স্ট্যাক: পাথ আইডি অনুসারে প্রতিটি অনির্ধারিত পাথ সংরক্ষণ করে (যা সরানো সংখ্যার সাথে সরাসরি সম্পর্কিত যার ফলে ছোট পাথগুলি প্রথমে পরীক্ষা করা হয়)। পাথটি নিম্নরূপে সংরক্ষণ করা হয়েছে:
  
  • রট: বর্তমান পাথের শেষে ঘোরানো: 0 বাম দিকে এবং ঘড়ির কাঁটার দিকে 5 এ বাড়ানো
  • সরান: বর্তমান সরানো নম্বর (নির্দেশাবলী - 1)
  • পথ: বর্তমান পথ, সঙ্গে চতুরাত্মক সঞ্চিত F, R, Lযেমন 1, 2, 3যথাক্রমে
  • x / y: বর্তমান পাথের শেষে স্থানাঙ্ক: x + 1 -1s ডান হলে y মান আপ করে (যদিও রেফারেন্স তথ্য থেকে রেলকে পৃথক করার উদ্দেশ্যে y = 0 1 হিসাবে প্রক্রিয়াকরণ করা হয়)

অন্যান্য গুরুত্বপূর্ণ স্মৃতি অবস্থান:

1. এর x / y Eএখানে সঞ্চিত আছে।
2. এই স্থানটি মেমরির ভিতরে এবং বাইরে পাথকে স্থানান্তর করতে ব্যবহৃত হয়।
3. এই অবস্থানটি কেন্দ্রের যেখানে প্রতিটি পাথ প্রক্রিয়াকরণের সময় সংরক্ষণ করা হয়।

Comments

পরবর্তী পদক্ষেপটি আপনার সংক্ষিপ্ততম গোলকধাঁধার রুটটি খুঁজে পেতে আপনার প্রোগ্রামের মাধ্যমে প্রোগ্রাম চালাচ্ছে।

— ভেস্কাহ

আমি জানি যে কেউ এটি পোস্ট করবে। শেষ অবধি ... / আমারও একটি আলাদা পরিকল্পনা আছে যা সম্ভবত আপনার চেয়ে কম কোড নেওয়া উচিত। এটি বাস্তবায়নের জন্য কখনই সময় নেই।

— ব্যবহারকারী 202729

@20202729 এটি সম্পর্কে শুনতে আকর্ষণীয় হবে। আমি বলব এই পদ্ধতিটি কমপক্ষে 2 মাপের নীচে গল্ফ করা যেতে পারে তবে সেখানে অবশ্যই আরও ভাল কিছু আছে।

— ববাকউক

কেবলমাত্র @lirtosiast এর জন্য অপেক্ষা করছি।

— জে আটকিন

বিলম্বের জন্য ক্ষমাপ্রার্থী.

— lirtosiast

Answer 3

পাইথন 3, 466 বাইট

আমি যদি গভীরতা-প্রথম অনুসন্ধান বা অন্য কিছু ব্যবহার করি তবে সম্ভবত আরও ছোট হয়ে যেতে পারত। এই একত্ববাদটি ডিজকস্ট্র ব্যবহার করে এবং এটি বেশ দ্রুত, তবে খুব দীর্ঘ।

কোডটি এমন একটি ফাংশন সংজ্ঞায়িত করে Sযা গোলকধাঁধাটির সাথে একাধিক স্ট্রিং নেয় এবং ফলাফলটি দেয়।

def F(M,L,c):y=M[:M.index(c)].count("\n");return L[y].index(c),y
def S(M):
 L=M.split("\n");Q=[("",)+F(M,L,"S")+(0,)];D={};R=range;H=len;U=R(2**30)
 while Q:
  C,*Q=sorted(Q,key=H);w,x,y,d=C
  for e in R(H(L)>y>-1<x<H(L[y])>0<H(D.get(C[1:],U))>H(w)and(L[y][x]in"+SE")*6):D[C[1:]]=w;E=(d+e)%6;Q+=[(w+",R,RR,RRR,LL,L".split(",")[e]+"F",x+[-1,1,2,1,-1,-2][E],y+[-1,-1,0,1,1,0][E],E)]
 J=min([D.get(F(M,L,"E")+(d,),U)for d in R(6)],key=H);return[J,"Invalid maze!"][J==U]

এখানে কোডের একটি পরীক্ষা দেওয়া হচ্ছে।

Ungolfed

def find_char(maze, lines, char):
    y = maze[:maze.index(char)].count("\n")
    return lines[y].index(char), y
def solve(maze):
    lines = maze.split("\n")
    x, y = find_char(maze, lines, "S")
    queue = [("", x, y, 0)]
    solutions = {}
    very_long = range(2**30)
    x_for_direction = [-1,1,2,1,-1,-2]
    y_for_direction = [-1,-1,0,1,1,0]
    rotations = ["","R","RR","RRR","LL","L"]
    while len(queue) > 0:
        queue = sorted(queue, key=len)
        current, *queue = queue
        route, x, y, direction = current
        if 0 <= y < len(lines) and 0 <= x < len(lines[y]) and lines[y][x] in "+SE" and len(solutions.get(current[1:], very_long)) > len(route):
            solutions[current[1:]] = route
            for change in range(6):
                changed = (direction + change) % 6
                queue += [(route + rotations[change] + "F", x + x_for_direction[changed], y + y_for_direction[changed], changed)]
    end_x, end_y = find_char(maze, lines, "E")
    solution = min([solutions.get((end_x, end_y, direction), very_long) for direction in range(6)], key=len)
    return "Invalid maze!" if solution == very_long else solution

Comments

বাহ, খুব সুন্দর। লিখতে আপনাকে কতক্ষণ সময় লাগল?

— জে আতকিন

@ জ্যাটিন ওয়েল, ফাইলটি 1.5 ঘন্টা আগে তৈরি করা হয়েছিল, যদিও আমি নিশ্চিত নই যে আমি আসলে কোডটিতে কাজ করতে গিয়ে কতটা সময় ব্যয় করেছি। এছাড়াও, এটি এখানে সকাল 3 টা, সুতরাং আমার উত্পাদনশীলতা স্পষ্টতই এর সর্বোচ্চ।

— পুর্কাকুডারী

ভাল, আমি 2+ ঘন্টা ব্যয় করেছি এবং আমার বেশিরভাগটি ইতিমধ্যে একটি মানক গোলকধাঁধার জন্য লেখা ছিল।

— জে আতকিন

আপনার কি একটি অবারিত সংস্করণ আছে?

— জে আতকিন

@ জ্যাটিন এটি দরকার, কারণ আপনার শুরুতে ঘুরতে হবে need প্রারম্ভিক অবস্থান ব্যতীত এটি কাজ করবে L,,R।

— পূর্বকুডারী

Answer 4

গ্রোভি, 624 বাইট। ফোর!

সময় সময় একটি বড় এক সঙ্গে বল ঘূর্ণায়মান পেতে। মাল্টি-লাইন স্ট্রিংকে আর্গ হিসাবে গ্রহণ করেQ

Q={a->d=[0]*4
a.eachWithIndex{x,y->f=x.indexOf('S');e=x.indexOf('E');
if(f!=-1){d[0]=f;d[1]=y}
if(e!=-1){d[2]=e;d[3]=y}}
g=[]
s={x,y,h,i,j->if(h.contains([x, y])|y>=a.size()||x>=a[y].size()|x<0|y<0)return;k = a[y][x]
def l=h+[[x, y]]
def m=j
def n=1
if(h){
o=h[-1]
p=[x,y]
q=[p[0]-o[0],p[1]-o[1]]
n=[[-2,0]:0,[-1,-1]:1,[1,-1]:2,[2,0]:3,[1,1]:4,[-1,1]:5][q]
r=n-i
m=j+((r==-5|r==5)?' LR'[(int)r/5]:['','R','RR','LL','L'][r])+'F'}
if(k=='E')g+=m
if(k=='+'|k=='S'){s(x-2,y,l,n,m)
s(x+2,y,l,n,m)
s(x+1,y+1,l,n,m)
s(x+1,y-1,l,n,m)
s(x-1,y+1,l,n,m)
s(x-1,y-1,l,n,m)}}
s(d[0],d[1],[],1,'')
print(g.min{it.size()}?:"Invalid maze!")}

অবরুদ্ধ সংস্করণ:

def map =
        """
  + 0 0 0 0 0 0
 0 0 0 0 0 + + 0
0 0 E 0 + 0 0 + 0
 0 0 0 0 0 0 0 +
  0 + 0 0 + + +
   0 0 + + 0 0
    S + 0 0 0""".split('\n').findAll()
//map =
//        """
// 0 + +
//E + 0 S 0
// 0 0 0 +
//  + + +""".split('\n').findAll()

//map = [""]// TODO remove this, this is type checking only
//map.remove(0)
//reader = System.in.newReader()
//line = reader.readLine()
//while (line != '') {
//    map << line
//    line = reader.readLine()
//}

startAndEnd = [0, 0, 0, 0]
map.eachWithIndex { it, idx ->
    s = it.indexOf('S'); e = it.indexOf('E');
    if (s != -1) {
        startAndEnd[0] = s; startAndEnd[1] = idx
    }
    if (e != -1) {
        startAndEnd[2] = e; startAndEnd[3] = idx
    }
}

def validPaths = []
testMove = { x, y, visited ->// visited is an array of x y pairs that we have already visited in this tree
    if (visited.contains([x, y]) || y >= map.size() || x >= map[y].size() || x < 0 || y < 0)
        return;


    def valueAtPos = map[y][x]
    def newPath = visited + [[x, y]]

    if (valueAtPos == 'E') validPaths += [newPath]
    if (valueAtPos == '+' || valueAtPos == 'S') {
        println "$x, $y passed $valueAtPos"
        testMove(x - 2, y, newPath)
        testMove(x + 2, y, newPath)

        testMove(x + 1, y + 1, newPath)
        testMove(x + 1, y - 1, newPath)

        testMove(x - 1, y + 1, newPath)
        testMove(x - 1, y - 1, newPath)
    }
}

//if (!validPath) invalid()
testMove(startAndEnd[0], startAndEnd[1], [])
println validPaths.join('\n')

//println validPath

def smallest = validPaths.collect {
    def path = ''
    def orintation = 1
    it.inject { old, goal ->
        def chr = map[goal[1]][goal[0]]
        def sub = [goal[0] - old[0], goal[1] - old[1]]
        def newOrin = [[-2, 0]: 0, [-1, -1]: 1, [1, -1]: 2, [2, 0]: 3, [1, 1]:4, [-1, 1]:5][sub]
        def diff = newOrin - orintation// 5L -5R
        def addedPath= ((diff==-5||diff==5)?' LR'[(int)diff/5]:['', 'R', 'RR', 'LL', 'L'][diff]) + 'F'//(diff == 0) ? '' : (diff > 0 ? 'R'*diff : 'L'*(-diff)) + 'F'
//        println "old:$old, goal:$goal chr $chr, orintation $orintation, sub:$sub newOrin $newOrin newPath $addedPath diff $diff"
        path += addedPath
        orintation = newOrin
        goal
    }
    path
}.min{it.size()}
//println "paths:\n${smallest.join('\n')}"
if (smallest)
    println "path $smallest"
else
    println "Invalid maze!"

Answer 5

সি #, 600 574 বাইট

সম্পূর্ণ প্রোগ্রাম, STDIN, এসটিডিআউট থেকে আউটপুট গ্রহণ করে।

সম্পাদনা করুন: মোড়ানো হ্যান্ডলিংয়ে একটি বাগ ছিল (প্রদত্ত পরীক্ষার কোনও ক্ষেত্রেই ভেঙে পড়েনি) যা 1 বাইট যুক্ত করেছিল, তাই ক্ষতিপূরণ দেওয়ার জন্য আমি আরও কিছুটা গল্ফ করেছিলাম।

using Q=System.Console;struct P{int p,d;static void Main(){string D="",L;int w=0,W=0,o,n=1;for(;(L=Q.ReadLine())!=null;D+=L)w=(o=(L+="X").Length+1)>w?o:w;for(;W<D.Length;)D=D.Insert(W+1,"".PadLeft(D[W++]>87?w-W%w:0));P[]K=new P[W*6];var T=new string[W*6];P c=K[o=0]=new P{p=D.IndexOf('S')};for(System.Action A=()=>{if(c.p>=0&c.p<W&System.Array.IndexOf(K,c)<0&&D[c.p]%8>0){T[n]=T[o]+L;K[n]=c;n=D[c.p]==69?-n:n+1;}};o<n;o++){c=K[o];L="R";c.d=++c.d%6;A();L="L";c.d=(c.d+4)%6;A();L="F";c=K[o];c.p+=new[]{~w,1-w,2,1+w,w-1,-2}[c.d%6];A();}Q.WriteLine(n>0?"Invalid maze!":T[-n]);}}

এটি মানচিত্রে পড়া শুরু করে (প্রতিটি লাইনে সংযোজন করা হয় যাতে এটি কোথায় শেষ হয় তা জানতে পারে এবং ফিরে যেতে এবং মানচিত্রটিকে আয়তক্ষেত্রাকার করে তুলতে এবং ডান পাশের ফাঁকা ফাঁকা জায়গাগুলির সাথে যুক্ত করতে পারে (এটি সংরক্ষণ করে) আমাদের নীচে ব্যাখ্যা করা হবে মোড়ানো চেক করা)। এটি এর এক পর্যায়ে আয়তক্ষেত্রের প্রস্থের কাজ করে এবং মানচিত্রের মোট দৈর্ঘ্য নির্ধারণ করে।

এর পরে, এটি একটি প্রস্থ-প্রথম-অনুসন্ধানের জন্য সমস্ত কিছু শুরু করে। দুটি বিগ অ্যারে তৈরি করা হয়েছে, একটি আমাদের সন্ধানে আমাদের অনুসন্ধান করতে হবে এমন সমস্ত রাজ্য সংরক্ষণ করার জন্য, অন্যটি প্রতিটি রাজ্যে যাওয়ার জন্য আমরা যে পথটি নিয়েছি তা রেকর্ড করতে। প্রাথমিক অবস্থাটি যথাযথ অ্যারেতে যুক্ত করা হয়েছে, মাথা এবং লেজ পয়েন্টারগুলির উপরে কিছুটা আগে সেট করা হয়েছে। সবকিছু 1 ইনডেক্সড।

এরপরে আমরা লেজটি মাথার মধ্যে ক্র্যাশ না হওয়া পর্যন্ত পুনরাবৃত্তি করি বা কমপক্ষে এটি মাথার মধ্যে ক্র্যাশ হয়ে গেছে বলে মনে হয়। আমরা যে প্রতিটি রাষ্ট্র পরিদর্শন করেছি তার জন্য আমরা বাম বা ডানদিকে ঘোরানো একই অবস্থানে একটি নতুন রাষ্ট্র যুক্ত করার চেষ্টা করি এবং তারপরে যেখানে আমরা এগিয়ে চলেছি one দিকনির্দেশগুলি সূচকযুক্ত করা হয়, 0"উপরের-বামে" প্রাসঙ্গিক প্রাথমিক দিকের সাথে (ডিফল্ট হিসাবে )।

যখন আমরা কোনও রাজ্যের সারিবদ্ধ করার চেষ্টা করি, তখন এটি চেক করা আবদ্ধ হয়, তবে মোড়ক চেক করা যায় না, কারণ ডানদিকে ফাঁকা স্থানগুলির কলামগুলির কারণে, যা "আমাদের এখানে থাকার অনুমতি দেওয়া হচ্ছে?" পরীক্ষা করুন (আপনাকে স্পেসে থাকতে দেওয়া হচ্ছে না)। যদি রাজ্যটি সারিবদ্ধ থাকে, তবে আমরা এটি Eকোষে রয়েছে কিনা তা পরীক্ষা করে দেখি এবং যদি এটি হয় তবে আমরা কাতারের মাথাটি নিজেই বিয়োগ করতে প্রস্তুত করি যা মূল লুপটি প্রস্থান করে এবং প্রোগ্রামটির শেষ লাইনটি মুদ্রণের জন্য বলে দেয় ব্যর্থতার বার্তার পরিবর্তে সম্পর্কিত রুটটি বাদ দিন (যা দেখায় আমরা প্রসারিত হয়ে রাজ্যগুলি ছুঁড়ে ফেলেছি (লেজ মাথার মধ্যে ক্র্যাশ হয়ে গেছে))।

using Q=System.Console;

// mod 8 table (the block of zeros is what we are after - it's everywhere we /can't/ go)
//   0 (space)
// O 0
// X 0
// S 3
// + 3
// E 5

struct P
{
    int p,d;
    static void Main()
    {
        // it's probably a bad thing that I have my own standards for naming this stupid read sequence by now
        string D="", // map
        L; // line/path char

        int w=0, // width
        W=0, // full length
        o, // next state to expand
        n=1; // next state to fill

        for(;(L=Q.ReadLine())!=null;D+=L) // read in map
            w=(o=(L+="X").Length+1)>w?o:w; // assertain max length (and mark end, and remove any need for wrap checking)

        // now we need to add those trailing spaces...
        for(;W<D.Length;)
            D=D.Insert(W+1,"".PadLeft(D[W++]>87?w-W%w:0)); // inject a load of spaces if we hit an X

        P[]K=new P[W*6]; // create space for due states (can't be more states than 6*number of cells)
        var T=new string[W*6]; // create space for routes (never done it this way before, kind of exciting :D)
        P c=K[o=0]=new P{p=D.IndexOf('S')}; // set first state (assignment to c is just to make the lambda shut up about unassigned variables)

        // run bfs
        for(

            System.Action A=()=> // this adds c to the list of states to be expanded, if a whole load of checks pass
            {
                if(//n>0& // we havn't already finished - we don't need this, because we can't win on the first turn, so can't win unless we go forward, which we check last
                   c.p>=0&c.p<W& // c is within bounds
                   System.Array.IndexOf(K,c)<0&& // we havn't seen c yet (the && is to prevent the following lookup IOBing)
                   D[c.p]%8>0) // and we can move here (see table at top of code)
                {
                    T[n]=T[o]+L; // store route
                    K[n]=c; // store state
                    n=D[c.p]==69?-n:n+1; // check if we are at the end, if so, set n to be negative of itself so we know, and can look up the route (otherwise, increment n)
                }
            }

            ;o<n;o++) // o<n also catches n<0
        {
            c=K[o]; // take current
            L="R"; // say we are going right
            c.d=++c.d%6; // turn right
            A(); // go!

            L="L"; // say we are going left
            c.d=(c.d+4)%6; // turn left
            A(); // go!

            L="F"; // say we - you get the picture
            c=K[o];
            c.p+=new[]{~w,1-w,2,1+w,w-1,-2}[c.d%6]; // look up direction of travel (~w = -w-1)
            A();
        }

        // check if we visited the end
        Q.WriteLine(n>0?"Invalid maze!":T[-n]); // if n<0, then we found the end, so spit out the corresponding route, otherwise, the maze is invlida
    }
}

এই সাইটে আমার বেশিরভাগ গ্রাফ-অনুসন্ধানগুলির মতো, আমি সি # স্ট্রাক্টগুলির ভাল ব্যবহার করছি, যা আক্ষরিক মানের সাথে তুলনা করতে ডিফল্ট।

Answer 6

পাইথন 2, 703 বাইট

অন্যান্য দুটি সংস্করণ হিসাবে ভাল না, তবে কমপক্ষে এটি haha ​​কাজ করে। Mগোলকধাঁধা সেট ।

যেহেতু মাইজগুলি সমাধান করার আমার কোনও অভিজ্ঞতা নেই, এটি কেবল একটি নিষ্ঠুর শক্তি পদ্ধতির দ্বারা যায়, যেখানে এটি এমন সমস্ত সমাধান খুঁজে পাবে যা এটির নিজের উপর দিয়ে ক্রসিংয়ের সাথে জড়িত না can এটি সংক্ষিপ্ততমগুলির থেকে মোড়গুলি গণনা করে এবং তারপরে সংক্ষিপ্ত ফলাফলটি বেছে নেয়।

z=zip;d=z((-1,1,-2,2,-1,1),(-1,-1,0,0,1,1));E=enumerate;D={};t=tuple;o=list;b=o.index
for y,i in E(M.split('\n')):
 for x,j in E(o(i)):
  c=(x,y);D[c]=j
  if j=='S':s=c
  if j=='E':e=c
def P(s,e,D,p):
 p=o(p);p.append(s);D=D.copy();D[s]=''
 for i in d:
  c=t(x+y for x,y in z(s,i))
  if c not in p and c in D:
   if D[c]=='E':L.append(p+[c])
   if D[c]=='+':P(c,e,D,p)
def R(p):
 a=[0,1,3,5,4,2];h=d[0];x=p[0];s=''
 for c in p[1:]:
  r=t(x-y for x,y in z(c,x));n=0
  while h!=r:n+=1;h=d[a[(b(a,b(d,h))+1)%6]]
  s+=['L'*(6-n),'R'*n][n<3]+'F';x=t(x+y for x,y in z(x,h))
 return s
L=[];P(s,e,D,[])
try:l=len(min(L))
except ValueError:print"Invalid maze!"
else:print min([R(i)for i in L if len(i)==l],key=len)

অগোছালো সংস্কৃত সংস্করণ:

maze = """
     0 0 0 0
    0 + 0 + 0
   0 0 0 + + 0
  0 + 0 + 0 + 0
 0 0 + + 0 0 + 0
0 0 + 0 + 0 0 + 0
 E 0 + 0 0 + + 0 
  + + 0 + 0 + 0
   0 0 0 0 0 +
    + 0 + + +
     0 S 0 0
     """
directions = [(-1, -1), (1, -1),
              (-2, 0), (2, 0),
              (-1, 1), (1, 1)]


maze_dict = {}
maze_lines = maze.split('\n')
for y, row in enumerate(maze_lines):
    if row:
        for x, item in enumerate(list(row)):
            coordinates = (x, y)
            maze_dict[coordinates] = item
            if item == 'S':
                start = coordinates
            elif item == 'E':
                end = coordinates

list_of_paths = []


def find_path(start, end, maze_dict, current_path=None):
    if current_path is None:
        current_path = []
    current_path = list(current_path)
    current_path.append(start)
    current_dict = maze_dict.copy()
    current_dict[start] = '0'

    for direction in directions:
        new_coordinate = (start[0] + direction[0], start[1] + direction[1])

        if new_coordinate in current_path:
            pass

        elif new_coordinate in current_dict:
            if current_dict[new_coordinate] == 'E':
                list_of_paths.append(current_path + [new_coordinate])
                break
            elif current_dict[new_coordinate] == '+':
                find_path(new_coordinate, end, current_dict, current_path)


find_path(start, end, maze_dict)


def find_route(path):

    heading_R = [0, 1, 3, 5, 4, 2]
    heading = (-1, -1)
    current_pos = path[0]
    current_heading = directions.index(heading)
    output_string = []
    for coordinate in path[1:]:
        required_heading = (coordinate[0] - current_pos[0], coordinate[1] - current_pos[1])

        count_R = 0
        while heading != required_heading:
            count_R += 1
            heading_index = directions.index(heading)
            heading_order = (heading_R.index(heading_index) + 1) % len(heading_R)
            heading = directions[heading_R[heading_order]]

        if count_R:
            if count_R > 3:
                output_string += ['L'] * (6 - count_R)
            else:
                output_string += ['R'] * count_R

        output_string.append('F')
        current_pos = (current_pos[0] + heading[0], current_pos[1] + heading[1])
    return ''.join(output_string)


routes = []
try:
    min_len = len(min(list_of_paths))
except ValueError:
    print "Invalid maze!"
else:
    for i in list_of_paths:
        if len(i) == min_len:
            routes.append(find_route(i))

    print 'Shortest route to end: {}'.format(min(routes, key=len))

Comments

আপনি প্রতিস্থাপন করতে পারেন if heading != required_heading: while heading != required_heading: শুধু সঙ্গেwhile heading != required_heading:

— জে Atkin

হ্যাঁ ধন্যবাদ হাহা, আমি গল্ফযুক্ত সংস্করণটি করার সময় কিছুটা লক্ষ্য করেছি, কেবলমাত্র মূল কোডটি আপডেট করেনি, আমি এখনই কিছুটা করব কারণ আমি আরও কয়েকটি চরিত্রের শেভ করতে পেরেছি

— পিটার

নিস! (15 চর মিনিট ভরাট করে)

— জে আত্কিন

<এটি একটি অচেনা HTML ট্যাগটি কোন likey, তাই দঃপূঃ।>

— CalculatorFeline