Bugün için göreviniz: bir ejderha eğrisi çizin!

Bir Ejderha Eğrisi'nin ne olduğunu bilmiyorsanız, işte bir ViHart videosu (Gerçekten harika, lütfen izleyin!)

Göreviniz: En az 9 kez yinelenen bir ejderha eğrisi çizin. 1'den 9'a kadar yinelemeleri göstermeniz gerekmez, sadece 9 yinelemeyi tamamladıktan sonra üretilen son eğriyi göstermeniz yeterlidir. Eğri, eğri üzerindeki noktaları birleştiren düz çizgiler olarak çizilmelidir; çıktı, 9 veya daha fazla yineleme gösteren aşağıdaki görüntülerden biriyle eşleşmelidir (yansıma, döndürme, ölçekleme ve çizgi genişliği, çizgi rengi ve arka plan rengindeki değişiklik). Çıktınız, tek tek satırların ve oluşturdukları "kutuların" birbirinden ayırt edilebilecek kadar büyük olmalıdır; iki çizgi eğriyle kesişmiyorsa, çıktıda aynı veya bitişik pikselleri işgal etmemelidirler (aralarında görünen arka planın en az bir pikseli olmalıdır). Görüntüyü ekranda görüntüleyebilir veya görüntüyü bir dosyaya kaydedebilirsiniz kabul edilir. Çıktı grafik olmalıdır - ASCII sanatı olamaz.

Baytlardaki en kısa kod kazanır, ancak kütüphaneler için yönergeler bayt sayısına dahil edilmemelidir ve kayıttan önce yazılmışlarsa, seçtiğiniz dil için yazılmış grafik kütüphanelerini veya diğer kütüphaneleri kullanabilirsiniz.

Lütfen programınızın çıktısının bir resmini ekleyin.

Videoyu izlediyseniz bu paragrafı atlayın:Videoyu izlememeye karar verenler için, ejderha eğrisinin ilk 12 iterasyonu aşağıda gösterilmiştir. Bu görevin amaçları için, bir ejderha eğrisi aşağıdaki kural tarafından oluşturulan bir eğridir: geçerli eğrinin bitiş noktasını alın, orijinalin bitiş noktası olacak şekilde bu bitiş noktasının etrafında 90 derece döndürülmüş ikinci bir eğri oluşturun eğri, yeni eğrinin başlangıç ​​noktasıdır ve iki eğriyi buluştukları yerde tek bir eğri halinde birleştirir. Aşağıda gösterilen görüntülerde, her yeni yineleme, önceki yinelemenin her yinelemenin bitiş noktası etrafında saat yönünde 90 derece döndürülmesiyle üretilir. Eğri ekranda görüntülendiğinde, hangi ucun "bitiş noktası" olarak sayıldığı açık değildir, ancak eğri bir nokta dizisi olarak saklandığında, "bitiş noktasını" son nokta olarak tanımlamak kolaydır dizi.

Ascii sanatı takdir edilir, ancak kabul edilmez: Bu grafiksel çıktıdır, ascii sanatı değildir.

x86, MSDOS, 16 bayt

Bunu bir süre önce yazdım, bence bir ejderha fraktal üretmek için en küçük rutin. Gerçek bir yineleme kullanmaz, bunun yerine, içerdiği her bir ayrı pikseli doğrudan fraktalın içine çizerek nihai görüntüyü gösterir. Bu paketteki diğer birçok küçük prodüksiyona dahildir . 16 baytlık versiyon, 2014 yılında bu 32 baytlık üretimle ejderha fraktalını mümkün olduğunca küçük hale getirme çabamın sonu oldu .

büyü

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

kod

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

Piton 2/3, 169 167 , 150 111 98 78 bayt

Meydan okuma özelliklerine göre, içe aktarmanın bayt sayısına dahil edilmediğini unutmayın.

39 (!) Bayt kaydettiği için @AlexHall ve 13 için @ nedla2004

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)

Bir liste veya sağ (90) ve sola (-90) dönüşler oluşturarak başlar, ardından listeye girer ve kaplumbağayı hareket ettirir.

