"क्षमा करें, जवान आदमी, लेकिन यह कछुए नीचे सभी तरह से है!"

Question

एक लिंडेनमायर सिस्टम निष्पादित करें

एक Lindenmayer सिस्टम (या एल प्रणाली) से संबंधित है Thue और पोस्ट प्रणाली, और प्रयोग किया जाता है वनस्पति मॉडलिंग और भग्न पीढ़ी ।

एक एल-सिस्टम को स्ट्रिंग-पुनर्लेखन द्वारा वर्णित किया जाता है जहां प्रतीक-वर्णमाला से एक प्रतीक को प्रतीकों के प्रतिस्थापन अनुक्रम में मैप किया जाता है । इन मैपिंग का एक संग्रह एल-सिस्टम को उचित बनाता है।

मैपिंग एक करने के लिए लागू किया गया है के बाद चित्रमय परिणाम विधि के रूप में Prusinkiewicz द्वारा तैयार जिसके परिणामस्वरूप अनुक्रम व्याख्या प्रारंभिक की एक निर्धारित संख्या के लिए अनुक्रम पुनरावृत्तियों आगे, पिछड़े, बाएँ, दाएँ, तरह का और सामान:, कछुए-ड्राइंग आदेशों के रूप में। ड्राइंग के पैमाने को नियंत्रित करने के लिए इसके लिए अतिरिक्त कोड की आवश्यकता हो सकती है क्योंकि विभिन्न पुनरावृत्तियों की गिनती बहुत भिन्न-भिन्न आकार की छवियां उत्पन्न कर सकती है।

आपका कार्य कम से कम वर्णों में L- सिस्टम निष्पादित करना है। आपका प्रोग्राम उपयुक्त इनपुट (फ़ाइल, कमांड-लाइन, लेकिन स्रोत के लिए बाहरी, कृपया) प्रदान करके विकिपीडिया पृष्ठ से ड्रैगन वक्र और शाखाओं के तने दोनों को प्रस्तुत करने में सक्षम होना चाहिए।

यह कोड गोल्फ है।

संपादित करें: यहां कुछ उदाहरण दिए गए हैं जो मैंने शहर के आसपास पोस्ट किए हैं। उत्तर: SO / रोटेट-टू-नॉर्थ { जहाँ मैंने पहली बार L-system की खोज की थी } , SO / how-to-program-a-fractal का उत्तर , SO / recursion-in-postcript , comp.lang.posts पर चर्चा का उत्तर दें / गायन , पोस्टस्क्रिप्ट एल-सिस्टम संग्रह , codegolf.SE/draw-a-sierpinski-triangle {खुद और thomasW के बीच प्रतियोगिता की उत्पत्ति} ।

Comments

सैंडबॉक्स को छोड़ दिया। यह अपेक्षाकृत सरल लगता है और मजेदार होना चाहिए।

— लूजर

BTW, किसी को भी उपरोक्त उद्धरण की उत्पत्ति पता है? मैंने विलियम जेम्स को सुना है, और मैंने फैराडे को सुना है।

— लूसर डॉग

विकिपीडिया का कहना है कि मूल विवाद में है, सबसे अच्छा अनुमान बर्ट्रेंड रसेल है।

— बदसूरत

ITYM बर्ट्रेंड रसेल ।

— पॉल आर

क्या वर्णमाला के आकार, नियमों की संख्या, राउंड की संख्या या संभव (विज़ुअलाइज़ेशन) नियमों पर कोई सीमा है (एक सीधी रेखा खींचना, धक्का / पॉप स्थिति / कोण, कितने डिग्री आदि को मोड़ना) अगर हमें केवल आकर्षित करना है उन दो को तब हमें धक्का और पॉपिंग की आवश्यकता होगी, सीधी रेखाएँ खींचना और दोनों दिशाओं में 45 डिग्री को मोड़ने में सक्षम होना, केवल दो नियम और आकार का एक वर्णमाला 4.

