ลำดับไม้จิ้มฟันคืออะไร?

ตามที่Wikipedia

ในเรขาคณิตลำดับไม้จิ้มฟันเป็นลำดับของรูปแบบ 2 มิติซึ่งสามารถเกิดขึ้นได้โดยการเพิ่มส่วนของเส้น ("ไม้จิ้มฟัน") ซ้ำกับรูปแบบก่อนหน้าในลำดับ

ขั้นตอนแรกของการออกแบบคือ "ไม้จิ้มฟัน" เดียวหรือส่วนของเส้น แต่ละขั้นตอนหลังจากครั้งแรกจะเกิดขึ้นโดยการออกแบบก่อนหน้านี้และสำหรับทุกปลายไม้จิ้มฟันสัมผัสวางไม้จิ้มฟันอีกเป็นศูนย์กลางที่มุมขวาในปลายนั้น

กระบวนการนี้ส่งผลในรูปแบบของการเจริญเติบโตซึ่งจำนวนของส่วนที่ระยะ oscillates กับรูปแบบเศษส่วนระหว่าง 0.45n2 และ 0.67n2 ถ้า T (n) หมายถึงจำนวนของเซ็กเมนต์ที่ระยะ n ดังนั้นค่าของ n ที่ T (n) / n2 ใกล้เคียงกับค่าสูงสุดที่เกิดขึ้นเมื่อ n อยู่ใกล้กับกำลังสองเท่าในขณะที่ค่าที่ใกล้ที่สุด เกิดขึ้นใกล้กับตัวเลขที่มีค่าประมาณ 1.43 เท่าของกำลังสอง โครงสร้างของลำดับขั้นในลำดับไม้จิ้มฟันมักจะมีลักษณะคล้ายกับแฟร็กทัล T-square หรือการจัดเรียงของเซลล์ในหุ่นยนต์เคลื่อนที่ของ Ulam-Warburton

ทุกพื้นที่ที่ล้อมรอบด้วยไม้จิ้มฟันในรูปแบบ แต่ไม่ใช่ตัวเองผ่านไม้จิ้มฟันต้องเป็นสี่เหลี่ยมหรือสี่เหลี่ยม มันได้รับการคาดเดาว่าทุกรูปสี่เหลี่ยมผืนผ้าที่เปิดอยู่ในรูปแบบไม้จิ้มฟัน (นั่นคือรูปสี่เหลี่ยมผืนผ้าที่ล้อมรอบอย่างสมบูรณ์ด้วยไม้จิ้มฟัน แต่ไม่มีไม้จิ้มฟันข้ามภายใน) มีความยาวด้านและพื้นที่ที่เป็นพลังของสองกับหนึ่งในความยาวด้าน อยู่ที่มากที่สุดสองคน

งาน

คุณต้องสร้างโปรแกรมหรือฟังก์ชั่นที่รับอินพุตจาก STDIN, อาร์กิวเมนต์ของฟังก์ชันหรืออาร์กิวเมนต์บรรทัดคำสั่งและสร้างเศษส่วน tootpick ในขั้นตอนนั้น ขึ้นบรรทัดใหม่นำหน้าและต่อท้ายเป็นสิ่งต้องห้ามเว้นแต่เป็นสิ่งที่หลีกเลี่ยงไม่ได้ กล่องอย่างน้อยต้องเป็นกล่องรวมถึงพื้นที่นำหน้าและส่วนท้าย สำหรับเส้น inital เราทำสอง\เส้นทแยงมุมในอวกาศ อินพุตรับประกันว่าจะน้อยกว่าสองพัน อย่างน้อยหนึ่งบรรทัดมีอักขระที่ไม่ใช่ช่องว่าง อนุญาตให้ใช้พื้นที่ต่อท้าย

กรณีทดสอบ

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*

ทดสอบที่นี่ หากคุณต้องการทดสอบอินพุตที่ใหญ่กว่าเช่น 89 บน Wikipedia นั้นTryItOnlineของ Dennis ใช้ล่าม 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*

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

Ungolfed ในโปรแกรมทดสอบ

รุ่นนี้ใช้ลูปซ้อนกัน 2 วง

builtin ที่ไม่ค่อยได้ใช้จะsumส่งคืนการตรวจสอบดิบโดยการเพิ่มไบต์ทั้งหมดของสตริง 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]