ASCII L- सिस्टम रेंडरर

Question

पृष्ठभूमि

एक एल-सिस्टम (या लिंडेनमेयर सिस्टम) एक समानांतर पुनर्लेखन प्रणाली है जो अन्य चीजों के अलावा, आसानी से फ्रैक्टल्स को मॉडल करने के लिए उपयोग किया जा सकता है। यह सवाल नियतात्मक, संदर्भ-मुक्त एल-सिस्टम की चिंता करता है । इनमें प्रतीकों की एक वर्णमाला, एक प्रारंभिक स्वयंसिद्ध स्ट्रिंग और फिर से लिखना नियमों का एक सेट होता है, जो प्रत्येक वर्णमाला प्रतीक को एक नए स्ट्रिंग में मैप करता है। नियमों को समानांतर में स्वयंसिद्ध के लिए लागू किया जाता है, एक नया स्ट्रिंग पैदा करता है। इस प्रक्रिया को फिर दोहराया जाता है।

उदाहरण के लिए, स्वयंसिद्ध "A" और रूल्स A = ABA; B = BBB के साथ सिस्टम "ABA", "ABABBBA", "ABABBBABABBBBBBBBBABABBABA" आदि स्ट्रिंग्स का क्रम उत्पन्न करता है, हम स्पष्टता के लिए स्पष्ट रूप से उल्लेख नहीं करते हैं। एल-सिस्टम को परिभाषित करते समय वर्णमाला। इसके अलावा, एक स्पष्ट पुनर्लेखन नियम के बिना किसी भी प्रतीक को अपरिवर्तित माना जाता है (यानी प्रतीक A के लिए डिफ़ॉल्ट नियम A = A है)।

कछुए ग्राफिक्स के एक रूप का उपयोग करके एल-सिस्टम की कल्पना की जा सकती है। अधिवेशन से, कछुआ दाईं ओर का सामना करना शुरू कर देता है। एक स्ट्रिंग को उसके प्रतीकों पर पुनरावृत्त करके खींचा जाता है: एक एफ का अर्थ है "एक इकाई को आगे बढ़ाएं", एक जी का अर्थ है "एक इकाई को आगे बढ़ाएं", एक + का अर्थ है "एक कोण को छोड़ दिया इकाई" और एक का अर्थ है - "सही एक कोण को चालू करें" इकाई "। स्ट्रिंग में अन्य सभी प्रतीकों को अनदेखा किया जाता है। इस प्रश्न के उद्देश्य के लिए, कोण इकाइयों को हमेशा 90 ° माना जाता है।

कार्य

किसी भी एल-सिस्टम के विनिर्देश और कई पुनरावृत्तियों को देखते हुए, आपके प्रोग्राम को बॉक्स-ड्राइंग वर्णों का उपयोग करके परिणामस्वरूप स्ट्रिंग (जैसा कि ऊपर वर्णित है) का एक ASCII प्रतिपादन करना चाहिए।

• पैरामीटर को अंतरिक्ष-पृथक स्ट्रिंग के रूप में पारित किया जाता है जिसमें स्वयंसिद्ध, पुन: लिखने के नियम (समीकरणों की -separated सूची) और पुन: लेखन पुनरावृत्तियों की संख्या शामिल होती है। उदाहरण के लिए, इनपुट "एफएफ = एफजीएफ; जी = जीजीजी 2" स्ट्रिंग "एफजीएफजीजीएफजीएफ" उत्पन्न करता है और इसलिए उपयुक्त अंतराल के साथ चार लाइनें खींचता है।
• एल-सिस्टम द्वारा उपयोग किए जाने वाले प्रतीक अंतरिक्ष और अर्धविराम के अलावा कोई भी ASCII वर्ण हो सकते हैं। प्रति प्रतीक में निर्दिष्ट एक सबसे स्पष्ट नियम है (डिफ़ॉल्ट पुनर्लेखन नियम के रूप में ऊपर वर्णित पहचान मानचित्रण)।
• आप मान सकते हैं कि आउटपुट में हमेशा कम से कम एक एफ होगा।
• विज़ुअलाइज़ेशन का प्रतिनिधित्व करने के लिए आउटपुट को निम्न UNICODE बॉक्स-ड्रॉइंग वर्णों का उपयोग करना चाहिए : U (U + 2500), 250 (U + 2502), ┌ (U + 250C), ┐ (U + 2510), └ (U + 2514) ,, (U + 2518), ┘ (U + 251C), U (U + 2524), 25 (U + 252C), ┴ (U + 2534), ┼ (U + 253C), ╴ (U + 2574), 25 (U + 2575), ╶ (U + 2576) और U (U + 2577)। उदाहरण के लिए नीचे देखें।
• आउटपुट में सबसे ऊपरी बॉक्स कैरेक्टर के ऊपर या बॉटलमोस्ट एक के नीचे की खाली लाइनें नहीं होनी चाहिए। इसमें बाईं ओर के बॉक्स चेज़र या दाईं ओर दाईं ओर कोई रिक्त स्थान नहीं होना चाहिए। अनुगामी स्थानों वाली रेखाएं जो सबसे सही बॉक्स वर्ण से आगे नहीं बढ़ती हैं, की अनुमति है।