— shiona

Answer 1

गणितज्ञ 200 198 188 171 168

स्पष्टता के लिए जोड़े गए स्थान:

f[i_, b_, h_, j_, r_, n_] :=
 (a = h; p = j; s = k = {}; t = Flatten;
  (Switch[#,
      6, s = {a, p, s},
      8, {a, p, s} = s,
      _C, k = {k, Line@{p, p += {Cos@a, Sin@a}}}];
     If[# < 9, a += I^# b ]) & /@ t@Nest[# /. r &, i, n];
  Graphics@t@k)

कहा पे:

i: प्रारंभिक अवस्था;
बी: रोटेशन कोण
एच: प्रारंभिक कोण
जम्मू: प्रारंभिक स्थिति
आर: उत्पादन नियम
एन: पुनरावृत्तियों

उत्पादन नियम व्याकरण:

2 = बाएं मुड़ें (-);
4 = सही मोड़ (+);
6 = पुश और टर्न लेफ्ट ("[");
8 = पॉप और टर्न राइट ("]");
C [i] = ड्रा (प्रतीकों की कोई संख्या)
कोई अन्य प्रतीक = कुछ भी न करें, बस इसे अगले राज्य के उत्पादन में उपयोग करें (किसी भी प्रतीक के नंबर)

{2,4,6,8} अनुक्रम वहां है क्योंकि मैं मोड़ बनाने के लिए I^n( I= काल्पनिक इकाई) का उपयोग कर रहा हूं ।

उदाहरण:

f[{C[1], X}, Pi/2, 0, {0, 0}, {X -> {X, 4, Y, C[1]}, Y -> {C[1], X, 2, Y}}, 10]

f[{C@1}, Pi/2, 0, {0,0}, {C@1->{C@1, 2, C@1, 4, C@1, 4, C@1, 2, C@1}}, 6]

f[{C[1]}, Pi/4, Pi/2, {0, 0}, {C[2] -> {C[2], C[2]}, C[1] -> {C[2], 6, C[1], 8, C[1]}}, 10]

f[{C[1]}, Pi/3, 0, {0, 0}, {C@1 -> {C@2, 4, C@1, 4, C@2}, C@2 -> {C@1, 2, C@2, 2, C@1}}, 10]

f[{X},5/36 Pi, Pi/3, {0,0},{X->{C@1, 4, 6, 6, X, 8, 2, X, 8, 2, C@1, 6, 2, C@1, X, 8, 4, X},
                            C@1->{C@1, C@1}}, 6]

Comments

बस को संशोधित Graphics@kकरके Graphics@Flatten@kआप कई पुनरावृत्तियों उपयोग करने के लिए योजना बना रहे हैं। अन्यथा एक पुनरावृत्ति सीमा आपको काट लेगी और आपका Mma सत्र समाप्त हो जाएगा।

— डॉ। बेलिसियस

मेरी मैक्रो-विस्तार पद्धति में उच्च पुनरावृत्तियों के साथ एक समान मुद्दा था। तार बस विशाल हो जाते हैं। लेकिन वहां समाधान समतल नहीं था । :)

— लूसर डॉग

+1 वास्तव में बहुत अच्छा;) एक अच्छा प्रदर्शन हो सकता है। क्या आप उन्हें जमा करते हैं?

— विटालि कौरोव

@VitaliyKaurov नहीं, लेकिन इसे बेझिझक इस्तेमाल करें अगर आपको लगता है कि यह प्रयास के लायक है

— डॉ। बेलिसरियस

@ अविशासन प्रदर्शनों

— विटालि

Answer 2

पायथन, 369 294

विजेता नहीं है, लेकिन मैं वैसे भी पोस्ट करूँगा जो मैंने कोशिश की है।

from turtle import*
I=open('l').read().split()
s,S,p=I[0],'',[]
for j in range(8):
    for i in s:S+=eval('{'+I[1]+'}')[i]
    s,S=S,''
