Narysuj trójkąt Sierpińskiego

43

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.

wprowadź opis zdjęcia tutaj

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.

Kibbee
źródło
1
Zobacz także starą wersję Przepełnienie stosu: stackoverflow.com/questions/1726698/…
dmckee,
3
Pomysł na to wpadłem, gdy zobaczyłem pytanie o trójkąt pascala i przypomniałem sobie przykładowy program w mojej instrukcji TI-86. Postanowiłem przekonwertować go na QBasic, a następnie kodować golfa.
Kibbee
Nie ma problemu z uruchomieniem tutaj wyzwania, które zostało już uruchomione na przepełnieniu stosu, ale wiele osób nie będzie chciało ponownie prezentować tego samego materiału. Łączę je więc dla budowania późniejszych odwiedzających.
dmckee
Aby uniknąć powielania, być może powinieneś zmienić reguły, aby umożliwić tylko implementacje graficzne.
primo
Wiele pomysłów od wolfram: wolframscience.com/nksonline/page-931
luser droog

Odpowiedzi:

41

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.

wprowadź opis zdjęcia tutaj

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.

Kevin Reid
źródło
22
Nikogo nie obchodzi, czy Twój kod HTML sprawdza się w codegolf :-) Kilka ulepszeń: <canvas id=c>a potem c.getContext. Skróć pętle:for(x=k=128;x--;)for(y=k;y--;)
skopiuj
4
przekształcanie identyfikatorów w zmienne globalne jest strasznym błędem, którego odmawiam uznania, a WebKit nie implementuje go w trybie standardowym. Dziękuję za sztuczkę w pętli.
Kevin Reid,
1
Niewielka poprawa: x&y?0:można ją zastąpić x&y||innym fajnym rozwiązaniem.
primo
5
Brawo, to jest po prostu cudowne.
stoisko
2
Ponieważ zawiera on skrypt, zaleciłbym nadanie mu tytułu HTML + JavaScript . Ułatwi to komuś przeglądanie, jaka to odpowiedź.
30

GolfScript ( 43 42 znaków)

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

Wynik:

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

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

Peter Taylor
źródło
27

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.

Trójkąt Sierpińskiego

Oleh Prypin
źródło
1
import cairo as cmoże uratować ci kilka znaków
quasimodo
1
ta odpowiedź wymaga więcej głosów pozytywnych
ixtmixilix
26

Mathematica - 32 znaki

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

wprowadź opis zdjęcia tutaj

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.

wprowadź opis zdjęcia tutaj

Witalij Kaurow
źródło
2
Kosztem 5 dodatkowych znaków twoje drugie rozwiązanie będzie wyświetlać się lepiej z ArrayPlot@CellularAutomaton[90, {{1}, 0}, 31]lub MatrixPlot@CellularAutomaton[90, {{1}, 0}, 31].
DavidC
1
... lub z ReliefPlot@...
DavidC
Mam to . Jak uzyskałeś wynik bez wszystkich nawiasów?
Mr.Wizard
@ Mr.Wizard hmm ... skąd na świecie są nawiasy? Działa nawet tutaj: mathics.net Spróbuj i daj mi znać.
Witalij Kaurow
1
@Vitaliy Kaurov Podstawowe rozwiązanie (32 znaki) jest zadziwiające. Czy możesz wykonać wyzwanie „drzewa fraktali” (gdzie indziej na PCG) przy użyciu tej samej techniki?
Michael Stern
22

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:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
boothby
źródło
To wygląda naprawdę fajnie: D
beary605
Korzystanie z tego kapitału U + 0394 Delta jest naprawdę miłym akcentem.
David Conrad
16

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ę. :-)

Gareth
źródło
1
Czy mógłbyś krótko wyjaśnić, jak to działa? Nie znam J
aditsu
1
|.(,~,.~)^:6,'o'jest krótszy i bez dodatkowych spacji. A (,~,.~)^:6,1także zapewnia przyzwoity wkład w zaledwie 12 znaków!
randomra
@aditsu Dodałem wyjaśnienie.
Gareth
Więc jeśli go zdobędę, operator połączy dwie tablice 2D?
MaiaVictor
13

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:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○  
marinus
źródło
1
Yikes. Spodziewałem się, że będą to 4 znaki, wykorzystujące dwumianowy mod 2 ... (ok ... może trochę dłużej)
boothby
13

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:

               /\
              /__\
             /\  /\
            /__\/__\
           /\      /\
          /__\    /__\
         /\  /\  /\  /\
        /__\/__\/__\/__\
       /\              /\
      /__\            /__\
     /\  /\          /\  /\
    /__\/__\        /__\/__\
   /\      /\      /\      /\
  /__\    /__\    /__\    /__\
 /\  /\  /\  /\  /\  /\  /\  /\
/__\/__\/__\/__\/__\/__\/__\/__\
saeedn
źródło
13

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

wprowadź opis zdjęcia tutaj

