Mũi tên nhọn ở đâu?


32

Mũi tên nhọn ở đâu?

Trong thử thách này, mục tiêu của bạn là đi theo một mũi tên và xuất ra ký tự mà nó đang trỏ tới.

Ví dụ

Đầu vào:

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

Đầu ra: a


Đầu vào:

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

Đầu ra: b

Mũi tên không chỉ vào cvì nó được chia cho a, có nghĩa là đường dẫn này không bao giờ dẫn đến đầu mũi tên.


Đầu vào:

a S      s
  |      |
  V      V
  b      c

Đầu ra: b


Đầu vào:

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

Đầu ra: Q

Đường dẫn này bắt đầu từ S, đi xuống, sang phải, đi lên, sang phải, sau đó chỉ xuống Q. Lưu ý rằng đường dẫn không đi thẳng từ Sđến +.


Đầu vào:

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

Đầu ra: A


Đầu vào:

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

Đầu ra: B

Bởi vì dòng hợp lệ sẽ không bao giờ dẫn đến một ký tự khoảng trắng. Dòng duy nhất không dẫn đến một ký tự khoảng trắng dẫn đến mộtB

Thử thách

Đầu vào sẽ là một chuỗi nhiều dòng trong đó bạn cần tìm ký tự mà mũi tên đang trỏ vào. Sẽ chỉ có một mũi tên hợp lệ. Mũi tên hợp lệ sẽ chỉ trỏ đến các ký tự chữ và số không bao gồm S. Một dòng sẽ không bao giờ chồng lên chính nó. ví dụ-|-

  • S (vốn) đại diện cho nơi mũi tên bắt đầu.
  • - đại diện cho một đường ngang
  • +đại diện cho một sự thay đổi có thể trong trục. Một mũi tên hợp lệ sẽ không bao giờ bắt đầu với a +.
  • | đại diện cho một đường thẳng đứng
  • > < V ^bất kỳ trong số này đại diện cho đầu mũi tên. Những điều này sẽ không bao giờ kết nối với a +.

Sẽ chỉ có một Strong chuỗi. Đầu vào cũng sẽ được đệm thành hình chữ nhật (không nhất thiết phải là hình vuông).


1
"Điều này sẽ không bao giờ xuất hiện liền kề với a S." Có lẽ nên được đặt lại thành "Đây sẽ không bao giờ là nhân vật đầu tiên của mũi tên." (Bởi vì Qví dụ có một +liền kề với một S.) " +Đại diện cho một sự thay đổi trong trục." có thể tốt hơn là " +đại diện cho một sự thay đổi có thể trong trục." (Vì Bví dụ cho thấy bạn có thể di chuyển qua +mà không thay đổi hướng.) Nếu không, thử thách hay. :)
Martin Ender

Tôi đã thực hiện một thay đổi cho một trong những trường hợp thử nghiệm của bạn. Tôi nghĩ rằng điều đó sẽ làm cho việc viết các chương trình chỉ xảy ra để có câu trả lời đúng, khó như tôi đã làm lúc đầu.
El'endia Starman

Đầu mũi tên có thể thay đổi hướng, tức là ---^? Nói cách khác, nếu trong ví dụ B, B có thể ở hàng đầu tiên không?
edc65

@ edc65 bạn có nghĩa như trong ví dụ Q không?
Hạ cấp

1
Đầu mũi tên sẽ không được kết nối với '+'. Nhưng nó có thể được kết nối với 'S' không? Có S>ahợp lệ không?
edc65

Câu trả lời:


9

JavaScript (ES6), 195 245 231 242 246 250

Edit4 Bây giờ, một hàm đệ quy duy nhất. Có lẽ không thể chơi gôn nhiều hơn

Edit3 Kiểm tra đường thẳng và kiểm tra đầu mũi tên được hợp nhất trong chức năng T, chức năng S và H bị loại bỏ.

