Thực thi một hệ thống Lindenmayer

Một hệ thống Lindenmayer (hoặc L-hệ thống) có liên quan đến Thue và bài viết hệ thống, và được sử dụng trong mô hình thực vật và hệ fractal .

Một hệ thống L được mô tả bằng cách viết lại chuỗi trong đó một ký hiệu từ bảng chữ cái ký hiệu được ánh xạ tới một chuỗi các ký hiệu thay thế . Một bộ sưu tập các ánh xạ này cấu thành hệ thống L thích hợp.

Phương thức đầu ra đồ họa do Prusinkiewicz nghĩ ra diễn giải chuỗi kết quả sau khi ánh xạ đã được áp dụng cho chuỗi ban đầu cho một số lần lặp được chỉ định , như các lệnh Vẽ Rùa: tiến, lùi, trái, phải, loại công cụ đó. Điều này có thể yêu cầu mã bổ sung để kiểm soát tỷ lệ của bản vẽ vì số lần lặp khác nhau có thể tạo ra hình ảnh có kích thước khác nhau đáng kể.

Nhiệm vụ của bạn là thực thi một hệ thống L với số lượng ký tự ít nhất. Chương trình của bạn phải có khả năng hiển thị cả Đường cong rồng và Cành nhánh từ trang Wikipedia bằng cách cung cấp đầu vào thích hợp (tệp, dòng lệnh, nhưng bên ngoài nguồn, xin vui lòng).

Đây là mã golf.

Chỉnh sửa: Đây là một số ví dụ tôi đã đăng xung quanh thị trấn. trả lời cho SO / rotation-to-south { Lần đầu tiên tôi phát hiện ra hệ thống L } , trả lời SO / how-to-program-a-fractal , trả lời SO / recursion-in-postcript , comp.lang.postscript / recital , bộ sưu tập hệ thống l mô tả , codegolf.SE/draw-a-sierpinski-trigin {nguồn gốc của cuộc cạnh tranh giữa tôi và thomasW} .

Toán học 200 198 188 171 168

Không gian được thêm vào cho rõ ràng:

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)

Ở đâu:

i: Trạng thái ban đầu;
b: góc quay
h: góc ban đầu
j: vị trí ban đầu
r: quy tắc sản xuất
n: lặp

Quy tắc sản xuất ngữ pháp:

2 = Rẽ trái (-);
4 = Rẽ phải (+);
6 = Đẩy và rẽ trái ("[");
8 = Pop và Rẽ phải ("]");
C [i] = Vẽ (Bất kỳ số lượng biểu tượng)
Bất kỳ biểu tượng nào khác = Không làm gì, chỉ cần sử dụng nó trong việc tạo trạng thái tiếp theo (Bất kỳ số lượng biểu tượng nào)

Chuỗi {2,4,6,8} là có bởi vì tôi đang sử dụng I^n( I= đơn vị tưởng tượng) để thực hiện lần lượt.

Ví dụ:

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]

Con trăn, 369 294

Không phải là người chiến thắng nhưng tôi sẽ đăng những gì tôi đã thử.

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

Không giỏi chơi gôn Python ...... Có lẽ người khác có thể làm được.

Đầu vào

Đầu vào là từ một tệp bên ngoài có tên "l" (không có phần mở rộng), với định dạng sau:
Dòng 1 : Trạng thái ban đầu (Tiên đề)
Dòng 2 : Quy tắc được phân tách bằng dấu phẩy

Biểu tượng
f và F: Vẽ về phía trước
+: Rẽ phải 5 độ
-: Rẽ trái 5 độ
[: Lưu vị trí và tiêu đề
]: Vị trí bật và tiêu đề
Các biểu tượng khác bị bỏ qua bởi chức năng vẽ.

Quy tắc
Một quy tắc có định dạng "predecessor":"successor(s)"
Lưu ý rằng các trích dẫn là cần thiết, cho dù là đơn hay đôi.
predecessorphải là một nhân vật duy nhất.
Ngoài ra, không có hằng số ngầm định: Bạn phải xác định rõ ràng quy tắc không thay đổi cho những quy tắc đó.

Ví dụ

Cành nhánh

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

Đầu ra

