Trójkąt Sierpińskiego to fraktal utworzony przez wzięcie trójkąta, zmniejszenie wysokości i szerokości o 1/2, utworzenie 3 kopii wynikowego trójkąta i umieszczenie ich tak, aby każdy trójkąt dotykał dwóch pozostałych w rogu. Proces ten powtarza się w kółko z powstającymi trójkątami, tworząc trójkąt Sierpińskiego, jak pokazano poniżej.

Napisz program do wygenerowania trójkąta Sierpińskiego. Możesz użyć dowolnej metody, aby wygenerować wzór, albo poprzez narysowanie rzeczywistych trójkątów, albo za pomocą losowego algorytmu do wygenerowania obrazu. Możesz rysować w pikselach, grafice ascii lub cokolwiek zechcesz, pod warunkiem, że wydruk będzie wyglądał podobnie do ostatniego obrazu pokazanego powyżej. Wygrywa niewiele postaci.

HTML + JavaScript, 150 znaków (patrz uwagi na 126 znaków)

Wstawiono białe znaki w celu zapewnienia czytelności i nie jest liczone.

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

Jego rdzeniem jest stosowanie reguły kolorowania pikseli, dla których x & y == 0przez warunek x&y||, który tworzy „trójkąt prostokątny Sierpińskiego”; i x-~y/2,k-ysą transformacją współrzędnych, aby uzyskać w przybliżeniu równoboczny obraz.

Mniej poprawna (HTML) wersja ma 126 znaków:

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

(Sposób, w jaki jest to mniej poprawne, polega na tym, że pomija titleelement i znacznik końcowy canvaselementu, które są wymagane dla poprawnego dokumentu, nawet jeśli ich pominięcie nie zmienia interpretacji dokumentu.)

Trzy postacie można uratować, eliminując kna korzyść stałej 64, kosztem mniejszego wyniku; Nie liczyłbym tej 8opcji, ponieważ nie ma wystarczających szczegółów.

Zauważ, że rozmiar 256 lub większy wymaga atrybutów, <canvas>aby zwiększyć rozmiar płótna z domyślnego.

GolfScript ( 43 42 znaków)

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

Wynik:

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

Zmień „3” na większą liczbę, aby uzyskać większy trójkąt.

Python (234)

Maksymalny golf, malutki obraz:

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

Wymaga python3-cairo.

Aby uzyskać ładny duży obraz, potrzebowałem 239 znaków.

Mathematica - 32 znaki

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

Mathematica - 37 znaków

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

Spowoduje to utworzenie tabeli 2D 0 i 1, gdzie 1 s rysują Trójkąt Sierpińskiego.

Python, 101 86

Korzysta z automatu reguły 90.

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

To jest dłuższe, ale ładniejsze.

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

Edycja: bezpośrednia gra ze strunami, pozbycie się nieprzyjemnie długiego krojenia, sprawiając, że wyjście jest ładniejsze.

Wynik:

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

jot

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

Nie jest to idealne, ponieważ trójkąt jest przekrzywiony, a po nim mnóstwo białych znaków - ale mimo to ciekawe.

Wynik:

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

Szybkie wyjaśnienie:

Czasownik (,~,.~)tutaj wykonuje pracę. Jest to haczyk, który najpierw zszywa ,.argument do siebie ( o-> oo), a następnie dołącza oryginalny argument do wyniku:

oo

staje się

oo
o

Ten czasownik powtarza się 6 razy, ^:6a wynik każdej iteracji staje się wejściem następnej iteracji. Więc

oo
o

staje się

oooo
o o
oo
o

który z kolei staje się

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

itd. Następnie użyłem skośnego przysłówka na append, ,/.aby odczytać rzędy po przekątnej, aby wyprostować (ish) trójkąt. Jak podkreśla randomra , nie musiałem tego robić . Mógłbym właśnie odwrócić |.los, aby uzyskać ten sam wynik. Co więcej, mógłbym po prostu (,,.~)^:6,'o'całkowicie zapisać krok wstecz.

Ach, żyjesz i uczysz się. :-)

APL (51)

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

Wyjaśnienie:

• A←67⍴0: A jest wektorem 67 zer
• A[34]←1: 34. element to 1
• {...}A: zaczynając od A, wykonaj:
• ~⊃⍵:: jeśli pierwszy element bieżącego wiersza ma wartość zero
• ⍵,∇: dodaj bieżący wiersz do odpowiedzi i powtórz z:
• (1⌽⍵)≠¯1⌽⍵: wektor, w którym każdy element jest XOR jego sąsiadów w poprzedniej generacji
• ⋄⍬: w przeciwnym razie skończymy
• 32 67⍴: sformatuj to w macierzy 67x32
• 1+: dodaj jeden, aby wybrać odpowiednią wartość z tablicy znaków
• ' ○'[... ]: wyprowadza spację (nie jest częścią trójkąta) lub okrąg (gdy jest częścią trójkąta)

