화살표는 어디에 있습니까?


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예제에서는 +방향을 바꾸지 않고 이동할 수 있음을 보여줍니다 .) 그렇지 않으면 좋은 도전입니다. :)
Martin Ender

테스트 사례 중 하나를 변경했습니다. 나는 그것이 처음에했던 것처럼 정답을 얻는 데만 발생 하는 프로그램을 작성하는 것을 더 어렵게 할 것이라고 생각합니다 .
El'endia Starman

화살촉이 방향을 바꿀 수 있습니까 ---^? 다시 말해, B 예에서 B가 첫 번째 행에 머물 수 있습니까?
edc65

@ edc65 Q 예제에서와 같은 의미입니까?
Downgoat

1
화살촉은 '+'에 연결되지 않습니다. 그러나 'S'에 연결할 수 있습니까? 가 S>a유효?
edc65

답변:


9

자바 스크립트 (ES6) 195 245 231 242 246 250

Edit4 이제 단일 재귀 함수입니다. 아마 더 골프를 칠 수 없다

Edit3 직선 테스트 및 T 기능으로 병합 된 화살촉 테스트, S 및 H 기능 제거.

Edit2 개정 및 이후 :( 후 이 설명

편집하다CJammers가 들어 오기를 기다리면서 약간의 개선 사항을 하여 약간의 숯을 여기 저기 잘라

EcmaScript 6 호환 브라우저에서 아래 스 니펫을 테스트하십시오. (Firefox에서 작동합니다. Chrome에 여전히 스프레드 연산자가 없습니다. ...)

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, 264263249240235 바이트

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

내 노트 중 일부에 흩어져 있습니다.

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).
Charles가 아닙니다.

또한 코드 골프에서는 for(;;)루프가 가장 효율적입니다. 이 경우에는 잘못된 것일 수 있지만 시도해보십시오.
Charles가 아닙니다.

1
테스트 케이스는 a<-+S->b나는 그것이 제공해야한다고 생각 b으로 만 유효한 화살표가 +로 시작하지 않습니다
edc65

그 문제를 해결하고 f를 한 줄짜리로 바꿨습니다. 그건 그렇고,이 문제에 대한 당신의 접근 방식이 정말 마음에 들었습니다.
bopjesvla

참고 사항 : 배열 이해를 정말로 좋아하지만 더 이상 EcmaScript 표준 버전에는 없습니다. 나는 당신에게 anser 태그를 달 것을 제안합니다 JavaScript 2016(문제가 아닌 타당하고 좋은 답변이 될 것입니다)
edc65

3

VBA Excel 2007, 894 바이트

글쎄요, 이것보다 훨씬 더 잘 시작되었습니다. 나는 내 논리에 결함이 있다고 생각하고 내 논리의 일부를 재정렬하면 많은 양의 바이트를 절약 할 수 있었지만 너무 많은 시간이 이미 이것에 빠졌다 = P

이에 대한 입력은 현재 사용중인 시트의 A 열입니다. 이 방법은 Excel에 멋진 격자가 있고 모든 것을 분리하여 더 명확하게 수행하는 것을 볼 수 있다는 사실을 사용합니다.

Sub m()그냥 붙여 넣은 데이터를 A 열에서 가져 와서 char로 나눕니다. 만약 우리가 수정 된 입력을 허용한다면 미로를 셀당 1 개의 문자로 미리 포맷하면 제거하여 몇 바이트를 절약 할 수 있습니다sub m()

최대 99 행 x 27 자 크기의 미로를 Excel에 붙여 넣습니다. 더 큰 미로를 원한다면 범위를 999 행과 ZZ 열로 늘리기 위해 2 바이트 만 추가하십시오.

또한 엑셀 시트가 VBA 답변에 유효한 "표준 입력"인지 여부에 대한 판사 호출이 필요할 수 있습니다. 그렇지 않은 경우 VBA 멀티 라인 입력 VIA에 즉시 창을 제공하는 것은 거의 불가능합니다.

이 코드를 실행하려면이 코드를 Excel 모듈에 붙여 넣고 미로를 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, 당신 말이 맞아요. 좋은 자리!
El'endia Starman

여러 줄 문자열을 input()어떻게 사용할 수 있습니까? 나에게 문제가있다.
The_Basset_Hound

@The_Basset_Hound : 줄 바꿈을 수동으로 입력 할 수 없습니다. 한 번에 전체 내용을 복사하여 붙여 넣어야합니다.
El'endia Starman

@ El'endiaStarman 복사 / 붙여 넣기 중이며 여전히 첫 번째 줄만 읽습니다.
The_Basset_Hound

2

펄 5

이 솔루션은 다른 솔루션보다 길었습니다.
골프 후에도. 그래서 이것은 ungolfed 버전입니다.
커서를 따라갈 수 있도록 맵을 인쇄합니다.

작동 방식? 각 단계에서 스택에 가능한 이동을합니다. 그리고 스택에 아무것도 남지 않거나 솔루션을 찾을 때까지 계속 실행됩니다.
모든 솔루션을 찾고 가장 가까운-> 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;
}

테스트

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

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

2
제목을보고 "Perl"과 "5 bytes로 완료"라고 생각했습니다. 심장 마비
Conor O'Brien

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 바이트

Javascripters에 축하드립니다! 현상금을 주었지만 여기에 내가 가진 것이 있습니다. May / May는 모든 경우에 작동하지는 않지만 실제로 +아는 한 시작 화살표와 화살촉을 처리합니다 . 심지어 검색을 포함하지 않았다 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

APL 버전을보고 싶습니다 https://www.youtube.com/watch?v=a9xAKttWgP4의

시작으로, 벡터화 된 Julia 솔루션은 1 : 0.3을 APL 또는 J로 변환 할 수 있다고 생각합니다. L x K 화살표를 나타내는 문자열 R이 필요합니다. 먼저 기호 행렬을 문자열 "\ 0 \ x18 \ fH \ t]] \ x1cI"의 문자가 이진 확장 된 작은 3x3 행렬의 행렬로 변환합니다. 예를 들어 '+'는 형태 변경으로 인코딩됩니다 ([0, digits (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

그건 그렇고, 나는 "또 다른 +가 인접 해있을 수 있지만 화살표는 우선적으로-또는 | 벡터 접근 방식에 단점이 있습니다. 어쨌든, 나는 그것을 무시했습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.