Tugas Anda hari ini: menggambar kurva naga!

Jika Anda tidak tahu apa itu Dragon Curve, berikut adalah video pengantar ViHart (Sungguh keren, tolong tonton!)

Tugas Anda: menggambar kurva naga, iterasi setidaknya 9 kali. Anda tidak harus menunjukkan iterasi 1 hingga 9, Anda hanya harus menunjukkan kurva akhir yang dihasilkan setelah menyelesaikan (setidaknya) 9 iterasi. Kurva harus digambarkan sebagai garis lurus yang menghubungkan titik-titik pada kurva; output harus cocok dengan salah satu gambar di bawah ini yang menunjukkan 9 atau lebih iterasi (hingga refleksi, rotasi, penskalaan, dan variasi dalam lebar garis, warna garis, dan warna latar belakang). Output Anda harus cukup besar sehingga garis individual dan "kotak" yang mereka bentuk dapat dibedakan satu sama lain; jika dua garis tidak berpotongan dalam kurva, mereka seharusnya tidak menempati piksel yang sama atau berdekatan dalam output (harus ada setidaknya satu piksel dari latar belakang yang terlihat di antara mereka). Anda dapat menampilkan gambar ke layar atau menyimpan gambar ke file diterima. Outputnya harus grafis - tidak boleh ASCII art.

Kode terpendek dalam byte menang, namun termasuk arahan untuk perpustakaan tidak boleh dimasukkan dalam jumlah byte, dan Anda dapat menggunakan perpustakaan grafis atau perpustakaan lain yang ditulis untuk bahasa pilihan Anda jika ditulis sebelum posting.

Harap sertakan gambar output program Anda.

Lewati paragraf ini jika Anda menonton video:Bagi Anda yang memutuskan untuk tidak menonton video, 12 iterasi pertama dari kurva naga ditampilkan di bawah ini. Untuk keperluan tugas ini, kurva naga adalah kurva yang dihasilkan oleh aturan berikut: ambil titik akhir dari kurva saat ini, buat kurva kedua diputar 90 derajat di sekitar titik-akhir sehingga titik akhir dari dokumen asli kurva adalah titik awal dari kurva baru, dan bergabung dengan dua kurva menjadi kurva tunggal di mana mereka bertemu. Pada gambar yang ditunjukkan di bawah ini, setiap iterasi baru dihasilkan dengan memutar iterasi sebelumnya 90 derajat ke kiri di sekitar titik akhir setiap iterasi. Ketika kurva ditampilkan di layar, tidak jelas ujung mana yang dianggap sebagai "titik akhir", namun ketika kurva disimpan sebagai array titik, mudah untuk menentukan "titik akhir" sebagai titik terakhir dalam array.

Seni Ascii dihargai, tetapi tidak diterima: Ini adalah keluaran grafis, bukan seni-ascii.

x86, MSDOS, 16 byte

Saya menulis ini beberapa waktu yang lalu, setahu saya rutin terkecil untuk menghasilkan fraktal naga. Tidak menggunakan iterasi nyata, melainkan plot setiap pixel disk yang terkandung di dalam fraktal secara langsung, menunjukkan gambar akhir . Sudah termasuk dengan banyak produksi kecil lainnya dalam paket ini . Versi 16 byte adalah akhir dari upaya saya untuk mendapatkan fraktal naga sekecil mungkin, mulai 2014 dengan produksi 32 byte ini .

Hex

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

Kode

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 Bytes

Perhatikan bahwa impor tidak termasuk dalam hitungan byte, sesuai dengan spesifikasi tantangan.

Terima kasih kepada @AlexHall untuk menghemat 39 (!) Byte dan @ nedla2004 untuk 13 lainnya

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)

Mulai dengan membuat daftar atau belok kanan (90) dan kiri (-90), kemudian menelusuri daftar dan memindahkan kura-kura.

Output yang dihasilkan:

