Saya suka> <>,> <> adalah hidup! Bahasa 2D menakjubkan! Dalam tantangan ini, Anda harus mengatakan apakah jalan "mencurigakan" telah berakhir, sementara bermain golf kode.

Definisi

Jalan mencurigakan dibangun dengan ubin, termasuk yang berikut:

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

Karakter lain (kecuali -|+) dapat dianggap sebagai pengalih perhatian, seperti beberapa bunga (atau kepala ikan) di perbatasan jalan.

Jalan selalu dimulai di sudut kiri atas kotak persegi panjang, dibatasi oleh -|+simbol. Jalan memiliki akhir jika, dengan mengikutinya, Anda berakhir di perbatasan, jika tidak, Anda akan terjebak di jalan yang tak terbatas.

Menemukan jalan Anda di jalan dicapai dengan mengikuti petunjuk yang diberikan oleh v>^<dan cermin. Sebuah cermin akan memantulkan hingga 90 ° tergantung dari mana Anda berasal. Begini cara kerjanya (gunakan v>^<untuk menunjukkan arah):

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

Jalan mungkin terlihat seperti ini jika berakhir:

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

Loop tak terbatas:

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

Spesifik

Jalan tidak hanya terdiri dari instruksi. Spasi atau huruf dapat digunakan untuk melengkapinya. Ini berarti Anda harus terus bergerak ke arah yang sama kecuali jika Anda melewati karakter <v^>-|.

Akan selalu ada satu v>^<di sudut kiri atas, <atau ^menyiratkan ujung jalan ini.

Anda dapat mengirimkan fungsi yang menggunakan string sebagai parameter, atau program mandiri menggunakan STDIN / apa pun alternatif terdekat dalam bahasa Anda.

Kiriman Anda harus mengembalikan atau mencetak nilai STDOUT yang benar / salah saat selesai. Nilai kebenaran yang berarti jalan memiliki akhir, sedangkan falsy berarti itu adalah loop tak terbatas.

Uji kasus

+--------------------+
|>\/  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

Celah standar dilarang (seperti biasa).

Pemenang akan menjadi orang dengan kode terpendek dalam byte. (Akan luar biasa melihat>> jawaban> :))

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)

Kami dapat mendeteksi siklus dengan melintasi jalur dan mendeteksi pengulangan tuple

• lokasi
• datang dari arah

Artinya, jika kita memasuki suatu posisi yang (x,y)datang dari arah tertentu Duntuk kedua kalinya, kita tahu bahwa siklus ini akan berulang selamanya. Oleh karena itu, kode melacak semua lokasi yang dikunjungi, dan dari arah mana, dan memeriksa catatan itu setiap kali ruang baru dikunjungi.

The arah atas, bawah, kiri, dan kanan ditugaskan nomor 1, 2, 3, dan 4. Kode menganggap simbol saat ini sedang dikunjungi ( s[i+L]) dan mengubah arah saat ini ( D), kemudian arah baru digunakan untuk memanggil fungsi secara rekursif dan mengevaluasi ruang berikutnya. 5sebagai arah menunjukkan dinding, dan truepenghentian program.

Berikut ini penjelasan tentang kode kurang golf:

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)

String template `431255${5-D+'X3412'[D]}`memiliki ekspresi bersarang yang menangani mirror: karena arahnya angka, mereka juga dapat digunakan sebagai indeks. Ekspresi 'X3412'[D], mengevaluasi ke 8 karakter dalam string arah yang mungkin, dan sesuai dengan \, 8 karakter dalam string simbol '><^v-|/\\'). Ungkapan itu mengatakan,

• Jika arah saat Dini 1(atas), maka arah baru mengenai memukul \cermin akan 3(kiri)
• Jika arah saat Dini 2(turun), maka arah baru mengenai memukul \cermin akan menjadi 4(kanan)
• dll.

Cermin lainnya /akan menggunakan ekspresi 'X4321'[D], tetapi karena itu hanyalah hitungan mundur dari 4, kita dapat mengekspresikannya lebih sederhana 5-D.

Tidak patuh> <> jawabannya

Anda ingin> <>, saya memberi Anda> <>!

Saya percaya satu-satunya cara yang waras untuk melakukan ini di> <> adalah dengan menyalin input di ruang kode dan membiarkan penerjemah memutuskan dengan sendirinya jika input mengarah ke suatu tempat. Karena> <> tidak menerapkan threading lagi, itu meninggalkan kita dengan masalah besar: jika input memiliki loop, kita akan terjebak ke dalamnya.

Pertimbangan-pertimbangan ini dipertimbangkan, saya memutuskan untuk membuat solusi yang kompatibel dengan penerjemah online> <> sehingga dimungkinkan untuk menegaskan apakah penerjemah terjebak dalam input atau hanya perlu waktu lama untuk melakukan semuanya. Saya juga harus menambahkan baris tambahan ke kode sehingga penerjemah online menunjukkan kode yang ditambahkan dan tidak macet ketika mencoba menulisnya.

Oh dan karena saya jelas didiskualifikasi sekarang, saya tidak repot-repot dengan kode golf.

Tanpa basa-basi lagi, kode dalam semua kemuliaan:

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

Untuk menggunakannya, salin di penerjemah online, tambahkan garis trailing yang cukup untuk menangani input Anda, kirim kode, berikan input sebagai ;garis terpisah dan nikmati perjalanan.

Beberapa tes:

Dengan

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

Ruang kode akhir:

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     .
. /\/         ^<     .
 ....................

Output "true" dan berhenti.

Dengan

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

Ruang kode akhir:

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

Loops selamanya.