Sierpinsky Üçgeni , bir üçgen alarak, yüksekliği ve genişliği 1/2 oranında azaltarak, elde edilen üçgenin 3 kopyasını yaratarak ve bunları her üçgenin bir köşesine diğerine değecek şekilde yerleştirerek oluşturulmuş bir fraktaldır. Bu işlem, aşağıda gösterildiği gibi Sierpinski üçgeni üretmek için ortaya çıkan üçgenlerle tekrar tekrar tekrar edilir.

Bir Sierpinski üçgeni oluşturmak için bir program yazın. Deseni oluşturmak istediğiniz herhangi bir yöntemi, gerçek üçgenleri çizerek veya resmi oluşturmak için rastgele bir algoritma kullanarak kullanabilirsiniz. Çıktı yukarıda gösterilen son resme benzer gözüktüğü sürece, pikseller, astalik resimler veya ne istersen çizebilirsiniz. En az karakter kazanır.

HTML + JavaScript, 150 karakter (126 karakter için notlara bakınız)

Boşluk okunabilirlik için takılmış ve sayılmamıştır.

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

Bunun özü x & y == 0, koşullu x&y||olarak bir “Sierpinski dik üçgeni” üreten renklendirme kuralını uygulamaktır ; ve x-~y/2,k-yyaklaşık eşkenar ekranın üretilmesi için bir koordinat dönüşümüdür.

Daha az doğru (HTML-bilge) sürüm 126 karakterdir:

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

(Bunun daha az doğru olması, titleöğeyi ve öğenin bitiş etiketini atlamamasıdır canvas, her ikisi de doğru bir belge için gerekli olsa da, atlamak belgenin yorumunu değiştirmez .)

Daha küçük bir sonuç karşılığında k, sabit lehine kaldırılarak üç karakter kaydedilebilir 64; Bu 8seçeneği yetersiz ayrıntı olduğu için saymazdım.

256 veya daha yüksek bir boyutun <canvas>, tuval boyutunu varsayılan değerden artırmak için gerekli nitelikler gerektirdiğini unutmayın.

GolfScript ( 43 42 karakter)

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

Çıktı:

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

Daha büyük bir üçgen için "3" ü daha büyük bir sayı olarak değiştirin.

Python (234)

Maksimum golf, minik görüntü:

#!/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')

Gerektirir python3-cairo.

Güzel bir görüntü elde etmek için 239 karaktere ihtiyacım vardı .

Mathematica - 32 karakter

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

Mathematica - 37 karakter

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

Bu, 1'lerin Sierpinski Üçgeni çizdiği 2 ve 0'lık bir 2B tablo üretecektir.

Python, 101 86

90 otomat kuralını kullanır.

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

Bu daha uzun, ama daha güzel.

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

Düzenleme: doğrudan dizelerle oynamak, iğrenç derecede uzun dilimlemeden kurtulmak, daha güzel çıktı almak.

Çıktı:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ

J

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

İdeal değil, çünkü üçgen iç içe geçmiş ve çok fazla boşluk var - ama yine de ilginç sanıyordum.

Çıktı:

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

Hızlı bir açıklama:

Fiil (,~,.~)burada işi yapan şeydir. Bu bir var kanca ilk dikişler ,.(kendisine argüman o-> oo) ve daha sonra çıkışa orijinal argümanı ekler:

oo

olur

oo
o

Bu fiil 6 kez tekrarlanır ^:6ve her bir yinelemenin çıktısı bir sonraki yinelemenin girişi olur. Yani

oo
o

olur

oooo
o o
oo
o

sırayla

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

Daha sonra, üzerine eğri zarf eki ,/.olarak, üçgeni düzeltmek (ish) için satırları çapraz olarak okumak için kullandım. Randomra'nın işaret ettiği gibi, bunu yapmak zorunda değildim . |.Aynı sonucu elde etmek için çok şeyi tersine çevirebilirdim . Daha da iyisi, (,,.~)^:6,'o'tam tersi adımı tamamen kaydetmek için kullanabilirdim.

Ah iyi, sen yaşa ve öğren. :-)

APL (51)

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

Açıklama:

• A←67⍴0: A 67 sıfırdan oluşan bir vektör
• A[34]←1: 34. element 1
• {...}A: A ile başlayanlar:
• ~⊃⍵:: Geçerli satırın ilk elemanı sıfır ise
• ⍵,∇: mevcut satırı cevaba ekleyin ve aşağıdakilerle tekrarlayın:
• (1⌽⍵)≠¯1⌽⍵: her bir öğenin önceki nesilde komşularının XOR'u olduğu vektör
• ⋄⍬: aksi takdirde, bittik
• 32 67⍴: bunu 67x32 matriste biçimlendirin
• 1+: karakter dizisinden doğru değeri seçmek için bir tane ekleyin
• ' ○'[... ]: ya bir boşluk (üçgenin parçası değil) ya da bir çember (üçgenin parçası olduğunda) çıkar

