Draw A Sierpinski Triangle

43

Segitiga Sierpinsky adalah fraktal yang dibuat dengan mengambil segitiga, mengurangi tinggi dan lebar sebesar 1/2, membuat 3 salinan dari segitiga yang dihasilkan, dan menempatkan mereka sedemikian rupa sehingga setiap segitiga menyentuh dua lainnya di sudut. Proses ini diulangi berulang kali dengan segitiga yang dihasilkan untuk menghasilkan segitiga Sierpinski, seperti diilustrasikan di bawah ini.

masukkan deskripsi gambar di sini

Tulis sebuah program untuk menghasilkan segitiga Sierpinski. Anda bisa menggunakan metode apa pun yang ingin Anda hasilkan polanya, baik dengan menggambar segitiga sebenarnya, atau dengan menggunakan algoritma acak untuk menghasilkan gambar. Anda dapat menggambar dalam pixel, ascii art, atau apa pun yang Anda inginkan, selama outputnya mirip dengan gambar terakhir yang ditunjukkan di atas. Karakter yang paling sedikit menang.

code-golf math kolmogorov-complexity fractal Kibbee
sumber
1
Lihat juga versi Stack Overflow lama: stackoverflow.com/questions/1726698/…
dmckee
3
Saya mendapatkan ide untuk ini setelah melihat pertanyaan segitiga pascal, dan mengingat contoh program untuk ini dalam manual TI-86 saya. Saya memutuskan untuk mengubahnya menjadi QBasic dan kemudian kode golf itu.
Kibbee
Tidak ada masalah dengan menjalankan tantangan di sini yang sudah berjalan di Stack Overflow, tetapi banyak orang tidak ingin menyajikan materi yang sama lagi. Jadi saya menautkannya untuk membangun pengunjung yang akan datang.
dmckee
Untuk menghindari duplikasi, mungkin Anda harus mengubah aturan untuk mengizinkan hanya implementasi grafis.
Primo
Banyak ide dari wolfram: wolframscience.com/nksonline/page-931
luser droog

Jawaban:

41

HTML + JavaScript, 150 karakter (lihat catatan untuk 126 karakter)

Spasi dimasukkan untuk dibaca dan tidak dihitung.

<title></title><canvas></canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

Inti dari itu adalah menerapkan aturan pewarnaan piksel yang x & y == 0oleh persyaratan x&y||, yang menghasilkan "segitiga kanan Sierpinski"; dan x-~y/2,k-ymerupakan transformasi koordinat untuk menghasilkan tampilan yang kira-kira sama sisi.

masukkan deskripsi gambar di sini

Versi yang kurang benar (dalam HTML) adalah 126 karakter:

<canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
  x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>

(Cara yang kurang tepat adalah menghilangkan titleelemen dan tag akhir canvaselemen, keduanya diperlukan untuk dokumen yang benar meskipun menghilangkannya tidak mengubah interpretasi dokumen.)

Tiga karakter dapat diselamatkan dengan menghilangkan kdemi konstanta 64, dengan biaya hasil yang lebih kecil; Saya tidak akan menghitung 8pilihan karena detailnya tidak mencukupi.

Perhatikan bahwa ukuran 256 atau lebih tinggi memerlukan atribut pada <canvas>untuk meningkatkan ukuran kanvas dari default.

Kevin Reid
sumber
22
Tidak ada yang peduli jika HTML Anda divalidasi di codegolf :-) Beberapa peningkatan: <canvas id=c>lalu c.getContext. Perpendek loop:for(x=k=128;x--;)for(y=k;y--;)
salin
4
id yang diubah menjadi variabel global adalah kesalahan yang mengerikan yang saya tolak untuk mengakui, dan WebKit tidak mengimplementasikannya dalam mode standar. Terima kasih atas trik putarannya.
Kevin Reid
1
Perbaikan kecil: x&y?0:bisa diganti dengan x&y||solusi sebaliknya.
Primo
5
Bravo, ini luar biasa.
Stanby
2
Karena ini berisi skrip, saya sarankan titling sebagai HTML + Javascript . Itu akan membuatnya lebih jelas bagi seseorang yang membaca jawaban seperti apa itu.
30

GolfScript ( 43 42 karakter)

' /\ /__\ '4/){.+\.{[2$.]*}%\{.+}%+\}3*;n*

Keluaran:

               /\               
              /__\              
             /\  /\             
            /__\/__\            
           /\      /\           
          /__\    /__\          
         /\  /\  /\  /\         
        /__\/__\/__\/__\        
       /\              /\       
      /__\            /__\      
     /\  /\          /\  /\     
    /__\/__\        /__\/__\    
   /\      /\      /\      /\   
  /__\    /__\    /__\    /__\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/__\/__\/__\/__\/__\/__\/__\/__\

Ubah "3" ke angka yang lebih besar untuk segitiga yang lebih besar.

Peter Taylor
sumber
27

Python (234)

Golf maksimal, gambar kecil:

#!/usr/bin/env python3
from cairo import*
s=SVGSurface('_',97,84)
g=Context(s)
g.scale(97,84)
def f(w,x,y):
 v=w/2
 if w>.1:f(v,x,y);f(v,x+w/4,y-v);f(v,x+v,y)
 else:g.move_to(x,y);g.line_to(x+v,y-w);g.line_to(x+w,y);g.fill()
f(1,0,1)
s.write_to_png('s.png')

Membutuhkan python3-cairo.

Untuk mendapatkan gambar besar yang bagus, saya membutuhkan 239 karakter.

