Con cá yêu dấu bơi qua mã của > <> (một ngôn ngữ lập trình bí truyền) đã được đưa ra khỏi môi trường tự nhiên của nó. Sự thay đổi này đã khiến nó không có khả năng di chuyển theo cách mà nó đã từng sử dụng: những gì từng là chuyển động hình xuyến đã bị hạn chế đối với chuyển động từ trái sang phải đơn giản. Nhưng các chương trình> <> vẫn được viết như thể cá có khả năng di chuyển qua chúng. Nhiệm vụ của bạn là lập trình viên thân yêu, viết một chương trình để tuyến tính hóa một chương trình> <>. Và làm điều đó trong càng ít byte càng tốt; cá không có những kỷ niệm rất lớn

Di chuyển trong> <>

Trong> <>, chuyển động là hình xuyến và mỗi lần một ký tự. Điều này có nghĩa là cá (con trỏ) có thể "quấn" xung quanh từ cuối dòng trở lại từ đầu. Trong> <>, cá cũng có khả năng di chuyển từ trên xuống dưới, từ dưới lên trên và từ phải sang trái, trái ngược với cách mà hầu hết các con trỏ di chuyển. Vì vậy, mô hình chuyển động này sẽ hợp lệ:

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

và nó sẽ kết thúc trên một vòng lặp vô hạn (lặp lại dòng trên cùng một khi nó vượt qua đáy vô hạn).

Cá di chuyển trong một lưới có chiều dài bằng max (chiều dài hàng) và chiều cao bằng số lượng hàng.

Làm thế nào để bạn tìm ra cách cá di chuyển? Các lệnh này thay đổi vectơ hướng di chuyển (ví dụ: (-1,0)từ phải sang trái):

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)

Như đã lưu ý, cá bắt đầu di chuyển từ trái sang phải, tức là với vectơ chỉ hướng (1,0). Con cá bắt đầu phân tích các lệnh bắt đầu bằng lệnh đầu tiên mà nó nhìn thấy và thay đổi hướng của nó nếu một lệnh khớp với một trong những thay đổi hướng đã nói ở trên.

Con cá dừng di chuyển khi nhìn thấy a ;và chấm dứt chương trình.

Đầu vào

Đầu vào sẽ là một chương trình hợp lệ (ví dụ: không lặp vô hạn) được đưa ra thông qua STDIN. Bạn cũng có thể đọc một tập tin nếu bạn muốn. Các dòng của mỗi chương trình sẽ không nhất thiết phải có cùng độ dài.

Đầu vào được đưa ra dưới dạng một chuỗi, với các dòng mới phân tách từng dòng trong chương trình.

Các chương trình sẽ không lặp, điều đó cũng có nghĩa là chúng sẽ luôn chấm dứt với a ;.

Đầu ra

Đầu ra sẽ là chương trình tuyến tính hóa. Đó là, bạn nên trả lại tất cả các ký tự (bao gồm cả bộ thay đổi hướng) mà cá sẽ thấy nếu nó chạy chương trình "bình thường". Đây là tất cả các nhân vật trong đường dẫn đến ;.

Nếu đầu vào có các dòng có độ dài không bằng nhau và cá cuối cùng di chuyển dọc theo một dòng ngắn hơn chiều dài của dòng dài nhất, bạn nên xử lý như thể cá đang di chuyển trên một không gian (xem trường hợp kiểm tra).

Những người quen thuộc với> <> sẽ biết rằng những người thay đổi hướng không phải là cách duy nhất để thực hiện chuyển động trong đó, nhưng vì đơn giản, hãy đối xử với đầu vào như thể họ là cách duy nhất ảnh hưởng đến chuyển động.

Quy tắc

1. Áp dụng sơ hở tiêu chuẩn
2. Bạn có thể viết một chương trình hoặc chức năng đầy đủ
3. Đầu vào được cung cấp thông qua STDIN hoặc một tệp dưới dạng chuỗi chứa các dòng chương trình được phân tách bằng dòng mới ( \n)
   • Bạn có thể lấy đầu vào khác nhau, theo lý do (vui lòng hỏi tôi nếu bạn có một loại đầu vào cụ thể trong đầu). Bạn không thể đệm đầu vào với khoảng trắng để độ dài dòng khớp.
   • Tham khảo bài viết meta này liên quan đến đầu vào linh hoạt. Theo quan điểm của việc đăng bài, sự đồng thuận chung là phải linh hoạt nhất có thể trong lý do.
