Kürdan Dizisi nedir?

Wikipedia'ya göre

Geometride, kürdan sekansı, sekanstaki önceki desene tekrar tekrar çizgi segmentleri ("kürdan") eklenerek oluşturulabilen 2 boyutlu desenlerden oluşan bir dizidir.

Tasarımın ilk aşaması tek bir "kürdan" veya çizgi segmentidir. Birinciden sonraki her aşama, önceki tasarımı alarak ve açıkta kalan her kürdan ucu için, o ucun üzerinde dik bir açıda ortalanmış başka bir kürdan yerleştirilerek oluşturulur.

Bu işlem, aşama n'deki segment sayısının 0.45n2 ile 0.67n2 arasında bir fraktal paternle salındığı bir büyüme paterniyle sonuçlanır. Eğer T (n) n evresindeki segment sayısını belirtirse, n (iki) bir güce yakın olduğunda T (n) / n2'nin maksimum değerine yakın olduğu n değerleri n değerlerinin minimum değerine yakın olduğu zaman meydana gelir. ikisinin gücünün yaklaşık 1.43 katı olan sayıların yakınında meydana gelir. Kürdan dizisindeki aşamaların yapısı genellikle T-kare fraktalına veya Ulam-Warburton hücresel otomatındaki hücrelerin düzenlenmesine benzer.

Desendeki kürdanlarla çevrili, ancak kendinden kürdan ile geçmeyen tüm sınırlı bölgeler kareler veya dikdörtgenler olmalıdır. Kürdan desenindeki her açık dikdörtgenin (yani kürdanlarla tamamen çevrili, ancak kürdanı içten geçen bir kürdan içermeyen bir dikdörtgen) yan uzunluklara ve yan güçlerden biri olan iki güç alanlarına sahip olduğu tahmin edilmiştir. en fazla iki olmak.

Görev

STDIN, işlev bağımsız değişkeni veya komut satırı bağımsız değişkeninden girdi alan bir program veya işlev yapmanız ve o aşamada bir kürdan fraktal yapmanız gerekir. Kaçınılmaz olması haricinde satır başı ve sondaki satır başı yasaktır. Sınırlama kutusu, ön ve arka boşluk dahil olmak üzere minimum olmalıdır. Başlangıç ​​çizgisi için, \uzayda iki köşegen yapıyoruz . Girdinin iki binden az olması garanti edilir. En az bir satırda boşluk karakteri yok. Sondaki boşluğa izin verilir.

Test Durumları

1
\ 
 \     

5
    \     
    /\    
   /\     
  / /\   
\/\/\ \ \ 
 \ \ \/\/\
    \/ /  
     \/   
    \/    
     \    

CJam, 99 93 bayt

Bu oldukça uzundu ...