EDIT: Jika ini terlalu membosankan, tonton speed(0)tepat sebelum yang pertama fd(5). Ini akan berjalan sama, kecuali kura-kura akan bergerak lebih cepat.

Logo, 43 byte

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

Coba dengan penerjemah di http://www.calormen.com/jslogo/#

Ini menggunakan prinsip yang sama dengan jawaban seni ASCII saya sebelumnya dan rumus di wikipedia kecuali saya membalik arah untuk mencocokkan gambar dalam pertanyaan:

Pertama, ungkapkan n dalam bentuk di k*(2^m)mana k adalah bilangan ganjil. Arah putaran ke-n ditentukan oleh k mod 4 yaitu sisa yang tersisa ketika k dibagi dengan 4. Jika k mod 4 adalah 1 maka putaran ke-n adalah R L; jika k mod 4 adalah 3 maka putaran ke-n adalah L R

bitand :i -:imenemukan sedikit signifikan i. Kami membagi iini untuk mengurangi ijumlah yang diperlukan, memberikan jumlah ganjil yang diperlukan k. Tidak perlu membedakan antara belokan kiri dan kanan; kita belok kiri sedikit demi sedikit k*90dan mengandalkan fakta bahwa rotasi adalah operasi modulo 360 untuk melakukan modulo bagi kita.

Keluaran

gunakan htuntuk menyembunyikan kura-kura jika diperlukan.

Keluaran (dimodifikasi)

Berikut ini menunjukkan bagaimana kurva adalah untai tunggal.

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 Bytes

LindenMASM adalah bahasa yang saya buat untuk suatu tantangan beberapa waktu lalu yang akan selamanya hidup di Sandbox. Itu menggunakan konsep sistem Lindenmayer untuk menggambar hal-hal seperti kurva Naga, tanaman fraktal, segitiga Sierpinski, dll.

Kode sumber adalah sebagai berikut:

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

Untuk mengatur ini n = 6misalnya:

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

Ini menghasilkan gambar berikut melalui Python 3 turtle:

Mungkin ada sedikit perbedaan penomoran untuk iterasi, seperti dalam sistem Lindenmayer, iterasi pertama adalah satu baris. Begini tampilannya n = 10:

Hanya untuk bersenang-senang, inilah yang terlihat seperti dengan 15 generasi (dengan instruksi tambahan MOV 2untuk membuatnya sedikit lebih kecil):

Setelah Anda mendapatkan hingga 20 generasi (dengan MOV 0.5) Anda tidak dapat benar-benar melihat garis lagi, dan dibutuhkan BANYAK langkah untuk membuat (pasang +-dan -+tidak dioptimalkan). Inilah yang Anda dapatkan:

^{Perhatikan bahwa juru bahasa saat ini dapat menyajikan masalah grafis untuk jumlah generasi yang lebih kecil, yaitu mungkin tidak menarik ke layar. Sayangnya ketika penerjemah ini dibuat tidak ada masalah, kemungkinan perubahan pada Python 3 bisa menyebabkan ini atau itu bisa saja sistem saya}

Di bawah beban, 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

Saya pikir mungkin menarik untuk mencoba tantangan ini di esolang bertenaga rendah; Underload cukup baik untuk bahasa dengan jumlah perintah yang rendah.

Outputnya adalah file SVG dengan tag yang sangat bersarang, dan beberapa pintasan golf. Sejauh ini, saya belum menemukan browser yang dapat menampilkannya (Firefox hang selama beberapa menit mencoba memuatnya, dan baik Firefox maupun Chromium memberikan layar kosong). Sebagian besar program pengolah gambar tidak dapat memuatnya (membuatnya sulit untuk dikonversi ke format lain), tetapi saya berhasil memuatnya di Eye view Gnome (yang merupakan bagian dari penginstalan default pada Ubuntu). Jadi saya mengambil tangkapan layar gambar sehingga Anda dapat melihatnya (gambar sebenarnya memiliki latar belakang transparan, tetapi Anda tidak dapat benar-benar tangkapan layar transparan):

