Nhiệm vụ của bạn cho ngày hôm nay: vẽ một đường cong rồng!

Trong trường hợp bạn không biết Dragon Curve là gì, đây là video ViHart giới thiệu (Thật tuyệt, xin vui lòng xem!)

Nhiệm vụ của bạn: vẽ một đường cong rồng, lặp đi lặp lại ít nhất 9 lần. Bạn không phải hiển thị các lần lặp từ 1 đến 9, bạn chỉ cần hiển thị đường cong cuối cùng được tạo sau khi hoàn thành (ít nhất) 9 lần lặp. Đường cong phải được vẽ dưới dạng các đường thẳng nối các điểm trên đường cong; đầu ra phải khớp với một trong các hình ảnh bên dưới hiển thị 9 lần lặp trở lên (tối đa để phản chiếu, xoay, chia tỷ lệ và thay đổi về độ rộng đường, màu đường và màu nền). Đầu ra của bạn phải đủ lớn để các dòng riêng lẻ và "hộp" mà chúng hình thành có thể được phân biệt với nhau; nếu hai đường thẳng không giao nhau trong đường cong, chúng sẽ không chiếm các pixel giống nhau hoặc liền kề trong đầu ra (nên có ít nhất một pixel của nền có thể nhìn thấy giữa chúng). Bạn có thể hiển thị hình ảnh ra màn hình hoặc lưu hình ảnh vào một tệp được chấp nhận. Đầu ra phải là đồ họa - nó không thể là nghệ thuật ASCII.

Tuy nhiên , mã ngắn nhất tính theo byte sẽ bao gồm các lệnh cho các thư viện không được bao gồm trong số byte và bạn có thể sử dụng các thư viện đồ họa hoặc các thư viện khác được viết cho ngôn ngữ bạn chọn nếu chúng được viết trước khi đăng.

Vui lòng bao gồm một hình ảnh của đầu ra của chương trình của bạn.

Bỏ qua đoạn này nếu bạn đã xem video:Đối với những người quyết định không xem video, 12 lần lặp đầu tiên của đường cong rồng được hiển thị bên dưới. Đối với mục đích của nhiệm vụ này, đường cong rồng là một đường cong được tạo bởi quy tắc sau: lấy điểm cuối của đường cong hiện tại, tạo đường cong thứ hai xoay 90 độ quanh điểm cuối đó sao cho điểm cuối của điểm gốc đường cong là điểm bắt đầu của đường cong mới và nối hai đường cong thành một đường cong duy nhất nơi chúng gặp nhau. Trong các hình ảnh hiển thị bên dưới, mỗi lần lặp mới được tạo bằng cách xoay vòng lặp 90 độ trước đó theo chiều kim đồng hồ quanh điểm cuối mỗi lần lặp. Khi đường cong được hiển thị trên màn hình, không rõ ràng điểm cuối nào được tính là "điểm cuối", tuy nhiên khi đường cong được lưu trữ dưới dạng một mảng các điểm, thật dễ dàng để xác định "điểm cuối" là điểm cuối cùng trong các mảng.

Nghệ thuật Ascii được đánh giá cao, nhưng không được chấp nhận: Đây là đầu ra đồ họa, không phải nghệ thuật ascii.

x86, MSDOS, 16 byte

Tôi đã viết điều này một thời gian trước đây, theo hiểu biết của tôi về thói quen nhỏ nhất để sản xuất một mảnh xương rồng. Nó không sử dụng các lần lặp thực, thay vào đó là các ô riêng lẻ chứa bên trong fractal trực tiếp, hiển thị hình ảnh cuối cùng . Nó bao gồm nhiều sản phẩm nhỏ khác trong gói này . Phiên bản 16 byte là kết thúc nỗ lực của tôi để có được con rồng nhỏ nhất có thể, bắt đầu từ năm 2014 với sản xuất 32 byte này .

Lục giác

14 10 19 CA D1 FA 10 DE 01 D1 CD 10 B4 0C EB F0

Mã

S: 
adc al,0x10
sbb dx,cx       
sar dx,0x01 
adc dh,bl
add cx,dx
int 0x10
mov ah,0x0C
jmp short S

