टूथपिक अनुक्रम उत्पन्न करें

Question

टूथपिक अनुक्रम क्या है?

विकिपीडिया के अनुसार

ज्यामिति में, टूथपिक अनुक्रम 2-आयामी पैटर्न का एक अनुक्रम है, जिसे अनुक्रम में पिछले पैटर्न में बार-बार लाइन सेगमेंट ("टूथपिक्स") जोड़कर बनाया जा सकता है।

डिजाइन का पहला चरण एक एकल "टूथपिक", या लाइन सेगमेंट है। पहले चरण के बाद प्रत्येक चरण पिछले डिज़ाइन को ले कर बनता है और, प्रत्येक उजागर टूथपिक अंत के लिए, उस छोर पर एक सही कोण पर केंद्रित एक और टूथपिक रखकर।

इस प्रक्रिया के परिणामस्वरूप विकास का एक पैटर्न होता है जिसमें चरण n पर खंडों की संख्या 0.45n2 और 0.67n2 के बीच एक भग्न पैटर्न के साथ दोलन करती है। यदि T (n) स्टेज n पर सेगमेंट की संख्या को निरूपित करता है, तो n का मान जिसके लिए T (n) / n2 है, अधिकतम तब होता है जब n दो की शक्ति के पास होता है, जबकि वह मान जिसके लिए यह न्यूनतम है ऐसी संख्याओं के पास जो दो की शक्ति का लगभग 1.43 गुना है। टूथपिक अनुक्रम में चरणों की संरचना अक्सर टी-वर्ग भग्न, या उलम-वारबटन सेलुलर ऑटोमेटन में कोशिकाओं की व्यवस्था से मिलती जुलती है।

पैटर्न में टूथपिक्स से घिरे हुए सभी बंधे हुए क्षेत्र, लेकिन स्वयं टूथपिक से पार नहीं हुए, चौकोर या आयताकार होने चाहिए। यह अनुमान लगाया गया है कि टूथपिक पैटर्न में हर खुली आयत (यानी, एक आयत जो पूरी तरह से टूथपिक्स से घिरी हुई है, लेकिन उसके इंटीरियर को पार करने वाला कोई टूथपिक नहीं है) की लंबाई और क्षेत्र दो की शक्तियां हैं, जिनमें से एक की लंबाई लंबाई के साथ है अधिकतम दो पर।

कार्य

आपको एक प्रोग्राम या फ़ंक्शन बनाना चाहिए जो STDIN, फ़ंक्शन तर्क, या कमांडलाइन तर्क से इनपुट लेता है और उस स्तर पर एक टॉटिक फ्रैक्टल बनाता है। न्यूलाइन को छोड़ना और पीछे छोड़ना निषिद्ध है, भले ही वह अपरिहार्य हो। बाउंडिंग बॉक्स कम से कम होना चाहिए, जिसमें प्रमुख और अनुगामी स्थान शामिल है। Inital line के लिए, हम \अंतरिक्ष में दो विकर्ण बनाते हैं। इनपुट दो हजार से कम होने की गारंटी है। कम से कम एक पंक्ति में गैर-अंतरिक्ष वर्ण होता है। ट्रेलिंग स्पेस की अनुमति है।

परीक्षण के मामलों

1
\ 
 \     

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

Answer 1

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 की तरह, डेनिस की ट्रिप इटऑनलाइन हुड के तहत बहुत तेज़ जावा दुभाषिया का उपयोग करता है और कुछ सेकंड में इस तरह के इनपुट को संभाल सकता है।

मुझे यकीन है कि सुधार के लिए बहुत जगह है, और स्कोर के साथ खुश होने के बाद मैं एक स्पष्टीकरण जोड़ूंगा ...

यहाँ के लिए उत्पादन है 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*

Answer 2

जावास्क्रिप्ट (ईएस 6), 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>

Answer 3

रूबी, 151 बाइट्स

गोल्फ संस्करण केवल एक लूप का उपयोग करता है 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 नेस्टेड छोरों का उपयोग करता है।

एक शायद ही कभी बनाया गया बेसिन होता है sumजो एक एससीआई स्ट्रिंग के सभी बाइट्स को जोड़कर एक क्रूड चेकसम लौटाता है।

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]