Wynik:

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

Haskell (291)

Nie jestem zbyt dobry w golfowym haskellu.

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

Dane wyjściowe solve 4to:

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

QBasic 151 znaków

Jako przykład, oto jak można to zrobić w 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

Python (42)

Początkowo chciałem opublikować kilka sugestii dotyczących rozwiązania boothbys (który faktycznie stosuje regułę 18 :), ale nie miałem wystarczającej reputacji, aby komentować, więc znalazłem inną odpowiedź. Ponieważ zmienił podejście, dodałem wyjaśnienia. Moje sugestie byłyby następujące:

1. użyj '% d' * 64% krotki (x) zamiast '' .join (map (str, x)
2. przesuwaj zera zamiast zawijać listę

co doprowadziłoby do następującego kodu (93 znaki):

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

Ale zoptymalizowałem dalej, najpierw używając longinta zamiast tablicy liczb całkowitych i po prostu drukując reprezentację binarną (75 znaków):

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

I na koniec, drukując reprezentację ósemkową, która jest już obsługiwana przez interpolację printf (42 znaki):

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

Wszystkie wydrukują:

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

Oczywiście istnieje również rozwiązanie graficzne (131 znaków):

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

:RE

8086 Kod maszynowy - 30 bajtów.

UWAGA: To nie jest mój kod i nie należy go akceptować jako odpowiedzi . Znalazłem to podczas pracy nad innym problemem CG w celu emulacji procesora 8086 . Dołączony plik tekstowy napisał David Stafford , ale to najlepsze, co mogłem wymyślić.

Publikuję to, ponieważ jest sprytne, krótkie i pomyślałem, że chciałbyś to zobaczyć.

Wykorzystuje nakładające się kody, aby spakować więcej instrukcji na mniejszej przestrzeni. Niezwykle sprytny. Oto kod maszynowy:

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

Prosty dekod wygląda następująco:

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

Po uruchomieniu, gdy nastąpi skok o wartości 0x0115, zauważ, że przeskakuje z powrotem do 0x010C, w sam środek poprzedniej instrukcji:

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]

Znakomity! Mam nadzieję, że nie macie nic przeciwko, żebym to udostępnił. Wiem, że nie jest to odpowiedź sama w sobie, ale interesuje ją wyzwanie.

Oto jest w akcji:

C 127 119 116 108 65

Ten wykorzystuje sztuczkę z odpowiedzi HTML ^ i & j, aby uzyskać ładny wydruk, zajęłoby 1 znak więcej (możesz uzyskać naprawdę brzydki wynik, poświęcając go a^).

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

Żeby było całkiem obrócić (32^i&j)się (32|!(i&j))i obrócić go od ++i<acelu ++i<=a. Jednak marnowanie znaków na wygląd wydaje mi się niemiłe.

Brzydka wydajność:

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

Właściwie to podoba mi się jak to wygląda. Ale jeśli nalegasz, aby była ładna, możesz zadokować cztery znaki. Ładna wydajność:

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

Pozostawiając starszą wersję 108 znaków, automatów komórkowych.

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

Więc nie sądzę, że skracam to znacznie, więc wyjaśnię kod. Wyjaśnię to wyjaśnienie, ponieważ niektóre sztuczki mogą być przydatne.

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
}

Niektóre dane wyjściowe

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

Kod 80x86 / MsDos - 10 bajtów

Jako sizecoder specjalizujący się w bardzo małych wejściach na MsDos udało mi się wymyślić program, który zajmuje tylko 10 bajtów.

w hex:

04 13 CD 10 20 E9 B4 0C E2 F6

w asm:

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

Pierwsza kodowana przeze mnie wersja to „Colpinski”, która ma rozmiar 16 bajtów, a nawet interaktywna w sposób umożliwiający zmianę koloru za pomocą klawiatury i myszy. Razem z „Frag” - innym sizecoderem - obniżyliśmy ten rozmiar do 13 bajtów, pozwalając na 10-bajtowy program, który zawiera tylko podstawową procedurę.

To staje się trochę bardziej interesujące, gdy rzeczy są animowane, więc wspomnę o innej wersji, Zoompinski 64 - próbując naśladować dokładne zachowanie „Zoompinski C64” w 512 bajtach - również dla MsDos, 64 bajty wielkości, jak sugeruje nazwa.

Możliwe jest zoptymalizowanie tego dalszego downto do 31 bajtów, jednocześnie tracąc elegancję, kolory i symetrię (źródło i plik wykonywalny dostępne za linkiem powyżej)

