Các thách thức

Tạo một hàm, khi được cung cấp đầu vào của nghệ thuật ASCII (chỉ đạo một đường dẫn cuối cùng có thể lặp lại), xuất ra độ dài của vòng lặp (nếu có) và độ dài của "đuôi" dẫn vào vòng lặp trong một trong các các hình thức dưới đây.

Đầu vào

Đầu vào của bạn phải được chuyển đến một chức năng. Dưới đây là một ví dụ về một đầu vào đơn giản.

# --> # --> #
      ^     |
      |     |
      |     v
      # <-- #

Bạn có thể hình dung các khối trên như thế này

"Đuôi" là một mục, trong khi vòng lặp dài bốn.

Một khó khăn hơn:

            # --> # --> #
            ^           |
            |           |
            |           v
      # --> # <-- #     # --> #
      ^           ^           |
      |           |           |
      |           |           v
# --> #           # <-- # <-- #

Đầu ra

Bạn phải xuất thông qua STDOUT hoặc ngôn ngữ thay thế gần nhất của bạn.

Hai số nguyên đầu ra của bạn phải là chiều dài của đuôi và chiều dài của vòng lặp. Đầu ra này có thể ở hai dạng.

1. một chuỗi giới hạn không gian: "2 10"
2. một mảng các số nguyên: [2, 10]

Quy tắc

• Mỗi khối, hoặc #, sẽ chỉ có một con đường duy nhất cách xa nó.

• Mỗi mũi tên là hai đoạn đường và một đầu.

• Khối bắt đầu sẽ luôn ở cột ngoài cùng bên trái.

• Đầu vào sẽ không bao giờ chỉ là một vòng lặp.

Thí dụ

# --> # --> # --> #
^     ^           |
|     |           |
|     |           v
#     # <-- # <-- #

Cái này có chiều dài đuôi là 2 và chiều dài vòng là 6. Dưới đây, đuôi và vòng được tách ra.

Đuôi

# -->
^
|
|
#

Vòng

# --> # --> #
^           |
|           |
|           v
# <-- # <-- #

Các đầu ra chính xác là [2, 6]và "2 6".

Nếu đầu vào chỉ là một cái đuôi , thì độ dài vòng lặp bằng không.

# --> # --> # --> #
                  |
                  |
                  v
        <-- # <-- #

Các đầu ra chính xác cho đầu vào trên là [6, 0]và"6 0"

JavaScript (ES6), 221 229

Một chức năng với đầu vào là một tham số, đầu ra dưới dạng một chuỗi thông qua cửa sổ bật lên (cảnh báo).

Quét liên tục đầu vào:
ở mỗi bước

• loại bỏ phần cuối của đuôi
• đếm số '#' còn lại

Khi không còn đuôi để loại bỏ, số bước cho đến nay là kích thước của đuôi và số '# còn lại là kích thước của vòng lặp.

Tất cả các dòng mới bên trong backticks đều có ý nghĩa và được tính

Kiểm tra chạy đoạn mã dưới đây với Firefox (không phải Chrome, vì nó không hỗ trợ ...)

F=s=>{s=`


${s}


`.split`
`.map(r=>[...r]);for(t=0,f=1;f;)s.map((r,y)=>r.map((c,x)=>c=='#'&&((r[x+2]+r[x-2]+s[y-1][x]+s[y+1][x]).match`[v<>^]`?++l:t+=(f=r[x-4]=r[x+4]=s[y-3][x]=s[y+3][x]=r[x]=1))),f=l=0);alert(t+' '+l)}

// Less golfed
U=s=>{
  s=`\n\n\n${s}\n\n\n`.split`\n`.map(r=>[...r])
  t=0
  do {
    f=l=0
    s.forEach((r,y) => {
      r.forEach((c,x) => {
        if (c == '#')
        {
          if (!(r[x+2] == '<' || r[x-2] == '>' || s[y-1][x] == 'v' || s[y+1][x] == '^'))
            t+=(f=r[x-4]=r[x+4]=s[y-3][x]=s[y+3][x]=r[x]=1)
          else
            ++l
        }
      })
    })
  } while(f)
  alert(t+' '+l)
}  

//Test

// Redefine console.log
alert=(...x)=>O.innerHTML+=x+'\n'

test=[`
# --> # --> #
      ^     |
      |     |
      |     v
      # <-- #`
,`
            # --> # --> #
            ^           |
            |           |
            |           v
      # --> # <-- #     # --> #
      ^           ^           |
      |           |           |
      |           |           v
# --> #           # <-- # <-- #`
,`
# --> # --> # --> #
^     ^           |
|     |           |
|     |           v
#     # <-- # <-- #`      
]

test.forEach(t=>(alert(t),F(t)))

<pre id=O></pre>

Ruby, 287 278 byte

->i{n={}
g=->x{n[x]||=[0,p]}
t=y=0
i.lines{|l|x=0
l.chars{|c|x+=1
'><'[c]&&(r=c.ord-61;s,d=[y,x-4*r],[y,x+2*r])
'^v'[c]&&(r=c<?_?1:-1;s,d=[y+r*3,x],[y-r,x])
s&&(g[s][1]=g[d])[0]+=1}
y+=1}
c,*_,s=n.values.sort_by{|v|v[0]}
l=n.size
s[0]>1?((t+=1;c=c[1])while c!=s):t=l-=1
[t,l-t]}

Hãy thử nó ở đây .

Điều này xây dựng một hàm băm (từ điển) của các nút. Đối với mỗi nút, số lượng kết nối đến và nút tiếp theo (có thể là null) được lưu trữ.

Cuối cùng:

• Nếu không có nút nào có 2 kết nối đến (nghĩa là không có vòng lặp), hãy trả về 0 cho đuôi và số lượng nút hiện có cho vòng lặp.
• Mặt khác, bắt đầu lặp từ nút có 0 kết nối đến (bắt đầu) qua tiếp theo -> ...-> tiếp theo cho đến khi nút có 2 kết nối đến (bắt đầu vòng lặp) đạt được. Trả lại số lượng thích hợp.

Phiên bản có thể đọc được của mã có sẵn ở đây .

Ruby, 276

->s{a=k=w=s.index(r='
')*2+2
s=r*w+s+r*w
(s.size).times{|i|s[i,2]=='
#'&&(s[3+j=i+1]+s[j+w]+s[j-w]).strip.size<2&&(a=[j]
d=0
loop{("|-|-"[d])+?#=~/#{s[k=j+[-w,3,w,-3][d]]}/?(a.include?(k)&&break;a<<(j=k);d-=1):d=(d+1)%4}
)}
u=a.size
v=a.index(k)
t=(u-v)/4*2
print u/2-t," ",t}