> <> (비밀 한 프로그래밍 언어) 의 코드를 통해 수영하는 사랑하는 물고기 는 자연 환경에서 제거되었습니다. 이 변경으로 인해 예전 방식으로 움직일 수 없었습니다. 토 로이드 움직임이었던 것은 단순한 왼쪽에서 오른쪽 움직임으로 제한되었습니다. 그러나> <> 프로그램은 마치 물고기가 마치 물고기를 통해 이동할 수있는 것처럼 작성되었습니다. > <> 프로그램을 선형화하는 프로그램을 작성하는 것은 프로그래머 여러분의 임무입니다. 그리고 가능한 적은 바이트로 수행하십시오. 물고기는 매우 큰 기억이 없습니다.

> <>의 움직임

> <>에서 움직임은 환상적이며 한 번에 한 문자입니다. 이것은 물고기 (포인터)가 줄의 끝에서 처음으로 다시 줄 바꿈 될 수 있음을 의미합니다. > <>에서 물고기는 대부분의 포인터가 움직이는 방식과 달리 위에서 아래로, 아래에서 위로, 오른쪽에서 왼쪽으로 움직일 수 있습니다. 따라서이 운동 패턴은 유효합니다.

>>>^  >>>v
   >>>^  v

그리고 무한 루프에서 끝날 것입니다.

물고기는 최대 길이 (행 길이)와 높이가 행 수와 동일한 격자로 이동합니다.

물고기가 어떻게 움직이는 지 어떻게 알 수 있습니까? 이 명령은 이동 방향 벡터를 변경합니다 (예 : (-1,0)오른쪽에서 왼쪽으로).

Command | Direction Change
---------------------------
   >    | (1,0) (default)
   <    | (-1,0)
   ^    | (0,1)
   v    | (0,-1)
   /    | (x,y) -> (y,x)
   \    | (x,y) -> (-y,-x)
   |    | (x,y) -> (-x,y)
   _    | (x,y) -> (x,-y)
   #    | (x,y) -> (-x,-y)
   ;    | (0,0)

언급 한 바와 같이, 물고기는 왼쪽에서 오른쪽으로, 즉 방향 벡터로 움직이기 시작합니다 (1,0). 물고기는 명령이 위에서 언급 한 방향 변경 기 중 하나와 일치하면보고 첫 번째 명령부터 시작하여 명령 구문 분석을 시작합니다.

가 표시되면 물고기가 움직이지 ;않고 프로그램이 종료됩니다.

입력

입력은 STDIN을 통해 제공되는 유효한 (예 : 무한 반복되지 않는) 프로그램입니다. 원하는 경우 파일을 읽을 수도 있습니다. 각 프로그램의 행은 반드시 같은 길이 일 필요 는 없습니다 .

입력은 문자열로 제공되며, 줄 바꿈은 프로그램의 각 줄을 구분합니다.

프로그램은 반복되지 않습니다. 또한 항상로 종료됩니다 ;.

산출

출력은 프로그램이 선형화됩니다. 즉, 물고기가 프로그램을 "정상적으로"실행했는지 확인할 수있는 모든 문자 (방향 변경자를 포함)를 반환해야합니다. 이 경로에있는 모든 문자입니다 ;.

입력에 길이가 다른 선이 있고 물고기가 가장 긴 선의 길이보다 짧은 선을 따라 움직이면 마치 마치 물고기가 공간 위로 움직이는 것처럼 취급해야합니다 (테스트 사례 참조).

> <>에 익숙한 사람은 방향 전환기가 이동을 수행 할 수있는 유일한 방법이 아니라 단순성을 위해 입력 을 이동에 영향을 미치는 유일한 방법 인 것처럼 취급합니다 .

규칙

1. 표준 허점 적용
2. 당신은 전체 프로그램이나 기능을 작성할 수 있습니다
3. 입력은 STDIN 또는 파일을 통해 줄 바꿈 ( \n)으로 구분 된 프로그램 행을 포함하는 문자열로 제공됩니다.
   • 이유 내에서 입력을 다르게 취할 수 있습니다 (특정 종류의 입력을 염두에두면 언제든지 문의하십시오). 공백으로 입력을 채울 수 없으므로 선 길이가 일치합니다.
   • 유연한 입력에 대해서는 이 메타 게시물을 참조하십시오 . 게시의 의미에서 일반적인 합의는 가능한 한 융통성이 있어야합니다.
4. 출력은 STDOUT을 통해 단일 문자열이거나 함수에 의해 리턴됩니다 (선택한 내용에 따라 규칙 2 참조)

테스트 사례

v     >v
>abcv//;
gfed<^ih

v>abcv<defghi^//>v;



v     >v
>abcv//;
gfed<^

v>abcv<defg  ^//>v;


abcdef;

abcdef;


abcd|;

abcd|dcba;


abcd#;

abcd#dcba;


abcd\;
    _

abcd\_\dcba;


^;
>abcde/
 ^jihg<

