Cos'è la sequenza di stuzzicadenti?

Secondo Wikipedia

In geometria, la sequenza di stuzzicadenti è una sequenza di motivi bidimensionali che possono essere formati aggiungendo ripetutamente segmenti di linea ("stuzzicadenti") al modello precedente nella sequenza.

Il primo stadio del design è un singolo "stecchino", o segmento di linea. Ogni fase dopo la prima si forma prendendo il disegno precedente e, per ogni estremità dello stecchino esposta, posizionando un altro stecchino centrato ad angolo retto su quell'estremità.

Questo processo provoca uno schema di crescita in cui il numero di segmenti allo stadio n oscilla con uno schema frattale tra 0,45 n2 e 0,67 n2. Se T (n) indica il numero di segmenti allo stadio n, allora i valori di n per i quali T (n) / n2 è vicino al suo massimo si verificano quando n è vicino a una potenza di due, mentre i valori per i quali è vicino al suo minimo si verificano vicino a numeri che sono circa 1,43 volte una potenza di due. La struttura degli stadi nella sequenza degli stuzzicadenti assomiglia spesso al frattale del quadrato a T, o alla disposizione delle cellule nell'automa cellulare Ulam-Warburton.

Tutte le regioni delimitate circondate da stuzzicadenti nel motivo, ma non attraversate da stuzzicadenti, devono essere quadrate o rettangolari. È stato ipotizzato che ogni rettangolo aperto nel modello di stuzzicadenti (cioè un rettangolo che è completamente circondato da stuzzicadenti, ma non ha stuzzicadenti che attraversano il suo interno) ha lunghezze laterali e aree che sono potenze di due, con una delle lunghezze laterali essere al massimo due.

Compito

È necessario creare un programma o una funzione che prendano input da STDIN, argomento della funzione o argomento della riga di comando e che facciano un frattale di stuzzicadenti in quella fase. La guida e il trascinamento di newline è vietata, tranne se è inevitabile. Il riquadro di delimitazione deve essere minimo, compreso lo spazio iniziale e finale. Per la linea iniziale, facciamo due \diagonali nello spazio. L'input è garantito per essere inferiore a duemila. Almeno una riga ha un carattere non spaziale. È consentito lo spazio di trascinamento.

Casi test

1
\ 
 \     

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

CJam, 99 93 byte

Questo è piuttosto lungo ...

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

Provalo qui. Se vuoi testare input più grandi, come l'89 su Wikipedia, TryItOnline di Dennis usa l'interprete Java molto più veloce sotto il cofano e può gestire input del genere in pochi secondi.

Sono sicuro che c'è molto margine di miglioramento e aggiungerò una spiegazione quando sarò più felice con il punteggio ...

Ecco l'output per N = 13:

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

Per il mio riferimento quando si gioca a golf ulteriormente, alcune altre idee:

"\ "_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`
`)

Spiegazione

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
)

Test

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>

Rubino, 151 byte

La versione golfizzata utilizza solo un loop j, con ie kcalcolata al volo.

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

Non registrato nel programma di test

Questa versione utilizza 2 loop nidificati.

Un builtin usato raramente è sumche restituisce un checksum grezzo aggiungendo tutti i byte di una stringa 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]