Kibbee
źródło
Czy mógłbyś opisać miarę, pod którą ten program ma 129 znaków? Dostaję 151, jeśli usunę wszystkie prawdopodobnie niepotrzebne białe znaki. (Nie znam QBasic.)
Kevin Reid,
Usunąłem wszystkie białe znaki dla mojego obliczenia. Chyba mógłbym policzyć tylko nieistotne białe znaki. Nie jestem pewien, jaka jest „oficjalna” zasada dla golfa kodowego.
Kibbee
4
Rzeczywistą liczbę znaków, w tym spacje, należy policzyć w programie, który uruchamia i generuje prawidłowe dane wyjściowe . Oczywiście nie będziesz potrzebować niepotrzebnych białych znaków.
Kevin Reid,
1
Poprawiłem liczbę moich postaci.
Kibbee
13

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

bardzo mały trójkąt sierpiński :RE

quasimodo
źródło
1
36:x=8**31;exec"print'%o'%x;x^=x/8;"*32
aditsu
13

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:

Bieganie

JoeFish
źródło
11

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

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
walpen
źródło
1
To nie wydaje się być trójkątem Sierpińskiego; dzieli się na trzy pod trójkąty (postępujące w dół), a nie na dwa, i można zauważyć, że nie tworzy to dużego centralnego pustego trójkąta.
Kevin Reid,
1
To dlatego, że zastosowałem niewłaściwą zasadę: O. Naprawiono i ogolono kilka znaków.
walpen
9

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

wprowadź opis zdjęcia tutaj

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”

HellMood
źródło
2
Powinieneś opublikować zrzut heksadecymalny kodu, abyśmy mogli zobaczyć rzeczywiste bajty.
mbomb007,
8

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:

Renderowane dane wyjściowe 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.

Thomas W.
źródło
+1 Bardzo miło. Nie miałem pojęcia, że ​​z góry można tak korzystać.
luser droog
Hej, masz przedstawiciela, który może teraz dodać ten obraz!
luser droog
@luserdroog: Zgadza się (nawet częściowo dzięki tobie)!
Thomas W.
7

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

Wizerunek

Mark Allen
źródło
jak ... co?
akolit
4
Kod wykorzystuje właściwość trójkąta Pascala, że ​​jeśli pokolorujesz wszystkie nieparzyste (parzyste) liczby na czarno (biały), powstanie trójkąt Sierpińskiego. (patrz ten obraz). i.32 generuje listę 0 1 2 ... 31. Następnie! / ~ oblicza dwumianowe współczynniki każdego elementu na liście względem siebie, tj. tworzy macierz 32 x 32 z osadzonym trójkątem Pascala. Następnie 2 | jest po prostu każdym elementem w tym macierzy mod 2, tworząc trójkąt Sierpińskiego.
Mark Allen
4

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

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○
TwiNight
źródło
4

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)

poziom 7

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.

DenDenDo
źródło
3

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
hal9000w
źródło
+1 Przeczytałem o logo. Jakiego tłumacza używasz? ... Logo może być naturalnym wyborem dla mojego wyzwanie l-system .
luser droog
Jeśli po prostu usuniesz to fi endwokół e 99 5, masz kompletny program, który można uruchomić w mniejszej liczbie znaków. Ponadto w UCBLogo (choć nie w innych wersjach) możesz stracić dwukropki na zmiennych, aby zapisać więcej znaków.
Mark Reed
3

Matlab 56

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

wprowadź opis zdjęcia tutaj

chyanog
źródło
3

J (18 znaków)

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

Wynik

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************
Vivek Ramanujan
źródło
3

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

AMK
źródło
Przed uruchomieniem zalecam wstawianie ht();speed(0);up();goto(20-window_width()/2, 20-window_height()/2);down()po imporcie. Spowoduje to uruchomienie go znacznie szybciej i upewni się, że dane wyjściowe mieszczą się na płótnie.
mbomb007,
3

Mathematica 67

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

wprowadź opis zdjęcia tutaj

Mathematica 92

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

wprowadź opis zdjęcia tutaj

chyanog
źródło
3

Mathematica , 29 bajtów

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

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

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

alephalpha
źródło
3

J , 37 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?

       /\       
      /__\      
     /\  /\     
    /__\/__\    
   /\      /\   
  /__\    /__\  
 /\  /\  /\  /\ 
/__\/__\/__\/__\
Jonasz
źródło
@]^:[-> @[&0i ' /\ '->' /\'
FrownyFrog
Czy wiesz, gdzie &0udokumentowano sztuczkę?
Jonasz
1
Wspomniany tutaj na dole strony. Podczas gdy oszczędza bajt, tracisz możliwość posiadania ujemnej liczby powtórzeń.
FrownyFrog
Och, powinieneś być w stanie zamienić operandy ,~dookoła.
FrownyFrog,
3

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.

wprowadź opis zdjęcia tutaj

alephalpha
źródło
2

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.

popraw obraz używając <code> fill </code> (prawie tak samo)

luser droog
źródło
Ten jest moim ulubionym.
cjfaure
Jest sposób, aby go skrócić dzięki tej zewnętrznej bibliotece , którą napisałem po fakcie i nie mogę jej używać. : P
luser droog
2

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:

Trójkąt Sierpińskiego

algmyr
źródło
2

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.

Sacchan
źródło
1
154 bajty: Wypróbuj online! Przy okazji fajne wyjaśnienie!
Laikoni
@Laikoni Ooh, kilka bardzo fajnych ulepszeń!
Sacchan
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.

chlebak
źródło