¿Qué es la secuencia del palillo de dientes?

De acuerdo con Wikipedia

En geometría, la secuencia del palillo de dientes es una secuencia de patrones bidimensionales que se pueden formar agregando repetidamente segmentos de línea ("palillos de dientes") al patrón anterior en la secuencia.

La primera etapa del diseño es un solo "palillo de dientes", o segmento de línea. Cada etapa después de la primera se forma tomando el diseño anterior y, para cada extremo expuesto del palillo, colocando otro palillo centrado en ángulo recto en ese extremo.

Este proceso da como resultado un patrón de crecimiento en el que el número de segmentos en la etapa n oscila con un patrón fractal entre 0.45n2 y 0.67n2. Si T (n) denota el número de segmentos en la etapa n, entonces los valores de n para los cuales T (n) / n2 está cerca de su máximo se producen cuando n está cerca de una potencia de dos, mientras que los valores para los que está cerca de su mínimo ocurren cerca de números que son aproximadamente 1.43 veces una potencia de dos. La estructura de las etapas en la secuencia del palillo a menudo se asemeja al fractal en T cuadrado, o la disposición de las células en el autómata celular Ulam-Warburton.

Todas las regiones delimitadas rodeadas por mondadientes en el patrón, pero no cruzadas por ellas, deben ser cuadrados o rectángulos. Se ha conjeturado que cada rectángulo abierto en el patrón de palillo de dientes (es decir, un rectángulo que está completamente rodeado de palillos de dientes, pero no tiene un palillo de dientes cruzando su interior) tiene longitudes laterales y áreas que son potencias de dos, con una de las longitudes laterales. siendo a lo sumo dos.

Tarea

Debe crear un programa o función que reciba información de STDIN, argumento de función o argumento de línea de comandos y crear un fractal de palillo en esa etapa. La nueva línea inicial y posterior está prohibida, excepto si es inevitable. El cuadro delimitador debe ser mínimo, incluido el espacio inicial y final. Para la línea inicial, hacemos dos \diagonales en el espacio. Se garantiza que la entrada sea inferior a dos mil. Al menos una línea tiene carácter no espacial. Se permite espacio final.

Casos de prueba

1
\ 
 \     

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

CJam, 99 93 bytes

Esto se hizo bastante largo ...

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

Pruébalo aquí. Si desea probar entradas más grandes, como la 89 en Wikipedia, TryItOnline de Dennis utiliza el intérprete de Java mucho más rápido bajo el capó y puede manejar entradas como esa en unos segundos.

Estoy seguro de que hay mucho margen de mejora, y agregaré una explicación una vez que esté más feliz con el puntaje ...

Aquí está la salida para N = 13:

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

Para mi propia referencia al jugar golf más allá, algunas otras ideas:

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

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

Explicación

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
)

Prueba

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 bytes

La versión de golf utiliza solo un bucle j, con iy kcalculado sobre la marcha.

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

Sin golf en el programa de prueba

Esta versión usa 2 bucles anidados.

Una construcción incorporada raramente utilizada es la sumque devuelve una suma de verificación cruda al agregar todos los bytes de una cadena 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]