Python 2/3, 169 167 150 111 98 78 byte

Lưu ý rằng việc nhập không được bao gồm trong số byte, theo thông số kỹ thuật thách thức.

Cảm ơn @AlexHall vì đã lưu 39 (!) Byte và @ nedla2004 cho 13 khác

from turtle import*
o=[90]
for z in o*9:o+=[90]+[-x for x in o[::-1]]
fd(5)
for i in o:rt(i);fd(5)

Bắt đầu bằng cách tạo danh sách hoặc rẽ phải (90) và rẽ trái (-90), sau đó đi qua danh sách và di chuyển rùa.

Tạo đầu ra:

EDIT: Nếu điều này quá nhàm chán quá xem, hãy thêm speed(0)ngay trước khi đầu tiên fd(5). Nó sẽ chạy như vậy, ngoại trừ con rùa sẽ di chuyển nhanh hơn nhiều.

Logo, 43 byte

for[i 1 512][fd 9 lt :i/(bitand :i -:i)*90]

Hãy thử với thông dịch viên tại http://www.calormen.com/jslogo/#

Điều này sử dụng nguyên tắc giống như câu trả lời nghệ thuật ASCII trước đây của tôi và công thức trên wikipedia ngoại trừ tôi đã đảo ngược hướng để khớp với hình ảnh trong câu hỏi:

Đầu tiên, biểu thị n ở dạng k*(2^m)k là số lẻ. Hướng của lượt thứ n được xác định bởi k mod 4 tức là phần còn lại khi k chia hết cho 4. Nếu k mod 4 là 1 thì lượt thứ n là R L; nếu k mod 4 là 3 thì lượt thứ n là L R

bitand :i -:itìm thấy các bit quan trọng nhất của i. Chúng tôi chia icho số này để shitft iđúng số lượng cần thiết, đưa ra số lẻ cần thiết k. Không cần phân biệt rẽ trái và rẽ phải; chúng ta chỉ rẽ trái theo k*90độ và dựa vào thực tế là phép quay là một toán hạng modulo 360 để thực hiện modulo cho chúng ta.

Đầu ra

dùng htđể giấu rùa nếu cần.

Đầu ra (sửa đổi)

Sau đây cho thấy đường cong là một sợi đơn.

bk 6 for[i 1 512][fd 6 rt :i/(bitand :i -:i)%4*45-90 fd 3 rt :i/(bitand :i -:i)%4*45-90]

LindenMASM , 51 byte

LindenMASM là ngôn ngữ tôi tạo ra cho một thử thách cách đây một thời gian sẽ tồn tại mãi mãi trong Sandbox. Nó sử dụng khái niệm hệ thống Lindenmayer để vẽ những thứ như đường cong Rồng, cây fractal, hình tam giác Sierpinki, v.v.

Mã nguồn như sau:

STT
AXI FX
INC 9
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

Để thiết lập điều này n = 6chẳng hạn:

STT
AXI FX
INC 6
SET F 0
RPL X X+YF+
RPL Y -FX-Y
END

Điều này tạo ra hình ảnh sau thông qua Python 3's turtle:

Có thể có một chút khác biệt về số cho các lần lặp, vì trong hệ thống Lindenmayer, lần lặp đầu tiên là một dòng duy nhất. Đây là những gì nó trông giống như n = 10:

Để giải trí, đây là giao diện của 15 thế hệ (có thêm hướng dẫn MOV 2để làm cho nó nhỏ hơn một chút):

Khi bạn nhận được tối đa 20 thế hệ (với MOV 0.5), bạn thực sự không thể nhìn thấy các dòng nữa và phải mất rất nhiều bước để tạo (các cặp +-và -+không được tối ưu hóa). Đây là những gì bạn nhận được:

^{Lưu ý rằng trình thông dịch hiện tại có thể trình bày các vấn đề đồ họa cho số lượng thế hệ nhỏ hơn, tức là có thể không vẽ lên màn hình. Thật không may khi trình thông dịch này được tạo ra không có vấn đề gì, một sự thay đổi có thể có trong Python 3 có thể đã gây ra điều này hoặc nó chỉ có thể là hệ thống của tôi}