Pobierz oryginał i skomentuj „Pouet”

PostScript, 120 znaków

-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

Wyjście Ghostscript:

To rysuje rysunek poprzez rekurencyjne potrojenie tego, co już zostało narysowane.

Pierwszym krokiem jest narysowanie linii. Linia jest zapisywana jako ścieżka użytkownika, następnie ścieżka użytkownika jest dodawana jeszcze dwa razy po każdym obrocie o 120 stopni. [2 0 0 2 7 4]concatprzesuwa „punkt obrotu” na środek następnego dużego białego „trójkąta środkowego”, który ma być ujęty w replikacje trójkąta, który już mamy. Wracamy do kroku 1 (tworzenie wzniesienia potrojonego przez obrót).

Liczba iteracji jest kontrolowana przez pierwszą liczbę w wierszu 3.

J (9 znaków)

Łatwo najbrzydszy, naprawdę musisz zmrużyć oczy, aby zobaczyć wynik;)

2|!/~i.32

produkuje dane wyjściowe

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

oczywiście możesz to wyświetlić graficznie:

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

APL, 37 32 ( 28 23)

Trójkąt pionowy ( 37 32 znaków)

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

Wyjaśnienie

• 1 2⍴'/\': Utwórz macierz znaków 1 × 2 /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Funkcja wypełniająca spacje prawym argumentem po obu stronach spacjami, aby utworzyć matrycę podwójnie szeroką, a następnie laminuje sam argument podwojony na dole.
  Np. Stałby /\się

 / \ 
/ \ / \

• ⍣⎕: Ponów funkcję (wprowadzane przez użytkownika) razy.

Przykładowe dane wyjściowe

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

Skośny trójkąt ( 28 23 znaków)

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

Wyjaśnienie

• 1 1⍴'○': Utwórz macierz znaków 1 × 1 ○
• {(⍵,∊⍵)⍪⍵,⍵}: Funkcja wypełniająca spacje prawym argumentem spacjami, aby utworzyć matrycę podwójnie szeroką, a następnie laminuje sam argument podwojony na dole.
  Np. Stałby ○się

○ 
○○

• ⍣⎕: Ponów funkcję (wprowadzane przez użytkownika) razy.

Przykładowe dane wyjściowe

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

Python (75)

Jestem spóźniona na przyjęcie o dwa lata, ale jestem zaskoczona, że ​​nikt jeszcze nie przyjął takiego podejścia

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

Używa produktu Kronecker do zastąpienia macierzy wieloma jej kopiami.

Mógłbym zapisać dwa znaki, używając x=kron(x,x);x=kron(x,x)linii trzeciej, aby uzyskać obraz 16 x 16 pikseli z trzema widocznymi poziomami lub dodać kolejny znak do iteratora i uzyskać obraz 2 ^ 16 x 2 ^ 16 = 4,3 gigapiksela i 15 poziomów trójkąta.

Logo, 75 znaków

59 znaków dla pierwszej funkcji, druga wywołuje pierwszą z rozmiarem i głębokością / liczbą iteracji. Możesz więc po prostu wywołać pierwszą funkcję z interpretera za pomocą polecenia: e 99 5 lub dowolnego rozmiaru, który chcesz wyprowadzić

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 znaków)

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

Wynik

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

Python (90 znaków)

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)

Wypróbuj online

Narysuj linię fraktalną wypełniającą Trójkąt Sierpińskiego

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 bajtów

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

Czworościan Sierpińskiego można narysować w podobny sposób:

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

J , ³⁷ 35 bajtów

-2 bajty dzięki FrownyFrog

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

Wypróbuj online!

To jest ascii artystyczna wersja Petera Taylora przekonwertowana na J. Mógłby zapisać bajty z mniej ładną wersją, ale dlaczego?

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

Skrypt Lua w Golly , 54 bajty

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

Golly to symulator automatów komórkowych z obsługą skryptów Lua i Python.

Ten skrypt ustawia regułę na regułę 60 Wolfram, ustawia komórkę na (0,0) na 1 i wykonuje 512 kroków.

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

Przepisywanie przy użyciu łańcuchów i rekurencji kończy się dokładnie w tej samej liczbie. Jednak ograniczenia dotyczące makro-podejścia zostały przezwyciężone.

Edycja: fill jest krótsza niż stroke.

Wcięte i skomentowane.

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

Dodanie 0 setlinewidthdaje lepsze wyobrażenie o głębokości tego.

APL (Dyalog Classic) , 12 bajtów

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

Wypróbuj online!

Asymptote, 152 bajty

