तीर इशारा कहाँ है?


32

तीर इशारा कहाँ है?

इस चुनौती में, आपका लक्ष्य एक तीर का पालन करना है और उस चरित्र को आउटपुट करना है जो इसे इंगित कर रहा है।

उदाहरण

इनपुट:

d  S------+    b
          |     
          |     
   c      +--->a

आउटपुट: a


इनपुट:

S-----+---a->c
      |       
      V       
      b       

आउटपुट: b

तीर इंगित नहीं कर रहा है cक्योंकि यह द्वारा विभाजित है a, जिसका अर्थ है कि यह मार्ग कभी भी तीर के सिर की ओर नहीं जाता है।


इनपुट:

a S      s
  |      |
  V      V
  b      c

आउटपुट: b


इनपुट:

d s<+S+--V
    |||  Q
    -++   

आउटपुट: Q

यह रास्ता शुरू होता है S, नीचे जाता है, दाईं ओर जाता है, दाईं ओर जाता है, फिर Q पर ध्यान देता है। मार्ग सीधे से नहीं Sजाता है +


इनपुट:

d s-+   +-S  +--+
    +-->b |  |  |
     |  | +--+  |
     +--+ A<----+

आउटपुट: A


इनपुट:

S-----+   
|     +-^ 
+---+->B  
    +---^ 

आउटपुट: B

क्योंकि वैध रेखा कभी भी व्हाट्सएप चरित्र को जन्म नहीं देगी। एकमात्र लाइन जो व्हॉट्सएप के चरित्र को जन्म नहीं देती है वह एक की ओर ले जाती हैB

चुनौती

इनपुट एक बहु-पंक्ति स्ट्रिंग होगा जिसमें आपको उस वर्ण को ढूंढना होगा जिसे तीर इंगित कर रहा है। केवल एक मान्य तीर होगा। मान्य तीर केवल अल्फ़ान्यूमेरिक वर्णों को छोड़कर इंगित करेगा S। एक लाइन कभी खुद को ओवरलैप नहीं करेगी। जैसे-|-

  • S (पूंजी) का प्रतिनिधित्व करता है जहां तीर शुरू होता है।
  • - एक क्षैतिज रेखा का प्रतिनिधित्व करता है
  • +अक्ष में संभावित परिवर्तन का प्रतिनिधित्व करता है। एक मान्य तीर कभी भी शुरू नहीं होगा +
  • | एक ऊर्ध्वाधर रेखा का प्रतिनिधित्व करता है
  • > < V ^इनमें से कोई भी तीर सिर का प्रतिनिधित्व करता है। ये एक से कनेक्ट कभी नहीं होगा +

Sस्ट्रिंग में केवल एक ही होगा । इनपुट को एक आयत (जरूरी नहीं कि एक वर्ग) होने के लिए गद्देदार किया जाएगा।


1
"यह कभी भी आसन्न नहीं दिखाई देगा S।" शायद "इस तीर का पहला चरित्र नहीं होगा।" (क्योंकि Qउदाहरण में +आसन्न है S।) " +अक्ष में परिवर्तन का प्रतिनिधित्व करता है।" बेहतर हो सकता है " +अक्ष में परिवर्तन में संभव का प्रतिनिधित्व करता है।" (क्योंकि Bउदाहरण से पता चलता है कि आप +बिना बदलते दिशा में आगे बढ़ सकते हैं ।) अन्यथा, अच्छी चुनौती। :)
मार्टिन एंडर

मैंने आपके एक परीक्षण के मामले में बदलाव किया। मुझे लगता है कि यह लिखने प्रोग्राम हैं जो केवल करने के लिए कठिन कर देगा हो , सही जवाब पाने के लिए की तरह मेरा पहली बार में किया था।
एल'एंडिया स्ट्रैटन

क्या तीर का सिर दिशा बदल सकता है, अर्थात ---^? दूसरे शब्दों में, यदि बी उदाहरण में, क्या बी पहली पंक्ति में रह सकता है?
edc65