Çıktı:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○  

Haskell (291)

Ben haskell kodlarını çalmada pek iyi değilim.

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

Çıktı solve 4:

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

QBasic 151 Karakterler

Örnek olarak, burada QBasic'te nasıl yapılabileceği açıklanmaktadır.

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

Python (42)

Orijinal olarak boothbys çözümü hakkında birkaç öneride bulunmak istedim (aslında 18 kuralını kullanan :), ancak yorum yapmak için yeterli itibarım yoktu, bu yüzden başka bir cevaba verdim. Yaklaşımını değiştirdiğinden beri, bazı açıklamalar ekledim. Önerilerim olurdu:

1. '' yerine '% d' *% 64 lü (x) kullanın .join (harita (str, x)
2. Listeyi çevrelemek yerine, sıfırlar arasında geçiş yapmak

Bu, aşağıdaki koda yol açacaktır (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

Ancak, önce bir tamsayı dizisi yerine bir longint kullanarak ve sadece ikili gösterimi (75 karakter) yazdırarak daha da iyimser oldum:

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

Ve son olarak printf enterpolasyonu tarafından desteklenen sekizli gösterimi yazdırarak (42 karakter):

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

Hepsi yazdıracak:

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

Elbette grafiksel bir çözüm de var (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')

: D

8086 Makine kodu - 30 bayt.

NOT: Bu benim kodum değil ve cevap olarak kabul edilmemelidir . Bunu , 8086 işlemciyi taklit etmek için farklı bir CG problemi üzerinde çalışırken buldum . İçerdiği metin dosyası David Stafford'u kredilendiriyor , ancak bulabildiğim en iyisi bu.

Bunu gönderiyorum çünkü zekice, kısa ve görmek isteyeceğini düşündüm.

Daha küçük bir alanda daha fazla talimatı paketlemek için çakışan kodlardan yararlanır. Şaşırtıcı derecede zekice. İşte makine kodu:

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

Düzgün kod çözme şöyle görünür:

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

Çalıştırdığınızda, 0x0115'teki atlama gerçekleştiğinde, önceki komutun tam ortasına, 0x010C'ye geri döndüğüne dikkat edin:

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]

Parlak! Umarım bunu paylaşmamın sakıncası yoktur. Biliyorum bu başlı başına bir cevap değil ama zorluğun ilgisini çekiyor.

İşte eylemde:

C 127 119 116 108 65

Bu bir ^ i & jgüzel çıktı yazdırmak için HTML cevabı hilesini kullanır 1 daha char alır (gerçekten feda ederek çirkin çıktı alabilirsiniz a^).

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

Oldukça dönüş yapmak için (32^i&j)için (32|!(i&j))ve onu açmak ++i<aiçin ++i<=a. Ancak görünüşe göre karakterleri boşa harcamak bana zararsız geliyor.

Çirkin çıktı:

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

Aslında görünüşünü seviyorum. Ancak güzel olmak için ısrar ederseniz, dört karakter yerleştirebilirsiniz. Oldukça Çıktı:

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

Eski 108 karakter, hücresel otomat versiyonu.

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(""));}

Bu yüzden bundan daha kısa süreceğimi sanmıyorum, bu yüzden kodu açıklayacağım. Püf noktalarının bazıları yararlı olabileceğinden, bu açıklamayı açıklayacağım.

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
}

Bazı çıktı

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

80x86 Kod / MsDos - 10 Bayt

MsDos'ta çok küçük tanıtımlar için uzmanlaşmış bir sizecoder olarak sadece 10 baytlık bir program buldum.

altıgen içinde:

04 13 CD 10 20 E9 B4 0C E2 F6

asm:

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

Kodladığım ilk sürüm 16 bayt boyutundaki "Colpinski" ve hatta rengi klavye ve fare ile değiştirebileceğiniz şekilde etkileşime giriyordu. "Frag" ile birlikte - başka bir boyut kodlayıcı - bunu sadece 13 byte'a getirdik, sadece çekirdek rutini içeren 10 baytlık bir programa izin verdik.

İşler canlandırıldığında biraz daha ilginç hale geliyor, bu yüzden başka bir sürümden bahsedeceğim, Zoompinski 64 - 560 baytta "Zoompinski C64" ün tam davranışını taklit etmeye çalışıyorum - ayrıca MsDos için, adından da anlaşılacağı gibi 64 bayt.

Eleganlığı, renkleri ve simetriyi kaybederken, bunu 31 Bayta kadar optimize etmek mümkündür (yukarıdaki bağlantının arkasındaki kaynak ve çalıştırılabilir kaynak)

