Tôi yêu> <>,> <> là cuộc sống! Langages 2D là tuyệt vời! Trong thử thách này, bạn sẽ phải nói liệu một con đường "tanh" có kết thúc hay không, trong khi chơi golf.

Định nghĩa

Một con đường đầy cá được xây dựng bằng gạch, bao gồm những con đường sau:

v (go down)
> (go right)
^ (go up)
< (go left)
/ (mirror)
\ (mirror)

Bất kỳ nhân vật nào khác (ngoại trừ -|+) có thể được coi là một vật gây xao lãng, như một số bông hoa (hoặc đầu cá) trên biên giới của con đường.

Một con đường luôn bắt đầu ở góc trên bên trái của lưới hình chữ nhật, được phân định bằng -|+các ký hiệu. Con đường có một kết thúc nếu, bằng cách đi theo nó, bạn kết thúc ở một biên giới, nếu không, bạn sẽ bị mắc kẹt trong một con đường vô tận.

Tìm đường trên đường được thực hiện bằng cách làm theo chỉ dẫn được đưa ra bởi v>^<và gương. Một chiếc gương sẽ phản chiếu 90 ° tùy thuộc vào nơi bạn đến. Đây là cách nó hoạt động (sử dụng v>^<để hiển thị hướng):

 ^    ^
>/<  >\<
 v    v
</>  <\>
 ^    ^

Một con đường có thể trông như thế này nếu nó kết thúc:

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+

Một vòng lặp vô hạn:

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

Cụ thể

Một con đường không nhất thiết chỉ bao gồm các hướng dẫn. Không gian hoặc chữ cái có thể được sử dụng để hoàn thành nó. Điều này có nghĩa là bạn phải tiếp tục di chuyển theo cùng một hướng trừ khi bạn vượt qua một nhân vật <v^>-|.

Sẽ luôn có một v>^<trong những góc trên bên trái, <hoặc ^ngụ ý con đường này kết thúc.

Bạn có thể gửi một hàm lấy một chuỗi làm tham số hoặc một chương trình độc lập bằng STDIN / bất cứ điều gì là sự thay thế gần nhất trong ngôn ngữ của bạn.

Nội dung gửi của bạn phải trả lại hoặc in trên các giá trị trung thực / giả mạo STDOUT khi hoàn thành. Giá trị trung thực có nghĩa là con đường có một kết thúc, trong khi sai lầm có nghĩa là nó là một vòng lặp vô hạn.

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

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/ ><>     ^<     |
+--------------------+
    True

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+
    False

+--+
|<v|
|^<|
+--+
    True

+--+
|>v|
|^<|
+--+
    False

+----------+
|v Hello \ |
|\\/\/   / |
| \/\\   \ |
|/  // >\  |
|  ^/\>\\/ |
|\  /\/\/  |
+----------+
    False

+-----+
|>\/\\|
|//\\/|
|\/\\\|
|//\//|
|\/\/ |
+-----+
    True

2 test cases added as suggested by @MartinBüttner
+----+
|v   |
|\\  |
|//\ |
|\\v |
| \/ |
+----+
    False

+----+
|v   |
|\\  |
|//\ |
|\\^ |
| \/ |
+----+
    False

Test case inspired by @ETHproductions
+-------------------------+
|><>                      |
|something smells fishy...|
+-------------------------+
    False

Sơ hở tiêu chuẩn bị cấm (như mọi khi).

Người chiến thắng sẽ là người có mã ngắn nhất tính bằng byte. (thật tuyệt vời khi thấy một> <> câu trả lời :))

JavaScript, ES6, 177 161 145 byte

f=(s,i=1,M=[],D)=>D==5||!~M[O="indexOf"](D+i)&&f(s,i-[M.push(D+i),L=s[O]('|'),-L,1,-1][D=`431255${5-D+'X3412'[D]}`['><^v-|/\\'[O](s[i+L])]||D],M,D)

Chúng ta có thể phát hiện một chu kỳ bằng cách duyệt qua đường dẫn và phát hiện sự lặp lại của bộ dữ liệu

• vị trí
• đến từ hướng

Đó là, nếu chúng ta đang bước vào một vị trí (x,y)đến từ hướng nào đó Dlần thứ hai, chúng ta biết rằng chu kỳ này sẽ lặp lại mãi mãi. Do đó, mã theo dõi tất cả các vị trí đã được truy cập và từ hướng nào và kiểm tra bản ghi đó mỗi khi không gian mới được truy cập.