आप STDIN (या निकटतम वैकल्पिक), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेते हुए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं। परिणामों को STDOUT (या निकटतम विकल्प) पर मुद्रित किया जाना चाहिए, एक फ़ाइल में सहेजा गया या एक स्ट्रिंग के रूप में लौटाया जा सकता है।

उदाहरण

# Cantor dust
>> "F F=FGF;G=GGG 0"
╶╴
>> "F F=FGF;G=GGG 1"
╶╴╶╴
>> "F F=FGF;G=GGG 2"
╶╴╶╴  ╶╴╶╴
>> "F F=FGF;G=GGG 3"
╶╴╶╴  ╶╴╶╴        ╶╴╶╴  ╶╴╶╴

# Koch curve
>> "F F=F+F−F−F+F 1"
 ┌┐
╶┘└╴
>> "F F=F+F-F-F+F 2"
    ┌┐
   ┌┘└┐
  ┌┘  └┐
 ┌┼┐  ┌┼┐
╶┘└┘  └┘└╴

आपके कार्यक्रम को शामिल करने के लिए अन्य उदाहरणों में शामिल हैं:

# Dragon curve
>> "FX X=X+YF+;Y=-FX-Y n"

# Hilbert curve
>> "A A=-BF+AFA+FB-;B=+AF-BFB-FA+ n"

# Sierpinski carpet
>> "F F=F+F-F-F-G+F+F+F-F;G=GGG n"

पहले दो जो निम्नानुसार दिखते हैं (@ edc65 के उत्तर का उपयोग करके निर्मित):

आप इस पृष्ठ पर किसी भी सिस्टम का परीक्षण कर सकते हैं ।

स्कोरिंग

सबसे छोटा कोड (बाइट्स में) जीतता है। मानक नियम लागू होते हैं।

Miscellania

यह चुनौती ड्रॉ के साथ रैंडम वॉक से प्रेरित थी । वास्तव में, एल-सिस्टम के रूप में एक यादृच्छिक चलना का प्रतिनिधित्व करना संभव है अगर हम प्रतिलेखन के दौरान गैर-नियतात्मक रूप से चुने गए विस्तार के साथ प्रति प्रतीक कई नियमों की अनुमति देने के लिए सिस्टम का विस्तार करते हैं । एक सूत्रीकरण है:

"F F=FF;F=F+F;F=F++F;F=F+++F"

एक और आम विस्तार, जिसका उपयोग अक्सर पौधों को मॉडलिंग करते समय, [] और चरित्रों की व्याख्या करने के लिए किया जाता है क्योंकि वर्तमान स्थिति और कोण को धकेलने और पॉप करने के रूप में। अधिकांश पौधे 90 ° से छोटे कोण का उपयोग करते हैं, लेकिन यहाँ एक उदाहरण है जो नहीं है:

"FAX X=[-FAX][FAX][+FAX];A=AFB;B=A"

इस चुनौती में न तो इन उदाहरणों का समर्थन किया जाना चाहिए।

