Meydan okuma

Bir ASCII sanatı girdisi verildiğinde (sonunda döngü oluşturabilecek bir yolu yönlendirerek), döngünün uzunluğunu (varsa) ve "kuyruk" un uzunluğundan aşağıdaki formlar.

Giriş

Girişiniz bir işleve geçirilmelidir. Aşağıda basit bir giriş örneği verilmiştir.

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

Yukarıdaki blokları bu şekilde görselleştirebilirsiniz

Döngü dört uzunken "kuyruk" bir öğedir.

Daha zor olanı:

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

Çıktı

STDOUT veya dilinizin en yakın alternatifi aracılığıyla çıktı almalısınız.

İki çıkış tamsayı, kuyruğun uzunluğu ve ilmeğin uzunluğu olmalıdır. Bu çıktı iki şekilde olabilir.

1. boşlukla ayrılmış bir dize: "2 10"
2. bir tamsayı dizisi: [2, 10]

kurallar

• Her bloğun ya da #kendisinden sadece bir tek yolu olacaktır .

• Her ok iki çizgi parçası ve bir kafa.

• Başlangıç ​​bloğu her zaman en soldaki sütunda olacaktır.

• Giriş asla sadece bir döngü olmayacaktır.

Misal

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

Bunun kuyruk uzunluğu 2 ve döngü uzunluğu 6'dır. Aşağıda, kuyruk ve halka ayrılmıştır.

Kuyruk

# -->
^
|
|
#

döngü

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

Doğru çıkışlar [2, 6]ve "2 6".

Giriş yalnızca bir kuyruksa , döngü uzunluğu sıfırdır.

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

Yukarıdaki giriş için doğru çıkışlar [6, 0]ve"6 0"

JavaScript (ES6), 221 229

Parametre olarak girişe sahip bir işlev, açılır pencere yoluyla dize olarak çıktı (uyarı).

Girişi tekrar tekrar tarayın:
her adımda

• kuyruğun ucunu çıkarmak
• kalan '#' say

Kaldırılacak daha fazla kuyruk olmadığında, şu ana kadarki adımların sayısı kuyruğun büyüklüğü ve kalan '# sayısı da döngünün boyutudur.

Ters tırnakların içindeki tüm yeni satırlar önemli ve sayıldı

Aşağıdaki snippet'i Firefox ile çalıştırmayı test edin (desteklemediği için Chrome değil ...)

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>

Yakut, 287278 bayt

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

Burada deneyin .

Bu düğümlerden oluşan bir karma (sözlük) oluşturur. Her düğüm için, gelen bağlantıların sayısı ve (muhtemelen boş) sonraki düğüm saklanır.

En sonunda:

• 2 gelen bağlantıya sahip bir düğüm yoksa (döngü yok demektir), kuyruk için 0 değerini ve döngü için mevcut düğümlerin sayısını döndürün.
• Aksi takdirde, 2 gelen bağlantıya (döngü başlangıcı) sahip olan düğüme ulaşılana kadar sonraki -> ...-> sonraki ile 0 gelen bağlantı (başlat) ile düğümden yinelemeye başlayın. Uygun sayıları döndürün.

Kodun okunabilir sürümü burada mevcuttur .

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