Dodam to, głównie dlatego, że nie widziałem mniej więcej odpowiedzi w asymptocie na tej stronie. Kilka zmarnowanych bajtów na ładne formatowanie i ogólność, ale mogę z tym żyć. Zmiana A, B i C zmieni się tam, gdzie są narożniki trójkąta zawierającego, ale prawdopodobnie nie w taki sposób, jak myślisz. Zwiększ liczbę w nierówności, aby zwiększyć głębokość.

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

lub bez golfa i czytelne

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

Tak więc asymptota jest zgrabnym językiem grafiki wektorowej z nieco podobną do C składnią. Całkiem przydatne w przypadku nieco technicznych diagramów. Dane wyjściowe mają oczywiście domyślnie format wektorowy (eps, pdf, svg), ale można je przekonwertować na właściwie wszystko, co obsługuje imagemagick. Wynik:

Haskell , 166 154 bajtów

(-12 bajtów dzięki Laikoni, (zapis zip i listy zamiast zipWith i lambda, lepszy sposób generowania pierwszego wiersza))

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)

Wypróbuj online!

Wyjaśnienie:

Funkcja i#nrysuje trójkąt ASCII wysokości 2^npo ikrokach iteracji.

Zastosowane kodowanie koduje wewnętrznie puste pozycje jako 1i pełne pozycje jako 0. W związku z tym, pierwsza linia trójkąta jest zakodowany jako [1,1,1..0..1,1,1]z 2^n-1tych po obu stronach zera. Aby zbudować tę listę, zaczynamy od listy x=1<$[2..2^n], tj. Listy [2..2^n]ze wszystkim, na co mapowane 1. Następnie tworzymy pełną listę jakox++0:x

Operator k!p(szczegółowe wyjaśnienie poniżej), podany indeks linii ki odpowiadająca mu pgeneruje nieskończoną listę kolejnych linii p. Wzywamy go za pomocą 1i linii początkowej opisanej powyżej, aby uzyskać cały trójkąt, a następnie wziąć tylko pierwsze 2^nlinie. Następnie po prostu drukujemy każdą linię, zastępując 1ją spacją i 0znakiem M(uzyskując dostęp do listy "M "w lokalizacji 0lub 1).

Operator k!pdefiniuje się w następujący sposób:

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

Po pierwsze, możemy wygenerować trzy wersje p: 1:pco jest pz 1poprzedzany, psam i tail p++[1]co jest wszystko, ale pierwszy element p, z 1dołączone. Następnie spakowujemy te trzy listy, dając nam skutecznie wszystkie elementy pz ich lewym i prawym sąsiadem, as (l,m,r). Używamy rozumienia listy, aby następnie obliczyć odpowiednią wartość w nowym wierszu:

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

Aby zrozumieć to wyrażenie, musimy zdać sobie sprawę z tego, że należy wziąć pod uwagę dwa podstawowe przypadki: albo po prostu rozszerzamy poprzednią linię, albo jesteśmy w punkcie, w którym zaczyna się puste miejsce w trójkącie. W pierwszym przypadku mamy wypełnione miejsce, jeśli któreś z miejsc w okolicy jest wypełnione. Można to obliczyć jako m*l*r; jeśli którykolwiek z tych trzech jest równy zero, to nowa wartość wynosi zero. Drugi przypadek jest nieco trudniejszy. W zasadzie potrzebujemy wykrywania krawędzi. Poniższa tabela podaje osiem możliwych sąsiedztw z wynikową wartością w nowym wierszu:

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

Prosta formuła umożliwiająca uzyskanie tej tabeli byłaby 1-m*r*(1-l)-m*l*(1-r)prostsza m*(2*l*r-l-r)+1. Teraz musimy wybrać między tymi dwoma przypadkami, w których używamy numeru linii k. Jeśli mod k (2^(n-i)) == 0musimy użyć drugiego przypadku, w przeciwnym razie użyjemy pierwszego przypadku. Terminem 0^(mod k(2^n-i))jest zatem, 0jeśli musimy użyć pierwszego przypadku i 1jeśli musimy użyć drugiego przypadku. W rezultacie możemy użyć

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

w sumie - jeśli użyjemy pierwszego przypadku, po prostu otrzymamy m*l*r, podczas gdy w drugim przypadku zostanie dodany dodatkowy termin, który daje sumę całkowitą m*(2*l*r-l-r)+1.

C, 106 znaków

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?"/__\\":"/\\");}

(Wciąż mnie to bawi, że puts("")jest to najkrótszy sposób na wygenerowanie nowego wiersza w C.)

Należy pamiętać, że można tworzyć większe (lub mniejsze) uszczelki zastępując 32w tego fortestu pętli jest z większej (mniejszej) moc dwóch, tak długo, jak również wymienić 33w środku malowniczego printf()z power-of-two-Plus- jeden.