यह चुनौती भी "माफ करना, जवान आदमी के समान है , लेकिन यह कछुए नीचे सभी तरह से है!" । हालाँकि, उस चुनौती ने ASCII के बजाय लाइन रेंडरिंग का इस्तेमाल किया और एक अधिक लचीली वाक्य रचना की अनुमति दी।

Answer 1

जावास्क्रिप्ट (ES6), 440 बाइट्स (410 वर्ण)

F=p=>([a,r,n]=p.split(' '),t=>{r.split(';').map(x=>r[x[0]]=x.slice(2),r={});for(;n--;)a=[...a].map(c=>r[c]||c).join('');u=x=y=0,g=[];for(c of a)c=='+'?[t,u]=[u,-t]:c=='-'?[u,t]=[t,-u]:c<'F'|c>'G'?0:((y+=u)<0?(g=[[],...g],++y):g[y]=g[y]||[],(x+=t)<0?(g=g.map(r=>[,...r]),++x):0,c>'F'?0:g[g[f=t?0.5:2,y][x]|=(3+t-u)*f,y-u][x-t]|=(3+u-t)*f)})(1)||g.map(r=>[for(c of r)' ╶╴─╵└┘┴╷┌┐┬│├┤┼'[~~c]].join('')).join('\n')

कम गोल्फ वाला

F=p=>{
  [a,r,n]=p.split(' '),
  r.split(';').map(x=>r[x[0]]=x.slice(2),r={}); // set rules
  for(;n--;)a=[...a].map(c=>r[c]||c).join(''); // build string
  t=1,u=x=y=0, // start pos 0,0 start direction 1,0
  g=[[]]; // rendering in bitmap g
  for(c of a)
    c=='+'?[t,u]=[u,-t] // left turn
    :c=='-'?[u,t]=[t,-u] // right turn
    :c=='F'|c=='G'?(     // move or draw
      (y+=u)<0?(g=[[],...g],++y):g[y]=g[y]||[], // move vertical, enlarge grid if needed
      (x+=t)<0?(g=g.map(r=>[,...r]),++x):0, // move horizontal, enlarge grid if needed
      c=='F'&&( // draw: set bits
        f=t?0.5:2,
        g[y][x]|=(3+t-u)*f,
        g[y-u][x-t]|=(3+u-t)*f
      )
    ):0;
  // render bits as box characters
  return g.map(r=>[' ╶╴─╵└┘┴╷┌┐┬│├┤┼'[~~c]for(c of r)].join('')).join('\n')
}

टेस्ट कोड स्निपेट टेस्ट करने के लिए (फ़ायरफ़ॉक्स में)

F=p=>([a,r,n]=p.split(' '),t=>{r.split(';').map(x=>r[x[0]]=x.slice(2),r={});for(;n--;)a=[...a].map(c=>r[c]||c).join('');u=x=y=0,g=[];for(c of a)c=='+'?[t,u]=[u,-t]:c=='-'?[u,t]=[t,-u]:c<'F'|c>'G'?0:((y+=u)<0?(g=[[],...g],++y):g[y]=g[y]||[],(x+=t)<0?(g=g.map(r=>[,...r]),++x):0,c>'F'?0:g[g[f=t?0.5:2,y][x]|=(3+t-u)*f,y-u][x-t]|=(3+u-t)*f)})(1)||g.map(r=>[for(c of r)' ╶╴─╵└┘┴╷┌┐┬│├┤┼'[~~c]].join('')).join('\n')

fs=18;(Z=d=>(Result.style.fontSize=(fs+=d)+'px',Result.style.lineHeight=fs+'px'))(0)

#Result { font-size: 10px }
#Param { width: 400px }

Param: <input type=text id=Param />
<button onclick="Result.innerHTML=F(Param.value)">Start</button><br>
Output <button onclick="Z(-2)">Z-</button> <button onclick="Z(2)">Z+</button>
<br>
<pre id=Result></pre>

Comments

महान (और त्वरित!) उत्तर। मैंने प्रश्न के लिए ड्रैगन और हिल्बर्ट वक्र आउटपुट के स्क्रीनशॉट जोड़े हैं।