"\ "_W%]{{Sf+W%z}4*2ew{2fewz{_sa"\//\\"4S**4/^_,3={:.e>W%2/\}&;}%z{\)a@.e>+}:Ff*}%{F}*}q~(*N*

Burada test edin.Wikipedia'daki 89 gibi daha büyük girdileri test etmek isterseniz, Dennis'in TryItOnline , kaputun altında çok daha hızlı Java yorumlayıcısını kullanır ve birkaç saniye içinde böyle girişleri işleyebilir.

Eminim iyileştirme için çok yer vardır ve skordan memnun kaldıktan sonra bir açıklama ekleyeceğim ...

İşte çıktı N = 13:

            \             
            /\            
           /\             
          / /\            
        \/\/\ \ \         
         \ \/\/\/\        
           /\/\/          
          / /\ \          
    \    /\/\ \     \     
    /\  /  \/\/\    /\    
   /\  /\  /\/  \ \/\     
  / /\/ /\/ /\  /\ \/\    
\/\/\/\/\/\/\ \/\ \/\ \ \ 
 \ \ \/\ \/\ \/\/\/\/\/\/\
    \/\ \/  \/ /\/ /\/ /  
     \/\ \  /\/  \/  \/   
    \/    \/\/\  /  \/    
     \     \ \/\/    \    
          \ \/ /          
          /\/\/           
        \/\/\/\ \         
         \ \ \/\/\        
            \/ /          
             \/           
            \/            
             \            

Bunu daha da golf yaparken kendi referansım için, diğer bazı fikirler:

"\ "_W%]{{Sf+W%z}4*2few2ew::.{+_a"\//\\"4S**4/^_,3={:.e>W%\}&;2/}:z{\)a@.e>+}ff*{\)a@..e>+}*}ri(*N*

"\ "_W%]{{Sf+W%z}4*2ew{2fewz{_sa"\//\\"4S**4/^_,3={:.e>W%2/\}&;}%{.{\)a@.e>+}}*}%{\)a@.e>+}*}q~(*N*

JavaScript (ES6), 263 bayt

n=>(o=(o=[..." ".repeat(n*2)]).map(_=>o.map(_=>s=c=" ")),(g=a=>s++<n&&g(q=[],a.map(p=>o[p[4]][p[3]]==c&&(o[y=p[1]][x=p[0]]=o[y-1][(b=+p[2])?x-1:x+1]="/\\"[b],q.push([x,++y,!b,b?x+1:x-1,y],[b?x-=2:x+=2,y-2,!b,x,y-3])))))([[n,n,1,n,n]]),o.map(r=>r.join``).join`
`)

açıklama

n=>(                           // n = desired stage

  o=                           // o = output grid
                               //     [ [ "\\", " " ], [ " ", "\\" ], etc... ]
    (o=[..." ".repeat(n*2)])   // create an array the size of the grid
    .map(_=>o.map(_=>          // loop over it and return the output grid
      s=                       // s = current stage (" " acts the same as 0)
        c=                     // c = blank character
          " "                  // initialise each element to " "
    )),

  (g=                          // g = compute stage function
    a=>                        // a = positions to place toothpicks
                               //     [ x, y, isBackslash, checkX, checkY ]
      s++<n&&                  // do nothing if we have reached the desired stage
      g(q=[],                  // q = positions for the next stage's toothpicks
        a.map(p=>              // p = current potential toothpick position
          o[p[4]][p[3]]==c&&(  // check the position to make sure it is clear

            o[y=p[1]][x=p[0]]= // place bottom toothpick, x/y = position x/y
            o[y-1][            // place top toothpick
              (b=+p[2])        // b = isBackslash
              ?x-1:x+1         // top toothpick x depends on direction
            ]="/\\"[b],        // set the location to the appropriate character

            // Add the next toothpick positions
            q.push([x,++y,!b,b?x+1:x-1,y],
              [b?x-=2:x+=2,y-2,!b,x,y-3])
          )
        )
      )
  )([[n,n,1,n,n]]),            // place the initial toothpicks
  o.map(r=>r.join``).join`
` // return the grid converted to a string
)

Ölçek

Stages: <input type="number" oninput='result.innerHTML=(

n=>(o=(o=[..." ".repeat(n*2)]).map(_=>o.map(_=>s=c=" ")),(g=a=>s++<n&&g(q=[],a.map(p=>o[p[4]][p[3]]==c&&(o[y=p[1]][x=p[0]]=o[y-1][(b=+p[2])?x-1:x+1]="/\\"[b],q.push([x,++y,!b,b?x+1:x-1,y],[b?x-=2:x+=2,y-2,!b,x,y-3])))))([[n,n,1,n,n]]),o.map(r=>r.join``).join`
`)

)(+this.value)' /><pre id="result"></pre>

Ruby, 151 bayt

Golfed versiyon kullandığı tek döngü, jbirlikte ive kanında hesaplanır.

->n{m=n*2
s=(' '*m+$/)*m
l=m*m+m
s[l/2+n]=s[l/2-n-2]=?\\
(n*l-l).times{|j|(s[i=j%l]+s[i-m-2+2*k=j/l%2]).sum==124-k*45&&s[i-m-1]=s[i-1+2*k]="/\\"[k]}
s}

Test programında yönlendirilmemiş

Bu sürüm 2 iç içe döngü kullanır.

Nadiren kullanılan sumbir yapı, bir ascii dizesinin tüm baytlarını ekleyerek ham bir sağlama toplamı döndürür.

f=->n{
  m=n*2                                       #calculate grid height / width            
  s=(' '*m+$/)*m                              #fill grid with spaces, separated by newlines
  l=m*m+m                                     #calculate length of string s
  s[l/2+n]=s[l/2-n-2]=?\\                     #draw the first toothpick
  (n-1).times{|j|                             #iterate n-1 times
    l.times{|i|                               #for each character in the string
      (s[i]+s[i-m-2+2*k=j%2]).sum==124-k*45&& #if checksum of current character + character diagonally above indicates the end of a toothpick
         s[i-m-1]=s[i-1+2*k]="/\\"[k]         #draw another toothpick at the end
    }                                         
  }
s}                                            #return value = s


puts f[gets.to_i]