@ edc65 आप Q उदाहरण में पसंद करते हैं?
डाउनगेट

1
एक तीर का सिर '+' से जुड़ा नहीं होगा। लेकिन क्या इसे 'S' से जोड़ा जा सकता है? है S>aमान्य है?
edc65

जवाबों:


9

जावास्क्रिप्ट (ईएस 6), 195 245 231 242 246 250

Edit4 अब, एक एकल पुनरावर्ती कार्य। शायद अधिक गोल्फ नहीं हो सकता

Edit3सीधी रेखा के लिए टेस्ट और तीर फ़ंक्शन के लिए परीक्षण T फ़ंक्शन में विलय कर दिया गया, S और H फ़ंक्शंस निकाले गए।

EDIT2 संशोधित और लंबे समय तक :( के बाद इस इस स्पष्टीकरण

संपादित करेंछोटे सुधारों को , कुछ चर को इधर-उधर काट कर, CJammers के कदम बढ़ाने की प्रतीक्षा में

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें। (फ़ायरफ़ॉक्स पर काम करता है। क्रोम अभी भी प्रसार ऑपरेटर को याद कर रहा है ...)

f=(s,p=s[I='indexOf']`S`,w=m=[o=~s[I]`
`,1,-o,-1],q,v,r)=>m.some((d,i)=>{for(v=w,q=p;r=s[q+=d],r=='|-'[i&1];)v='+';return r=r==v?f(s,q,v):/\w/.test(r=s[q+m['^>V<'[I](r)]])&&r},s=[...s],s[p]=0)&&r


// Less golfed
// U: recursive scan function
U = (s, // input string or array
     p = s.indexOf`S`, // current position, defult to position of S into string (at first call)
     w = // char to compare looking for a '+', at first call default to garbage as you can't follow '+' near 'S'
       m = [// m, global, offset array form movements. 
         o = ~s.indexOf`\n`, // o, global, row line +1 (negated)
         1, -o, -1], // complete the values of m array
     // m and o are assigned again and again at each recursive call, but that is harmless
     // params working as local variables as the function is recursive
     q,v,r) => 
{
   s = [...s]; //convert to array, as I have to modify it while scanning
     //the conversion is done again and again at each recursive call, but that is harmless
   s[p] = 0; // make s[p] invalid to avoid bouncing back and forth
  
   m.some( // for each direction, stop if endpoint found
      (d,i ) => {
        q = p; // start at current position, then will add the offset relative to current direction
        v = w; // for each direction, assign the starting value that can be '+' or garbage at first call
        // compare char at next position with the expected char based on direction (- for horiz, | for vertical)
        // in m array, values at even positon are vertical movements, odds are horizontal
        while (s[q+=d] == '|-'[i&1]) // while straight direction, follow it until it ends
          v = '+'; // from now on '+' is allowed
        r = s[q];
        if (r == v) // check if found a '+'
          r = U(s, q, v) // recursive call to check all directions from current position
        else
        {
          r = s[q + m['^>V<'.indexOf(r)]], // pointed char in p (if arrowhead, else will return undefined)
          r = /\w/.test(r) && r // if alphanumeric, then we found our result - else r = false
        }  
        return r; // returning r to .some; if r is truthy, the .some function will stop
      }
   ) 
   return r; // result if found, else undefined or null
}

// TEST
out=x=>O.innerHTML+=x.replace(/</g,'&#60;')+'\n'

// Using explicit newlines '\n' to ensure the padding to a rectangle
;[
 ['z<+S-+->a','a'] 
,['a<-+S>b','b']
,['S-+\n  |\n  V\n  a','a']
,['a S      s\n  |      |\n  V      V\n  b      c  ','b']
,['S-----+  \n|     +-^  \n+---+->B \n    +---^','B']
,['d s<+S+--V\n    |||  Q\n    -++    ','Q']
,['d s-+   +-S  +--+\n    +-->b |  |  |\n     |  | +--+  |\n     +--+ A<----+  ','A']
,['S-----+   \n|     +-^ \n+---+->B  \n    +---^ ','B']
].forEach(t=>{
  r=f(t[0])
  k=t[1]
  out('Test '+(r==k?'OK':'Fail')+'\n'+t[0]+'\nResult: '+ r +'\nCheck: '+k+'\n')
})
<pre id=O></pre>


5

जावास्क्रिप्ट 2016, 264 263 249 240 235 234 बाइट्स

इसे फ़ायरफ़ॉक्स में चलाएं:

m=l=>{o=(q,e)=>q.indexOf(e)
s=[-1,1,c=~o(l,`
`),-c]
f=i=>!o[i]&(!(r=l[i+s[o(a="<>^V",o[i]=c=l[i])]])|r<"0"|r>"z"|r=="S"||alert(s=r))&&c&&[for(j of (c!='+'?a:"")+"-|+")for(k of s)l[i+k]!=j|~o(l[i]+j,k*k>1?"-":"|")||f(i+k)]
f(o(l,'S'))}

m(`d s-+   +-S  +--+
    +-->b |  |  |
     |  | +--+  |
     +--+ A<----+`)

मेरे कुछ नोट्स में बिखरे हुए:

m=l=>{o=(q,e)=>q.indexOf(e) //shorthand for indexOf
s=[-1,1,c=o(l,`
`)+1,-c] // get all possible moves in 1d
w=[] // to keep track of the already-visited indexes
f=i=>{c=l[i] // current character
if(!w[i]&&c) // only continue if the index wasn't already visited and we aren't out of bounds
{r=l[i+s[o(a="<>^V",w[i]=c)]] // sets w[i] to a truthy value and maps the arrows to their corresponding moves in s. If c is an arrow, r is the character it's pointing to.
if(!r||r<"0"||r>"z"||r=="S"||alert(r)) // if r is an alphanumeric character that isn't r, show it and return. If not, continue.
for(j of (c!='+'?a:"")+"-|+") // iterate over all characters to make sure plusses are checked out last, which is necessary at the start.
for(k of s) // check out all possible moves
l[i+k]!=j|| // check if the move leads to the character we're looking for
~o(l[i]+j,k*k>1?"-":"|")|| // make sure the current nor that character goes against the direction of the move
f(i+k)}} // make the move, end of f
f(o(l,'S'))} // start at S

आप कुछ बिट्स को करने से बचा सकते हैं o = 'indexOf'और तब कर q[o](e)सकते हैं जब आप इसका उपयोग करना चाहते हैं।
नहीं कि चार्ल्स

इसके अलावा, कोड गोल्फ में, for(;;)लूप आमतौर पर सबसे कुशल होते हैं। इस मामले में गलत हो सकता है, लेकिन इसे आज़माएं।
नहीं कि चार्ल्स

1
टेस्ट केस a<-+S->bमुझे लगता है कि यह bकेवल देना चाहिए , क्योंकि एक वैध तीर एक +
edc65 के

फिक्स्ड और एक लाइनर में बदल गया। मैं वास्तव में इस समस्या के लिए आपके दृष्टिकोण को पसंद करता हूं, वैसे।
bopjesvla 2

एक ओर ध्यान दें: मैं वास्तव में सरणी समझ से प्यार करता हूं, लेकिन यह अब EcmaScript मानक के किसी भी संस्करण में नहीं है। मैं आपको JavaScript 2016aser को टैग करने का सुझाव देता हूं (एक वैध और अच्छे उत्तर पर ध्यान दें, इसके साथ समस्या नहीं है)
edc65

3

VBA Excel 2007, 894 बाइट्स

खैर यह एक बहुत अच्छा शुरू हुआ तो यह समाप्त हो गया। मुझे लगता है कि मेरा तर्क त्रुटिपूर्ण है और अगर मैं अपने कुछ तर्क को दोहराता, तो मैं एक टन बाइट बचा सकता था, लेकिन बहुत समय पहले ही इस में डूब गया था = P

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

Sub m()बस कॉलम A से कॉपी पेस्ट डेटा को ले रहा है और उसे चार करके तोड़ रहा है। यदि हम एक संशोधित इनपुट की अनुमति देते हैं तो यदि आप भूलभुलैया को 1 चार्ट प्रति सेल में सुधारते हैं तो आप कुछ बाइट्स को हटाकर बचा सकते हैंsub m()

Excel में किसी भी आकार को 27 पंक्तियों तक 99 पंक्तियों तक एक भूलभुलैया में चिपकाएँ। यदि आप बड़ा mazes चाहते हैं तो इसकी केवल 2 अतिरिक्त बाइट्स को 999 पंक्तियों और ZZ कॉलम के दायरे को बढ़ाने के लिए

एक VBA उत्तर के लिए एक्सेल शीट वैलिड "स्टैंडर्ड इनपुट" है या नहीं, इसके लिए न्यायाधीशों की आवश्यकता हो सकती है। यदि नहीं, तो VBA मल्टी-लाइन इनपुट VIA को तत्काल विंडो देना बहुत असंभव है

इस कोड को चलाने के लिए इस कोड को एक एक्सेल मॉड्यूल में पेस्ट करें, एक भूलभुलैया को A1 में पेस्ट करें और चलाएं sub j()

Sub m()
For k=1 To 99
u=Cells(k,1).Value
For i=1 To Len(u)
Cells(k,i+1).Value=Mid(u,i,1)
Next
Next
Columns(1).Delete
End Sub
Sub j()
m
With Range("A:Z").Find("S",,,,,,1)
h .row,.Column,0
End With
End Sub
Sub h(r,c,t)
If t<>1 Then l r-1,c,1,0,r
If t<>-1 Then l r+1,c,-1,0,r
If t<>2 Then l r,c-1,2,0,r
If t<>-2 Then l r,c+1,-2,0,r
End Sub
Sub l(r,c,y,p,i)
On Error GoTo w
q=Cells(r,c).Text
If q="V" Or q="^" Or q="<" Or q=">" Then
p=1
End If
f="[^V<>]"
If p=1 And q Like "[0-9A-UW-Za-z]" Then
MsgBox q: End
Else
If q="^" Then p=1: GoTo t
If q="V" Then p=1: GoTo g
If q="<" Then p=1: GoTo b
If q=">" Then p=1: GoTo n
Select Case y
Case 1
t:If q="|" Or q Like f Then l r-1,c,y,p,q
Case -1
g:If q="|" Or q Like f Then l r+1,c,y,p,q
Case 2
b:If q="-" Or q Like f Then l r,c-1,y,p,q
Case -2
n:If q="-" Or q Like f Then l r,c+1,y,p,q
End Select
If q="+" And i<>"S" Then h r,c,y*-1
p=0
End If
w:
End Sub

2

पायथन 3, 349 बाइट्स

उह, इतने सारे बाइट्स।

S=input().split('\n')
Q=[[S[0].find('S'),0]]
D=[[1,0],[0,1],[-1,0],[0,-1]]
A='-S--++-'
B='|S||++|'
P='>V<^'
i=0
while D:
 a,b=Q[i];i+=1
 j=S[b][a]
 for x,y in D:
  try:
   c,d=a+x,b+y;k=S[d][c]
   if k in P:
    z=P.index(k);print(S[d+D[z][1]][c+D[z][0]]);D=[]
   if (j+k in A and x)+(j+k in B and y)*~([c,d]in Q):Q+=[[c,d]]
  except IndexError: pass

अनिवार्य रूप से एक चौड़ाई-पहली खोज। बोनस: यह वास्तव में उपयोग करने के बजाय इनायत से बाहर निकलता है exit(), जो वैसे भी लंबा है।


यह खोज बाधाओं के लगभग आधे को लागू नहीं करता है, आदमी। ideone.com/OzoWRX
bopjesvla

@bopjesvla: Drat, आप सही कह रहे हैं। अच्छी जगह!
एल'एंडिया स्ट्रैटन

आप एक बहुस्तरीय स्ट्रिंग का उपयोग कैसे कर सकते हैं input()? यह मेरे लिए समस्याग्रस्त है।
The_Basset_Hound

@The_Basset_Hound: आप मैन्युअल रूप से नईलाइनों में प्रवेश नहीं कर सकते; आपको एक ही बार में पूरी चीज़ को कॉपी-पेस्ट करना होगा।
एलेंडिया स्ट्राटन

@ El'endiaStarman मैं कॉपी / पेस्ट कर रहा हूं और यह अभी भी केवल पहली पंक्ति को पढ़ रहा है ऐसा लगता है।
The_Basset_Hound

2

पर्ल ५

समाधान अन्य समाधानों की तुलना में अधिक लंबा निकला।
गोल्फिंग के बाद भी। तो यह ungolfed संस्करण है।
यह नक्शे को प्रिंट करता है ताकि आप कर्सर का अनुसरण कर सकें।

जिस तरह से यह काम करता है? प्रत्येक चरण में यह स्टैक पर संभावित चालें डालता है। और यह तब तक चलता रहता है जब तक कि स्टैक पर कुछ भी नहीं बचा है, या एक समाधान नहीं मिला है।
यह आसानी से सभी समाधान खोजने और निकटतम चुनने के लिए संशोधित किया जा सकता है -> जबकि (@_) {...

while(<>){
  chomp;
  @R=split//;
  $j++;$i=0;
  for(@R){$nr++;$i++;$A[$i][$j]=$_;if('S'eq$_){$x=$i;$y=$j}}
  $xm=$i,if$xm<$i;$ym=$j;
}
push(@_,[($x,$y,'S',0)]);
$cr='';
while(@_&&''eq$cr){
 @C=pop@_;
 ($x,$y,$d,$n)=($C[0]->[0],$C[0]->[1],$C[0]->[2],$C[0]->[3]);
 $c=$A[$x][$y];
 $A[$x][$y]='.';
 if($c=~m/[S+]/){
    if('L'ne$d&&$A[$x+1][$y]=~m/[+-]/){push(@_,[($x+1,$y,'R',$n+1)])}
    if('D'ne$d&&$A[$x][$y-1]=~m/[+|]/){push(@_,[($x,$y-1,'U',$n+1)])}
    if('R'ne$d&&$A[$x-1][$y]=~m/[+-]/){push(@_,[($x-1,$y,'L',$n+1)])}
    if('U'ne$d&&$A[$x][$y+1]=~m/[+|]/){push(@_,[($x,$y+1,'D',$n+1)])}
 }
 if($c eq'|'){
    if($d ne'U'&&$A[$x][$y+1]=~m/[+|<>^V]/){push(@_,[($x,$y+1,'D',$n+1)])}
    if($d ne'D'&&$A[$x][$y-1]=~m/[+|<>^V]/){push(@_,[($x,$y-1,'U',$n+1)])}
 }
 if($c eq'-'){
    if($d ne'L'&&$A[$x+1][$y]=~m/[+-<>^V]/){push(@_,[($x+1,$y,'R',$n+1)])}
    if($d ne'R'&&$A[$x-1][$y]=~m/[+-<>^V]/){push(@_,[($x-1,$y,'L',$n+1)])}
 }
 if($c=~m/[<>^V]/&&$n<$nr){
    if($c eq'>'&&$A[$x+1][$y]=~m/\w/){$cr=$A[$x+1][$y];$nr=$n}
    if($c eq'<'&&$A[$x-1][$y]=~m/\w/){$cr=$A[$x-1][$y];$nr=$n}
    if($c eq'V'&&$A[$x][$y+1]=~m/\w/){$cr=$A[$x][$y+1];$nr=$n}
    if($c eq'^'&&$A[$x][$y-1]=~m/\w/){$cr=$A[$x][$y-1];$nr=$n}
 }
 print_map()
}
print "$cr\n";
sub print_map {
    print "\033[2J"; #clearscreen
    print "\033[0;0H"; #cursor at 0,0
    for$j(1..$ym){for$i(1..$xm){print (($x==$i&&$y==$j)?'X':$A[$i][$j])}print"\n"}
    sleep 1;
}

परीक्षा

$ cat test_arrows6.txt
S-----+
|     +-^
+---+->B
    +---^

$ perl arrows.pl < test_arrows6.txt
.-----+
.     +-^
......XB
    .....
B

2
मैंने शीर्षक देखा और सोचा "पर्ल" और "5 बाइट्स में किया गया"। दिल का दौरा
कॉनर ओ'ब्रायन

2

PHP संस्करण (टिप्पणियाँ फ्रेंच हैं, क्षमा करें)

<?php
/*
* By Gnieark https://blog-du-grouik.tinad.fr oct 2015
* Anwser to "code golf" http://codegolf.stackexchange.com/questions/57952/where-is-the-arrow-pointing in PHP
*/
//ouvrir le fichier contenant la "carte et l'envoyer dans un array 2 dimmension
$mapLines=explode("\n",file_get_contents('./input.txt'));
$i=0;
foreach($mapLines as $ligne){
    $map[$i]=str_split($ligne,1);
    if((!isset($y)) && in_array('S',$map[$i])){
        //tant qu'à parcourir la carte, on cherche le "S" s'il n'a pas déjà été trouvé.
        $y=$i;
        $x=array_search('S',$map[$i]);
    }
    $i++;
}
if(!isset($y)){
    echo "Il n'y a pas de départ S dans ce parcours";
    die;
}
echo "\n".file_get_contents('./input.txt')."\nLe départ est aux positions ".$map[$y][$x]." [".$x.",".$y."]. Démarrage du script...\n";
$previousX=-1; // Contiendra l'ordonnée de la position précédente. (pour le moment, une valeur incohérente)
$previousY=-1; // Contiendra l'absycede la position précédente. (pour le moment, une valeur incohérente)
$xMax=count($map[0]) -1;
$yMax=count($map) -1;
$previousCrosses=array(); //On ne gardera en mémoire que les croisements, pas l'ensemble du chemin.
while(1==1){ // C'est un défi de codagee, pas un script qui sera en prod. j'assume.
    switch($map[$y][$x]){
        case "S":
            //même fonction que "+"
        case "+":
            //on peut aller dans les 4 directions
            $target=whereToGoAfterCross($x,$y,$previousX,$previousY);
            if($target){
          go($target[0],$target[1]);
            }else{
          goToPreviousCross();
            }
            break;
        case "s":
            goToPreviousCross();
            break;
        case "-":
        //déplacement horizontal
        if($previousX < $x){
          //vers la droite
          $targetX=$x+1;
          if(in_array($map[$y][$targetX],array('-','+','S','>','^','V'))){
        go($targetX,$y);
          }else{
        //On est dans un cul de sac
        goToPreviousCross();
          }
        }else{
          //vers la gauche
          $targetX=$x-1;
          if(in_array($map[$y][$targetX],array('-','+','S','<','^','V'))){
        go($targetX,$y);
          }else{
        //On est dans un cul de sac
        goToPreviousCross();
          }
        }
            break;
        case "|":
        //déplacement vertical
        if($previousY < $y){
          //on descend (/!\ y augmente vers le bas de la carte)
          $targetY=$y+1;
          if(in_array($map[$targetY][$x],array('|','+','S','>','<','V'))){
        go ($x,$targetY);
          }else{
        goToPreviousCross();
          }
        }else{
        //on Monte (/!\ y augmente vers le bas de la carte)
          $targetY=$y - 1;
          if(in_array($map[$targetY][$x],array('|','+','S','>','<','V'))){
        go ($x,$targetY);
          }else{
        goToPreviousCross();
          } 
        }
            break;
    case "^":
    case "V":
    case ">":
    case "<":
      wheAreOnAnArrow($map[$y][$x]);
      break;
    }
}
function wheAreOnAnArrow($arrow){
  global $x,$y,$xMax,$yMax,$map;
  switch($arrow){
    case "^":
      $targetX=$x;
      $targetY=$y -1;
      $charsOfTheLoose=array(" ","V","-","s");
      break;
    case "V":
      $targetX=$x;
      $targetY=$y + 1;
      $charsOfTheLoose=array(" ","^","-","s");
      break;
    case ">":
      $targetX=$x + 1;
      $targetY=$y;
      $charsOfTheLoose=array(" ","<","|","s");   
      break;
    case "<":
      $targetX=$x - 1;
      $targetY=$y;
      $charsOfTheLoose=array(" ",">","|","s");   
      break;
    default:     
      break;
  }
  if(($targetX <0) OR ($targetY<0) OR ($targetX>$xMax) OR ($targetY>$yMax) OR (in_array($map[$targetY][$targetX],$charsOfTheLoose))){
      //on sort du cadre ou on tombe sur un caractere inadapté
      goToPreviousCross();
  }else{
    if(preg_match("/^[a-z]$/",strtolower($map[$targetY][$targetX]))){
      //WIN
      echo "WIN: ".$map[$targetY][$targetX]."\n";
      die;
     }else{
      //on va sur la cible
      go($targetX,$targetY);
     }
  }
}
function whereToGoAfterCross($xCross,$yCross,$previousX,$previousY){

            //haut
            if(canGoAfterCross($xCross,$yCross +1 ,$xCross,$yCross,$previousX,$previousY)){
                return array($xCross,$yCross +1);
            }elseif(canGoAfterCross($xCross,$yCross -1 ,$xCross,$yCross,$previousX,$previousY)){
                //bas
                return array($xCross,$yCross -1);
            }elseif(canGoAfterCross($xCross-1,$yCross,$xCross,$yCross,$previousX,$previousY)){
                //gauche
                return array($xCross-1,$yCross);
            }elseif(canGoAfterCross($xCross+1,$yCross,$xCross,$yCross,$previousX,$previousY)){
                //droite
                return array($xCross+1,$yCross);
            }else{
          //pas de direction possible
          return false;
            }  
}
function canGoAfterCross($xTo,$yTo,$xNow,$yNow,$xPrevious,$yPrevious){
    global $previousCrosses,$xMax,$yMax,$map;
    if(($xTo < 0) OR ($yTo < 0) OR ($xTo >= $xMax) OR ($yTo >= $yMax)){return false;}// ça sort des limites de la carte
    if(
    ($map[$yTo][$xTo]==" ") // on ne va pas sur un caractere vide
    OR (($xTo==$xPrevious)&&($yTo==$yPrevious)) //on ne peut pas revenir sur nos pas (enfin, ça ne servirait à rien dans cet algo)
    OR (($xTo==$xNow)&&($map[$yTo][$xTo]=="-")) //Déplacement vertical, le caractere suivant ne peut etre "-"
    OR (($yTo==$yNow)&&($map[$yTo][$xTo]=="|")) // Déplacement horizontal, le caractère suivant ne peut être "|"
    OR ((isset($previousCrosses[$xNow."-".$yNow])) && (in_array($xTo."-".$yTo,$previousCrosses[$xNow."-".$yNow]))) //croisement, ne pas prendre une direction déjà prise
   ){    
      return false;
    }
    return true;    
}
function go($targetX,$targetY){
    global $previousX,$previousY,$x,$y,$previousCrosses,$map;
    if(($map[$y][$x]=='S')OR ($map[$y][$x]=='+')){
        //on enregistre le croisement dans lequel on renseigne la direction prise et la direction d'origine
        $previousCrosses[$x."-".$y][]=$previousX."-".$previousY;
        $previousCrosses[$x."-".$y][]=$targetX."-".$targetY; 
    }
    $previousX=$x;
    $previousY=$y;
    $x=$targetX;
    $y=$targetY;
    //debug
    echo "deplacement en ".$x.";".$y."\n";   
}
function goToPreviousCross(){
  global $x,$y,$previousX,$previousY,$xMax,$yMax,$previousCrosses;

  /*
  * On va remonter aux précédents croisements jusqu'à ce 
  * qu'un nouveau chemin soit exploitable
  */
  foreach($previousCrosses as $key => $croisement){
    list($crossX,$crossY)=explode("-",$key);
    $cross=whereToGoAfterCross($crossX,$crossY,-1,-1);
    if($cross){
      go($crossX,$crossY);
      return true;
    } 
  }
  //si on arrive là c'est qu'on est bloqués
  echo "Aucun chemin n'est possible\n";
  die;
}

1

हास्केल, 268 बाइट्स

जावास्क्रिप्ट के लिए बधाई! इनाम दिया, लेकिन यहाँ जो मुझे मिला है। मई / सभी मामलों में काम नहीं कर सकते हैं, लेकिन वास्तव में तीर को शुरू करने और तीर को संभालने के लिए +, जहाँ तक मुझे पता है, संभालती है। के लिए खोज भी शामिल नहीं है S, अभी के (0,0)लिए है।

import Data.List
x%m=length m<=x||x<0
a s(x,y)z|y%s||x%(head s)=[]|0<1=b s(x,y)z$s!!y!!x
b s(x,y)z c|g c>[]=filter(>' ')$concat[a s(x+i k,y+i(3-k))k|k<-g c,k-z`mod`4/=2]|0<1=[c]
i=([0,-1,0,1]!!)
g c=findIndices(c`elem`)$words$"V|+S <-+S ^|+S >-+S"
f s=a(lines s)(0,0)0

0

मैं https://www.youtube.com/watch?v=a9xAKttWgP4 की भावना से APL संस्करण देखना चाहूंगा

एक शुरुआत के रूप में, एक वेक्टर जूलिया समाधान जो मुझे लगता है कि इसका अनुवाद 1: 0.3 से एपीएल या जे हो सकता है। यह एक स्ट्रिंग आर लेता है जो एल एक्स के तीर का प्रतिनिधित्व करता है। यह पहले प्रतीकों के मैट्रिक्स को छोटे 3x3 मैट्रिक्स के एक मैट्रिक्स में अनुवाद करता है, जिसके पैटर्न स्ट्रिंग "\ 0 \ x18 \ fH \ t]] \ X1cI" के अक्षरों के द्विआधारी विस्तार हैं। उदाहरण के लिए '+' को आकारबद्ध किया जाता है ([0, अंक (int (')'), 2,8)], 3,3)

  0 2 0
  2 2 2
  0 2 0

इस प्रतिनिधित्व में, पथ 2 के होते हैं और शुरुआती बिंदु से 3 से बाढ़ जाते हैं।

A=zeros(Int,L*3+3,K*3+3)
s(i,j=i,n=2)=A[i:end+i-n,j:end+j-n]
Q=Int['A':'Z';'a':'z']
for k=0:K-1,l=0:L-1
r=R[K*l+k+1]
q=search(b"V^><+S|-",r)
d=reverse(digits(b"\0\x18\fH\t]]\x1cI"[q+1],2,8))
A[1+3l:3l+3,1+3k:3k+3]=2*[d;0]
A[3l+2,3k+2]+=r*(r in Q&&r!='V'&&r!='^')+(1-r)*(r=='S')+3(5>q>0)
end
m=0
while sum(A)>m
m=sum(A)
for i=0:1,j=1:2,(f,t)=[(3,6),(11,15)]
A[j:end+j-2,j:end+j-2]=max(s(j),f*(s(j).*s(2-i,1+i).==t))
end
end
for i=[1,4],k=Q
any(s(1,1,5).*s(5-i,i,5).==11*k)&&println(Char(k))
end

परीक्षा करना,

   R=b"""
       d  S------+    b
                 |     
                 |     
          c      +--->a
       """;

   K=search(R,'\n') # dimensions
   L=div(endof(R),K)


   include("arrow.jl")

a

वैसे, मुझे लगता है कि खंड "एक और + आसन्न हो सकता है, लेकिन तीर को पहले या - या पहले चल रहा होना चाहिए।" एक नुकसान में एक वेक्टर दृष्टिकोण डालता है। वैसे भी, मैंने इसे अनदेखा कर दिया।

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