— उड़ी ग्राम

Answer 2

हास्केल, 568 बाइट्स

import Data.List.Split
p=splitOn
l=lookup
m=maximum
n=minimum
o[h,x]=(h,x)
Just x#_=x
_#x=x
g[s,r,i]=iterate((\c->lookup[c](map(o.p"=")(p";"r))#[c])=<<)s!!read i
u v@(a,x,y,d,e)c|c=='+'=(a,x,y,-e,d)|c=='-'=(a,x,y,e,-d)|c=='G'=(a,x+d,y+e,d,e)|c=='F'=(s(x,y)(d%e)a:s(x+d,y+e)(d?e)a:a,x+d,y+e,d,e)|1<2=v
s p n a=(p,n+(l p a)#0)
1%0=2;0%1=8;-1%0=1;0%(-1)=4
1?0=1;0?1=4;-1?0=2;0?(-1)=8
f z=unlines[[" ╴╶─╷┐┌┬╵┘└┴│┤├┼"!!(l(x,y)q#0)|x<-[n a..m a]]|y<-[m b,m b-1..n b]]where a=map(fst.fst)q;b=map(snd.fst)q;(q,_,_,_,_)=foldl u([],0,0,1,0)$g$p" "z

परीक्षण चालन:

*Main> putStr $ f "F F=F-F+F+F-F 3"
╶┐┌┐  ┌┐┌┐        ┌┐┌┐  ┌┐┌╴
 └┼┘  └┼┼┘        └┼┼┘  └┼┘
  └┐  ┌┼┼┐        ┌┼┼┐  ┌┘
   └┐┌┼┘└┘        └┘└┼┐┌┘
    └┼┘              └┼┘   
     └┐              ┌┘
      └┐┌┐        ┌┐┌┘
       └┼┘        └┼┘
        └┐        ┌┘
         └┐┌┐  ┌┐┌┘
          └┼┘  └┼┘
           └┐  ┌┘
            └┐┌┘
             └┘

यह काम किस प्रकार करता है:

• पुनर्लेखन (फ़ंक्शन g): मैं नियमों को एक एसोसिएशन सूची (पत्र -> प्रतिस्थापन स्ट्रिंग) में पार्स करता हूं और बार-बार इसे स्वयंसिद्ध पर मैप करता हूं।
• पथ बनाने (समारोह u(मैं एक मैट्रिक्स में लेकिन साथ (एक्स, वाई) कुंजी और 4 बुनियादी ब्लॉक के बिट पैटर्न के रूप में पदों एक और संघ सूची में पथ की दुकान नहीं है: एक ही चरण के लिए) ╴, ╶, ╷और ╵मूल्यों के रूप में) । जिस तरह से मैं वर्तमान स्थिति और दिशा का ट्रैक रखता हूं।
• पथ (फ़ंक्शन f) खींचना : पहले मैं पथ सूची से अधिकतम / मिनट आयामों की गणना करता हूं और फिर मैं [अधिकतम y -> मिनट y] और [मिनट x -> अधिकतम x] पर पुनरावृति करता हूं और आकर्षित करने के लिए ब्लॉकों की खोज करता हूं।

Answer 3

ईएस 7, 394 चार्ट, 424 बाइट्स

F=p=>([a,r,n]=p.split` `,t=>{r.split`;`.map(x=>r[x[0]]=x.slice(2),r={});for(;n--;)a=[...a].map(c=>r[c]||c).join``;u=x=y=0,g=[];for(c of a)c=='+'||c=='-'?[t,u]=[u,-t]:c<'F'|c>'G'?0:((y+=u)<0?(g=[[],...g],++y):g[y]=g[y]||[],(x+=t)<0?(g=g.map(r=>[,...r]),++x):0,c>'F'?0:g[g[f=t?0.5:2,y][x]|=(3+t-u)*f,y-u][x-t]|=(3+u-t)*f)})(1)||g.map(r=>[for(c of r)'╶╴─╵└┘┴╷┌┐┬│├┤┼'[~~c]].join``).join`
`