रिवर्स एरो भूलभुलैया को हल करें

14

यह एक "तीर भूलभुलैया" है:

  v      < 
>     v    
      >  ^ 
>         v
^ <       *

*निशान स्थान है जहाँ आप खत्म हो जाएगा। आपका लक्ष्य यह पता लगाना है कि भूलभुलैया कहाँ से शुरू होती है (इसलिए, रिवर्स भूलभुलैया)। इस मामले में, यह >दूसरी पंक्ति में पहला है ।

  v------< 
S-+---v  | 
  |   >--^ 
>-+-------v
^ <       *

ध्यान दें कि सभी तीरों का उपयोग किया जाना चाहिए। यह भी ध्यान दें कि आप मान सकते हैं कि लाइनें रिक्त स्थान के साथ समान लंबाई में गद्देदार होंगी।

आपके प्रोग्राम को भूलभुलैया को किसी भी उचित तरीके से इनपुट करना चाहिए (एक फ़ाइल, संदेश बॉक्स, आदि से स्टड), हालांकि भूलभुलैया पूरी तरह से बरकरार होना चाहिए। उदाहरण के लिए, आप कॉमा द्वारा अलग की गई लाइनों को इनपुट नहीं कर सकते हैं; इनपुट बिल्कुल भूलभुलैया होना चाहिए।

आपको किसी भी उचित तरीके से भूलभुलैया की शुरुआत का उत्पादन करना होगा। उदाहरण के लिए, आप कर सकते थे

  • उत्पादन शुरू के निर्देशांक
  • प्रारंभ के साथ प्रतिस्थापित तीर के साथ पूरे भूलभुलैया का उत्पादन किया S
  • प्रारंभ तीर को हटाने के अलावा सभी तीर के साथ पूरे भूलभुलैया का उत्पादन (व्हाट्सएप बरकरार!)
  • आदि।

जब तक आप अपने आउटपुट से बता सकते हैं कि कौन सा तीर प्रारंभ तीर है, तो ठीक है। उदाहरण के लिए, का एक आउटपुट

"0"
"2"

नई कहानियों और उद्धरणों की परवाह किए बिना, ठीक है, क्योंकि आप अभी भी बता सकते हैं कि शुरुआत कहां थी।

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

code-golf 
— Doorknob
स्रोत
क्या यह मान लेना उचित है कि प्रत्येक तीर के पास केवल एक अन्य तीर है जो इसे इंगित करता है? ऐसा कोई उदाहरण नहीं है जहां कई शुरुआती बिंदु हो सकते हैं?
— डैनी
क्या "चक्रव्यूह की शुरुआत" एक ऐसा तीर है जिससे एक दूसरे के तीर को एक बार देखा जाता है? दूसरे शब्दों में डैनी के प्रश्न + धारणा कोई छोर नहीं हैं।
— शियोना
3
"आप कॉमा द्वारा अलग की गई लाइनों को इनपुट नहीं कर सकते, इनपुट बिल्कुल भूलभुलैया होना चाहिए।" यह एक अनावश्यक प्रतिबंध की तरह लगता है के बाद से "वास्तव में उलझन" पहले से ही है वास्तविक सीमांकित पंक्तियों के बीच नई पंक्तियों से। एक से अधिक परिसीमन को प्राथमिकता क्यों दें?
— जोनाथन वान मैट्रे
1
@ डॉकोर्नोब यह उचित है, क्योंकि कोई भी सैद्धांतिक रूप से "सीमांकक" में संपूर्ण संपीड़ित समाधान को एनकोड कर सकता है। हालांकि, मुझे संदेह है कि प्रतिबंध कुछ भाषाओं के खिलाफ एक निश्चित भाषाई पूर्वाग्रह का परिचय देता है। क्या होगा यदि नियम "इनपुट पंक्तियों को आपकी पसंद के किसी एक चरित्र द्वारा सीमांकित किया जा सकता है । सभी पंक्तियों को एक ही वर्ण द्वारा सीमांकित किया जाना चाहिए ।" मुझे लगता है कि ऊपरी सीमा उपयोगी है क्योंकि यह एक डोमेन स्थापित करता है जिसके भीतर आपके कार्यक्रम को काम करना चाहिए ।
— जोनाथन वान मैट्रे
1
यही कारण है कि सिर्फ अर्थ यह है कि, उदाहरण के लिए, में @Peter की ओर इशारा करते है , नहीं । जब मैं आज कंप्यूटर पर वापस घर आऊंगा तो अधिक सामान संपादित करूँगा। >v^>v^
— दरवाज़े

