通过> <>（一种深奥的编程语言）的代码游泳的心爱的鱼已被带出自然环境。这种变化使它无法像过去那样四处移动：过去的环形运动仅限于简单的从左到右运动。但是仍然编写程序，好像鱼能够通过它们。亲爱的程序员，您的任务是编写程序来线性化> <>程序。并尽可能减少字节数；鱼没有很大的记忆。

在> <>中移动

在> <>中，移动是环形的，一次只能移动一个字符。这意味着鱼（指针）可以从一行的结尾“回到”开头。在> <>中，与大多数指针移动的方式相比，鱼还能够从上到下，从下到上和从右到左移动。因此，此移动方式将是有效的：

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

并以无限循环结束（一旦它越过底部无限循环回到顶部）。

鱼在长度等于max（行长）且高度等于行数的网格中移动。

您如何找出鱼移动的方式？这些命令改变了运动的方向向量（例如，(-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)。鱼会从第一个看到的命令开始解析命令，并在命令匹配上述方向转换器之一时更改其方向。

鱼在看到a时停止移动;并终止程序。

输入值

输入将是通过STDIN给出的有效（例如，非无限循环）程序。如果愿意，您也可以阅读文件。每个节目的线将不一定是相同的长度。

输入以字符串形式给出，换行符分隔程序中的每一行。

程序不会循环，这也意味着它们将始终以终止;。

输出量

输出将线性化程序。也就是说，您应该返回鱼是否“正常”运行程序时看到的所有字符（包括换向器）。这是指向的所有字符;。

如果输入的线长度不等，并且鱼最终沿着比最长线的长度短的线移动，则应将鱼视为在空间上移动（请参见测试用例）。

熟悉> <>的人会知道，方向改变器不是在其中进行移动的唯一方法，但是为了简单起见，将输入视为它们是 影响运动唯一方法。

规则

1. 适用标准漏洞
2. 您可以编写完整的程序或函数
3. 输入是通过STDIN或文件作为字符串提供的，其中包含用换行符分隔的程序行（\n）
   • 在合理的范围内，您可能会采取不同的输入方式（请随时问我是否有特定的输入方式）。您可能无法在输入处加上空格，以使行长匹配。
   • 有关灵活输入，请参阅此 meta帖子。就其发布而言，一般共识应在合理范围内尽可能地灵活。
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 */
}

编辑

• 通过使用@fergusq，节省了10个字节 %而不是检查x或y是否超出边界，这，这为另外2个铺平了道路！
• 用过的 `\`代替"\\"
• 感动 c=""到第二行，然后删除其后的换行符
• 将行到单字符数组的转换移动到循环中，而不是开始时（受Python答案启发）
• 使用了大括号语法 while（感谢@fergusq指出了这一点）
• 移动了 a=X出来的if语句的
• 感谢@fergusq为找到最长行的长度找到了一种更短的方法
• 使用数组语法代替if语句（如Python答案）以节省大量字节
• 删除了填充空格的代码，而是在> <>移动时添加空格
• 修复了一个错误，感谢@fergusq打了一个角色
• 删除+1末尾的indexOf并重组代码以节省2个字节
• 通过移动来节省2个字节（再次感谢@fergusq）
• @fergusq通过使用不同的填充空间方法节省了1个字节
• 使用until[c=";"]代替节省了1个字节while[c!=";"]
• 感谢@fergusq的提示，我删除了填充空格的循环并将其替换为 l.=[" "]*L
• 通过删除将程序环绕在左边缘和上边缘的末尾的if语句，节省了20多个字节

Python 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个字节
-2个字节（提取max(map(L,i))到一个变量中）（因为理论上使用两次）。
通过减少-1字节i[y][x]显示次数。
通过使用-1字节，'\x00'因此我不必在输出中使用 -2字节的[1:]部分，而不必使用 -10字节。感谢@KritixiLithos意识到我可以在右侧填充尽可能多的内容，因为额外的错误将被忽略 （无字节更改）固定的错误，因为提取的变量在循环 -2字节之外，因为现在我仅使用2次，因此重新分配它需要2个额外的字节而不是o[1:]
\0\x00


len
-2字节，while';'not in o而不是while o[-1]!=';'，并使用o=''o='\0'。这不仅节省了2个字节，而且摆脱了技术上实际上无效的前导空字节。

说明

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]??' ';

JavaScript中，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}

在线尝试！