for k in s:
    if k=='[':p+=[heading(),pos()];continue
    if k==']':pu();goto(p.pop());seth(p.pop());pd();continue
    try:{'f':fd,'F':fd,'+':rt,'-':lt}[k](5)
    except:pass

गोल्फिंग पायथन में अच्छा नहीं ...... शायद कोई और कर सकता है।

इनपुट

इनपुट "l" नामक बाहरी फ़ाइल से है (कोई एक्सटेंशन नहीं), निम्न प्रारूप के साथ:
पंक्ति 1 : प्रारंभिक स्थिति (Axiom)
पंक्ति 2 : कोमा से अलग किए गए नियम

प्रतीक
f और F: आगे खींचें
+: दाएं मुड़ें 5 डिग्री
-: बाएं 5 डिग्री मुड़ें
[: स्थिति और शीर्ष को बचाएं
]: पॉप स्थिति और शीर्षक
अन्य प्रतीकों को ड्राइंग फ़ंक्शन द्वारा अनदेखा किया जाता है।

नियम
एक नियम प्रारूप में है "predecessor":"successor(s)"
कि उद्धरण आवश्यक हैं, चाहे वह एकल हो या दोहरा।
predecessorएकल चरित्र होना चाहिए।
इसके अलावा, कोई अंतर्निहित स्थिरांक नहीं हैं: आपको स्पष्ट रूप से उन लोगों के लिए नो-चेंज नियम निर्दिष्ट करना होगा।

उदाहरण

शाखा तने

------------------f
'-':'-','+':'+','[':'[',']':']','F':'FF','f':'F[+++++++++f]---------f'

आउटपुट

ध्यान दें कि स्रोत को संशोधित करने के लिए इसे बाहर रखा जा सकता है केवल विज़ुअल क्षेत्र के लिए ग्रैप को डाउनलोड करें। कंसोल का उपयोग "कछुए" को छिपाने के लिए भी किया जाता है।

ड्रैगन वक्र

fx
'-':'-','+':'+','[':'[',']':']','f':'f','x':'x++++++++++++++++++yf','y':'fx------------------y'

आउटपुट

फिर से, कंसोल का उपयोग "कछुए" को छिपाने के लिए किया जाता है।

सीरपिन्स्की त्रिकोण

f------------------------F------------------------F
'-':'-','+':'+','[':'[',']':']','f':'f------------------------F++++++++++++++++++++++++f++++++++++++++++++++++++F------------------------f','F':'FF'

आउटपुट

जनरेशन यहां 5 तक कम हो गई।

Comments

आप कार्यों को हटाने के द्वारा एक सभ्य बचत प्राप्त कर सकते हैं (मैं इसे 32 वर्ण बनाने) f, r, l, करने के लिए एक डमी पैरामीटर जोड़ने oऔर c; और फिर छद्म-स्विच को बदलकर{'f':fd,'F':fd,'+':rt,'-':lt,'[':o,']':c}[k](5)

— पीटर टेलर

तुम भी इनलाइन कर सकते हैं g, और मुझे लगता है कि oऔर cइनलाइन साथ नष्ट करने लायक रहे ifबयानों (की तुलना में सस्ता globalघोषणा)

— पीटर टेलर

@PeterTaylor अच्छा काम। मुझे इस बात का आभास था कि उन कार्यों में से कुछ को इनबिल्ट किया जा सकता है, लेकिन इसे सार्थक रूप से सुझाने के लिए पर्याप्त पायथन की जानकारी नहीं है।

— लूज़र

@luserdroog, मैं या तो पायथन को नहीं जानता: मैंने सिर्फ यह देखने के लिए परीक्षण और त्रुटि की कि क्या काम किया है - यानी कुछ चीजें जो मैंने कोशिश कीं (जैसे कि लंबोदा में oऔर cसीधे छद्म स्विच के लिए उपयोग करना) ने सिंटैक्स त्रुटियां दीं, लेकिन दूसरों ने नहीं किया ' टी।