जवाबों:

4

गोल्फस्क्रिप्ट, 55 बाइट्स

:&,,{&=42>},.{.&="><^v"?[1-1&n?~.~)]=:d;{d+.&=32=}do}%-

ऑनलाइन डेमो

मान लेता है कि सभी इनपुट लाइनों को एक ही लंबाई के रिक्त स्थान के साथ गद्देदार किया जाता है और नए सिरे से अलग किया जाता है। इनपुट स्ट्रिंग की शुरुआत से प्रारंभ तीर के बाइट ऑफसेट को आउटपुट करता है (उदाहरण के 12लिए चुनौती में भूलभुलैया)।

विशेष रूप से, यह कार्यक्रम उन सभी तीरों के बाइट ऑफ़सेट को ढूंढता है जिनके पास कोई अन्य तीर नहीं है जो उन्हें इंगित करता है (यह मानते हुए कि सभी तीर एक तीर या एक लक्ष्य को इंगित करते हैं; यदि यह सत्य नहीं है तो अजीब व्यवहार हो सकता है)। डिफ़ॉल्ट रूप से, यदि ऐसे कई तीर हैं (जो, प्रति युक्ति, वैध इनपुट में संभव नहीं होना चाहिए), तो उनके ऑफ़सेट को बस आउटपुट में संक्षिप्त किया जाएगा। यदि आप चाहते हैं, तो आप n*उन्हें कार्यक्रम को इसके बजाय नए सिरे से अलग करने के लिए अपील कर सकते हैं ।

टिप्पणियों के साथ डी-गोल्फ संस्करण:

:&                     # save a copy of the input string in the variable "&"
,, { &= 42> },         # make a list of the byte offsets of all arrows 
.                      # duplicate the list and apply the following loop to it:
{
  .                    # make a copy of the original offset...
  &=                   # ...and get the corresponding character in the input
  "><^v" ?             # map the arrow character to integers 0 to 3, and...
  [ 1 -1 &n?~ .~) ]=   # ...map these to +1, -1, -len-1 or +len+1, where len is the...
  :d;                  # ...length of the first input line, and save result as "d"
  { d+ . &= 32= } do   # add d to the byte offset until another non-space is found
} %
-                      # subtract the resulting list of target offsets from the
                       # original list of arrow offsets; this should leave exactly
                       # one offset, which is left on the stack for output
— इल्मरी करोनें
स्रोत
1
यदि आप इनलाइन करते हैं तो आप 3 चार्ट बचा सकते हैं w।
— हॉवर्ड
@ हावर्ड: हुह, तो मैं कर सकता हूँ। धन्यवाद! नाम बदलने के लिए किया था zके लिए &, एक अतिरिक्त स्थान की आवश्यकता होगी, से बचने के लिए, हालांकि। OTOH, ?~.~)एक बहुत अच्छा स्माइली बनाता है। :-)
— इल्मरी करोनें
5

GolfScript ( 101 100 बाइट्स)