Üretilen Çıktı:

EDIT: Bu da çok sıkıcı izle, speed(0)ilk önce hemen ekleyin fd(5). Aynı şekilde çalışır, ancak kaplumbağa çok daha hızlı hareket eder.

Logo, 43 bayt

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

Http://www.calormen.com/jslogo/# adresinden tercüman kullanmayı deneyin.

Bu, önceki ASCII sanat yanıtımla ve wikipedia'daki formülle aynı prensibi kullanıyor, ancak sorudaki görüntüyle eşleşme yönünü tersine çevirdim :

İlk olarak, n'yi k*(2^m)k'nın tek bir sayı olduğu formda ifade edin . N'inci dönüş yönü ile belirlenir k mod 4 örneğin, k4 1 mod ise geri kalan k 4 ile bölündüğünde, daha sonra sola n'inci dönüş R L; k mod 4 3 ise, n'inci tur L R olur

bitand :i -:ien az önemli parçayı bulur i. Bunu , gerekli miktarı sağlayarak, gerekli tek sayıyı vermek iiçin böleriz . Sol ve sağ dönüşler arasında ayrım yapmaya gerek yoktur; sadece derece derece sola dönüyoruz ve rotasyonun bizim için modulo gerçekleştirmek için bir modulo 360 operatörü olduğuna güveniyoruz.ikk*90

Çıktı

htgerekirse kaplumbağayı gizlemek için kullanın .

Çıktı (değiştirildi)

Aşağıda eğrinin nasıl tek bir tel olduğu gösterilmiştir.

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 Bayt

LindenMASM, bir süre önce Sandbox'ta sonsuza dek yaşayacak bir meydan okuma için oluşturduğum bir dildi. Ejderha eğrileri, fraktal bitkiler, Sierpinski üçgenleri gibi şeyleri çizmek için Lindenmayer sistemleri kavramını kullanır .

Kaynak kodu aşağıdaki gibidir:

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

n = 6Örneğin bunu ayarlamak için:

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

Bu, Python 3'ler aracılığıyla aşağıdaki görüntüyü üretir turtle:

Lindenmayer sisteminde olduğu gibi, ilk yineleme tek bir satır olduğundan, yinelemeler için küçük bir numaralandırma farkı olabilir. İşte böyle görünüyor n = 10:

Sadece eğlenmek için, 15 nesil ile böyle görünüyor ( MOV 2biraz daha küçük yapmak için ek bir talimatla ):

20 nesile kadar (ile MOV 0.5) bir kez artık hatları gerçekten göremezsiniz ve oluşturmak ( +-ve-+ optimize edilmez). İşte elde ettiğiniz:

^{Mevcut yorumlayıcının daha küçük miktarlarda nesiller için grafiksel sorunlar sunabileceğini, yani muhtemelen ekrana çizim yapamayacağını unutmayın. Ne yazık ki bu yorumlayıcı oluşturulduğunda hiçbir sorun yoktu, Python 3'te olası bir değişiklik buna neden olmuş olabilir veya sadece sistemim olabilir}

Düşük yük, 196 bayt

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

Bu mücadeleyi düşük güçlü bir esolangda denemenin ilginç olabileceğini düşündüm; Düşük yük, bu kadar az sayıda komut içeren bir dil için oldukça iyidir.

Çıktı, çok yoğun içiçe etiketler ve bazı golf kısayolları içeren bir SVG dosyasıdır. Şimdiye kadar, görüntüleyebilecek bir tarayıcı bulamadım (Firefox yüklemeye çalışırken birkaç dakika kilitleniyor ve hem Firefox hem de Chromium boş bir ekran veriyor). Çoğu görüntü işleme programı da yükleyemez (başka bir formata dönüştürmeyi zorlaştırır), ancak görüntü görüntüleyici Eye of Gnome'a ​​(Ubuntu'daki varsayılan yüklemenin bir parçası olan) yüklemeyi başardım. Görmek için görüntünün ekran görüntüsünü aldım (gerçek görüntünün şeffaf bir arka planı var, ancak gerçekten şeffaf bir ekran görüntüsü alamıyorsunuz):

