Що таке послідовність зубочисток?

За даними Вікіпедії

У геометрії послідовність зубочистки - це послідовність двовимірних візерунків, яку можна сформувати багаторазовим додаванням відрізків рядків ("зубочисток") до попереднього шаблону в послідовності.

Перший етап проектування - це єдиний «зубочистка», або лінійний сегмент. Кожен етап після першого формується за допомогою попередньої конструкції і для кожного відкритого кінця зубочистки, розміщуючи ще одну зубочистку, орієнтовану під прямим кутом на цьому кінці.

Цей процес призводить до картини зростання, при якій кількість сегментів на n стадії коливається за фрактальною картиною між 0,45n2 та 0,67n2. Якщо T (n) позначає кількість відрізків на стадії n, то значення n, для яких T (n) / n2 є близьким до максимуму, виникають, коли n знаходиться поблизу потужності двох, тоді як значення, для яких це близько його мінімального трапляються поблизу чисел, які приблизно в 1,43 рази перевищують потужність двох. Структура стадій у послідовності зубочисток часто нагадує фрактал Т-квадрата, або розташування клітин у клітинному автоматі Улам-Варбуртон.

Усі обмежені ділянки, оточені зубочистками за малюнком, але самі по собі не перетинаються зубочистками, повинні бути квадратами або прямокутниками. Можна припустити, що кожен відкритий прямокутник за малюнком зубочистки (тобто прямокутник, повністю оточений зубочистками, але зубочисткою не перетинає його внутрішню частину) має бічні довжини та ділянки, потужність яких дві, з однією з бічних довжин будучи не більше двох.

Завдання

Ви повинні зробити програму або функцію, яка приймає вхід зі STDIN, аргумент функції або аргумент командного рядка і зробити фрактал Tootpick на цьому етапі. Ведення та переведення нового рядка заборонено, за винятком випадків, коли це неминуче. Обмежувальний ящик повинен бути як мінімум, включаючи провідний і кінцевий простір. Для первинної лінії робимо дві \діагоналі в просторі. Гарантований вклад становить менше двох тисяч. Принаймні один рядок має непробільний характер. Доступний простір дозволено.

Випробування

1
\ 
 \     

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

CJam, 99 93 байт

Це стало досить довго ...

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

Тестуйте це тут. Якщо ви хочете перевірити більші дані, як 89 у Вікіпедії, TryItOnline Денніса використовує набагато швидший інтерпретатор Java під кришкою і може обробляти такі входи за кілька секунд.

Я впевнений, що є багато можливостей для вдосконалення, і я додам пояснення, як тільки я щасливіший з оцінкою ...

Ось вихід для N = 13:

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

Для моєї власної довідки, коли гольфу далі, ще деякі ідеї:

"\ "_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 байти

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

Пояснення

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
)

Тест

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>

Рубін, 151 байт

У версії для гольфу використовується лише одна петля j, з iта kобчислюється на льоту.

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

Ungolfed в тестовій програмі

Ця версія використовує 2 вкладені петлі.

Рідко використовується вбудований модуль, sumякий повертає неочищену контрольну суму, додаючи всі байти рядка 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]