ดำเนินการระบบ Lindenmayer

Lindenmayer ระบบ (หรือ L ระบบ) มีความเกี่ยวข้องกับThueและโพสต์ระบบและถูกนำมาใช้ในการสร้างแบบจำลองทางพฤกษศาสตร์และรุ่นเศษส่วน

L-ระบบมีการอธิบายโดยสตริงเขียนใหม่ที่เป็นสัญลักษณ์จากสัญลักษณ์ตัวอักษรจะถูกจับคู่กับการเปลี่ยนลำดับของสัญลักษณ์ การรวบรวมการแม็พเหล่านี้ถือเป็นระบบ L ที่เหมาะสม

วิธีการแสดงผลกราฟิกที่คิดค้นโดย Prusinkiewicz ตีความลำดับผลลัพธ์หลังจากการแมปได้ถูกนำไปใช้กับลำดับเริ่มต้นสำหรับการวนซ้ำตามจำนวนที่ระบุตามคำสั่ง Turtle-Drawing นี่อาจต้องใช้รหัสพิเศษเพื่อควบคุมขนาดของการวาดภาพเนื่องจากจำนวนการทำซ้ำที่แตกต่างกันอาจสร้างภาพที่มีขนาดต่างกันอย่างมาก

งานของคุณคือรันระบบ L ในจำนวนอักขระน้อยที่สุด โปรแกรมของคุณจะต้องสามารถแสดงผลทั้ง Dragon Curve และ Branching Stems จากหน้า Wikipedia โดยให้ข้อมูลที่เหมาะสม (ไฟล์บรรทัดคำสั่ง แต่ภายนอกไปยังแหล่งที่มาโปรด)

นี่คือรหัสกอล์ฟ

แก้ไข: นี่คือตัวอย่างที่ฉันโพสต์รอบเมือง คำตอบ SO / หมุนไปทางทิศเหนือ { ที่ฉันค้นพบครั้งแรก L-ระบบ } , คำตอบ SO / วิธีการโปรแกรม-a-เศษส่วน , คำตอบ SO / recursion ในวรรณกรรม , การอภิปราย comp.lang.postscript / การบรรยาย , คอลเลกชัน ป.ล. L-ระบบ , codegolf.SE/draw-a-sierpinski-triangle {ที่มาของการแข่งขันระหว่างตัวเองและ thomasW}

Mathematica 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: สถานะเริ่มต้น;
b: มุมการหมุน
h: มุมเริ่มต้น
j: ตำแหน่งเริ่มต้น
r: กฎการผลิต
n: การวนซ้ำ

ไวยากรณ์กฎการผลิต:

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]

Python, 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

เล่นกอล์ฟ Python ไม่เก่ง ...... อาจจะมีคนอื่นทำได้

อินพุต

อินพุตมาจากไฟล์ภายนอกชื่อ "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'

เอาท์พุท

อีกครั้งคอนโซลใช้เพื่อซ่อน "เต่า"

สามเหลี่ยม Sierpinski

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

การ

สร้างเอาต์พุตลดลงถึง 5 ที่นี่

Javascript (179 ไบต์)

ไม่แน่ใจว่าสิ่งนี้มีคุณสมบัติครบถ้วนเนื่องจากวัตถุกฎทำตามรูปวาดจริงทั้งหมด

การสาธิต (Dragon, ภาพเคลื่อนไหว):
- ขยาย: http://jsfiddle.net/SVkMR/9/show/light
- ด้วยรหัส: http://jsfiddle.net/SVkMR/9/

minified:

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
};

ป.ล. 264 298 295 255

นี่คือความพยายามของฉันที่จะทำมันแตกต่างกัน แทนที่จะเป็นการขยายมาโครที่ฉันมักจะใช้อันนี้จะตรวจสอบขนาดของสแต็กการเรียกใช้งานเพื่อโยงการสอบถามซ้ำ หากเกินขอบเขตมันจะหยุดการตรวจสอบขั้นตอนซ้ำและพยายามตีความคำสั่งเต่า (และทิ้งเป็นpop popอย่างอื่น) ข้อดีของวิธีนี้คือไม่ต้องใช้หน่วยความจำจำนวนมหาศาล ข้อเสียคือการควบคุมการเรียกซ้ำค่อนข้างงุ่มง่ามเมื่อขนาดสแต็กเพิ่มขึ้นมากกว่า 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

มันต้องมีการกำหนดระบบ L ในพจนานุกรมบน dictstack โดยมีสตริงเริ่มต้นและตำแหน่งเริ่มต้นของเต่าบนตัวถูกดำเนินการสแต็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

Ungolfed และแสดงความคิดเห็น

[                                 % 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: หรือgs dragon.ps lsys.ps gs stems.ps lsys.psพวกเขายังสามารถตัดแบ่งแรกถ้าต้องการ: หรือcat dragon.ps lsys.ps | gs -cat stems.ps lsys.ps | gs -

ไม่มีรูปลำต้น มันไม่น่าสนใจอีกต่อไปที่ระดับความลึกที่สูงขึ้น

Mathematica 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]]]]

การใช้

พารามิเตอร์แรกพิจารณาว่าจะแสดง Dragon Curve หรือ Branch Stems หรือไม่ คำที่สองหมายถึงรุ่น

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

ตัวอย่างเพิ่มเติม

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