Segitiga Sierpinski

Oleh Prypin
sumber
1
import cairo as cyang dapat menyelamatkan Anda beberapa karakter
quasimodo
1
jawaban ini perlu lebih banyak upvotes
ixtmixilix
26

Mathematica - 32 karakter 

Nest[Subsuperscript[#,#,#]&,0,5]

masukkan deskripsi gambar di sini

Mathematica - 37 karakter 

Grid@CellularAutomaton[90,{{1},0},31]

Ini akan menghasilkan tabel 2D 0 dan 1, di mana 1s menggambar Sierpinski Triangle.

masukkan deskripsi gambar di sini

Vitaliy Kaurov
sumber
2
Dengan biaya 5 karakter tambahan, solusi kedua Anda akan ditampilkan lebih baik dengan ArrayPlot@CellularAutomaton[90, {{1}, 0}, 31]atau MatrixPlot@CellularAutomaton[90, {{1}, 0}, 31].
DavidC
1
... atau dengan ReliefPlot@...
DavidC
Saya mendapatkan ini . Bagaimana Anda mendapatkan output tanpa semua tanda kurung?
Mr.Wizard
@ Mr.Wizard hmm ... dari mana tanda kurung itu berasal? Ia bahkan berfungsi di sini: mathics.net Cobalah dan beri tahu saya.
Vitaliy Kaurov
1
@Vitaliy Kaurov Solusi utama (32 karakter) sangat mencengangkan. Bisakah Anda melakukan tantangan "pohon fraktal" (di tempat lain di PCG) menggunakan teknik yang sama?
Michael Stern
22

Python, 101 86

Menggunakan aturan 90 otomat.

x=' '*31
x+='.'+x
exec"print x;x=''.join(' .'[x[i-1]!=x[i-62]]for i in range(63));"*32

Ini lebih lama, tetapi lebih cantik.

x=' '*31
x+=u'Δ'+x
exec u"print x;x=''.join(u' Δ'[x[i-1]!=x[i-62]]for i in range(63));"*32

Sunting: bermain dengan string secara langsung, menyingkirkan irisan yang terlalu lama, membuat output lebih cantik.

Keluaran:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
stan
sumber
Itu terlihat sangat keren: D
beary605
Menggunakan modal U + 0394 Delta itu adalah sentuhan yang sangat bagus.
David Conrad
16

J

,/.(,~,.~)^:6,'o'

Tidak ideal, karena segitiga miring dan diikuti oleh banyak ruang putih - tapi tetap menarik saya pikir.

Keluaran:

o                                                               
oo                                                              
o o                                                             
oooo                                                            
o   o                                                           
oo  oo                                                          
o o o o                                                         
oooooooo                                                        
o       o                                                       
oo      oo                                                      
o o     o o                                                     
oooo    oooo                                                    
o   o   o   o                                                   
oo  oo  oo  oo                                                  
o o o o o o o o                                                 
oooooooooooooooo                                                
o               o                                               
oo              oo                                              
o o             o o                                             
oooo            oooo                                            
o   o           o   o                                           
oo  oo          oo  oo                                          
o o o o         o o o o                                         
oooooooo        oooooooo                                        
o       o       o       o                                       
oo      oo      oo      oo                                      
o o     o o     o o     o o                                     
oooo    oooo    oooo    oooo                                    
o   o   o   o   o   o   o   o                                   
oo  oo  oo  oo  oo  oo  oo  oo                                  
o o o o o o o o o o o o o o o o                                 
oooooooooooooooooooooooooooooooo                                
o                               o                               
oo                              oo                              
o o                             o o                             
oooo                            oooo                            
o   o                           o   o                           
oo  oo                          oo  oo                          
o o o o                         o o o o                         
oooooooo                        oooooooo                        
o       o                       o       o                       
oo      oo                      oo      oo                      
o o     o o                     o o     o o                     
oooo    oooo                    oooo    oooo                    
o   o   o   o                   o   o   o   o                   
oo  oo  oo  oo                  oo  oo  oo  oo                  
o o o o o o o o                 o o o o o o o o                 
oooooooooooooooo                oooooooooooooooo                
o               o               o               o               
oo              oo              oo              oo              
o o             o o             o o             o o             
oooo            oooo            oooo            oooo            
o   o           o   o           o   o           o   o           
oo  oo          oo  oo          oo  oo          oo  oo          
o o o o         o o o o         o o o o         o o o o         
oooooooo        oooooooo        oooooooo        oooooooo        
o       o       o       o       o       o       o       o       
oo      oo      oo      oo      oo      oo      oo      oo      
o o     o o     o o     o o     o o     o o     o o     o o     
oooo    oooo    oooo    oooo    oooo    oooo    oooo    oooo    
o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   o   
oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  oo  
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o 
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

Penjelasan singkat:

Kata kerjanya (,~,.~)adalah apa yang melakukan pekerjaan di sini. Ini adalah pengait yang pertama kali menjahit ,.argumen ke dirinya sendiri ( o-> oo) dan kemudian menambahkan argumen asli ke output:

oo

menjadi

oo
o

Kata kerja ini diulang 6 kali ^:6dengan output dari setiap iterasi menjadi input dari iterasi berikutnya. Begitu

oo
o

menjadi

oooo
o o
oo
o

yang pada gilirannya menjadi

oooooooo
o o o o 
oo  oo
o   o
oooo
o o
oo
o

dll. Saya kemudian menggunakan kata keterangan miring pada append ,/.untuk membaca baris secara diagonal untuk meluruskan (ish) segitiga. Saya tidak perlu melakukan ini, seperti yang ditunjukkan oleh randomra . Saya bisa saja membalikkan |.lot untuk mendapatkan hasil yang sama. Bahkan lebih baik, saya bisa saja digunakan (,,.~)^:6,'o'untuk menyelamatkan langkah mundur sepenuhnya.

Ah, kamu hidup dan belajar. :-)

Gareth
sumber
1
Bisakah Anda menjelaskan secara singkat cara kerjanya? Saya tidak terbiasa dengan J
aditsu
1
|.(,~,.~)^:6,'o'lebih pendek dan tanpa spasi tambahan. Dan (,~,.~)^:6,1juga memberikan input yang layak hanya dalam 12 karakter!
randomra
@aditsu Saya sudah menambahkan penjelasan.
Gareth
Jadi jika saya mendapatkannya, operator itu menggabungkan dua array 2d?
MaiaVictor
13

APL (51)

      A←67⍴0⋄A[34]←1⋄' ○'[1+32 67⍴{~⊃⍵:⍵,∇(1⌽⍵)≠¯1⌽⍵⋄⍬}A]

Penjelasan:

  • A←67⍴0: A adalah vektor dari 67 nol
  • A[34]←1: elemen ke-34 adalah 1
  • {...}A: dimulai dengan A, lakukan:
  • ~⊃⍵:: jika elemen pertama dari baris saat ini adalah nol
  • ⍵,∇: tambahkan baris saat ini ke jawabannya, dan ulangi dengan:
  • (1⌽⍵)≠¯1⌽⍵: vektor di mana setiap elemen adalah XOR tetangganya pada generasi sebelumnya
  • ⋄⍬: kalau tidak, kita sudah selesai
  • 32 67⍴: format ini dalam matriks 67x32
  • 1+: tambahkan satu untuk memilih nilai yang tepat dari array karakter
  • ' ○'[... ]: menghasilkan spasi (bukan bagian dari segitiga) atau lingkaran (ketika itu adalah bagian dari segitiga)

Keluaran:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
marinus
sumber
1
Astaga. Saya berharap ini menjadi 4 karakter, menggunakan binomials mod 2 ... (ok ... mungkin sedikit lebih lama dari itu)
boothby
13

Haskell (291)

Saya tidak pandai golf kode haskell.

solve n = tri (putStrLn "") [2^n] n
tri m xs 1 =
  do putStrLn (l1 1 xs "/\\" 0)
     putStrLn (l1 1 xs "/__\\" 1)
     m
tri m xs n=tri m' xs (n-1)
  where m'=tri m (concat[[x-o,x+o]|x<-xs]) (n-1)
        o=2^(n-1)
l1 o [] s t=""
l1 o (x:xs) s t=replicate (x-o-t) ' '++s++l1 (x+2+t) xs s t

Output dari solve 4adalah:

               /\
              /__\
             /\  /\
            /__\/__\
           /\      /\
          /__\    /__\
         /\  /\  /\  /\
        /__\/__\/__\/__\
       /\              /\
      /__\            /__\
     /\  /\          /\  /\
    /__\/__\        /__\/__\
   /\      /\      /\      /\
  /__\    /__\    /__\    /__\
 /\  /\  /\  /\  /\  /\  /\  /\
/__\/__\/__\/__\/__\/__\/__\/__\
Saeedn
sumber
13

QBasic 151 Karakter

Sebagai contoh, berikut ini cara melakukannya dalam QBasic. 

SCREEN 9
H=.5
P=300
FOR I=1 TO 9^6
    N=RND
    IF N > 2/3 THEN
        X=H+X*H:Y=Y*H
    ELSEIF N > 1/3 THEN
        X=H^2+X*H:Y=H+Y*H    
    ELSE
        X=X*H:Y=Y*H
    END IF
    PSET(P-X*P,P-Y*P)
NEXT

masukkan deskripsi gambar di sini

Kibbee
sumber
Bisakah Anda menggambarkan ukuran di mana program ini 129 karakter? Saya mendapatkan 151 jika saya menghapus semua spasi putih yang mungkin tidak perlu. (Saya tidak terbiasa dengan QBasic.)
Kevin Reid
Saya menghapus semua spasi putih untuk hitungan saya. Saya kira saya hanya bisa menghitung spasi putih yang tidak penting. Saya tidak yakin apa aturan "resmi" untuk kode golf.
Kibbee
4
Anda harus menghitung jumlah karakter aktual, termasuk spasi, dalam program yang berjalan dan menghasilkan output yang benar . Tentu Anda ingin tidak memiliki spasi putih yang tidak perlu.
Kevin Reid
1
Memperbaiki jumlah karakter saya.
Kibbee
13

Python (42)

Saya awalnya ingin mengirim beberapa saran tentang solusi boothbys (yang sebenarnya menggunakan aturan 18 :), tetapi saya tidak memiliki reputasi yang cukup untuk berkomentar, jadi saya membuatnya menjadi jawaban lain. Karena dia mengubah pendekatannya, saya menambahkan beberapa penjelasan. Saran saya adalah:

  1. gunakan '% d' * 64% tuple (x) alih-alih '' .join (peta (str, x)
  2. bergeser dalam nol bukannya membungkus daftar di sekitar

yang akan mengarah pada kode berikut (93 karakter):

x=[0]*63
x[31]=1
exec"print'%d'*63%tuple(x);x=[a^b for a,b in zip(x[1:]+[0],[0]+x[:-1])];"*32

Tapi saya optimis lebih lanjut, pertama dengan menggunakan longint bukan array integer dan hanya mencetak representasi biner (75 karakter):

x=2**31
exec"print'%d'*63%tuple(1&x>>i for i in range(63));x=x<<1^x>>1;"*32

Dan akhirnya dengan mencetak representasi oktal, yang sudah didukung oleh printf interpolasi (42 karakter):

x=8**31
exec"print'%063o'%x;x=x*8^x/8;"*32

Semuanya akan dicetak:

000000000000000000000000000000010000000000000000000000000000000
000000000000000000000000000000101000000000000000000000000000000
000000000000000000000000000001000100000000000000000000000000000
000000000000000000000000000010101010000000000000000000000000000
000000000000000000000000000100000001000000000000000000000000000
000000000000000000000000001010000010100000000000000000000000000
000000000000000000000000010001000100010000000000000000000000000
000000000000000000000000101010101010101000000000000000000000000
000000000000000000000001000000000000000100000000000000000000000
000000000000000000000010100000000000001010000000000000000000000
000000000000000000000100010000000000010001000000000000000000000
000000000000000000001010101000000000101010100000000000000000000
000000000000000000010000000100000001000000010000000000000000000
000000000000000000101000001010000010100000101000000000000000000
000000000000000001000100010001000100010001000100000000000000000
000000000000000010101010101010101010101010101010000000000000000
000000000000000100000000000000000000000000000001000000000000000
000000000000001010000000000000000000000000000010100000000000000
000000000000010001000000000000000000000000000100010000000000000
000000000000101010100000000000000000000000001010101000000000000
000000000001000000010000000000000000000000010000000100000000000
000000000010100000101000000000000000000000101000001010000000000
000000000100010001000100000000000000000001000100010001000000000
000000001010101010101010000000000000000010101010101010100000000
000000010000000000000001000000000000000100000000000000010000000
000000101000000000000010100000000000001010000000000000101000000
000001000100000000000100010000000000010001000000000001000100000
000010101010000000001010101000000000101010100000000010101010000
000100000001000000010000000100000001000000010000000100000001000
001010000010100000101000001010000010100000101000001010000010100
010001000100010001000100010001000100010001000100010001000100010
101010101010101010101010101010101010101010101010101010101010101

Tentu saja ada juga solusi grafis (131 karakter):

from PIL.Image import*
from struct import*
a=''
x=2**31
exec"a+=pack('>Q',x);x=x*2^x/2;"*32
fromstring('1',(64,32),a).save('s.png')

segitiga sierpinsky sangat kecil : D

quasimodo
sumber
1
36:x=8**31;exec"print'%o'%x;x^=x/8;"*32
aditsu
13

8086 Kode mesin - 30 byte.

CATATAN: Ini bukan kode saya dan tidak boleh diterima sebagai jawaban . Saya menemukan ini ketika sedang mengerjakan masalah CG yang berbeda untuk meniru CPU 8086 . File teks yang disertakan memuji David Stafford , tapi itu yang terbaik yang bisa saya lakukan.

Saya memposting ini karena pintar, pendek, dan saya pikir Anda ingin melihatnya.

Itu menggunakan opcode yang tumpang tindih untuk mengemas lebih banyak instruksi dalam ruang yang lebih kecil. Luar biasa pintar. Ini kode mesinnya:

B0 13 CD 10 B3 03 BE A0 A0 8E DE B9 8B 0C 32 28 88 AC C2 FE 4E 75 F5 CD 16 87 C3 CD 10 C3

Dekode langsung terlihat seperti ini:

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11

Saat dijalankan, ketika lompatan pada 0x0115 terjadi, perhatikan lompatan kembali ke 0x010C, tepat di tengah instruksi sebelumnya:

0100: B0 13              mov AL, 13h
0102: CD 10              int 10h
0104: B3 03              mov BL, 3h
0106: BE A0 A0           mov SI, A0A0h
0109: 8E DE              mov  DS, SI
010B: B9 8B 0C           mov CX, C8Bh
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]
010E: 32 28              xor  CH, [BX+SI]
0110: 88 AC C2 FE        mov  [SI+FEC2h], CH
0114: 4E                 dec SI
0115: 75 F5              jne/jnz -11
010C: 8B 0C              mov  CX, [SI]

Cemerlang! Semoga kalian tidak keberatan saya berbagi ini. Saya tahu itu bukan jawaban semata, tetapi menarik untuk tantangan.

Ini dia sedang beraksi:

Lari

JoeFish
sumber
11

C 127 119 116 108 108 65

Yang ini menggunakan trik jawaban HTML ^ i & juntuk mencetaknya dengan output yang cantik akan membutuhkan 1 karakter lagi (Anda bisa mendapatkan hasil yang benar-benar jelek dengan mengorbankannya a^).

a=32,j;main(i){for(;++i<a;)putchar(a^i&j);++j<a&&main(puts(""));}

Untuk membuatnya berubah (32^i&j)menjadi (32|!(i&j))dan mengubahnya dari ++i<amenjadi ++i<=a. Namun membuang-buang karakter pada penampilan sepertinya tidak janggal bagiku.

Output jelek:

 ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
""  ""  ""  ""  ""  ""  ""  ""
"# !"# !"# !"# !"# !"# !"# !"#
  $$$$    $$$$    $$$$    $$$$
 !$%$% ! !$%$% ! !$%$% ! !$%$%
""$$&&  ""$$&&  ""$$&&  ""$$&&
"#$%&' !"#$%&' !"#$%&' !"#$%&'
      ((((((((        ((((((((
 ! ! !()()()() ! ! ! !()()()()
""  ""((**((**  ""  ""((**((**
"# !"#()*+()*+ !"# !"#()*+()*+
  $$$$((((,,,,    $$$$((((,,,,
 !$%$%()(),-,- ! !$%$%()(),-,-
""$$&&((**,,..  ""$$&&((**,,..
"#$%&'()*+,-./ !"#$%&'()*+,-./
              0000000000000000
 ! ! ! ! ! ! !0101010101010101
""  ""  ""  ""0022002200220022
"# !"# !"# !"#0123012301230123
  $$$$    $$$$0000444400004444
 !$%$% ! !$%$%0101454501014545
""$$&&  ""$$&&0022446600224466
"#$%&' !"#$%&'0123456701234567
      ((((((((0000000088888888
 ! ! !()()()()0101010189898989
""  ""((**((**0022002288::88::
"# !"#()*+()*+0123012389:;89:;
  $$$$((((,,,,000044448888<<<<
 !$%$%()(),-,-010145458989<=<=
""$$&&((**,,..0022446688::<<>>
"#$%&'()*+,-./0123456789:;<=>?

Saya sebenarnya suka bagaimana tampilannya. Tetapi jika Anda bersikeras itu cantik Anda dapat merapat empat karakter. Cukup Output:

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
  !!  !!  !!  !!  !!  !!  !!  !
  !   !   !   !   !   !   !   !
!!    !!!!    !!!!    !!!!    !
!     ! !     ! !     ! !     !
      !!      !!      !!      !
      !       !       !       !
!!!!!!        !!!!!!!!        !
! ! !         ! ! ! !         !
  !!          !!  !!          !
  !           !   !           !
!!            !!!!            !
!             ! !             !
              !!              !
              !               !
!!!!!!!!!!!!!!                !
! ! ! ! ! ! !                 !
  !!  !!  !!                  !
  !   !   !                   !
!!    !!!!                    !
!     ! !                     !
      !!                      !
      !                       !
!!!!!!                        !
! ! !                         !
  !!                          !
  !                           !
!!                            !
!                             !
                              !
                              !

Meninggalkan 108 char, versi automata seluler yang lebih tua.

j,d[99][99];main(i){d[0][31]=3;for(;i<64;)d[j+1][i]=putchar(32|d[j][i+2]^d[j][i++]);++j<32&&main(puts(""));}

Jadi saya tidak berpikir saya akan mendapatkannya lebih pendek dari ini jadi saya akan menjelaskan kodenya. Saya akan membiarkan penjelasan ini, karena beberapa trik bisa bermanfaat.

j,d[99][99]; // these init as 0
main(i){ //starts at 1 (argc)
  d[0][48]=3; //seed the automata (3 gives us # instead of !)
  for(;i<98;) // print a row
    d[j+1][i]=putchar(32|d[j][i+2]]^d[j][i++]);
    //relies on undefined behavoir. Works on ubuntu with gcc ix864
    //does the automata rule. 32 + (bitwise or can serve as + if you know
    //that (a|b)==(a^b)), putchar returns the char it prints
  ++j<32&&main(puts(""));
  // repeat 32 times
  // puts("") prints a newline and returns 1, which is nice
}

Beberapa output

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
walpen
sumber
1
Ini tampaknya bukan segitiga Sierpinski; itu terbagi menjadi tiga sub-segitiga (melanjutkan ke bawah) daripada dua, dan dapat dilihat bahwa ini tidak menghasilkan segitiga kosong pusat yang besar.
Kevin Reid
1
Itu karena saya menggunakan aturan yang salah: O. Memperbaiki, dan mencukur beberapa karakter.
walpen
9

80x86 Code / MsDos - 10 Bytes

Sebagai sizecoder yang dikhususkan untuk intro yang sangat kecil pada MsDos saya berhasil membuat program yang hanya menempati 10 byte.

dalam hex:

04 13 CD 10 20 E9 B4 0C E2 F6

masukkan deskripsi gambar di sini

dalam asm:

X: add al,0x13
int 0x10
and cl,ch
mov ah,0x0C
loop X

Versi pertama yang saya kodekan adalah "Colpinski" yang berukuran 16 byte, dan bahkan interaktif dengan cara Anda dapat mengubah warna dengan keyboard dan mouse. Bersama dengan "Frag" - sizecoder lain - kami membawa yang satu ke 13 byte, memungkinkan untuk program 10 byte yang hanya berisi inti rutin.

Ini menjadi sedikit lebih menarik ketika hal-hal dianimasikan, jadi saya akan menyebutkan versi lain, Zoompinski 64 - mencoba meniru perilaku tepat "Zoompinski C64" dalam 512 byte - juga untuk MsDos, dengan ukuran 64 byte seperti namanya.

Dimungkinkan untuk mengoptimalkan ini lebih jauh hingga 31 Bytes, sambil kehilangan keanggunan, warna dan simetri (sumber dan dapat dieksekusi tersedia di belakang tautan di atas)

Unduh yang asli dan komentari "Pouet"

HellMood
sumber
2
Anda harus memposting hex dump kode Anda, sehingga kami dapat melihat byte yang sebenarnya.
mbomb007
8

PostScript, 120 karakter

-7 -4 moveto
14 0 rlineto
7{true upath dup
2{120 rotate uappend}repeat[2 0 0 2 7 4]concat}repeat
matrix setmatrix
stroke

Output Ghostscript:

Output Ghostscript yang diberikan

Ini menggambar sosok dengan secara tiga kali lipat secara berulang apa yang sudah digambar.

Langkah pertama adalah menggambar garis. Garis disimpan sebagai jalur pengguna, lalu jalur pengguna ditambahkan dua kali lagi setelah berputar 120 derajat setiap kali. [2 0 0 2 7 4]concatmemindahkan "titik rotasi" ke pusat "pusat segitiga" putih besar berikutnya yang akan ditutup oleh replikasi dari segitiga yang sudah kita miliki. Di sini, kita kembali ke langkah 1 (membuat upath yang tiga kali lipat oleh rotasi).

Jumlah iterasi dikendalikan oleh angka pertama pada baris 3.

Thomas W.
sumber
+1 Sangat bagus. Saya tidak tahu kalau bisa digunakan seperti itu.
luser droog
Hei, Anda punya perwakilan untuk menambahkan gambar itu sekarang!
luser droog
@luserdroog: Benar (bahkan sebagian berkat Anda)!
Thomas W.
7

J (9 karakter)

Mudah paling jelek, Anda benar-benar perlu menyipitkan mata untuk melihat output;)

2|!/~i.32

menghasilkan output

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

tentu saja Anda dapat menampilkannya secara grafis:

load 'viewmat'
viewmat 2|!/~i.32

Gambar

Mark Allen
sumber
bagaimana ... apa?
acolyte
4
Kode mengeksploitasi properti segitiga Pascal bahwa jika Anda mewarnai semua angka ganjil (genap) hitam (putih), Anda berakhir dengan segitiga Sierpinski. (lihat gambar ini ). i.32 menghasilkan daftar 0 1 2 ... 31. Kemudian! / ~ menghitung koefisien binomial dari setiap elemen dalam daftar terhadap dirinya sendiri, yaitu menghasilkan matriks 32 x 32 yang memiliki segitiga Pascal yang tertanam di dalamnya. Lalu 2 | hanya setiap elemen dalam matriks ini mod 2, menghasilkan segitiga Sierpinski.
Mark Allen
4

APL, 37 32 ( 28 23)

Segitiga tegak ( 37 32-char)

({((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 2⍴'/\'

Penjelasan

  • 1 2⍴'/\': Buat matriks karakter 1 × 2 /\
  • {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Sebuah fungsi yang melapisi argumen kanan di kedua sisi dengan kosong untuk membuat matriks ganda selebar, lalu laminasi argumen kanan itu sendiri berlipat ganda ke bagian bawah.
    Misalnya /\akan menjadi
 / \ 
/ \ / \
  • ⍣⎕: Mengulang fungsi (input pengguna) kali.

Contoh output

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Skewed Triangle ( 28 23-char)

({(⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 1⍴'○'

Penjelasan

  • 1 1⍴'○': Buat matriks karakter 1 × 1 ○
  • {(⍵,∊⍵)⍪⍵,⍵}: Sebuah fungsi yang melapisi argumen kanan di sebelah kanan dengan kosong untuk membuat matriks ganda selebar, lalu laminasi argumen kanan itu sendiri berlipat ganda ke bagian bawah.
    Misalnya ○akan menjadi
○ 
○○
  • ⍣⎕: Mengulang fungsi (input pengguna) kali.

Contoh output

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○
TwiNight
sumber
4

Python (75)

Saya terlambat dua tahun ke pesta, tetapi saya terkejut bahwa belum ada yang mengambil pendekatan ini

from pylab import*
x=[[1,1],[1,0]]
for i in'123':x=kron(x,x)
imsave('a',x)

level7

Menggunakan produk Kronecker untuk mengganti matriks dengan banyak salinannya sendiri.

Saya dapat menyimpan dua karakter dengan menggunakan x=kron(x,x);x=kron(x,x)baris tiga untuk mendapatkan gambar 16x16 piksel dengan tiga level yang terlihat atau menambahkan karakter lain ke iterator dan berakhir dengan 2 ^ 16 x 2 ^ 16 = 4,3 Gigapixel gambar dan 15 level segitiga.

DenDenDo
sumber
3

Logo, 75 karakter

59 karakter hanya untuk fungsi pertama, yang kedua memanggil yang pertama dengan ukuran dan kedalaman / jumlah iterasi. Jadi, Anda bisa memanggil fungsi pertama dari interpreter dengan perintah: e 99 5, atau ukuran apa pun yang Anda ingin hasilkan

to e :s :l
if :l>0[repeat 3[e :s/2 :l-1 fd :s rt 120]]
end
to f
e 99 5
end
hal9000w
sumber
+1 Saya sudah membaca tentang Logo. Juru bahasa apa yang Anda gunakan? ... Logo mungkin cocok untuk tantangan sistem-l saya .
luser droog
Jika Anda hanya menghapus to fdan endsekitar e 99 5, Anda memiliki program runnable lengkap dalam karakter yang lebih sedikit. Juga, di UCBLogo (meskipun bukan versi lain), Anda dapat kehilangan titik dua pada variabel untuk menyimpan lebih banyak karakter.
Mark Reed
3

matlab 56

v=[1;-1;j];plot(filter(1,[1,-.5],v(randi(3,1,1e4))),'.')

masukkan deskripsi gambar di sini

chyanog
sumber
3

J (18 karakter)

' *'{~(,,.~)^:9 ,1

Hasil

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************
Vivek Ramanujan
sumber
3

Python (90 karakter)

from turtle import*
def l():left(60)
def r():right(60)
def f():forward(1)
def L(n):
 if n:n-=1;R(n);l();L(n);l();R(n)
 else:f()
def R(n):
 if n:n-=1;L(n);r();R(n);r();L(n)
 else:f()
l();L(8)

Cobalah online

Gambar garis fraktal mengisi Segitiga Sierpinsky

AMK
sumber
Sebelum berjalan, saya sarankan memasukkan ht();speed(0);up();goto(20-window_width()/2, 20-window_height()/2);down()setelah impor. Ini akan menjalankannya lebih cepat dan memastikan bahwa keluarannya pas di kanvas.
mbomb007
3

Mathematica 67

ListPlot@NestList[(#+RandomChoice@{{0,0},{2,0},{1,2}})/2&,{0,0},8!]

masukkan deskripsi gambar di sini

Mathematica 92

Graphics@Polygon@Nest[Join@@(Mean/@#&/@#~Tuples~2~Partition~3&/@#)&,{{{0,0},{2,0},{1,1}}},3]

masukkan deskripsi gambar di sini

chyanog
sumber
3

Mathematica , 29 byte

Image@Array[BitAnd,{2,2}^9,0]

Image @ Array [BitAnd, {2,2} ^ 9,0]

Sierpinski tetrahedron dapat digambar dengan cara yang sama:

Image3D[1-Array[BitXor,{2,2,2}^7,0]]

Image3D [1-Array [BitXor, {2,2,2} ^ 7,0]]

alephalpha
sumber
3

J , 37 35 byte

-2 byte terima kasih kepada FrownyFrog

(,.~,~' '&,.^:#)@[&0' /\',:'/__\'"_

Cobalah online!

Ini adalah versi seni ascii Peter Taylor yang dikonversi menjadi J. Bisa menyimpan byte dengan versi yang kurang cantik, tetapi mengapa?

       /\       
      /__\      
     /\  /\     
    /__\/__\    
   /\      /\   
  /__\    /__\  
 /\  /\  /\  /\ 
/__\/__\/__\/__\
Jonah
sumber
@]^:[-> @[&0dan ' /\ '->' /\'
FrownyFrog
Apakah Anda tahu di mana &0trik didokumentasikan?
Jonah
1
Disebutkan di sini di bagian bawah halaman. Meskipun menghemat satu byte, Anda kehilangan kemampuan untuk memiliki jumlah pengulangan negatif.
FrownyFrog
Oh, Anda harus bisa menukar operan ke ,~sekitar.
FrownyFrog
3

Script Lua dalam Golly , 54 byte

g=golly()
g.setrule("W60")
g.setcell(0,0,1)
g.run(512)

Golly adalah simulator automata seluler dengan dukungan skrip Lua dan Python.

Script ini menetapkan aturan menjadi Wolfram Rule 60, menetapkan sel pada (0,0) menjadi 1, dan menjalankan 512 langkah.

masukkan deskripsi gambar di sini

alephalpha
sumber
2

Nota bene, 205 203

[48(0-1+0+1-0)49(11)43(+)45(-)/s{dup
0 eq{exch{[48{1 0 rlineto}49 1 index
43{240 rotate}45{120 rotate}>>exch
get exec}forall}{exch{load
exch 1 sub s}forall}ifelse 1 add}>>begin
9 9 moveto(0-1-1)9 s fill

Menulis ulang menggunakan string dan rekursi berakhir pada jumlah yang persis sama. Tetapi keterbatasan-kedalaman dari pendekatan makro diatasi.

Sunting: fill lebih pendek dari stroke.

Lekukan dan komentar.

%!
[   % begin dictionary
    48(0-1+0+1-0) % 0
    49(11)        % 1
    43(+)         % +
    45(-)         % -
    /s{ % string recursion-level
        dup 0 eq{ % level=0
            exch{  % iterate through string
                [
                    48{1 0 rlineto} % 0
                    49 1 index      % 1 
                    43{240 rotate}  % +
                    45{120 rotate}  % -
                >>exch get exec % interpret turtle command
            }forall
        }{ % level>0
            exch{  % iterate through string
                load exch  % lookup charcode
                1 sub s    % recurse with level-1
            }forall
        }ifelse
        1 add  % return recursion-level+1
    }
>>begin
9 9 moveto(0-1-1)9 s fill % execute and fill

Menambahkan 0 setlinewidthmemberi kesan yang lebih baik tentang seberapa dalam ini.

revisi gambar menggunakan <code> isi </code> (hampir sama)

luser droog
sumber
Yang ini favorit saya.
cjfaure
Ada cara untuk membuatnya lebih pendek dengan lib eksternal ini yang saya tulis setelah fakta dan tidak dapat digunakan. : P
luser droog
2

Asymptote, 152 byte

Saya akan menambahkan ini, sebagian besar karena saya telah melihat lebih atau tidak ada jawaban di asymptote di situs ini. Beberapa byte terbuang untuk format dan generalisasi yang bagus, tapi saya bisa hidup dengan itu. Mengubah A, B dan C akan mengubah di mana sudut-sudut segitiga yang mengandung berada, tetapi mungkin tidak dengan cara Anda berpikir. Tambah angka dalam ketidaksetaraan untuk menambah kedalaman.

pair A=(0,0),B=(1,0),C=(.5,1);void f(pair p,int d){if(++d<7){p*=2;f(p+A*2,d);f(p+B*2,d);f(p+C*2,d);}else{fill(shift(p/2)*(A--B--C--cycle));}}f((0,0),0);

atau ungolfed dan mudah dibaca

pair A=(0,0), B=(1,0), C=(.5,1);

void f(pair p, int d) {
    if (++d<7) {
        p *= 2;
        f(p+A*2,d);
        f(p+B*2,d);
        f(p+C*2,d);
    } else {
        fill(shift(p/2)*(A--B--C--cycle));
    }
}

f((0,0),0);

Jadi asymptote adalah bahasa grafis vektor yang rapi dengan sintaksis mirip C. Cukup berguna untuk diagram yang agak teknis. Output tentu saja dalam format vektor secara default (eps, pdf, svg) tetapi pada dasarnya dapat dikonversi menjadi semua yang didukung imagemagick. Keluaran:

Segitiga Sierpinski

algmyr
sumber
2

Haskell , 166 154 byte

(-12 byte terima kasih kepada Laikoni, (pemahaman zip dan daftar alih-alih zipWith dan lambda, cara yang lebih baik untuk menghasilkan baris pertama))

i#n|let k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]];x=1<$[2..2^n]=mapM(putStrLn.map("M "!!))$take(2^n)$1!(x++0:x)

Cobalah online!

Penjelasan:

Fungsi ini i#nmenggambar ASCII-Triangle dengan ketinggian 2^nsetelah ilangkah-langkah iterasi.

Pengkodean yang digunakan secara internal mengkodekan posisi kosong 1dan posisi penuh sebagai 0. Oleh karena itu, baris pertama dari segitiga dikodekan sebagai[1,1,1..0..1,1,1] dengan 2^n-1orang-orang di kedua sisi nol. Untuk membangun daftar ini, kita mulai dengan daftar x=1<$[2..2^n], yaitu daftar [2..2^n]dengan semua yang dipetakan 1. Kemudian, kami membangun daftar lengkap sebagaix++0:x

Operator k!p(penjelasan terperinci di bawah), diberi indeks garis kdan yang sesuai pmenghasilkan daftar garis tak terhingga yang mengikuti p. Kami memohonnya dengan 1dan garis awal yang dijelaskan di atas untuk mendapatkan seluruh segitiga, dan kemudian hanya mengambil 2^ngaris pertama . Kemudian, kami cukup mencetak setiap baris, mengganti1 dengan spasi dan 0dengan M(dengan mengakses daftar "M "di lokasi 0atau 1).

Operator k!pdidefinisikan sebagai berikut:

k!p=p:(k+1)![m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))|(l,m,r)<-zip3(1:p)p$tail p++[1]]

Pertama, kami menghasilkan tiga versi p: 1:pyang pdengan 1prepended, psendiri dan tail p++[1]yang semuanya kecuali elemen pertama p, dengan yang 1ditambahkan. Kami kemudian zip tiga daftar ini, memberi kami secara efektif semua elemen pdengan tetangga kiri dan kanan mereka, sebagai (l,m,r). Kami menggunakan pemahaman daftar untuk kemudian menghitung nilai yang sesuai di baris baru:

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))

Untuk memahami ungkapan ini, kita perlu menyadari ada dua kasus dasar untuk dipertimbangkan: Entah kita cukup memperluas baris sebelumnya, atau kita berada pada titik di mana titik kosong dalam segitiga dimulai. Dalam kasus pertama, kami memiliki tempat yang penuh jika ada tempat di lingkungan tersebut yang terisi. Ini dapat dihitung sebagaim*l*r ; jika salah satu dari ketiganya adalah nol, maka nilai yang baru adalah nol. Kasus lainnya agak rumit. Di sini, kita pada dasarnya membutuhkan deteksi tepi. Tabel berikut memberikan delapan lingkungan yang memungkinkan dengan nilai yang dihasilkan di baris baru:

000 001 010 011 100 101 110 111
 1   1   1   0   1   1   0   1

Rumus sederhana untuk menghasilkan tabel ini adalah 1-m*r*(1-l)-m*l*(1-r)yang disederhanakan m*(2*l*r-l-r)+1. Sekarang kita harus memilih di antara dua kasus ini, di mana kita menggunakan nomor baris k. Jika mod k (2^(n-i)) == 0, kita harus menggunakan case kedua, jika tidak, kita menggunakan case pertama. Karena 0^(mod k(2^n-i))itu istilahnya adalah 0jika kita harus menggunakan kasus pertama dan1 jika kita harus menggunakan case kedua. Hasilnya, kita bisa menggunakan

m*l*r+(m*(l*r-l-r)+1)*0^mod k(2^(n-i))

total - jika kita menggunakan kasus pertama, kita cukup mendapatkan m*l*r, sementara dalam kasus kedua, istilah tambahan ditambahkan, memberikan total keseluruhan m*(2*l*r-l-r)+1.

Sacchan
sumber
1
154 byte: Cobalah online! Omong-omong penjelasan yang bagus!
Laikoni
@Laikoni Ooh, beberapa peningkatan yang sangat bagus di sana!
Sacchan
1

C, 106 karakter

i,j;main(){for(;i<32;j>i/2?puts(""),j=!++i:0)
printf("%*s",j++?4:33-i+i%2*2,i/2&j^j?"":i%2?"/__\\":"/\\");}

(Ini masih menghibur saya bahwa itu puts("")adalah cara terpendek untuk menghasilkan baris baru dalam C.)

Perhatikan bahwa Anda dapat membuat gasket yang lebih besar (atau lebih kecil) dengan mengganti tes 32dalam forloop dengan kekuatan dua (yang lebih besar) yang lebih besar, asalkan Anda juga mengganti gasket 33di tengahnya printf()dengan kekuatan dua plus-plus- satu.

kotak roti
sumber