Lưu ý rằng nguồn được sửa đổi để lấy cái này ra, CHỈ CÓ QUY MÔ XUỐNG HÌNH ẢNH ĐẾN KHU VỰC TẦM NHÌN. Bảng điều khiển cũng được sử dụng để ẩn "con rùa".

Đường cong rồng

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

Đầu ra

Một lần nữa, giao diện điều khiển được sử dụng để ẩn "con rùa".

Tam giác Sierpinki

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

Thế hệ đầu ra giảm xuống còn 5 ở đây.

Javascript (179 byte)

Không hoàn toàn chắc chắn điều này đủ điều kiện, vì đối tượng quy tắc thực hiện tất cả các bản vẽ thực tế.

Bản demo (Rồng, hoạt hình):
- Mở rộng: http://jsfiddle.net/SVkMR/9/show/light
- Với Mã: http://jsfiddle.net/SVkMR/9/

Giảm thiểu:

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

Có thể đọc được (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)
}

Đầu vào:

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

Sử dụng:

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

Phần thưởng: Xoắn ốc vàng http://jsfiddle.net/SVkMR353/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
};

Bản thảo 264 298 295 255

Đây là nỗ lực của tôi để làm điều đó khác đi. Thay vì mở rộng macro mà tôi thường sử dụng, cái này sẽ kiểm tra kích thước của ngăn xếp thực thi để ràng buộc đệ quy. Nếu vượt quá giới hạn, nó dừng kiểm tra đệ quy thủ tục và cố gắng diễn giải các lệnh rùa (và loại bỏ pop popkhác). Một lợi thế của phương pháp này là nó không đòi hỏi số lượng bộ nhớ khổng lồ. Một bất lợi là điều khiển đệ quy khá vụng về, vì kích thước ngăn xếp tăng hơn 1 chỉ từ một cấp đệ quy đến cấp tiếp theo.

Chỉnh sửa: +34 ký tự cho phân nhánh.
Chỉnh sửa: -3 ký tự. Được thiết kế lại để sử dụng ngăn toán hạng cho điều khiển đệ quy. Điều này làm cho hệ thống cơ bản đơn giản hơn nhiều. Nhưng dấu ngoặc cần một ngăn xếp độc lập, vì vậy tôi đặt vị trí đã lưu trong ngăn xếp từ điển và gần như trả lại tất cả tiền tiết kiệm.

Ngoài ra, được thiết kế lại để sử dụng chuỗi và số nguyên thay vì mảng và tên.

Chỉnh sửa: -40 ký tự. Đã thêm hai quy trình gọi tên hệ thống theo số (tôi dường như không thể làm cho mã thông báo nhị phân thô hoạt động. Nhưng thành ngữ này hoạt động với tôi.)

/*{<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>$

Bán bình luận nhị phân.

/*{<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

Un- "nhị phân".

[/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

Nó đòi hỏi hệ thống L phải được xác định trong một từ điển trên dictstack, với chuỗi ban đầu và vị trí bắt đầu của rùa trên ngăn xếp toán hạng (ví dụ như nguồn, ví dụ. gs dragon.sys lsys.ps).

Đường cong rồng.

%!
[                     %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

Cành nhánh.

[
    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 và bình luận.

[                                 % 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

Để chạy nó, 3 khối này có thể được lưu thành 3 tệp: dragon.ps, stems.ps, lsys.ps (bất kỳ khối chương trình nào ở trên sẽ hoạt động giống hệt nhau). Sau đó chạy với gs: gs dragon.ps lsys.pshoặc gs stems.ps lsys.ps. Chúng cũng có thể được nối trước, nếu muốn: cat dragon.ps lsys.ps | gs -hoặc cat stems.ps lsys.ps | gs -.

Không có hình ảnh thân cây. Nó không có gì thú vị hơn ở độ sâu cao hơn.

Toán học 290

Việc thực hiện xương cốt này tập trung vào đầu ra hơn là xử lý. Nó không sử dụng quy tắc sản xuất. Vì vậy, nó có thể không phải là một phản ứng phù hợp với thách thức.

Cành cây thích nghi từ cuộc biểu tình của Theo Gray .

Mã

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

Sử dụng

Tham số đầu tiên xác định xem Dragon Curve hay Branch Stems sẽ được hiển thị. Thuật ngữ thứ hai đề cập đến thế hệ.

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

Thêm ví dụ

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