ความท้าทาย

สร้างฟังก์ชั่นที่เมื่อป้อนอินพุตของ ASCII art (นำทางเส้นทางที่อาจวนลูปในที่สุด) เอาต์พุตของความยาวของลูป (ถ้ามี) และความยาวของ "หาง" ที่นำไปสู่ลูปในหนึ่งใน แบบฟอร์มด้านล่าง

อินพุต

ข้อมูลของคุณจะต้องถูกส่งผ่านไปยังฟังก์ชั่น ด้านล่างเป็นตัวอย่างของการป้อนข้อมูลแบบง่าย

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

คุณสามารถเห็นภาพบล็อกด้านบนเช่นนี้

"หาง" เป็นหนึ่งรายการในขณะที่ห่วงยาวสี่

สิ่งที่ยากกว่านี้:

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

เอาท์พุต

คุณต้องแสดงผลผ่าน STDOUT หรือภาษาอื่นที่ใกล้เคียงที่สุด

จำนวนเต็มสองเอาต์พุตของคุณควรเป็นความยาวของหางและความยาวของลูป เอาต์พุตนี้สามารถอยู่ในสองรูปแบบ

1. สตริงที่คั่นด้วยช่องว่าง: "2 10"
2. อาร์เรย์ของจำนวนเต็ม: [2, 10]

กฎระเบียบ

• ทุกบล็อกหรือ#จะมีเส้นทางเดียวห่างจากตัวเอง

• ลูกศรทุกอันมีสองส่วนของเส้นตรงและหนึ่งหัว

• บล็อกเริ่มต้นจะอยู่ในคอลัมน์ซ้ายสุดเสมอ

• อินพุตจะไม่วนซ้ำ

ตัวอย่าง

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

อันนี้มีความยาวหาง 2 และความยาววน 6 ด้านล่างหางและวนถูกแยกออก

หาง

# -->
^
|
|
#

ห่วง

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

ผลที่ถูกต้องและ[2, 6]"2 6"

หากอินพุตเป็นหางเท่านั้นความยาวลูปจะเป็นศูนย์

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

เอาต์พุตที่ถูกต้องสำหรับอินพุตด้านบนคือ[6, 0]และ"6 0"

JavaScript (ES6), 221 229

ฟังก์ชั่นที่มีอินพุตเป็นพารามิเตอร์เอาต์พุตเป็นสตริงผ่านหน้าต่างป๊อปอัพ (การแจ้งเตือน)

สแกนอินพุตซ้ำ ๆ :
ในแต่ละขั้นตอน

• เอาปลายหางออก
• นับ '#' ที่เหลือ

เมื่อไม่มีหางที่จะเอาออกอีกจำนวนขั้นตอนจนถึงขนาดของหางและจำนวนที่เหลืออยู่ '# คือขนาดของห่วง

บรรทัดใหม่ทั้งหมดภายใน backticks มีความสำคัญและนับ

ทดสอบการเรียกใช้ตัวอย่างด้านล่างด้วย Firefox (ไม่ใช่ Chrome เนื่องจากไม่รองรับ...)

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 ไบต์

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

ลองมันนี่

สิ่งนี้จะสร้างแฮช (พจนานุกรม) ของโหนด สำหรับแต่ละโหนดจำนวนการเชื่อมต่อขาเข้าและโหนดถัดไป (อาจเป็นโมฆะ) จะถูกเก็บไว้

สุดท้าย:

• หากไม่มีโหนดที่มีการเชื่อมต่อขาเข้า 2 รายการ (หมายถึงไม่มีการวนซ้ำ) ให้ส่งคืน 0 สำหรับ tail และจำนวนโหนดที่มีอยู่สำหรับ loop
• มิฉะนั้นให้เริ่มการทำซ้ำจากโหนดด้วยการเชื่อมต่อขาเข้า 0 รายการ (เริ่มต้น) ผ่านถัดไป -> ...-> ถัดไปจนกว่าโหนดที่มีการเชื่อมต่อขาเข้า 2 รายการ (เริ่มลูป) ส่งคืนการนับที่เหมาะสม

รุ่นที่สามารถอ่านรหัสที่มีอยู่ที่นี่

ทับทิม, 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}