Tải trọng, 196 byte

()()(<svg width="99" height="147">)S(<g transform="translate):S((33,33)">)S((3,0)rotate)*a(*a(~*)*~("><path d="M0h3" stroke="#"/>)~*a(*)**:(-90)a~^~(90)a~^)*::*:**:*^S(</g>)(:*)::*:**:*^S(</svg>)S

Tôi nghĩ rằng nó có thể thú vị để thử thách này trong một esolang năng lượng thấp; Underload thực hiện khá tốt đối với một ngôn ngữ có số lượng lệnh thấp như vậy.

Đầu ra là một tệp SVG với các thẻ được lồng rất nhiều và một số phím tắt chơi gôn. Cho đến nay, tôi vẫn chưa tìm thấy một trình duyệt có thể hiển thị nó (Firefox bị treo trong vài phút khi cố tải nó và cả Firefox và Chromium đều cho một màn hình trống). Hầu hết các chương trình xử lý ảnh cũng không thể tải nó (khiến việc chuyển đổi sang định dạng khác trở nên khó khăn), nhưng tôi đã quản lý để tải nó trong trình xem ảnh Eye of Gnome (là một phần của cài đặt mặc định trên Ubuntu). Vì vậy, tôi đã chụp ảnh màn hình của hình ảnh để bạn có thể nhìn thấy nó (hình ảnh thực tế có nền trong suốt, nhưng bạn không thể thực sự chụp màn hình trong suốt):

Chúng ta cần xác định rõ kích thước hình ảnh. Chọn một hướng thích hợp cho hình ảnh, vẽ mọi thứ ở kích thước hợp pháp tối thiểu và thực hiện số lần lặp tối thiểu được chỉ định bởi thử thách, sẽ cho chúng ta một hình ảnh vừa với chiều rộng 99 pixel, tiết kiệm một byte. Thật tuyệt khi mọi thứ diễn ra như vậy.

Thuật toán chung được sử dụng để vẽ hình ảnh là duy trì hai biến (Underload không đặt tên biến, nhưng tôi nghĩ chúng là x và y ), cả hai ban đầu đều trống. Sau đó, chúng tôi liên tục thay thế ( x , y ) bằng ( x , rẽ trái và di chuyển về phía trước, y ) và ( x , rẽ phải và di chuyển về phía trước, y ). Sau mười lần lặp, cả x và y giữ một đường cong rồng chín lần.

Cũng có một vài tối ưu hóa vi mô và các thủ thuật dành riêng cho Tải trọng. Để tránh quá nhiều lộn xộn với đỉnh của ngăn xếp, mỗi lần lặp lại, chúng tôi bắt đầu bằng cách kết hợp x và y vào hàm "trả về chuỗi được tạo bằng cách nối: x , một lệnh rẽ, đối số hàm, di chuyển- chỉ dẫn về phía trước và y . " Hàm này chỉ chiếm một khoảng trống trên ngăn xếp, vì vậy chúng ta có thể nhân đôi nó, gọi nó bằng -90một đối số, hoán đổi giá trị trả về dưới dạng trùng lặp và gọi nó với 90tư cách là một đối số, để giữ các giá trị mới cho x và ymà không bao giờ cần phải chạm nhiều hơn hai yếu tố hàng đầu của ngăn xếp (mà cho đến nay là phổ biến nhất có thể truy cập). Hàm này được tạo mã khi chạy. Bản thân trình tạo cũng được tạo mã khi chạy, để cho phép nó sử dụng lại chuỗi <g transform="translatecũng được sử dụng để đặt gốc của hình ảnh. Chúng tôi tạo ra tất cả các thẻ mở trước, và sau đó vì tất cả các thẻ đóng chỉ là </g>, chúng tôi có thể xuất 1024 thẻ đóng thông qua việc lặp lại chuỗi, mà không phải lo lắng về việc khớp chúng với các thẻ mở. (Viết số hiệu quả trong Underload là một vấn đề thú vị theo cách riêng của nó; (:*)::*:**:*có lẽ là cách hiệu quả nhất để viết 1024, tuy nhiên, dịch thành "2 thành sức mạnh của (1 + 2 × 2) × 2".

Underload không có bất kỳ thư viện đồ họa nào, vì vậy tôi tạo ra SVG bằng cách sử dụng kết hợp các đường vẽ ở một vị trí cố định và xoay hình ảnh xung quanh một điểm nhất định; thay vì xoay bút, chúng ta lật giấy. Ý tưởng là bằng cách vẽ một dòng, xoay toàn bộ hình ảnh, vẽ một dòng khác, xoay hình ảnh một lần nữa, v.v., chúng ta có thể mô phỏng hiệu quả đồ họa rùa mà không phải thực hiện bất kỳ số học hoặc sử dụng bất kỳ thư viện đồ họa nào, vì tất cả các dòng được vẽ ở cùng một vị trí Tất nhiên, điều đó có nghĩa là chúng ta có một số thẻ xoay hình ảnh được lồng rất nhiều, khiến nhiều người xem SVG bối rối.

Tạo kiểu cho hình ảnh sẽ được tính theo số byte, vì vậy tôi cần đưa ra kiểu dáng tối thiểu cần thiết để hiển thị hình ảnh. Điều này hóa ra là stroke="#", mà ít nhiều dịch là "dòng cần phải có một số màu"; điều này dường như được mở rộng để vẽ nó bằng màu đen. (Thông thường bạn sẽ chỉ định màu như, nói, "# 000".) Nền mặc định trong suốt. Chúng tôi không chỉ định chiều rộng nét, nhưng lựa chọn được chọn bởi Eye of Gnome khiến mọi thứ hiển thị.

Nhiều trình thông dịch Underload đấu tranh với chương trình này, ví dụ như phiên bản trên Try It Online gặp sự cố, vì nó tạo ra một số chuỗi rất lớn trong nội bộ. Trình thông dịch Underload trực tuyến ban đầu hoạt động, mặc dù. (Thật thú vị, trình thông dịch đầu tiên là trực tuyến, vì vậy ngôn ngữ có thể sử dụng trực tuyến trước khi có thể sử dụng ngoại tuyến.)

Một điều tôi hơi khó chịu là dường như chỉ có 1023 phân đoạn dòng ở đây và chúng tôi mong đợi 1024. Có thể là một trong những phân đoạn ở cuối không được vẽ bằng thuật toán này (nó sẽ là được vẽ trên lần lặp tiếp theo thay thế). Nếu điều đó không đủ tiêu chuẩn, có thể điều chỉnh chương trình, nhưng nó có thể sẽ kết thúc lâu hơn đáng kể. (Không giống như thử thách này sẽ giành chiến thắng trong cuộc thi nào; đã có một vài mục ngắn hơn.)

MATL , 26 byte

0J1_h9:"tPJ*h]hYsXG15Y01ZG

Nếu các tỷ lệ khác nhau trong hai trục được chấp nhận, mã có thể được giảm xuống còn 19 byte:

0J1_h9:"tPJ*h]hYsXG

Các hình dưới đây tương ứng với phiên bản tỷ lệ bằng nhau (26 byte).

Đoạn mã trên tạo ra phép lặp thứ 9 (dựa trên 0), nghĩa là hình ảnh thứ mười trong thử thách:

Đối với các giá trị khác, thay đổi 9mã trong hoặc thay thế nó bằng cách ilấy số làm đầu vào của người dùng. Ví dụ: kết quả cho 13là:

Giải trình

Điều này sử dụng một vòng lặp để dần dần xây dựng một mảng các bước theo sau là đường cong trong mặt phẳng phức. Ví dụ, hai bước đầu tiên là 1j(lên) và -1(trái).

Trong mỗi lần lặp, mảng các bước cho đến nay được sao chép. Bản sao của mảng được đảo ngược , nhân bởi 1j(để xoay 90 độ), và nối với bản gốc.

Sau vòng lặp, tổng các bước tích lũy cho các điểm thực tế, sau đó được vẽ trong mặt phẳng phức.

0                          % Push 0
 J1_h                      % Push array [1j, -1]. This defines the first two steps
     9:                    % Push [1, 2, ..., 9]
       "                   % For each
        t                  %   Duplicate the array of steps so far
         P                 %   Reverse
          J*               %   Multiply by 1j
            h              %   Concatenate horizontally to previous steps
             ]             % End
              h            % Concatenate with the initial 0
               Ys          % Cumulative sum
                 XG        % Plot. Complex numbers are plotted with real and imag as x and y
                   15Y0    % Push string 'equal'
                       1ZG % Set equal scale in the two axes

Toán học 86 byte

{1,-1}
r=Reverse;Graphics@Line@Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]

