Trình tự tăm là gì?

Theo Wikipedia

Trong hình học, chuỗi tăm là một chuỗi các mẫu 2 chiều có thể được hình thành bằng cách liên tục thêm các phân đoạn dòng ("tăm xỉa răng") vào mẫu trước đó trong chuỗi.

Giai đoạn đầu tiên của thiết kế là một "tăm" duy nhất, hoặc phân khúc dòng. Mỗi giai đoạn sau lần đầu tiên được hình thành bằng cách lấy thiết kế trước đó và, cho mỗi đầu tăm lộ ra, đặt một cây tăm khác ở giữa một góc bên phải trên đầu đó.

Quá trình này dẫn đến một mô hình tăng trưởng trong đó số lượng các phân đoạn ở giai đoạn n dao động với mô hình fractal trong khoảng 0,45n2 đến 0,67n2. Nếu T (n) biểu thị số lượng phân đoạn ở giai đoạn n, thì các giá trị của n mà T (n) / n2 gần mức tối đa của nó xảy ra khi n ở gần công suất hai, trong khi các giá trị gần mức tối thiểu của nó xảy ra gần các số gần gấp 1,43 lần lũy thừa của hai. Cấu trúc của các giai đoạn trong chuỗi tăm thường giống với fractal hình chữ T, hoặc sự sắp xếp của các tế bào trong máy tự động tế bào Ulam tựa Warburton.

Tất cả các vùng giới hạn được bao quanh bởi tăm trong mô hình, nhưng bản thân chúng không bị vượt qua bởi tăm, phải là hình vuông hoặc hình chữ nhật. Người ta đã phỏng đoán rằng mọi hình chữ nhật mở trong mô hình tăm (nghĩa là một hình chữ nhật được bao quanh hoàn toàn bởi tăm, nhưng không có tăm xuyên qua bên trong của nó) có chiều dài bên và các khu vực có sức mạnh bằng hai, với một trong các chiều dài bên nhiều nhất là hai.

Bài tập

Bạn phải tạo một chương trình hoặc hàm lấy đầu vào từ STDIN, đối số hàm hoặc đối số dòng lệnh và tạo một dấu ngoặc kép ở giai đoạn đó. Hàng đầu và theo dõi dòng mới bị cấm ngoại trừ nếu không thể tránh khỏi. Hộp giới hạn phải ở mức tối thiểu, bao gồm không gian hàng đầu và dấu. Đối với dòng inital, chúng tôi làm cho hai\ đường chéo trong không gian. Đầu vào được đảm bảo dưới hai nghìn. Ít nhất một dòng có ký tự không phải không gian. Không gian lưu trữ được cho phép.

Các trường hợp thử nghiệm

1
\ 
 \     

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

CJam, 99 93 byte

Điều này khá dài ...

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

Kiểm tra nó ở đây. Nếu bạn muốn kiểm tra các đầu vào lớn hơn, như 89 trên Wikipedia, TryItOnline của Dennis sử dụng trình thông dịch Java nhanh hơn nhiều và có thể xử lý các đầu vào như thế trong vài giây.

Tôi chắc chắn có rất nhiều cơ hội để cải thiện và tôi sẽ thêm một lời giải thích một khi tôi hạnh phúc hơn với điểm số ...

Đây là đầu ra cho N = 13:

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

Để tôi tham khảo khi chơi golf này hơn nữa, một số ý tưởng khác:

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

Giải trình

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
)

Kiểm tra

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 byte

Phiên bản chơi gôn chỉ sử dụng một vòng lặp j, với ivà được ktính khi đang bay.

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

Ungolfed trong chương trình thử nghiệm

Phiên bản này sử dụng 2 vòng lặp lồng nhau.

Nội dung hiếm khi được sử dụng là sumtrả về tổng kiểm tra thô bằng cách thêm tất cả các byte của chuỗi 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]