Görüntü boyutunu açıkça belirtmemiz gerekiyor. Görüntü için uygun bir yönlendirme seçmek, her şeyi minimum yasal boyutta çizmek ve meydan okuma tarafından belirtilen minimum yineleme sayısını yapmak, bize yalnızca 99 piksel genişliğe sığan ve bayt tasarrufu sağlayan bir görüntü verir . İşler böyle çalıştığında hoş olur.

Görüntüyü çizmek için kullanılan genel algoritma, iki değişkeni korumaktır (Düşük yük değişkenleri adlandırmaz, ancak bunları x ve y olarak düşündüm ), her ikisi de başlangıçta boştur. Sonra tekrar tekrar (replace x , y ) ile ( x , sol ve ileriye taşımak dönün y ) ve ( x , sağa dönün ve ileriye taşımak y ). On tekrar, hem X ve Y , bir dokuz yineleme ejderha eğrisi tutun.

Birkaç mikro optimizasyon ve Düşük Yüke özgü hileler de var. Yığının üst kısmı, her döngü yinelemesi ile çok fazla karışıklıktan kaçınmak için x ve y işlevini birleştirerek başlarız "birleştirerek oluşturulan dizeyi döndürür: x , bir dönüş komutu, işlev argümanı, bir hareket- ileri talimatı ve y . " Bu işlev yığın üzerinde yalnızca bir yer kaplar, böylece x ve y için yeni değerleri elde etmek için -90çoğaltabilir, 90bağımsız değişken olarak çağırabilir, kopya değerinin altındaki dönüş değerini değiştirebilir ve bağımsız değişken olarak çağırabiliriz.yığının üst iki unsurundan daha fazlasına dokunmaya gerek kalmadan (en yaygın şekilde erişilebilir olan). Bu işlev çalışma zamanında kod üretilir. Jeneratörün kendisi de <g transform="translategörüntünün kökenini ayarlamak için kullanılan dizeyi yeniden kullanmasına izin vermek için çalışma zamanında kod üretilir . İlk olarak tüm açık etiketleri üretiyoruz ve sonra tüm yakın etiketler sadece </g>olduğundan, açık etiketlerle eşleştirmekten endişe etmeden dizeyi tekrarlayarak 1024 kapat etiket çıkarabiliriz. (Düşük yükte sayıları verimli bir (:*)::*:**:*şekilde yazmak kendi başına ilginç bir sorundur; 1024 yazmanın en etkili yolu muhtemelen "2'nin (1 + 2 × 2) × 2 gücüne" çevirmektir.

Düşük yükte herhangi bir grafik kütüphanesi yok, bu yüzden sabit bir konumda çizim çizgilerinin bir kombinasyonunu kullanarak ve görüntüyü belirli bir nokta etrafında döndürerek SVG üretiyorum; Kalemi çevirmek yerine kağıdı çeviriyoruz. Fikir şu ki, bir çizgi çizerek, tüm görüntüyü döndürerek, başka bir çizgi çizerek, görüntüyü tekrar döndürerek, vb. aynı yerde. Tabii ki bu, birçok SVG görüntüleyicisini şaşırtan çok iç içe resim döndürme etiketlerine sahip olduğumuz anlamına gelir.

Görüntüyü şekillendirmek bayt sayısına göre sayılır, bu yüzden görüntüyü görüntülemek için gereken minimum stili vermeliydim. Bu stroke="#", aşağı yukarı "çizginin bir renk olması gerekiyor" anlamına gelen; bu siyah renkte çizilecek şekilde genişletildi. (Normalde rengi "# 000" olarak belirtirsiniz.) Arka plan varsayılan olarak saydamdır. Bir kontur genişliği belirtmiyoruz, ancak Eye of Gnome tarafından seçilen seçim her şeyi görünür kılıyor.

