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

Согласно Википедии

В геометрии последовательность зубочисток представляет собой последовательность двухмерных рисунков, которые могут быть сформированы путем многократного добавления отрезков («зубочисток») к предыдущему рисунку в последовательности.

Первым этапом проектирования является одиночная «зубочистка», или отрезок. Каждый этап после первого формируется путем взятия предыдущего рисунка и, для каждого открытого конца зубочистки, размещения другой зубочистки с центром под прямым углом на этом конце.

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

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

задача

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

Тестовые случаи

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}

Неуправляемый в тестовой программе

Эта версия использует 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]