^ >abcde/ <ghij^a;


;

;

로다 , 405 393 392 391 371 366 361 236 234 232 230 223 200 바이트

F f{L=f()|[#_]|sort|tail
c=""x=0
y=0
X=1
Y=0{l=f[y]l.=[" "]*(L-#l)c=l[x]a=X
[c]
C=indexOf(c,`><v^/\|_#`)X=[1,-1,0,0,-Y,Y,-X,X,-X,X][C]Y=[0,0,1,-1,-a,a,Y,-Y,-Y,Y][C]x+=X
x=x%L
y+=Y
y=y%#f}until[c=";"]}

온라인으로 사용해보십시오!

출력을 확인하십시오!

설명 (오래됨)

F f{                          /* Declares a function F with parameter f */
                              /* Takes a 2D array of single-char Strings as f */
L =                           /* L contains the value of the length of the longest line*/
    f()                       /* Push the contents each element of f to the stream; this pushes each line*/
        | [#_]                /* Pull a line and push its length to the stream*/
               |sort|tail     /* Sort it and get the last value (the largest one) */
c=""                          /* c contains the value of the current char that is being processed */
x=0; y=0                      /* x and y contain the position of the fish */
X=1; Y=0                      /* X and Y contain the direction of the fish */
{ ... }while [c != ";"]       /* While c is not `;` do: */
l=f[y]                        /*  l is the line (row) the fish is at */
c=" " if [x >= #l]            /*  If x is more than or equal to the line's length, set c to a space (so that we don't need to pad spaces to the array at the beginning)*/
else c = l[x]                 /*  Else set c to the character a position x of l*/
[c]                           /*  Push c to the output stream; ie prints c without a trailing newline*/
a = X                         /*  a preserves the value of X before analysing c */
C = indexOf(c,`><v^/\|_#`)    /*  Simple enough */
X=[1,-1,0,0,-Y,Y,-X,X,-X,X][C]/*  Map each value of C to their respective X-direction in the array */
                              /*  If c cannot be found in `><v^/\|_#` then it will be given the value of -1, or in other words, the -1th element of an array its last element */
Y=[0,0,1,-1,-a,a,Y,-Y,-Y,Y][C]/*  Do the same thing for Y */
x += X                        /*  Change the x-pos by the X-direction */
x = x%L                       /*  Wrap around the right edge */
y += Y                        /*  Do the same for y */
y=y%#f                        /*  But wrap around the bottom instead */
x+=L if[x<0]                  /*  Wrap around the left */
y+=#f if[y<0]                 /*  Wrap around the top */
}

편집

• %x 또는 y가 경계를 넘는 지 확인 하는 대신 @fergusq 덕분에 10 바이트가 절약 되어 2 개 이상의 길을 열었습니다!
• 사용하는 `\`대신"\\"
• c=""두 번째 줄로 이동 한 다음 줄 바꿈을 제거했습니다.
• 줄을 단일 문자 배열로 변환하는 것이 처음이 아닌 루프로 변환되었습니다 (Python 답변에서 영감을 얻음)
• 괄호 구문을 사용했습니다 while(@fergusq 덕분에).
• a=Xif 문 밖으로 이동
• 가장 긴 줄의 길이를 찾는 더 짧은 방법을 찾은 @fergusq에게 감사드립니다.
• if 문 대신 파이썬 구문과 같은 배열 구문을 사용하여 많은 바이트를 절약했습니다.
• 공백을 채운 코드를 제거했지만 대신 <<>가 움직일 때 공백이 추가됩니다.
• @fergusq 덕분에 버그 감사와 한 캐릭터 골퍼
• 2 바이트를 절약하기 위해 코드 +1의 끝 부분을 제거 indexOf하고 재구성 한 코드
• 물건을 움직여 2 바이트를 절약했습니다 (다시 @fergusq 덕분에)
• 다른 패딩 공간 방법을 사용하여 @fergusq 덕분에 1 바이트를 절약했습니다.
• until[c=";"]대신 에 사용하여 1 바이트를 저장했습니다while[c!=";"]
• @fergusq의 힌트 덕분에 공백을 채우는 루프를 제거하고 l.=[" "]*L
• 프로그램의 왼쪽과 위쪽 가장자리를 감싸는 if 문을 제거하여 20 바이트 이상 절약

파이썬 2 262 243 237 235 234 233 231 221 219 218 217 바이트

다음과 같이 입력을받습니다. ['<line_1>', '<line_2>', ...]

i=input()
q=max(map(len,i))
i=[k+' '*q for k in i]
x=y=k=0
j=1
o=''
while';'not in o:r=[1,-1,-j,-k,0,0];o+=i[y][x];l='><#\\v^/|_'.find(o[-1]);a=(r+[k,-j,j])[l];k=([k,-k,k,j]+r)[~l];j=a;x=(x+j)%q;y=(y-k)%len(i)
print o

온라인으로 사용해보십시오!

@math_junkie 덕분에 -19 바이트-@ThisGuy 덕분에
-6 바이트- 변수
로 추출 max(map(L,i))하여 -2 바이트 (이론적으로 두 번 사용되기 때문에).
횟수를 줄이면 -1 바이트가 i[y][x]나타납니다.
-1 바이트를 사용 하여 출력에서 일부 '\x00'를 수행 할 필요 가 없으므로 @KritixiLithos 덕분 에 -10 바이트 대신 -2 바이트를 사용 하여 오른쪽에서 원하는만큼 패딩 할 수 있음을 인식했습니다. 추가 무시한다 (어떤 바이트 변경) 추출 가변 루프 밖에서 때문에 버그를 수정 지금만을 사용하므로 -2 바이트 는 2 개의 추가 바이트를 필요에 재 할당되도록 2 회 사용하여 -2 바이트 대신[1:]o[1:]
\0\x00


len
while';'not in owhile o[-1]!=';'o=''대신을 사용 합니다 o='\0'. 이것은 2 바이트를 절약 할뿐만 아니라 기술적으로 실제로 유효하지 않은 선행 null 바이트를 제거합니다.

설명

i = input()                       # Takes input as an array of strings
q = max(map(len,i))               # Finds the width of the longest line
i = [k + ' ' * q for k in i]      # Makes sure everything is at least that width
x = y = k = 0                     # Set the point to (0, 0). Set the vertical motion to 0
j = 1                             # Set the horizontal motion to 1
o = '\0'                          # Initialize the output to a null byte (this is output as nothing, so it doesn't actually affect output)
while o[-1] != ';':               # While the last character in the output is not ';' (this is why the output needs to be initialized with something, otherwise o[-1] gives an index error)
    r = [1,-1,-j,-k,0,0]          # Some of the vertical and horizontal coordinates correspond in opposite order
    o += i[y][x]                  # Add the current character to the output
    l = '><#\\v^/|_'.find(o[-1])  # Find the index of the current character here (or -1 if it's just a regular character)
    a = (r + [k, -j, j])[l]       # The fancy array contains the horizontal movement for each control character
    k = ([k, -k, k, j] + r)[~l]   # The fancy array contains the vertical movement for each control character. Using ~l to get the right index, because r has the values backwards
    j = a                         # a was a placeholder because otherwise k would not be correct
    x = (x + j) % q               # Adjust the pointer position
    y = (y - k) % len(i)          # Adjust the pointer position
print o                           # Print the output after the loop is finished

루비 274 200 187 183

운동량 배열을 삭제하여 몇 문자 만 더 면도했습니다 d.

나는 이것을 자랑스럽게 생각합니다. 이것은 재미 있었다! 문자열 배열을 받아서 적절한 문자열을 반환합니다.

->a{o,x,y='',-1,0
b,m=1,0
(o+=n=a[y=(y+m)%a.size][x=(x+b)%(a.map &:size).max]||' '
b,m=([1]+[0,-1,0]*2+[1,-m]+[-b,m,b]*2+[-m,-b,-m,b,m])[2*('><^v/\\|_#'.index(n)||9),2])until o[?;]
o}

아래에 댓글을 달았습니다.

->a{
    o,x,y='',-1,0  # o is the output string, x and y are the positions in the array
    b,m=1,0          # b and m are the direction of momentum
    until o[?;] # until o contains a semicolon
        w=(a.map &:size).max # w is the max width of the arrays
        h=a.size    # h is the height of arrays
        x=x+b % w   # increment cursor position
        y=y+m % h
        o+=n=a[y][x]||' ' # add the new char (or " ") to o
        ix=2*('><^v/\\|_#'.index(n)||9) # find the index new char in the string
        b,m=([1]+[0,-1,0]*2+[1,-m]+[-b,m,b]*2+[-m,-b,-m,b,m])[ix,2] # set momentum to its new value
    end
    o # return output string
}

PHP 7, 291260 바이트

for($m=max(array_map(strlen,$z=explode("
",$argv[1]))),$y=0,$r=count($z)-$v=1;';'!=$c;[$v,$w]=[[$v,1,-1,0,0,-$w,$w,-$v,$v,-$v][$o=strpos(' ><^v/\|_#',$c)],[$w,0,0,-1,1,-$v,$v,$w,-$w,-$w][$o]],$x+=$m+$v,$x%=$m,$y=0<=($y+=$w)?$r<$y?:$y:$r)echo$c=$z[$y][$x]??' ';

자바 스크립트, 242 236 235 231 220 바이트

a=>{n=a.length;m=x=y=p=0;a.map(g=>m=(w=g.length)<m?m:w);q=1,o="";while((t=a[y][x]||" ")!=";")o+=t,h=q,q=[q,1,0,p,-q][(s=">v\\| <^/_#".indexOf(t)+1)%5]*(r=s>5?-1:1),p=[p,0,1,h,p][s%5]*r,x=(x+q+m)%m,y=(y+p+n)%n;return o+t}

온라인으로 사용해보십시오!