Birçok Düşük Yüklü tercüman bu programla mücadele eder, örneğin Try It Online'daki gibi çöker, çünkü dahili olarak çok büyük dizeler üretir. Orijinal çevrimiçi Underload yorumlayıcısı çalışıyor. (İlginçtir, ilk yorumlayıcı çevrimiçi idi, bu yüzden dil çevrimdışı kullanılabilir olmadan önce çevrimiçi olarak kullanılabilirdi.)

Biraz tedirgin olduğum bir şey, burada sadece 1023 çizgi segmenti var gibi görünüyor ve 1024 bekliyoruz. Sonunda segmentlerden biri bu algoritma ile çizilmiyor olabilir ( bunun yerine sonraki yinelemede çizilir). Bu diskalifiye ederse, programı uyarlamak mümkün olabilir, ancak oldukça uzun sürebilir. (Bu meydan okuma yine de rekabeti kazanacak gibi değil; zaten birkaç daha kısa giriş var.)

MATL , 26 bayt

0J1_h9:"tPJ*h]hYsXG15Y01ZG

İki eksende farklı ölçekler kabul edilirse, kod 19 bayta indirilebilir:

0J1_h9:"tPJ*h]hYsXG

Aşağıdaki şekiller eşit ölçekli (26 bayt) versiyona karşılık gelir.

Yukarıdaki kod, 9'uncu (0 tabanlı) yinelemeyi, yani, meydan okumadaki onuncu görüntüyü üretir:

Diğer değerler 9için koddaki değişikliği değiştirin veya inumarayı kullanıcı girişi olarak almak için değiştirin . Örneğin, sonucu 13:

açıklama

Bu, aşamalı olarak bir dizi basamak ve ardından karmaşık düzlemdeki eğriyi oluşturmak için bir döngü kullanır . Örneğin, ilk iki adım 1j(yukarı) ve -1(sol) şeklindedir.

Her yinelemede, şu ana kadarki adımlar dizisi kopyalanır. Dizinin kopya olan ters , çarpılır ile 1j(döndürme 90 derece) ve birleştirilmiş orijinal.

Döngüden sonra, adımların kümülatif toplamı gerçek noktaları verir, bunlar daha sonra karmaşık düzlemde çizilir.

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 bayt

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

Nasıl çalışır: {1,-1}Çıktılar {1,-1}. Temel olarak "yığına iter". Bu değer ile hatırlanabilir %. r=ReverseTemelde sadece ters fonksiyonunu yeniden adlandırır çünkü kodda iki kez kullanıyorum. Graphics@Line@Sadece noktaların bir listesini alır ve bunları birleştiren bir çizgi çizer. Sorunun gerçek et bu kod kesimi olur: Nest[Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&,{{0,0},%},9]. Lemme size - bu segmentin karmaşık olduğunu söylüyor. İşte yapmanız gerekenler Nest: Nest[f,x,9]çağrının sonucunu verir f[f[f[f[f[f[f[f[f[x]]]]]]]]].

Benim kodunda, bu ilk argüman f: is Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&İkinci argüman, xbir {{0,0},%}(hiç değerlendirdiği {{0,0},{1,-1}}) ve üçüncü bağımsız değişken n(sadece ikinci argüman 9 kez ilk argüman geçerli olacaktır) sadece 9 olan.