Hướng lên, xuống, trái, và phải được giao những con số 1, 2, 3, và 4. Mã xem xét biểu tượng hiện tại đang được truy cập ( s[i+L]) và thay đổi hướng hiện tại ( D), sau đó hướng mới được sử dụng để gọi đệ quy hàm và đánh giá không gian tiếp theo. 5như một hướng chỉ ra một bức tường, và truechấm dứt chương trình.

Dưới đây là một lời giải thích về mã ít chơi gôn:

f=
(s,     // input string
 i=1,   // current location as offset string index
 M=[],  // record of previously visited spaces
 D      // current direction
  )=>(
    L=s[O="indexOf"]('|'), // find arena width `L` by index of first `|`

    // if D is 5, return true, or...
    D==5 ||

    // if direction + position is not new, return false
    !~M[O](D+i) &&

    // otherwise, save this direction + position
    M.push(D+i) &&

    // recursively call `f` with new direction and position
    f(s,
      i-[,L,-L,1,-1][D=            // modify position based on active direction
        `431255${5-D+'X3412'[D]}`  // from these possible directions...
          [                        // chose the one at the index...
            '><^v-|/\\'[O](        // based on the index of the symbol 
                           s[i+L]  // of the current character
                                 )
          ]
        ||D     // or preserve old D if symbol is not directional
      ],
      M,D)

Chuỗi mẫu `431255${5-D+'X3412'[D]}`có biểu thức lồng nhau xử lý các gương: vì các hướng là số, nên chúng cũng có thể được sử dụng làm chỉ mục. Biểu thức 'X3412'[D], ước tính cho ký tự thứ 8 trong chuỗi hướng có thể, và do đó tương ứng với \ký tự thứ 8 trong chuỗi ký hiệu '><^v-|/\\'). Biểu thức nói,

• Nếu hướng hiện tại Dlà 1(lên), thì hướng mới khi đánh \gương sẽ là 3(trái)
• Nếu hướng hiện tại Dlà 2(xuống), thì hướng mới khi đánh \gương sẽ là 4(phải)
• Vân vân.

Chiếc gương kia /sẽ sử dụng biểu thức 'X4321'[D], nhưng vì đơn giản chỉ là đếm ngược theo thứ tự 4, nên chúng ta có thể biểu thị nó đơn giản hơn 5-D.

Không tuân thủ> <> trả lời

Bạn muốn> <>, tôi cho bạn> <>!

Tôi tin rằng cách duy nhất để làm điều này trong> <> là sao chép đầu vào trong không gian mã và để trình thông dịch tự quyết định nếu đầu vào dẫn đến một nơi nào đó. Vì> <> không thực hiện phân luồng nữa, điều đó khiến chúng tôi gặp phải một vấn đề lớn: nếu đầu vào có vòng lặp, chúng tôi sẽ bị kẹt vào đó.

Những cân nhắc này được tính đến, tôi quyết định đưa ra một giải pháp tương thích với > <> trình thông dịch trực tuyến để có thể khẳng định nếu trình thông dịch bị kẹt trong đầu vào hoặc chỉ mất nhiều thời gian để làm mọi thứ. Tôi cũng đã phải thêm các dòng đuôi vào mã để trình thông dịch trực tuyến hiển thị mã được thêm và không gặp sự cố khi cố gắng ghi vào mã.

Ồ và vì bây giờ tôi rõ ràng bị loại, nên tôi không bận tâm đến việc đánh gôn.

Không cần phải quảng cáo thêm, mã trong tất cả vinh quang của nó:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
              ^

Để sử dụng nó, hãy sao chép nó trong trình thông dịch trực tuyến, thêm đủ các dòng theo dõi để xử lý dữ liệu đầu vào của bạn, gửi mã, cung cấp cho nó đầu vào dưới dạng ;các dòng riêng biệt và tận hưởng chuyến đi.

Một vài thử nghiệm:

Với

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+` 

Không gian mã cuối cùng:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ....................
.>\/           >\/>  .                   
. v^            \/   .
. v^   ^ ^           .
. \/\         >v     .
. /\/         ^<     .
 ....................

Đầu ra "đúng" và dừng lại.

Với

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

Không gian mã cuối cùng:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ........ 
.>>\     .
.\\      .
.  \\    .
. \ /    .
 ........

Vòng lặp mãi mãi.