— पीटर टेलर

आगे गोल्फ के लिए संकेत: 1. इनपुट प्रारूप बदलें: नियमों के चारों ओर ब्रेसिज़ की आवश्यकता होती है और एक स्थान (एक नई रेखा नहीं) द्वारा नियमों से स्वयंसिद्ध को अलग करना। 2. स्टडिन से पढ़ें s,R,*p=input().split():। 3. के अंतिम मूल्य उत्पन्न sद्वारा exec('s="".join(map(eval(R).get,s));'*8)। 4. बाहर जाना continue। 5. केवल 1 स्थान का संकेत। 6. ifपरीक्षण के लिए पक्षों को स्विच करके अंतरिक्ष को बचाएं । 7. (पहली प्रविष्टि) k:intमें डालें dictऔर फिर आपको ज़रूरत नहीं है except: try:। (मुझे 215 पात्र मिलते हैं।)

— मोनिका

Answer 3

जावास्क्रिप्ट (179 बाइट्स)

यह पूरी तरह से सुनिश्चित नहीं है कि नियम वस्तु के रूप में वास्तविक ड्राइंग के सभी।

डेमो (ड्रैगन, एनिमेटेड):
- विस्तारित: http://jsfiddle.net/SVkMR/9/show/light
- कोड के साथ: http://jsfiddle.net/SVkMR/9/

न्यूनतम किया गया:

function L(c,r,n){o=(function g(d,s,o,i){for(o=i='';a=d&&s[i++];)o+=r.r[a]?g(d-1,r.r[a]):a;return o||s;})(n,r.r[r.s]);(function z(i){r[s=o[i]]&&r[s](c)||setTimeout(z,10,i+1)})(0)}

पठनीय (ish):

function L(c,r,n){
    o=(function g(d,s,o,i){
        for(o=i='';a=d&&s[i++];)o+=r.r[a]?g(d-1,r.r[a]):o+=a
        return o||s
    })(n,r.r[r.s]);

    (function p(i){
        r[s=o[i]]&&r[s](c)||setTimeout(p,10,i+1)
    })(0)
}

इनपुट:

var sierspinski = {
    r:{'A':'B-A-B','B':'A+B+A'},
    '+':function(c){c.rotate(-this.a);c.rotate(this.a-=Math.PI/3)},
    '-':function(c){c.rotate(-this.a);c.rotate(this.a+=Math.PI/3)},
    'A':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    'B':function(c){this['A'](c)},
    s:'A',
    a:0,
    m:1
};

var koch = {
    r: {'F':'F+F-F-F+F'},
    '+':function(c){c.rotate(-this.a);c.rotate(this.a-=Math.PI/2)},
    '-':function(c){c.rotate(-this.a);c.rotate(this.a+=Math.PI/2)},
    'F':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    s:'F',
    a:0,
    m:2
};
var dragon = {
    r: {'X':'X+YF','Y':'FX-Y'},
    '+':function(c){c.rotate(-this.a);c.rotate(this.a-=Math.PI/2)},
    '-':function(c){c.rotate(-this.a);c.rotate(this.a+=Math.PI/2)},
    'F':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    s:'X',
    a:0,
    m:5
};

var algae = {
    r: {'A':'B[A]A','B':'BB'},
    '[':function(c){c.save();c.rotate(Math.PI/4);},  // save/restore will push/pop current state of context. 
    ']':function(c){c.restore();c.rotate(-Math.PI/4);},
    'A':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    'B':function(c){this['A'](c);},
    s:'A',
    a:-Math.PI/2,
    m:1
};

var tree = {
    r:{'X':'F-[[X]+X]+F[+FX]-X','F':'FF'},
    '+':function(c){c.rotate(-this.a);c.rotate(this.a+=Math.PI/180*25)},
    '-':function(c){c.rotate(-this.a);c.rotate(this.a-=Math.PI/180*25)},
    '[':function(c){c.save();},
    ']':function(c){c.restore();},
    'F':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    s:'X',
    a:-Math.PI/180*25,
    m:5
};