Kita perlu menentukan ukuran gambar secara eksplisit. Memilih orientasi yang tepat untuk gambar, menggambar semuanya pada ukuran hukum minimum, dan melakukan jumlah minimum iterasi yang ditentukan oleh tantangan, memberi kita sebuah gambar yang hanya cocok menjadi lebar 99 piksel, menyimpan byte. Sangat menyenangkan ketika semuanya berjalan seperti itu.

Algoritma umum yang digunakan untuk menggambar gambar adalah untuk mempertahankan dua variabel (Underload tidak menamai variabel, tetapi saya menganggapnya sebagai x dan y ), keduanya awalnya kosong. Kemudian kami berulang kali mengganti ( x , y ) dengan ( x , belok kiri dan bergerak maju, y ) dan ( x , belok kanan dan bergerak maju, y ). Setelah sepuluh iterasi, baik x dan y memegang kurva naga sembilan iterasi.

Ada juga beberapa optimasi mikro dan trik khusus yang kurang memuat. Untuk menghindari terlalu banyak bermain-main dengan bagian atas tumpukan, setiap iterasi loop, kita mulai dengan menggabungkan x dan y ke fungsi "mengembalikan string yang dibuat dengan menggabungkan: x , instruksi belok, argumen fungsi, argumen instruksi ke depan, dan y . " Fungsi ini hanya memakan satu ruang di stack, jadi kita bisa menduplikasinya, menyebutnya dengan -90argumen, menukar nilai kembali di bawah duplikat, dan menyebutnya dengan 90sebagai argumen, untuk mendapatkan nilai-nilai baru untuk x dan ytanpa perlu menyentuh lebih dari dua elemen teratas tumpukan (yang sejauh ini paling mudah diakses). Fungsi ini dihasilkan kode saat runtime. Generator itu sendiri juga dihasilkan kode saat runtime, untuk memungkinkannya menggunakan kembali string <g transform="translateyang juga digunakan untuk mengatur asal gambar. Kami membuat semua tag terbuka terlebih dahulu, dan kemudian karena semua tag dekat itu adil </g>, kami dapat menampilkan 1024 tag dekat hanya dengan mengulangi string, tanpa khawatir akan mencocokkannya dengan tag terbuka. (Menulis angka secara efisien dalam Underload adalah masalah yang menarik dalam dirinya sendiri; (:*)::*:**:*mungkin merupakan cara paling efisien untuk menulis 1024, meskipun, menerjemahkan ke "2 pangkat dari (1 + 2 × 2) × 2".

Underload tidak memiliki pustaka grafis, jadi saya membuat SVG menggunakan kombinasi garis gambar pada posisi tetap, dan memutar gambar di sekitar titik tertentu; alih-alih membalikkan pena, kita membalikkan kertas. Idenya adalah dengan menggambar garis, memutar seluruh gambar, menggambar garis lain, memutar gambar lagi, dll., Kita dapat secara efektif mensimulasikan grafik penyu tanpa harus melakukan aritmatika atau menggunakan perpustakaan grafik, karena semua garis digambar di lokasi yang sama. Tentu saja, itu berarti bahwa kami memiliki beberapa tag rotate-the-image yang sangat bersarang, yang membingungkan banyak pemirsa SVG.

Styling gambar akan dihitung melawan jumlah byte, jadi saya perlu memberikan styling minimum yang diperlukan untuk menampilkan gambar. Ini ternyata stroke="#", yang kurang lebih diterjemahkan sebagai "garis harus berwarna"; ini tampaknya diperluas untuk menggambarnya dalam warna hitam. (Biasanya Anda akan menentukan warna sebagai, katakanlah, "# 000".) Latar belakang transparan secara default. Kami tidak menentukan lebar goresan, tetapi pilihan yang dipilih oleh Eye of Gnome membuat semuanya terlihat.