Orijinali indirin ve "Pouet" hakkında yorum yapın

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

Ghostscript çıktısı:

Bu, zaten çizilenleri tekrar tekrar üçe katlayarak rakamı çiziyor.

İlk adım bir çizgi çizmektir. Satır bir kullanıcı yolu olarak kaydedilir, ardından kullanıcı yolu her seferinde 120 derece döndürüldükten sonra iki kez daha eklenir. [2 0 0 2 7 4]concat"dönme noktasını" zaten sahip olduğumuz üçgenin kopyaları ile çevrilecek olan bir sonraki büyük beyaz "merkez üçgenin" ortasına taşır. Burada, 1. adıma geri döndük (rotasyonla üçe katlanan bir upath oluşturma).

Yinelemelerin sayısı 3. satırdaki ilk sayı ile kontrol edilir.

J (9 karakter)

Kolayca en çirkin, çıktıyı görmek için gerçekten şaşıracaksınız;)

2|!/~i.32

çıktı üretir

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

Tabii ki grafik olarak görüntüleyebilirsiniz:

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

APL, 37 32 ( 28 23)

Dik üçgen ( 37 32 karakter)

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

açıklama

• 1 2⍴'/\': 1 × 2 karakterlik bir matris oluşturun /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Her iki tarafta da doğru argümanı boşluklarla dolduran bir fonksiyon, iki katına kadar geniş bir matris oluşturmak için, sonra sağ argümanın altını iki katına lamine eder.
  Örneğin /\olur

 / \ 
/ \ / \

• ⍣⎕: Fonksiyonu (kullanıcı girişi) defa tekrarlayın.

Örnek çıktı

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

Eğri Üçgen ( 28 23 karakter)

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

Açıklama

• 1 1⍴'○': 1 × 1 karakter matrisi oluştur ○
• {(⍵,∊⍵)⍪⍵,⍵}: Sağdaki argümanı sağda boşluklarla dolduran bir fonksiyon, daha geniş bir matris oluşturmak için boşlukları doldurun, ardından sağdaki argümanın altını iki katına lamine eder.
  Örneğin ○olur

○ 
○○

• ⍣⎕: Fonksiyonu (kullanıcı girişi) defa tekrarlayın.

Örnek çıktı

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○

Python (75)

Partiye iki yıl geç kaldım, fakat henüz kimsenin bu yaklaşıma ulaşmamasına şaşırdım.

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

Kronecker ürününü , matrisin kendisinin birden çok kopyasıyla değiştirmek için kullanır .

x=kron(x,x);x=kron(x,x)Üç görünür seviyeli bir 16x16 piksel görüntü elde etmek veya yineleyiciye başka bir karakter eklemek ve 2 ^ 16 x 2 ^ 16 = 4.3 Gigapixel görüntü ve 15 üçgen düzeyine sahip olmak için üç satırda iki karakter kaydedebilirim .

Logo, 75 karakter

Sadece ilk işlev için 59 karakter, ikincisi ise ilki boyut ve yineleme / derinlik sayısı ile çağırır. Böylece tercümandan ilk işlevi sadece şu komutla çağırabilirsiniz: e 99 5 veya ne boyutta bir sonuç almak isterseniz

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

matlab 56

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

J (18 karakter)

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

Sonuç

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************

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)

Çevrimiçi deneyin

Sierpinsky Üçgen doldurma fraktal çizgi çizin

Mathematica 67

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

Mathematica 92

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

Mathematica , 29 bayt

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

Sierpinski tetrahedron benzer şekilde çizilebilir:

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

J , ³⁷ 35 bayt

FrownyFrog sayesinde -2 bayt

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

Çevrimiçi deneyin!

Bu Peter Taylor’ın J’ye dönüştürülmüş ascii sanat versiyonu.

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

Lua komut dosyası Golly , 54 bayt

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

Golly, Lua ve Python komut dosyası desteğine sahip hücresel bir otomat simülatörüdür.

Bu senaryo kuralı Wolfram Kural 60'a ayarlar, hücreyi (0,0) 1'e ayarlar ve 512 adım çalıştırır.

Postscript, 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

Dizeleri kullanarak tekrar yazma ve özyineleme, tamamen aynı sayıda sona erer. Ancak makro yaklaşımın derinlik sınırlamaları aşılmıştır.

Düzenleme: fill den daha kısa stroke.

Girintili ve yorum yaptı.

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

Ekleme 0 setlinewidth, bunun ne kadar derin olduğu konusunda daha iyi bir izlenim veriyor.

APL (Dyalog Klasik) , 12 bayt

×.≥∘⍉⍨↑,⍳⎕⍴2

Çevrimiçi deneyin!

Asimptot, 152 bayt

