이쑤시개 순서는 무엇입니까?

Wikipedia 에 따르면

형상에서, 이쑤시개 시퀀스는 시퀀스의 이전 패턴에 라인 세그먼트 ( "이쑤시개")를 반복적으로 추가함으로써 형성 될 수있는 2 차원 패턴의 시퀀스이다.

디자인의 첫 번째 단계는 단일 "이쑤시개"또는 선분입니다. 첫 번째 이후의 각 단계는 이전 디자인을 취하고 노출 된 모든 이쑤시개 끝에 대해 ​​다른 이쑤시개를 그 끝에 직각으로 배치하여 형성됩니다.

이 공정은 단계 n에서의 세그먼트의 수가 0.45n2와 0.67n2 사이의 프랙탈 패턴으로 진동하는 성장 패턴을 초래한다. T (n)이 단계 n에서의 세그먼트 수를 나타내는 경우, n이 2의 거듭 제곱에 가까울 때 T (n) / n2가 최대치에 가까운 n의 값이 발생하는 반면 최소값에 가까운 값은 2의 거듭 제곱의 약 1.43 배인 숫자 근처에서 발생합니다. 이쑤시개 순서의 단계 구조는 종종 T-square 프랙탈 또는 Ulam-Warburton 세포 오토 마톤에서의 세포 배열과 유사합니다.

패턴에서 이쑤시개로 둘러싸인 경계 영역은 모두 이쑤시개로 교차하지 않으며 정사각형 또는 직사각형이어야합니다. 이쑤시개 패턴의 모든 열린 직사각형 (즉, 이쑤시개로 완전히 둘러싸여 있지만 내부를 가로 지르는 이쑤시개가없는 직사각형)은 측면 길이와 측면 길이 중 하나를 갖는 2의 거듭 제곱이있는 것으로 추측됩니다 최대 2 명입니다.

직무

STDIN, 함수 인수 또는 명령 행 인수에서 입력을 가져 와서 해당 단계에서 픽 토크 프랙탈을 작성하는 프로그램 또는 함수를 작성해야합니다. 피할 수없는 경우를 제외하고 선행 및 후행 줄 바꿈은 금지됩니다. 선행 및 후행 공간을 포함하여 경계 상자가 최소한 있어야합니다. 초기 선의 경우 \공간에 두 개의 대각선을 만듭니다 . 입력 값은 2 천 미만이어야합니다. 하나 이상의 줄에 공백이 아닌 문자가 있습니다. 후행 공간이 허용됩니다.

테스트 사례

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*

여기에서 테스트하십시오. Wikipedia의 89와 같이 더 큰 입력을 테스트하려는 경우 Dennis의 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*

자바 스크립트 (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 바이트

Golfed 버전에서 사용하는 하나 개의 루프는 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 개의 중첩 루프를 사용합니다.

거의 사용되지 않는 내장 함수는 sumASCII 문자열의 모든 바이트를 추가하여 원유 체크섬을 반환합니다.

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]