Banyak penerjemah Underload berjuang dengan program ini, misalnya yang ada di Try It Online mogok, karena menghasilkan beberapa string yang sangat besar secara internal. Namun, penerjemah Underload online asli berfungsi. (Yang menarik, juru bahasa pertama sedang online, jadi bahasanya bisa digunakan online sebelum bisa digunakan secara offline.)

Sesuatu yang saya sedikit tidak nyaman adalah sepertinya hanya ada 1023 segmen garis di sini, dan kita harapkan 1024. Bisa jadi salah satu segmen pada akhirnya tidak tertarik dengan algoritma ini (itu akan menjadi digambar pada iterasi berikutnya sebagai gantinya). Jika itu mendiskualifikasi, itu mungkin untuk mengadaptasi program, tetapi mungkin berakhir jauh lebih lama. (Bukannya tantangan ini akan memenangkan persaingan; sudah ada beberapa entri yang lebih pendek.)

MATL , 26 byte

0J1_h9:"tPJ*h]hYsXG15Y01ZG

Jika skala yang berbeda dalam dua sumbu diterima, kode dapat dikurangi menjadi 19 byte:

0J1_h9:"tPJ*h]hYsXG

Angka-angka di bawah ini sesuai dengan versi skala yang sama (26-byte).

Kode di atas menghasilkan iterasi ke 9 (berbasis 0), yaitu gambar kesepuluh dalam tantangan:

Untuk nilai-nilai lain, ubah 9kode tersebut, atau ganti dengan imengambil nomor tersebut sebagai input pengguna. Misalnya, hasilnya 13adalah:

Penjelasan

Ini menggunakan loop untuk secara bertahap membangun array langkah - langkah yang diikuti oleh kurva di bidang kompleks. Misalnya, dua langkah pertama adalah 1j(atas) dan -1(kiri).

Di setiap iterasi, array langkah sejauh ini disalin. Salinan array dibalik , dikalikan dengan 1j(untuk memutar 90 derajat), dan disatukan dengan aslinya.

Setelah loop, jumlah kumulatif dari langkah-langkah memberikan poin yang sebenarnya, yang kemudian diplot dalam bidang kompleks.

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

Mathematica 86 byte

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

Cara kerjanya: {1,-1}Output {1,-1}. Ini pada dasarnya "mendorongnya ke tumpukan". Nilai ini dapat ditarik kembali dengan %. r=Reversepada dasarnya hanya mengganti nama fungsi Reverse karena saya menggunakannya dua kali dalam kode. The Graphics@Line@hanya membutuhkan daftar poin dan menarik garis yang menghubungkan mereka. Daging yang sebenarnya dari masalah yang terjadi di segmen kode ini: Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]. Biar saya katakan - segmen itu rumit seperti f ****** ck. Begini Nestcaranya: Nest[f,x,9]menampilkan hasil panggilan f[f[f[f[f[f[f[f[f[x]]]]]]]]].

Dalam kode saya, argumen pertama ini fadalah Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&:, argumen kedua xadalah {{0,0},%}(yang mengevaluasi ke {{0,0},{1,-1}}), dan argumen ketiga adalah n, yang hanya 9 (yang hanya akan menerapkan argumen pertama ke argumen kedua sebanyak 9 kali).

Bagian paling kompleks dari semuanya adalah argumen pertama ini:, Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&yang merupakan kekacauan besar dari sintaksis gula yang hampir murni. Saya benar - benar menyalahgunakan gula sintaksis matematika untuk yang satu ini. Baris kode itu mewakili versi matematika dari fungsi anonim, kecuali untuk mempersingkat hal-hal yang sebenarnya saya definisikan dua fungsi anonim yang terpisah di dalam fungsi anonim itu. Ya, itu legal, kawan. Mari kita jabarkan.

JoinDibutuhkan dua argumen. Yang pertama adalah l=Last@#;h=#-l&/@#, dan yang kedua adalah r[r@#%&/@h].