4. Đầu ra là một chuỗi đơn thông qua STDOUT hoặc được trả về bởi hàm (tùy thuộc vào những gì bạn chọn làm, xem Quy tắc 2)

Các trường hợp thử nghiệm

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;


;

;

Röda , 405 393 392 391 371 366 361 236 234 232 230 223 200 byte

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=";"]}

Hãy thử trực tuyến!

Kiểm tra đầu ra!

Giải thích (lỗi thời)

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 */
}

Chỉnh sửa

• 10 byte được lưu nhờ @fergusq bằng cách sử dụng %thay vì kiểm tra xem x hoặc y có vượt qua ranh giới hay không, mở đường cho 2 người nữa!
• Được sử dụng `\`thay vì"\\"
• Đã chuyển c=""sang dòng thứ hai và sau đó xóa dòng mới theo sau nó
• Đã chuyển đổi các dòng thành mảng ký tự đơn thành các vòng lặp thay vì ở đầu (lấy cảm hứng từ câu trả lời của Python)
• Đã sử dụng cú pháp cú đúp của while(nhờ @fergusq để phát hiện ra điều đó)
• Đã chuyển a=Xra khỏi câu lệnh if
• Cảm ơn @fergusq vì đã tìm ra cách ngắn hơn để tìm độ dài của dòng dài nhất
• Đã sử dụng cú pháp mảng thay vì câu lệnh if (như câu trả lời của Python) để lưu hàng tấn byte
• Đã xóa mã mà không gian được đệm, thay vào đó, các khoảng trắng được thêm vào khi> <> di chuyển dọc
• Đã sửa lỗi cảm ơn và đánh golf một nhân vật nhờ @fergusq
• Đã xóa mã +1ở cuối indexOfvà cấu trúc lại mã để lưu 2 byte
• Đã lưu 2 byte bằng cách di chuyển mọi thứ xung quanh (nhờ @fergusq một lần nữa)
• Đã lưu 1 byte nhờ @fergusq bằng cách sử dụng một phương thức đệm khác
• Đã lưu 1 byte bằng cách sử dụng until[c=";"]thay vìwhile[c!=";"]
• Nhờ một gợi ý từ @fergusq, tôi đã loại bỏ vòng lặp đệm khoảng trống và thay thế nó bằng l.=[" "]*L
• Đã lưu hơn 20 byte bằng cách xóa các câu lệnh if ở cuối bao bọc chương trình quanh các cạnh trái và trên cùng

Python 2, 262 243 237 235 234 233 231 221 219 218 217 byte

Đưa đầu vào là ['<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

Hãy thử trực tuyến!

-19 byte nhờ @math_junkie
-6 byte nhờ @ ThisGuy
-2 byte bằng cách trích xuất max(map(L,i))thành một biến (vì về mặt lý thuyết nó được sử dụng hai lần).
-1 byte bằng cách giảm số lần i[y][x]hiển thị.
-1 byte bằng cách sử dụng '\x00'vì vậy tôi không phải thực hiện [1:]một phần o[1:]trong đầu ra
-2 byte bằng cách sử dụng \0thay vì \x00
-10 byte nhờ @KritixiLithos để nhận ra rằng tôi có thể đệm nhiều như tôi muốn ở phía bên phải vì thêm sẽ bị bỏ qua
(không thay đổi byte) lỗi đã sửa vì biến trích xuất nằm ngoài vòng lặp
-2 byte vì bây giờ tôi chỉ sử dụng len2 lần nên việc gán lại phải mất thêm 2 byte
-2 byte bằng cách sử dụng while';'not in othay vìwhile o[-1]!=';' và sử dụng o=''thay vìo='\0' . Điều này không chỉ tiết kiệm 2 byte mà còn loại bỏ byte null hàng đầu về mặt kỹ thuật không thực sự hợp lệ.

Giải trình

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

Hồng ngọc, 274 200 187 183

Cạo sạch chỉ một vài ký tự bằng cách thả mảng động lượng , d.

Tôi khá tự hào về điều này. Điều này thật thú vị! Nó nhận một mảng các chuỗi và trả về chuỗi thích hợp.

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

Bình luận dưới đây.

->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, 291 260 byte

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 byte

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}

Hãy thử trực tuyến!