টুথপিক সিকোয়েন্স তৈরি করুন

Question

টুথপিক সিকোয়েন্স কী?

উইকিপিডিয়া অনুসারে

জ্যামিতিতে, টুথপিক সিকোয়েন্সটি দ্বি-মাত্রিক প্যাটার্নগুলির একটি ক্রম যা ক্রমটিতে পূর্ববর্তী প্যাটার্নটিতে বারবার লাইন বিভাগগুলি ("টুথপিক্স") যুক্ত করে গঠন করা যেতে পারে।

ডিজাইনের প্রথম পর্যায়ে রয়েছে একক "টুথপিক" বা লাইন বিভাগ। প্রথমটির পরের প্রতিটি স্তর পূর্ববর্তী নকশা গ্রহণ করে এবং প্রতিটি উন্মুক্ত টুথপিক প্রান্তের জন্য, অন্য প্রান্তে ডান কোণে কেন্দ্র করে অন্য দাঁতপিক স্থাপন করে তৈরি হয়।

এই প্রক্রিয়াটির ফলে বৃদ্ধির এক ধরণের ফলাফল হয় যার মধ্যে স্টেজ এন-তে বিভাগগুলির সংখ্যা 0.45n2 এবং 0.67n2 এর মধ্যে ফ্র্যাক্টাল প্যাটার্ন সহ দোলায়। যদি টি (এন) n পর্যায়ে n অংশগুলির সংখ্যা চিহ্নিত করে, তবে n এর মান যেটির জন্য T (n) / n2 তার সর্বাধিক কাছাকাছি হয় যখন এন দুটির শক্তির নিকটে থাকে, যখন মানগুলি এটির সর্বনিম্নের নিকটে থাকে দুটি সংখ্যার পাওয়ারের প্রায় 1.43 গুণ বেশি সংখ্যার নিকটে উপস্থিত হয়। টুথপিক সিকোয়েন্সের পর্যায়গুলির কাঠামোটি প্রায়শই টি-স্কোয়ার ফ্র্যাক্টাল বা উলাম-ওয়ার্ববার্টন সেলুলার অটোমেটনে কোষগুলির বিন্যাসের সাথে সাদৃশ্যপূর্ণ।

প্যাটার্নে টুথপিকগুলি দ্বারা বেষ্টিত সমস্ত সীমানা অঞ্চল, তবে তারা নিজেরাই টুথপিকগুলি দ্বারা অতিক্রম না করে অবশ্যই চৌকো বা আয়তক্ষেত্র হতে হবে। এটি অনুমান করা হয়েছে যে টুথপিক প্যাটার্নের প্রতিটি উন্মুক্ত আয়তক্ষেত্রটি (এটি একটি আয়তক্ষেত্র যা সম্পূর্ণ টুথপিক্স দ্বারা বেষ্টিত, তবে এর অভ্যন্তর অতিক্রমকারী কোনও দাঁতপিক নেই) পাশের দৈর্ঘ্যগুলির একটির সাথে পাশের দৈর্ঘ্য এবং ক্ষেত্রগুলি দুটি যা দুটি শক্তিযুক্ত সর্বাধিক দুই হচ্ছে।

কার্য

আপনাকে অবশ্যই এমন একটি প্রোগ্রাম বা ফাংশন তৈরি করতে হবে যা STDIN, ফাংশন আর্গুমেন্ট, বা কমান্ডলাইন আর্গুমেন্ট থেকে ইনপুট নেয় এবং সেই পর্যায়ে একটি টটপিক ফ্র্যাক্টাল করে তোলে। নেতৃস্থানীয় এবং অনুসরণযোগ্য নতুন লাইনটি যদি অনিবার্য না হয় তবে তা নিষিদ্ধ। বাউন্ডিং বাক্সটি অবশ্যই নূন্যতম হতে হবে, শীর্ষস্থানীয় এবং পিছনের স্থান সহ। ইনিটাল লাইনের জন্য, আমরা দুটি করি\ মহাকাশে তির্যক । ইনপুটটি দুই হাজারেরও কম হওয়ার নিশ্চয়তা রয়েছে। কমপক্ষে একটি লাইনে ফাঁকবিহীন অক্ষর রয়েছে। চলার স্থান অনুমোদিত।

পরীক্ষার কেস

1
\ 
 \     

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

Answer 1

সিজেম, 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

জাভাস্ক্রিপ্ট (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>

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]