उपयोग:

var ctx = document.getElementById('l').getContext('2d'); // grab context
ctx.translate(299.5,199.5); // start drawing from center, fractional pixels because the canvas draws lines centered on the x/y coord specified
L(ctx, dragon, 8); // pass in context, rules object, and recursion cap

बोनस: गोल्डन सर्पिल http://jsfiddle.net/SVkMR/35/show/light/

var golden = {
    r:{'A':'FT[TT]A','T':'+F'},
    'F':function(c){c.beginPath();c.moveTo(0,0);c.translate(this.m,0);c.lineTo(0,0);c.stroke()},
    '[':function(c){c.save();},
    ']':function(c){
        c.restore();

        c.beginPath();
        c.arc(0,-this.m,this.m,Math.PI/2,Math.PI);
        c.stroke();

        this.m+=this.d;this.d=this.m-this.d
    },
    '+':function(c){c.rotate(-Math.PI/2);},
    s:'A',
    a:-Math.PI/2,
    m:1,
    d:0
};

Comments

मुझे लगता है कि एनीमेशन नियमों से अधिक किसी भी स्वतंत्रता के लिए क्षतिपूर्ति करता है। बहुत बढ़िया! +1

— लुसर डॉग

:) मजेदार चीजें! ।

— श्मिट्टी

Answer 4

परिशिष्ट भाग 264 298 295 255

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

संपादित करें: ब्रांचिंग के लिए +34 चार्ट।
संपादित करें: -3 वर्ण। पुनरावर्तन नियंत्रण के लिए ऑपरेंड स्टैक का उपयोग करने के लिए पुन: डिज़ाइन किया गया। यह बुनियादी प्रणाली को बहुत सरल बनाता है। लेकिन कोष्ठक को एक स्वतंत्र स्टैक की आवश्यकता होती है, इसलिए मैंने शब्दकोश स्टैक में सहेजे गए स्थान को रखा, और लगभग सभी बचत वापस कर दी।

इसके अलावा, सरणियों और नामों के बजाय तार और पूर्णांक का उपयोग करने के लिए पुन: डिज़ाइन किया गया।

संपादित करें: -40 चार्ट सिस्टम नामों को कॉल करने के लिए दो प्रक्रियाओं को जोड़ा गया है (मैं काम करने के लिए कच्चे बाइनरी टोकन प्राप्त नहीं कर सकता । लेकिन यह मुहावरा मेरे लिए काम करता है।)