n/:g,,{:&g=:r,,{&1$r='^v<>*'?70429 3base 2/=++}/}%{,4=},.{2<}%:&\{2/~\{[~2$~@+(@@+(\]&1$?)!}do\;}%^`

आउटपुट उस रूप में है [[x y]]जहां को-ऑर्डिनेट दोनों 0-आधारित हैं।

ऑनलाइन डेमो

प्रसंस्करण दो चरणों में होता है: पहला चरण भूलभुलैया को [x y dx dy]टुपल्स की एक सरणी में बदल देता है ; दूसरा चरण प्रत्येक तीर / तारांकन को तीर / तारांकन के लिए इंगित करता है। (तारांकन खुद को इंगित करने के लिए माना जाता है)। समस्या की परिभाषा के अनुसार, वास्तव में एक तीर है जो इस नक्शे के परिणाम में नहीं है, और यही समाधान है।

— पीटर टेलर
स्रोत
जब आप यह पोस्ट कर रहे थे तब मैं अपना उत्तर चिपका रहा था। हमारे पास एक ही विचार था, लेकिन आप इसे सफलतापूर्वक पूरा करने में कामयाब रहे। अच्छा है!
— वीरोस
@PeterTaylor मैं यह नहीं देख सकता कि यह मामले को सही ढंग से इंगित करता है जो टिप्पणियों में उल्लिखित है।
— हावर्ड
@ हावर्ड, मुझे नहीं पता कि वह मामला क्या है। स्पष्टीकरण मांगेंगे।
— पीटर टेलर
क्या आप कृपया अपने इनपुट और आउटपुट का एक उदाहरण पोस्ट करेंगे?
— डेविड एफसी
@DavidCarraher, ऑनलाइन डेमो देखें। स्टड के माध्यम से ;'STUFF'आपूर्ति का अनुकरण करता है STUFF।
— पीटर टेलर
2

गणितज्ञ 491 323

टिप्पणियों के साथ अपुष्ट

प्रक्रिया खत्म ("*") से शुरू होती है, उस तीर को ढूंढती है जो उसे इंगित करता है, और शुरुआत तक पहुंचने तक।

समारोह, एफ [भूलभुलैया]।

(* positions of the arrowheads *)
aHeads[a_]:=Position[m,#]&/@{"^","v",">","<"}

(* position of the final labyrinth exit*)
final[a_]:=Position[a,"*"][[1]];


(* find arrowheads that point to the current location at {r,c} *)
aboveMe[{r_,c_},a_]:=Cases[aHeads[a][[2]],{r1_,c}/;r1<r]
belowMe[{r_,c_},a_]:=Cases[aHeads[a][[1]],{r1_,c}/;r1>r]
rightOfMe[{r_,c_},a_]:=Cases[aHeads[a][[4]],{r,c1_}/;c1>c]
leftOfMe[{r_,c_},a_]:=Cases[aHeads[a][[3]],{r,c1_}/;c1<c]

(*find the precursor arrowhead*)
precursor[{loc_,a_,list_:{}}]:=

(* end the search when the precursor has already been traversed or when there is no precursor *)
Which[MemberQ[list,loc],list,
loc=={},list,True,


(* otherwise find the next precursor *)

अग्रदूत [{Flatten [{aboveMe [loc, a], नीचेMe [loc, a, rightOfMe [loc, a], leftOfMe [loc, a]}, 2], a, Prepend [सूची, loc]}]]

(* return the path through the maze from start to finish *)
f[maze_]:= precursor[{final[maze[[1]]],maze[[1]]}]

golfed

f@z_:=Module[{p,h,m=z[[1]]},h@a_:=Position[a,#]&/@{"^","v",">","<","*"};
  p[{v_,a_,j_:{}}]:=Module[{r,c,x=Cases},{r,c}=v;
  Which[MemberQ[j,v],j,v=={},j,True,
  p[{Flatten[{x[h[a][[2]],{r1_,c}/;r1<r],x[h[a][[1]],{r1_,c}/;r1>r],
  x[h[a][[4]],{r,c1_}/;c1>c],x[h[a][[3]],{r,c1_}/;c1<c]},2],a,Prepend[j,v]}]]];
  p[{Position[m,"*"][[1]],m}]]

उदाहरण

उलझन। प्रत्येक ऑर्डर की गई जोड़ी में सेल की पंक्ति और स्तंभ होते हैं। उदाहरण के लिए {2, 3} पंक्ति 2, कॉलम 3 पर सेल को दर्शाता है।

maze=Grid[Normal@ SparseArray[{{5, 5} -> "*",{1, 2} -> "v", {1, 5} -> "<",{2, 1} -> ">",
   {2, 3} -> "v",{3, 3} -> ">", {3, 5} -> "^",{4, 1} -> ">", {4, 5} -> "v",{5, 1} -> "^", 
   {5, 2} -> "<",{_, _} -> " "}]]

भूल भुलैया

इनपुट

f[maze]

आउटपुट : शुरू से अंत तक का रास्ता।

{{2, 1}, {2, 3}, {3, 3}, {3, 5}, {1, 5}, {1, 2}, {5, 2}, {5, 1}, { 4, 1}, {4, 5}, {5, 5}}

— DavidC
स्रोत
आपका इनपुट प्रारूप गलत है - "इनपुट बिल्कुल भूलभुलैया होना चाहिए"।
— दरवाज़े
इनपुट अब भूलभुलैया ही है।
— डेविड फेयर
मैंने कोड का पालन नहीं किया है, लेकिन जिस तरह से आपने "इनपुट अब भूलभुलैया है" को हल कर दिया है, वह प्रफुल्लित करने वाला है! +1 ... "STDIN सार्वभौमिक है" में विश्वासियों की संख्या आश्चर्यजनक है।
— डॉ। बेलिसरियस
मुझे खुशी है कि आपने इनपुट समस्या के समाधान की सराहना की।
— डेविड एफसी
1

मुझे लगता है कि मुझे इसे हल करने का एक अच्छा तरीका मिला, लेकिन मैं इसे गोल्फ में चूसने के लिए हुआ। मुझे लगता है कि यह कम हो सकता है, इसलिए मैं अपने विचार की व्याख्या करने जा रहा हूं ताकि अन्य लोग इसका उपयोग कर सकें यदि उन्हें यह अच्छा लगता है।

यदि प्रत्येक तीर का उपयोग किया जाना चाहिए, तो सभी तीरों को एक अन्य तीर द्वारा इंगित किया जाएगा, एक को छोड़कर, यही हमारा समाधान है।

इसका मतलब है कि हमें वास्तव में भूलभुलैया को पीछे की तरफ नहीं खेलना है, लेकिन, ऊपरी-बाएँ से शुरू करके, हमें बस हर एक के लिए निकटतम बिंदुवार तीर की जाँच करने की आवश्यकता है। यह बड़े mazes के लिए एक वास्तविक दर्द है (क्योंकि आपको सभी चार दिशाओं की जांच करने की आवश्यकता नहीं है, लेकिन सिर्फ एक)।

यहाँ मेरा समाधान है:

PHP, 622 बाइट्स

$h=fopen("a.txt","r");$b=0;while(($z=fgets($h))!==false){$l[$b]=str_split($z,1);$b++;}$v=array("^","<","v",">");$s=array();for($i=0;$i<count($l);$i++){for($j=0;$j<count($l[0]);$j++){if(in_array($l[$i][$j],$v)){switch($l[$i][$j]){case"^":$c=$i-1;while($l[$c][$j]==" ")$c--;$s[]=$c.",".$j;break;case"v":$c=$i+1;while($l[$c][$j]==" ")$c++;$s[]=$c.",".$j;break;case"<":$c=$j-1;while($l[$i][$c]==" ")$c--;$s[]=$i.",".$c;break;case">":$c=$j+1;while($l[$i][$c]==" ")$c++;$s[]=$i.",".$c;break;}}}}for($i=0;$i<count($l);$i++){for($j=0;$j<count($l[0]);$j++){if(in_array($l[$i][$j],$v)){if(!in_array($i.",".$j,$s)){echo$i.",".$j;}}}}

Ungolfed:

$h=fopen("a.txt","r");
$b=0;
while(($z=fgets($h))!==false) {
    $l[$b]=str_split($z,1);
    $b++;
}
//Input ends here
$v = array("^","<","v",">");
$s = array();
//Here i check every arrow, and save every pointed one in $s
for($i=0;$i<count($l);$i++){
    for($j=0;$j<count($l[0]);$j++){
        if(in_array($l[$i][$j],$v)){
            switch($l[$i][$j]) {
                case "^":
                    $c=$i-1;
                    while ($l[$c][$j]==" ")
                        $c--;
                    $s[]=$c.",".$j;
                    break;
                case "v":
                    $c=$i+1;
                    while ($l[$c][$j]==" ")
                        $c++;
                    $s[]=$c.",".$j;
                    break;
                case "<":
                    $c=$j-1;
                    while ($l[$i][$c]==" ")
                        $c--;
                    $s[]=$i.",".$c;
                    break;
                case">":
                    $c=$j+1;
                    while ($l[$i][$c]==" ")
                        $c++;
                    $s[]=$i.",".$c;
                    break;
            }
        }
    }
}
//I check if the arrow is in $s. If not, we have a solution.
for($i=0;$i<count($l);$i++){
    for($j=0;$j<count($l[0]);$j++){
        if (in_array($l[$i][$j],$v)){
            if (!in_array($i.",".$j,$s)){
                echo$i.",".$j;
            }
        }
    }
}
— Vereos
स्रोत
1

PHP - 492 बाइट्स

$r=split("\n",$m);$h=count($r);foreach($r as &$k)$k=str_split($k);$l=count($r[0]);$e=strpos($m,"*")+1-$h;$a=$x=$e%$l;$b=$y=floor(($e-$x)/$l);do{$c=0;for(;--$a>=0;){if($r[$b][$a]==">"){$x=$a;$c++;}if($r[$b][$a]!=" ")break;}$a=$x;for(;--$b>=0;){if($r[$b][$a]=="v"){$y=$b;$c++;}if($r[$b][$a]!=" ")break;}$b=$y;for(;++$a<$l;){if($r[$b][$a]=="<"){$x=$a;$c++;}if($r[$b][$a]!=" ")break;}$a=$x;for(;++$b<$h;){if($r[$b][$a]=="^"){$y=$b;$c++;}if($r[$b][$a]!=" ")break;}$b=$y;}while($c>0);echo "$x-$y";

यह समाधान बताता है कि मानचित्र स्थानीय चर में पाया जा सकता है $m। मेरे पास सबसे छोटी विधि जो गुजरने के लिए है $_GET: $m=$_GET['m'];14 बाइट्स पर। पढ़ने की स्पष्टता के लिए चर में नक्शे के साथ एक ungolfed संस्करण नीचे दिया गया है।

$m=<<<EOT
  v      < 
>     v    
      >  ^ 
>         v
^ <       * 
EOT;

$r=split("\n",$m);
$h=count($r);
foreach($r as &$k)
    $k=str_split($k);
$l=count($r[0]);

$e=strpos($m,"*")+1-$h;

$a=$x=$e%$l;
$b=$y=floor(($e-$x)/$l);
do{
$c=0;
for(;--$a>=0;)
    {
        if($r[$b][$a]==">"){$x=$a;$c++;}
        if($r[$b][$a]!=" ")break;
    }
$a=$x;
for(;--$b>=0;)
    {
        if($r[$b][$a]=="v")
            {
                $y=$b;
                $c++;
            }
        if($r[$b][$a]!=" ")break;

    }
$b=$y;
for(;++$a<$l;)
    {
        if($r[$b][$a]=="<")
            {
                $x=$a;
                $c++;
            }
        if($r[$b][$a]!=" ")break;
    }
$a=$x;
for(;++$b<$h;)
    {
        if($r[$b][$a]=="^")
            {
                $y=$b;
                $c++;
            }
        if($r[$b][$a]!=" ")break;
    }
$b=$y;
}while($c>0);
echo "$x-$y";
— योदा
स्रोत
1

के, 281 277 258

{{$[&/x in*:'{{~"*"=x 1}{(s;k . s;k;s:*1_w@&(k ./:w:{{x@&x in y}[(*:'{(x[1]@x 0;x 1)}\[x;(z;y)]);i]}[(h!b,b,a,a:#k:x 2)m;(h!(0 1+;0 -1+;1 0+;-1 0+))m:x 1;x 0])in"*",h:"><v^")}\(x;y;z;x)}[*x;y .*x;y];*x;.z.s[1_x]y]}[i@&~(x ./:i::,/(!#x),/:\:!b::#*x)in" *";x]}

यहाँ एक पहले वाला, अनगुल्ड वर्जन है

solve:{[x]
    //j - indices of all possible starting points
    //i - every index
    j::i@&~(x ./:i::,/(!a:#x),/:\:!b:#*x) in " *";

    h::">v<^";

    //d - dictionary mapping each directional character to
    //    increment/decerement it needs to apply to the x/y axis
    d::h!((::;1+);(1+;::);(::;-1+);(-1+;::));

    //e - dictionary mapping each directional character to
    //    the maximum number of moves it should make in a 
    //    given direction
    e::h!b,a,b,a;

    //f - function to produce the indices of each point that is 
    //    passed once we move in a certain direction from a 
    //    certain index
    f::{{x@&x in y}[(last'{(x[0];x[0]@'x 1)}\[x;(y;z)]);i]};

    //g - function that, given a starting and a direction,
    //    moves in that direction until hitting another directional
    //    character. It then moves in the new direction etc. until
    //    it reaches the end point -- *
    g::{[x;y;z]
        {[x]
            q:x 0;m:x 1; k:x 2;
            w:f[e m;d m;q];
            s:*1_w@&(k ./:w)in h,"*";
            m:k . s;
            (s;m;k;s)}\[{~"*"=x 1};(x;y;z;x)]};

    // recursive function that starts at the first possible starting point
    // and plots its way to the end. If all other potential starting points
    // have been touched in this path, then this is the correct starting point.
    // else, recursively call the function with the next possible starting point
    :{$[min "b"$j in last'g[*x;y . *x;y];*x;.z.s[1_x;y]]}[j;x]
  }

x y0 आधारित सूचकांकों के साथ प्रारंभिक बिंदु लौटाता है ।

k)maze
"  v      < "
">     v    "
"      >  ^ "
">         v"
"^ <       *"
k)solve maze
1 0
— tmartin
स्रोत
1

पायथन 422

with open("m.txt","r") as f:m=f.read().split("\n")
p=[(v.find("*"),p) for p,v in enumerate(m) if "*" in v][0]
g=[]
def f(a):
    x,y=b,c=a
    for p,i in enumerate((lambda x:[l[x] for l in m])(x)):
        if i in "^>v<" and((p<y and i=="v")or(p>y and i=="^")):return b,p
    for p,i in enumerate(m[y]):
        if i in "^>v<" and((p<x and i==">")or(p>x and i=="<")):return p,c
while True:
    z=f(p)
    if z in g:break
    else:g.append(z);p=z
print p

इनपुट नामक एक फाइल में है m.txt। आउटपुट है, (x, y)लेकिन यदि आप अंतिम प्रिंट स्टेटमेंट को बदल देते हैं print g, तो आउटपुट एक सूची होगी, [(x, y), (x, y), ...]जिसमें अंत से शुरू होने तक सभी चरणों के साथ होगा ।

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