Cách hoạt động: {1,-1}Đầu ra {1,-1}. Về cơ bản, nó "đẩy nó vào ngăn xếp". Giá trị này có thể được gọi lại với %. r=Reversevề cơ bản chỉ đổi tên hàm Reverse vì tôi sử dụng nó hai lần trong mã. Chỉ Graphics@Line@cần lấy một danh sách các điểm và vẽ một đường nối chúng. Phần cốt lõi của vấn đề xảy ra trong đoạn mã này:Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9] . Để tôi nói với bạn - đoạn đó phức tạp như f ****** ck. Đây là những gì Nest: Nest[f,x,9]xuất kết quả của cuộc gọi f[f[f[f[f[f[f[f[f[x]]]]]]]]].

Trong mã của tôi, số đầu tiên này flà: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&, đối số thứ hai xlà{{0,0},%} (ước tính {{0,0},{1,-1}}) và đối số thứ ba nchỉ là 9 (sẽ chỉ áp dụng đối số thứ nhất cho đối số thứ hai 9 lần).

Phần phức tạp nhất của tất cả là đối số đầu tiên này: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]& , đó là một mớ hỗn độn khổng lồ của đường cú pháp gần như thuần túy. Tôi đã thực sự lạm dụng đường cú pháp của mathicala cho cái này. Dòng mã đó biểu thị phiên bản toán học của một hàm ẩn danh, ngoại trừ rút ngắn những điều tôi thực sự xác định hai hàm ẩn danh riêng biệt trong hàm ẩn danh đó. Đúng, đó là hợp pháp, folks. Hãy phá vỡ nó.