/*{<920>dup 1 4 3 roll put cvx exec}def/${//* 73
*}def[/T[48{}49{}43{A<88>$}45{A<6e88>$}70{R
0<85>$}91{<1e39>$[/.[<286827>$]cvx>><0d0d>$}93{.<9c6b1e39390d>$}>>/S{dup
B eq{T<0d3e>${<643f>$}<4939>$}{exch{<643e>$ 1 add S}73 *}85 * 1 sub}>><0d6b>$
0 S<a7>$

अर्ध-टिप्पणी बाइनरी।

/*{<920>dup 1 4 3 roll put cvx exec}def/${//* 73 *}def %73=forall
[/T[70{R 0<85>$}48{}49{} %<85>=rlineto
43{A<88>$}45{A<6e88>$} %<88>=rotate <6e>=neg
91{<1e39>$ %<1e>=currentdict <39>=end
    [/.[<286827>$]cvx>> %<28>=currentpoint <68>=matrix <27>=currentmatrix
        <0d0d>$} %<0d>=begin
93{.<9c6b1e39390d>$}>> %<9c>=setmatrix <6b>=moveto
/S{dup B eq{T<0d3e>${<643f>$}<4939>$} %<3e>=exch <64>=load <3f>=exec <49>=forall
{exch{<643e>$ 1 add S}73 *}85 * 1 sub}>>
<0d6b>$ 0 S<a7>$  % 85=ifelse <a7>=stroke

संयुक्त राष्ट्र "बाइनरी"।

[/T[70{R 0 rlineto}48{}49{}43{A rotate}45{A neg rotate}91{currentdict
end[/.[currentpoint matrix currentmatrix]cvx>>begin begin}93{. setmatrix
moveto currentdict end end begin}>>/S{dup B eq{T begin exch{load exec}forall
end}{exch{load exch 1 add S}forall}ifelse 1 sub }>>begin moveto 0 S stroke

यह एल-सिस्टम को डिक्टस्टैक पर एक डिक्शनरी में परिभाषित करने की आवश्यकता है, प्रारंभिक स्ट्रिंग और ऑपरेंड स्टैक पर कछुए की शुरुआती स्थिति (स्रोत, जैसे प्रीपेड gs dragon.sys lsys.ps)।

ड्रैगन कर्व।

%!
[                     %begin dictionary construction
    % productions are described by integer-key/string-value pairs
    48(0+1F) %0       %ascii code for '0' defined as the string "0+1F"
    49(F0-1) %1       %  "     "   "  '1'   "     "   "    "    "F0-1"
    43(+) %+          %  "     "   "  '+' defined as itself
    45(-) %-          %  "     "   "  '-'   "     "   "
    70(F) %F          %  "     "   "  'F'   "     "   "
    % parameters
    /A 90 %angle
    /R 2  %radius
    /B 10 %maximum recursion-level
>>begin  % L-system dictionary on top of dictstack
(F0)     % initial string on stack
300 400  % starting position on stack

शाखाय तने।

[
    48(F[+0]-0) %0
    49(F0-1) %1
    43(+) %+
    45(-) %-
    70(FF) %F
    91([) %[
    93(]) %]
    /A 45 %angle
    /R 5  %radius
    /B 3 %recursion
>>begin
(++0)     % initial string
300 400  % starting position

असहमति और टिप्पणी की।

[                                 % begin dictionary construction
    /T[                           % /T is the Turtle dictionary containing
                                  % integer-key/procedure-value pairs
                                  % keyed to ascii values
        70{R 0 rlineto}        %F  
        48{}                   %0
        49{}                   %1  
        43{A rotate}           %+  
        45{A neg rotate}       %-  

          % For brackets, create a dictionary containing a single procedure '.' (dot)
          % which holds a saved matrix (orientation+size) and currentpoint.
          % Since this procedure is called while the Turtle dict is on top of the
          % dictstack, the temporary dictionary is placed just under the top.
        91{currentdict end[/.[currentpoint matrix currentmatrix]cvx>>begin begin} %[
          % Right bracket: reset position and orientation,
          % pop the dict just under the top.
        93{. setmatrix moveto currentdict end end begin}    %]  
    >>  
    /S{ % stack contains: string recursion-level
        dup B eq{ % hit recursion bound, interpret string as turtle commands
            T begin
                exch % level string
                %dup =
                {                      % iterate through string
                    load exec          % execute turtle command by integer code
                } forall % level       % string has been consumed
            end
            %(B)= pstack
        }{ % recurse
            %(A)= pstack
            exch % level string
            { % level char                   iterate through string
                load exch % string level   process production:load string by int code
                1 add S   % string level+1   increase level and call self
            } forall                       % string has been consumed
        }ifelse
        1 sub            % return level-1
        %(C)= pstack
    }
>>begin
moveto 0 S stroke

इसे चलाने के लिए, इन 3 ब्लॉकों को 3 फ़ाइलों के रूप में सहेजा जा सकता है: dragon.ps, stems.ps, lsys.ps (उपरोक्त प्रोग्राम ब्लॉक में से कोई भी पहचान कार्य करेगा)। फिर जीएस के साथ चलाएं: gs dragon.ps lsys.psया gs stems.ps lsys.ps। यदि वांछित है, तो उन्हें पहले भी समाप्‍त किया जा सकता है: cat dragon.ps lsys.ps | gs -या cat stems.ps lsys.ps | gs -।

कोई उपजा चित्र नहीं। यह किसी भी अधिक गहराई पर अधिक दिलचस्प नहीं है।

Answer 5

गणितज्ञ 290

यह नंगे हड्डियों का कार्यान्वयन प्रसंस्करण के बजाय आउटपुट पर केंद्रित है। यह उत्पादन नियमों का उपयोग नहीं करता है। तो यह चुनौती के लिए उपयुक्त प्रतिक्रिया नहीं हो सकती है।

ब्रोचिंग स्टोन्स को थियो ग्रे के प्रदर्शन से अनुकूलित किया गया ।

कोड

f@{a_, b_} := {{a, #}, {b, #}} &[a + (b - a)/2 + {{0, 1/2}, {-1/2, 0}}.(b - a)]; w = Flatten;
h[s_, g_] :=Graphics[If[s == 0,Line /@ Nest[w[f /@ #, 1] &, {{{0, 0}, {1, 0}}}, g], 
 MapIndexed[Line@# &, NestList[w[Map[{{#[[2]], #[[2]] + m.(#[[2]] - #[[1]])}, {#[[2]], 
 #[[2]] + ({{1, -1}, {-1,1}} m).(#[[2]] - #[[1]])}} &, #], 1] &, {{{0, -1}, {0, 0}}}, g]]]]

प्रयोग

पहला पैरामीटर निर्धारित करता है कि ड्रैगन वक्र या शाखा उपजी प्रदर्शित किया जाएगा या नहीं। दूसरा शब्द पीढ़ी को संदर्भित करता है।

h[0, 5]
h[1, 5]

---

और ज्यादा उदाहरण

GraphicsGrid@Partition[Flatten[Table[h[j, k], {j, 0, 1}, {k, 10}]], 5]

Comments

बहुत सुन्दर। लेकिन क्या यह तर्क के रूप में नियम को पारित करने के लिए कुछ बाइट्स नहीं बचाएगा?

— लूसर डॉग

यदि यह एक सामान्य समाधान था, तो शायद पैरामीटर के बजाय कोई नियम पारित कर सकता है। मैं लिंडेनमायर सिस्टम के बारे में अधिक जानकार होना चाहूंगा क्योंकि मैं वर्तमान में हूं।

— डेविड डे

मैं गणित नहीं पढ़ता। मुझे कुछ सीखना चाहिए। (इसे स्टैक में जोड़ें :) लेकिन आप इसका अर्थ यह लगा सकते हैं कि "जो कुछ भी छवि के विवरण का गठन करता है, जैसा कि इंजन से अलग है जो इसे चलाता है" फैक्टर आउट हो सकता है। यदि आप छवि की कुछ विशेषता को नियंत्रित करने के लिए डेटा को संशोधित कर सकते हैं, तो स्वतंत्र रूप से इंजन को छूने से उचित ; मुझे लगता है कि एक एल प्रणाली के लिए "कार्यात्मक रूप से समकक्ष" होना चाहिए। [ कि आप के साथ काम करने के लिए बहुत सारी कमियां देनी चाहिए;) ]। +1 वैसे भी इसका कारण बहुत सुंदर है।

— लूसर

@ मुझे लगता है कि यह है क्योंकि ग्राफिक्स आवश्यकताओं को उनके लिए अच्छी तरह से अनुकूल नहीं हैं

— डॉ। belisarius

अंत में अपने पेड़ के लिए एल-सिस्टम का पता लगाया: A->F[+A][-A]जहां Fचाल है, +बाएं 30 -को घुमाया जाता है , दाएं 30 को घुमाया जाता है, और [/ ]धक्का दिया जाता है / पॉप

— Shmiddty