Apa itu Urutan Tusuk Gigi?

Menurut Wikipedia

Dalam geometri, urutan tusuk gigi adalah urutan pola 2 dimensi yang dapat dibentuk dengan berulang kali menambahkan segmen garis ("tusuk gigi") ke pola sebelumnya dalam urutan.

Tahap pertama dari desain adalah "tusuk gigi" tunggal, atau segmen garis. Setiap tahap setelah yang pertama dibentuk dengan mengambil desain sebelumnya dan, untuk setiap ujung tusuk gigi yang terbuka, menempatkan tusuk gigi lain berpusat pada sudut yang tepat di ujung itu.

Proses ini menghasilkan pola pertumbuhan di mana jumlah segmen pada tahap n berosilasi dengan pola fraktal antara 0,45n2 dan 0,67n2. Jika T (n) menunjukkan jumlah segmen pada tahap n, maka nilai n yang T (n) / n2 mendekati maksimum terjadi ketika n berada di dekat kekuatan dua, sedangkan nilai yang dekat dengan minimum terjadi angka dekat yang sekitar 1,43 kali kekuatan dua. Struktur tahapan dalam urutan tusuk gigi sering menyerupai fraktal T-square, atau susunan sel dalam otomat seluler Ulam-Warburton.

Semua daerah yang dibatasi dikelilingi oleh tusuk gigi dalam pola, tetapi tidak sendiri dilintasi oleh tusuk gigi, harus berbentuk kotak atau persegi panjang. Telah diduga bahwa setiap persegi panjang terbuka dalam pola tusuk gigi (yaitu, persegi panjang yang sepenuhnya dikelilingi oleh tusuk gigi, tetapi tidak memiliki tusuk gigi yang melintasi interiornya) memiliki panjang sisi dan area yang memiliki kekuatan dua, dengan salah satu dari panjang sisi. paling banyak dua.

Tugas

Anda harus membuat program atau fungsi yang mengambil input dari STDIN, argumen fungsi, atau argumen baris perintah dan membuat fraktal tootpick pada tahap itu. Memimpin dan membuntuti baris baru dilarang kecuali jika tidak dapat dihindari. Kotak pembatas harus minimal, termasuk ruang awal dan akhir. Untuk garis inital, kita membuat dua \diagonal dalam ruang. Input dijamin kurang dari dua ribu. Setidaknya satu baris memiliki karakter non-spasi. Ruang tambahan diperbolehkan.

Uji Kasus

1
\ 
 \     

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

CJam, 99 93 byte

Ini agak lama ...

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

Uji di sini. Jika Anda ingin menguji input yang lebih besar, seperti 89 di Wikipedia, TryItOnline Dennis menggunakan interpreter Java yang jauh lebih cepat di bawah tenda dan dapat menangani input seperti itu dalam beberapa detik.

Saya yakin ada banyak ruang untuk perbaikan, dan saya akan menambahkan penjelasan setelah saya lebih bahagia dengan skor ...

Ini adalah output untuk N = 13:

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

Untuk referensi saya sendiri ketika bermain golf ini lebih lanjut, beberapa ide lain:

"\ "_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 byte

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`
`)

Penjelasan

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
)

Uji

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 byte

Versi golf hanya menggunakan satu loop j,, dengan idan kdihitung dengan cepat.

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

Tidak digabungkan dalam program uji

Versi ini menggunakan 2 loop bersarang.

Sebuah builtin sumyang jarang digunakan adalah yang mengembalikan checksum mentah dengan menambahkan semua byte dari string ascii.

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]