Joinmất hai đối số. Đầu tiên làl=Last@#;h=#-l&/@# , và thứ hai là r[r@#%&/@h].

Đối số đầu tiên của Tham gia: Bên trong hàm ẩn danh "chính", #là danh sách tất cả các điểm tại lần lặp hiện tại trong đường cong. Vì vậy, l=Last@#;có nghĩa là "Lấy điểm trong danh sách các điểm bạn nhận được làm đầu vào và gán điểm đó cho biến l. Đoạn tiếp theo, h=#-l&/@#phức tạp hơn một chút. Nó có nghĩa là" Bạn có một hàm. Hàm này lấy một điểm làm đầu vào, trừl nó và trả về kết quả. Bây giờ, áp dụng hàm đó cho mọi phần tử trong danh sách các điểm bạn nhận được làm đầu vào để tạo danh sách các điểm đã dịch chuyển và gán danh sách mới đó cho biến h.

Đối số thứ hai của Tham gia: r[r@#%&/@h] có nghĩa đen là cú pháp phức tạp nhất tôi từng viết. Tôi không thể tin bất kỳ phân đoạn mã nào có thể chứa thứ gì đó giống như @#%&/@- có vẻ như tôi đang chửi rủa như một nhân vật hoạt hình ở giữa chương trình! Nhưng nó có thể phá vỡ nó. Ghi nhớ - r[x]lấy danh sách các điểm và trả về danh sách đó theo thứ tự ngược lại. r@#%&là một hàm ẩn danh đảo ngược đầu vào của nó, sau đó nhân nó với giá trị được lưu trữ trong %(đó là {1,-1}) và trả về kết quả. Về cơ bản, nó xoay đầu vào 90 độ, nhưng trong mã ngắn nhất có thể tôi có thể viết. Sau đór@#%&/@h có nghĩa là "Xuất ra một danh sách mới, mỗi điểm hđược xoay 90 độ."

Vì vậy, về tổng thể, Join[l=Last@#;h=#-l&/@#,r[r@#*%&/@h]]&là một hàm lấy danh sách các điểm làm đầu vào và thêm vào cùng một danh sách các điểm được xoay 90 độ để có được lần lặp tiếp theo của đường cong. Điều này được lặp lại 9 lần để có được đường cong rồng. Sau đó, danh sách các điểm kết quả được vẽ lên màn hình dưới dạng một đường. Và đầu ra:

Python 2, 43 byte

Câu trả lời này là 43 byte không bao gồm câu lệnh nhập khẩu và phần lớn dựa trên câu trả lời Logo của Level River St và việc sử dụng i/(i&-i)mã của họ. Dùng thử trực tuyến tại trinket.io

from turtle import*
for i in range(1,513):fd(9);rt(90*i/(i&-i))

Dưới đây là hình ảnh của đầu ra.

Toán học, 56 55 byte

Graphics@Line@AnglePath[Pi/2JacobiSymbol[-1,Range@512]]

Giải thích: OEIS A034947

Để cho vui, đây là phiên bản màu của lần lặp thứ 19.

Toán học, 63 byte

Sử dụng AnglePath

Graphics@Line@AnglePath[Pi/2Nest[Join[#,{1},-Reverse@#]&,{},9]]

HTML + JavaScript, 182

<canvas id=C></canvas><script>c=C.getContext("2d")
C.width=C.height=400
s=n=9
x=y=200
for(i=d=0;i<=1<<n;d+=++i/(i&-i))
c.lineTo(x,y),
d&1?y+=d&2?s:-s:x+=d&2?-s:s
c.stroke()</script>

Sơ đồ Haskell +, 179 byte

import Diagrams.Prelude
import Diagrams.Backend.SVG
d 1=hrule 1<>vrule 1
d n=d(n-1)<>d(n-1)#reverseTrail#rotateBy(1/4)
main=renderSVG"d"(mkWidth 99)$strokeT(d 9::Trail V2 Double)

Đầu ra là một tệp svg rộng 99 pixel với nền trong suốt (một hình ảnh rộng 9 pixel sẽ có một nét quá dày để đánh giá lại bất cứ thứ gì). Ở đây nó được định cỡ lại và sáng tác trên nền trắng:

tosh , 518 byte

tosh là Scratch , nhưng với văn bản thay vì khối. Với 518 byte, câu trả lời này có lẽ còn tồi tệ hơn Java.

Câu trả lời này sử dụng logic tương tự như câu trả lời Python của @ Theo , nhưng với các chuỗi "L" và "R" thay vì số, vì khả năng danh sách của Scratch (và do đó là tosh) là khủng khiếp.

Bạn có thể chạy nó như một dự án Scratch tại đây . (tosh biên dịch cho các dự án Scratch)

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear
repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end
set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

Giải trình:

when flag clicked
set path to "R"
go to x: -50 y: 100
point in direction 90
pen down
set pen size to 2
clear

Phần đầu tiên này làm cho chương trình chạy khi cờ màu xanh lá cây được nhấp ( when flag clicked), đặt biến đường dẫn thành "R" và đưa sprite và giai đoạn ở trạng thái thích hợp để sẵn sàng vẽ.

repeat 9
    set path copy to path
    set path to join (path) "R"
    set i to length of path copy
    repeat length of path copy
        if letter i of path copy = "R" then
            set path to join (path) "L"
        else
            set path to join (path) "R"
        end
        change i by -1
    end
end

Bây giờ chúng ta đến mã tạo đường dẫn. Nó sử dụng logic tương tự như câu trả lời Python của @ Theo , ngoại trừ các chuỗi "R" và "L" thay vì số và chúng tôi sử dụng các vòng lặp lồng nhau thay vì hiểu danh sách.

set i to 0
repeat length of path
    change i by 1
    if letter i of path = "R" then
         turn cw 90 degrees
    else
         turn ccw 90 degrees
    end
    move 7 steps
end  

Cuối cùng, chúng ta vẽ đường dẫn bằng cách đi qua từng chữ cái của biến đường dẫn và rẽ trái hoặc phải tùy thuộc vào chữ cái.