Her şeyin en karmaşık kısmı bu ilk argüman: Join[l=Last@#;h=#-l&/@#,r[r@#%&/@h]]&neredeyse saf sözdizimsel şekerin dev bir karmaşası. Bunun için mathematica'nın sözdizimsel şekerini gerçekten kötüye kullanıyordum. Bu kod satırı, mathematica'nın anonim bir fonksiyonun versiyonunu temsil eder, şeyleri kısaltmak dışında, o anonim fonksiyon içinde aslında iki ayrı anonim fonksiyon tanımladım. Evet, bu yasal, millet. Hadi yıkalım.

Joiniki argüman alır. Birincisi l=Last@#;h=#-l&/@#, ikincisi r[r@#%&/@h].

Join'ın ilk argümanı: "ana" anonim işlev #içinde, eğrideki geçerli yinelemedeki tüm noktaların bir listesidir. Yani l=Last@#;"Girdi olarak aldığınız noktalar listesindeki noktayı alın ve bu noktayı değişkene atayın l. Bir sonraki segment, h=#-l&/@#biraz daha karmaşıktır." Bir fonksiyonunuz var. Bu işlev girdi olarak bir nokta alır, çıkarır lve sonucu döndürür. Şimdi, kaydırılan noktaların bir listesini oluşturmak için girdi olarak aldığınız nokta listesindeki her öğeye bu işlevi uygulayın ve bu yeni listeyi değişkene atayın h.

Join'ın ikinci argümanı: r[r@#%&/@h] kelimenin tam anlamıyla şimdiye kadar yazdığım en karmaşık sözdizimine sahip. Herhangi bir kod parçası gibi bir şey içerebilir inanamıyorum@#%&/@ - bir programın ortasında bir çizgi film karakteri gibi lanet gibi görünüyor! Ama yıkmak mümkün. Unutmayın - r[x]bir puan listesi alır ve bu listeyi ters sırada döndürür. r@#%&anonim bir işlevdir ve girdisini tersine çevirir, daha sonra onu içinde saklanan %(yani {1,-1}) değerle çarpar ve sonucu döndürür. Temelde girişi 90 derece döndürür, ancak yazabildiğim kadar kısa kodda. Sonra r@#%&/@h" h90 derece döndürülmüş her nokta olan yeni bir liste çıkar" anlamına gelir .

Genel Join[l=Last@#;h=#-l&/@#,r[r@#*%&/@h]]&olarak, girdi olarak bir nokta listesi alan ve eğrinin bir sonraki yinelemesini elde etmek için 90 derece döndürülmüş aynı nokta listesine ekleyen bir işlevdir. Bu, ejderha eğrisini elde etmek için 9 kez tekrarlanır. Sonra ortaya çıkan nokta listesi ekrana bir çizgi olarak çizilir. Ve çıktı:

Python 2, 43 bayt

Bu yanıt, ithalat ifadesini içermeyen 43 bayttır ve büyük ölçüde Level River St'nin Logo cevabına ve i/(i&-i)kodlarında kullanılmasına dayanmaktadır . Online trinket.io adresinde deneyin

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

İşte çıktının bir resmi.

Mathematica, 56 55 bayt

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

Açıklama: OEIS A034947

Sadece eğlence için, 19. iterasyonun renkli bir versiyonu.

Mathematica, 63 bayt

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

Haskell + diyagramları, 179 bayt

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)

Çıktı, şeffaf arka plana sahip 99 piksel genişliğinde bir svg dosyasıdır (9 piksel genişliğindeki bir görüntü, herhangi bir şeyi yeniden tanımlamak için çok kalın bir kontur olurdu). Burada yeniden düzenlenmiş ve beyaz bir arka plan üzerinde bestelenmiştir:

uydurma , 518 bayt

tosh olduğu Çizilmeye , ancak bloklar yerine metin içerir. 518 baytta, bu cevap muhtemelen Java'dan daha kötüdür.

Bu cevap @ Theo'nun Python cevabı ile aynı mantığı kullanır ile , ancak Scratch'ın (ve dolayısıyla tosh'un) liste yeteneklerinin korkunç olduğu gibi sayılar yerine "L" ve "R" dizeleriyle.

Burada bir Scratch projesi olarak çalıştırabilirsiniz . (tosh Scratch projelerini derler)

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  

Açıklama:

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

Bu ilk bölüm, yeşil bayrak tıklandığında programı çalıştırır (when flag clicked ) , path değişkenini "R" olarak ayarlar ve hareketli grafik ve sahneyi çizilmeye hazır duruma getirir.

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

Şimdi yol oluşturma koduna geçiyoruz. Aynı mantığı kullanırSayılar yerine "R" ve "L" dizeleri dışında @ Theo'nun Python cevabı ile liste kavrayışı yerine iç içe döngüler kullanırız.

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  

Son olarak, yolu, değişkenin her harfinden geçerek ve harfe bağlı olarak sola veya sağa döndürerek çiziyoruz.