Bunu ekleyeceğim, çoğunlukla bu sitedeki asimptote cevapları az ya da çok gördüm. Güzel biçimlendirme ve genellik için boşa harcanan bir kaç bayt, ancak bununla yaşayabilirim. A, B ve C'yi değiştirmek, üçgenin köşelerinin nerede olduğunu, ancak muhtemelen sizin düşündüğünüz gibi olmadığını değiştirecektir. Derinliği artırmak için eşitsizlikteki sayıyı arttırın.

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

veya sırsız ve okunabilir

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

Yani asimptot, C-benzeri sözdizimi olan temiz bir vektör grafik dilidir. Biraz teknik diyagramlar için oldukça yararlı. Çıktı elbette varsayılan olarak bir vektör formatındadır (eps, pdf, svg) ancak temelde imagemagick'in desteklediği her şeye dönüştürülebilir. Çıktı:

Haskell , 166 154 bayt

(Laikoni sayesinde -12 bayt, (zipWith ve lambda yerine zip ve list kavrama, ilk satırı oluşturmanın daha iyi bir yolu)

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)

Çevrimiçi deneyin!

Açıklama:

İşlev , yineleme adımlarından sonra i#nbir ASCII-Üçgen yükseklik çizer .2^ni

Kullanılan kodlama dahili olarak boş pozisyonları 1ve olduğu gibi tam konumları kodlar 0. Bu nedenle, üçgen ilk satırı olarak kodlanır [1,1,1..0..1,1,1]ile 2^n-1sıfır her iki tarafta olanlar. Bu listeyi oluşturmak için listeyle başlıyoruz x=1<$[2..2^n], yani [2..2^n]her şeyin eşlendiği liste 1. Ardından, tam listeyi şu şekilde oluştururuz:x++0:x

Operatör k!p(aşağıdaki ayrıntılı açıklama), bir satır indeksi kve karşılık gelen verilen pbir sınırsız satır listesi oluşturur p. 1Tüm üçgeni elde etmek için onu ve yukarıda açıklanan başlangıç ​​çizgisini çağırırız ve sonra sadece ilk 2^nsatırları alırız. Sonra biz sadece yerini alacak şekilde her satırı yazdırmak 1boşluk ve 0ile M(listeyi erişerek "M "yerde 0ya 1).

Operatör k!paşağıdaki gibi tanımlanır:

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

Öncelikle, üç sürümünü oluşturabilir p: 1:polan pbir ile 1, önüne pkendisini ve tail p++[1]her şey ama ilk öğesi hangi pbir ile, 1eklenen. Daha sonra bu üç listeyi sıkıştırıp psol ve sağ komşularıyla birlikte tüm öğelerini etkin bir şekilde bize veriyoruz (l,m,r). Yeni satırdaki karşılık gelen değeri hesaplamak için bir liste kavrama kullanırız:

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

Bu ifadeyi anlamak için, dikkate alınması gereken iki temel durum olduğunu fark etmemiz gerekir: Ya bir önceki satırı genişletiriz ya da üçgende boş bir noktanın başladığı bir noktadayız. İlk durumda, mahalledeki herhangi bir nokta doluysa dolu bir noktamız var. Bu m*l*r; bu üç değerden herhangi biri sıfırsa, yeni değer sıfırdır. Diğer dava biraz daha zor. Burada temel olarak kenar algılamaya ihtiyacımız var. Aşağıdaki tablo, yeni satırdaki sonuç değeriyle sekiz olası mahalleyi göstermektedir:

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

Bu tabloyu elde etmek için basit bir formül 1-m*r*(1-l)-m*l*(1-r)basitleştirici olacaktır m*(2*l*r-l-r)+1. Şimdi bu iki durum arasından seçim yapmamız gerekiyor, bu da satır numarasını kullandığımız yer k. Eğer mod k (2^(n-i)) == 0biz ikinci durumda kullanmak zorunda, aksi takdirde biz ilk harf kullanın. Terim 0^(mod k(2^n-i))nedenle 0biz ilk dava kullanmak zorunda olmadığını ve 1ikinci durumda kullanmak varsa. Sonuç olarak kullanabiliriz.

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

toplamda - eğer ilk vakayı m*l*rkullanırsak, ikinci durumda, toplamı veren ek bir terim eklenir m*(2*l*r-l-r)+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?"/__\\":"/\\");}

(Hala puts("")C ile yeni bir satır çıktısı almanın en kısa yolu beni eğlendiriyor )

Eğer değiştirerek daha büyük (veya daha küçük) contaların oluşturabilirsiniz Not 32içinde forde yerini sürece, bu ikisinin bir büyük (küçük) gücü ile döngünün testinde 33ortasında printf()güç-iki-artı-ile bir.