Argumen pertama Gabung: Di dalam fungsi anonim "utama", #adalah daftar semua titik pada iterasi saat ini di kurva. Jadi l=Last@#;berarti "Ambil titik dalam daftar poin yang Anda terima sebagai input, dan tetapkan titik itu ke variabel l. Segmen berikutnya,, h=#-l&/@#sedikit lebih kompleks. Ini berarti" Anda memiliki fungsi. Fungsi ini mengambil titik sebagai input, mengurangi l, dan mengembalikan hasilnya. Sekarang, terapkan fungsi itu ke setiap elemen dalam daftar poin yang Anda terima sebagai input untuk menghasilkan daftar poin bergeser, dan tetapkan daftar baru itu ke variabel h.

Argumen kedua dari Join: r[r@#%&/@h] memiliki sintaks yang paling kompleks yang pernah saya tulis. Saya tidak percaya ada segmen kode yang berisi sesuatu @#%&/@- sepertinya saya mengutuk seperti karakter kartun di tengah program! Tetapi mungkin untuk memecahnya. Ingat - r[x]mengambil daftar poin dan mengembalikan daftar itu dalam urutan terbalik. r@#%&adalah fungsi anonim yang membalikkan inputnya, lalu mengalikannya dengan nilai yang bertingkat %(yaitu {1,-1}), dan mengembalikan hasilnya. Pada dasarnya itu memutar input 90 derajat, tetapi dalam kode sesingkat mungkin saya bisa menulis. Kemudian r@#%&/@hberarti "Keluarkan daftar baru yang setiap titiknya hdiputar 90 derajat."

Jadi secara keseluruhan, Join[l=Last@#;h=#-l&/@#,r[r@#*%&/@h]]&adalah fungsi yang mengambil daftar poin sebagai input, dan menambahkan daftar poin yang sama diputar 90 derajat untuk mendapatkan iterasi kurva berikutnya. Ini diulangi 9 kali untuk mendapatkan kurva naga. Maka inilah daftar poin yang dihasilkan ditarik ke layar sebagai garis. Dan hasilnya:

Python 2, 43 byte

Jawaban ini adalah 43 byte tidak termasuk pernyataan impor dan sebagian besar didasarkan pada jawaban Logo Level River dan penggunaannya i/(i&-i)dalam kode mereka. Cobalah online di trinket.io

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

Ini adalah gambar dari output.

Mathematica, 56 55 byte

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

Penjelasan: OEIS A034947

Hanya untuk bersenang-senang, ini adalah versi berwarna dari iterasi ke-19.

Mathematica, 63 byte

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

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

Output adalah file svg lebar 99 piksel dengan latar belakang transparan (gambar dengan lebar 9 piksel akan memiliki garis yang terlalu tebal untuk melakukan recoqnize apa pun). Di sini itu diubah skala dan dikomposisi di atas latar belakang putih:

tosh , 518 byte

tosh adalah Scratch , tetapi dengan teks alih-alih blok. Pada 518 byte, jawaban ini mungkin bahkan lebih buruk daripada Java.

Jawaban ini menggunakan logika yang sama dengan jawaban Thethon Python @ , tetapi dengan string "L" dan "R" bukan angka, karena kemampuan daftar Scratch (dan dengan demikian tosh) mengerikan.

Anda dapat menjalankannya sebagai proyek Awal di sini . (tosh mengkompilasi ke Scratch proyek)

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  

Penjelasan:

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

Bagian pertama ini membuat program berjalan ketika bendera hijau diklik ( when flag clicked), menetapkan variabel path ke "R", dan membuat sprite dan stage dalam keadaan yang tepat untuk siap menggambar.

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

Sekarang kita sampai pada kode pembuatan jalur. Ia menggunakan logika yang sama dengan jawaban Thethon Python , kecuali dengan string "R" dan "L" alih-alih angka, dan kami menggunakan loop bersarang alih-alih daftar pemahaman.

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  

Akhirnya, kita menggambar path dengan menelusuri setiap huruf dari variabel path dan berbelok ke kiri atau kanan tergantung pada surat itu.