Co to jest sekwencja Wykałaczki?

Według Wikipedii

W geometrii sekwencja wykałaczki jest sekwencją dwuwymiarowych wzorów, które można utworzyć przez wielokrotne dodawanie segmentów linii („wykałaczek”) do poprzedniego wzoru w sekwencji.

Pierwszym etapem projektu jest pojedyncza „wykałaczka” lub segment linii. Każdy etap po pierwszym tworzy się, biorąc poprzedni projekt i, dla każdego odsłoniętego końca wykałaczki, umieszczając kolejną wykałaczkę wyśrodkowaną pod odpowiednim kątem na tym końcu.

Proces ten powoduje wzorzec wzrostu, w którym liczba segmentów na etapie n oscyluje z wzorem fraktalnym między 0,45n2 a 0,67n2. Jeśli T (n) oznacza liczbę segmentów na etapie n, wówczas wartości n, dla których T (n) / n2 jest bliski maksimum, występują, gdy n jest bliskie potędze dwóch, podczas gdy wartości, dla których jest bliski minimum występują w pobliżu liczb, które są około 1,43 razy potęgą dwóch. Struktura etapów w sekwencji wykałaczki często przypomina fraktal w kształcie litery T lub układ komórek w automacie komórkowym Ulam – Warburton.

Wszystkie ograniczone obszary otoczone wzorem wykałaczek, ale same nie przecięte wykałaczkami, muszą być kwadratami lub prostokątami. Przypuszcza się, że każdy otwarty prostokąt we wzorze wykałaczki (to znaczy prostokąt, który jest całkowicie otoczony wykałaczkami, ale żadna wykałaczka nie przecina jego wnętrza) ma długości boczne i obszary, które są potęgami dwóch, z jedną z długości bocznych być co najwyżej dwoma.

Zadanie

Musisz stworzyć program lub funkcję, która pobiera dane wejściowe ze STDIN, argument funkcji lub argument wiersza poleceń i na tym etapie tworzy fraktal wykałaczki. Wiodące i końcowe znaki nowej linii są zabronione, chyba że jest to nieuniknione. Pole ograniczające musi mieć co najmniej szerokość, w tym miejsce początkowe i końcowe. Dla linii początkowej wykonujemy dwie \przekątne w przestrzeni. Gwarantowany wkład jest mniejszy niż dwa tysiące. Co najmniej jedna linia ma znak spacji. Końcowe miejsce jest dozwolone.

Przypadki testowe

1
\ 
 \     

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

CJam, 99 93 bajtów

Trwało to dość długo ...

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

Sprawdź to tutaj. Jeśli chcesz przetestować większe dane wejściowe, takie jak 89 na Wikipedii, TryItOnline Dennisa używa znacznie szybszego interpretera Java pod maską i może obsłużyć takie dane wejściowe w kilka sekund.

Jestem pewien, że jest wiele do zrobienia i dodam wyjaśnienie, gdy będę zadowolony z wyniku ...

Oto dane wyjściowe dla N = 13:

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

Dla mojego własnego odniesienia podczas gry w golfa, kilka innych pomysłów:

"\ "_W%]{{Sf+W%z}4*2few2ew::.{+_a"\//\\"4S**4/^_,3={:.e>W%\}&;2/}:z{\)[email protected]>+}ff*{\)[email protected]>+}*}ri(*N*

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

JavaScript (ES6), 263 bajty

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

Wyjaśnienie

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>

Rubinowy, 151 bajtów

Golfed wersja używa tylko jednej pętli, jze ii kobliczana na bieżąco.

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

Niegolfowany w programie testowym

Ta wersja wykorzystuje 2 zagnieżdżone pętle.

Rzadko używane narzędzie wbudowane, sumktóre zwraca surową sumę kontrolną przez dodanie wszystkich bajtów ciągu 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]