Edit2 Revised và lâu hơn :( sau này làm rõ này

Chỉnh sửa các cải tiến nhỏ, cắt một số char ở đây và ở đó, chờ đợi CJammers bước vào

Kiểm tra chạy đoạn mã dưới đây trong trình duyệt tuân thủ EcmaScript 6. (hoạt động trên Firefox. Chrome vẫn thiếu toán tử lây lan ...)

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

JavaScript 2016, 264 263 249 240 235 234 byte

Chạy nó trong Firefox:

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<----+`)

Rải rác trong một số ghi chú của tôi:

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

Bạn có thể tiết kiệm một số bit bằng cách thực hiện o = 'indexOf'và sau đó thực hiện q[o](e)khi bạn muốn sử dụng nó.
Không phải Charles

Ngoài ra, trong golf code, for(;;)các vòng lặp thường hiệu quả nhất. Có thể sai trong trường hợp này, nhưng hãy thử nó.
Không phải Charles

1
trường hợp thử nghiệm a<-+S->bTôi nghĩ rằng nó chỉ nên cung cấp b, vì Một mũi tên hợp lệ sẽ không bao giờ bắt đầu bằng +
edc65

Đã sửa lỗi đó và biến f thành một lớp lót. Tôi thực sự thích cách tiếp cận của bạn đối với vấn đề này.
bopjesvla

Một lưu ý phụ: Tôi thực sự yêu thích việc hiểu mảng, nhưng nó không còn trong bất kỳ phiên bản nào của tiêu chuẩn EcmaScript nữa. Tôi đề nghị gắn thẻ cho bạn JavaScript 2016một câu trả lời (câu trả lời hợp lệ và tốt, không có vấn đề gì với nó)
edc65

3

VBA Excel 2007, 894 byte

Vâng, điều này bắt đầu tốt hơn rất nhiều sau đó nó đã kết thúc. Tôi có cảm giác logic của tôi bị thiếu sót và tôi có thể đã tiết kiệm được hàng tấn byte nếu tôi sắp xếp lại một số logic của mình, nhưng Quá nhiều thời gian đã bị chìm vào điều này rồi = P

Đầu vào cho cái này là Cột A của bất kỳ trang nào bạn đang ở. Phương pháp này sử dụng thực tế là Excel có lưới tốt đẹp này và phá vỡ mọi thứ để bạn có thể thấy những gì nó đang làm rõ ràng hơn.

Sub m()chỉ lấy dữ liệu đã dán Sao chép từ Cột A và phá vỡ nó bằng char. Nếu chúng tôi cho phép đầu vào được sửa đổi thì nếu bạn định dạng trước mê cung thành 1 char cho mỗi ô, bạn có thể lưu một vài byte bằng cách xóasub m()

Dán Mê cung vào Excel bất kỳ kích thước nào lên tới 99 hàng trên 27 ký tự. Nếu bạn muốn mê cung lớn hơn, chỉ có 2 byte bổ sung để tăng phạm vi lên 999 hàng và cột ZZ

Cũng có thể cần một thẩm phán gọi xem Bảng tính Excel có hợp lệ "Đầu vào tiêu chuẩn" cho câu trả lời VBA hay không. Nếu không, không thể cung cấp cho VBA nhiều dòng đầu vào VIA cửa sổ ngay lập tức

Để chạy mã này, chỉ cần dán mã này vào mô-đun Excel, Dán mê cung vào A1 và chạy 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

Python 3, 349 byte

Ugh, rất nhiều byte.

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

Về cơ bản là một tìm kiếm đầu tiên. Tiền thưởng: điều này thực sự thoát ra một cách duyên dáng thay vì sử dụng exit(), dù sao thì lâu hơn.


Điều này không thực hiện khoảng một nửa các hạn chế tìm kiếm, người đàn ông. ideone.com/OzoWRX
bopjesvla

@bopjesvla: Drat, bạn nói đúng. Điểm tốt!
El'endia Starman

Làm thế nào bạn có thể sử dụng một chuỗi multiline với input()? Đó là vấn đề đối với tôi.
The_Basset_Hound

@The_Basset_Hound: Bạn không thể nhập các dòng mới theo cách thủ công; bạn phải sao chép-dán toàn bộ mọi thứ cùng một lúc.
El'endia Starman

@ El'endiaStarman Tôi đang sao chép / dán và dường như nó vẫn chỉ đọc dòng đầu tiên.
The_Basset_Hound

2

Perl 5

Các giải pháp hóa ra lâu hơn các giải pháp khác.
Ngay cả sau khi chơi golf nó. Vì vậy, đây là phiên bản không linh hoạt.
Nó in bản đồ để bạn có thể theo con trỏ.

Cách nó hoạt động? Ở mỗi bước, nó có thể di chuyển trên ngăn xếp. Và nó tiếp tục chạy cho đến khi không còn gì trên ngăn xếp, hoặc một giải pháp được tìm thấy.
Có thể dễ dàng sửa đổi để tìm tất cả các giải pháp và chọn gần nhất -> while (@_) {...

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;
}

Kiểm tra

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

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

2
Tôi thấy tiêu đề và nghĩ "Perl" và "thực hiện trong 5 byte". đau tim
Conor O'Brien

2

Phiên bản PHP (ý kiến ​​là tiếng Pháp, xin lỗi)

<?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

Haskell, 268 byte

Xin chúc mừng các Javascript! Đưa tiền thưởng lên, nhưng đây là những gì tôi nhận được. Có thể / Không thể hoạt động trong mọi trường hợp, nhưng thực sự xử lý các mũi tên bắt đầu từ và đầu mũi tên liên quan đến +es, theo như tôi biết. Thậm chí không bao gồm tìm kiếm S, chỉ là (0,0)bây giờ.

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

Tôi muốn xem phiên bản APL theo tinh thần https://www.youtube.com/watch?v=a9xAKttWgP4

Khi bắt đầu, một giải pháp Julia được vector hóa mà tôi nghĩ có thể được dịch 1: 0,3 sang APL hoặc J. Nó lấy một chuỗi R đại diện cho một mũi tên L x K. Đầu tiên, nó dịch ma trận các ký hiệu thành một ma trận các ma trận 3x3 nhỏ có các mẫu là các mở rộng nhị phân của các chữ cái của chuỗi "\ 0 \ x18 \ fH \ t]] \ x1cI". Ví dụ: '+' được mã hóa dưới dạng định hình lại ([0, chữ số (int (']'), 2,8)], 3,3)

  0 2 0
  2 2 2
  0 2 0

Trong đại diện này, đường dẫn bao gồm 2 và bị ngập 3 điểm từ điểm bắt đầu.

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

Để kiểm tra,

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

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


   include("arrow.jl")

a

Nhân tiện, tôi nghĩ mệnh đề "Another + có thể liền kề nhưng mũi tên nên ưu tiên đi tiếp - hoặc | trước." đặt một cách tiếp cận vector ở một bất lợi. Dù sao, tôi chỉ bỏ qua nó.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.