Das Sierpinsky-Dreieck ist ein Fraktal, das durch Aufnehmen eines Dreiecks, Verringern der Höhe und Breite um die Hälfte, Erstellen von drei Kopien des resultierenden Dreiecks und Platzieren der beiden Dreiecke an einer Ecke erstellt wird. Dieser Vorgang wird mit den resultierenden Dreiecken immer wieder wiederholt, um das Sierpinski-Dreieck zu erzeugen, wie unten dargestellt.

Schreiben Sie ein Programm, um ein Sierpinski-Dreieck zu erzeugen. Sie können eine beliebige Methode zum Generieren des Musters verwenden, indem Sie entweder die tatsächlichen Dreiecke zeichnen oder das Bild mithilfe eines Zufallsalgorithmus generieren. Sie können in Pixeln, ASCII-Grafiken oder nach Belieben zeichnen, solange die Ausgabe dem zuletzt gezeigten Bild ähnelt. Die wenigsten Charaktere gewinnen.

HTML + JavaScript, 150 Zeichen (siehe Hinweise für 126 Zeichen)

Leerzeichen zur besseren Lesbarkeit eingefügt und nicht gezählt.

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

Der Kern davon ist das Anwenden der Regel zum Färben von Pixeln, für die x & y == 0durch die Bedingung x&y||ein "Sierpinski-rechtwinkliges Dreieck" erzeugt wird; und x-~y/2,k-ysind eine Koordinatentransformation, um die annähernd gleichseitige Anzeige zu erzeugen.

Eine weniger korrekte (HTML-weise) Version ist 126 Zeichen:

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

(Dies ist weniger richtig, weil das titleElement und das End-Tag des canvasElements weggelassen werden. Beide sind für ein korrektes Dokument erforderlich, obwohl das Weglassen die Interpretation des Dokuments nicht verändert .)

Durch Eliminieren kder Konstanten können drei Zeichen 64auf Kosten eines geringeren Ergebnisses gespeichert werden . Ich würde die 8Option nicht zählen, da sie nicht ausreichend detailliert ist.

Beachten Sie, dass für eine Größe von 256 oder höher Attribute für die erforderlich sind <canvas>, um die Leinwandgröße von der Standardgröße zu erhöhen.

GolfScript ( 43 42 Zeichen)

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

Ausgabe:

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

Ändern Sie die "3" in eine größere Zahl für ein größeres Dreieck.

Python (234)

Maximales Golfen, winziges Bild:

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

Benötigt python3-cairo.

Um ein schönes großes Bild zu bekommen, brauchte ich 239 Zeichen.

Mathematica - 32 Zeichen

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

Mathematica - 37 Zeichen

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

Dies erzeugt eine 2D-Tabelle von 0 und 1, wobei 1s das Sierpinski-Dreieck zeichnen.

Python, 101 86

Verwendet die Regel 90 Automat.

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

Das ist länger, aber schöner.

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

Edit: direkt mit Streichern spielen, störend lange Schnitte loswerden, Ausgabe schöner machen.

Ausgabe:

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

J

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

Nicht ideal, da das Dreieck schief ist und viele Leerzeichen folgen - aber trotzdem interessant, dachte ich.

Ausgabe:

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

Eine kurze Erklärung:

Das Verb (,~,.~)ist, was die Arbeit hier macht. Es ist ein Hook, der zuerst ,.das Argument an sich selbst näht ( o-> oo) und dann das ursprüngliche Argument an die Ausgabe anfügt:

oo

wird

oo
o

Dieses Verb wird sechsmal wiederholt, ^:6wobei die Ausgabe jeder Iteration zur Eingabe der nächsten Iteration wird. Damit

oo
o

wird

oooo
o o
oo
o

was wiederum wird

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

etc. Ich habe dann das schräge Adverb on append verwendet ,/., um die Zeilen diagonal zu lesen, um das Dreieck zu begradigen. Ich brauchte das nicht zu tun, wie Randomra betont . Ich hätte |.das Los einfach umkehren können , um das gleiche Ergebnis zu erzielen. Noch besser wäre es, wenn ich (,,.~)^:6,'o'den umgekehrten Schritt komplett hätte speichern können.

Na ja, du lebst und lernst. :-)

APL (51)

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

Erläuterung:

• A←67⍴0: A ist ein Vektor von 67 Nullen
• A[34]←1: das 34. Element ist 1
• {...}A: beginnend mit A, mache:
• ~⊃⍵:: wenn das erste Element der aktuellen Zeile Null ist
• ⍵,∇: füge die aktuelle Zeile zur Antwort hinzu und rekursiere mit:
• (1⌽⍵)≠¯1⌽⍵: der Vektor, in dem jedes Element das XOR seiner Nachbarn in der vorherigen Generation ist
• ⋄⍬: sonst sind wir fertig
• 32 67⍴: formatiere dies in einer 67x32 Matrix
• 1+: Fügen Sie einen hinzu, um den richtigen Wert aus dem Zeichenfeld auszuwählen
• ' ○'[... ]: gibt entweder ein Leerzeichen (nicht Teil des Dreiecks) oder einen Kreis (wenn es Teil des Dreiecks ist) aus

Ausgabe:

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

Haskell (291)

Ich bin nicht sehr gut darin, Haskell-Codes zu spielen.

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

Ausgabe von solve 4ist:

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

QBasic 151 Zeichen

Als Beispiel sehen Sie hier, wie dies in QBasic gemacht werden kann.

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)

Ursprünglich wollte ich ein paar Vorschläge zur Lösung von boothbys posten (wer verwendet eigentlich Regel 18 :), aber ich hatte nicht genug Ruf, um Kommentare abzugeben , also habe ich es zu einer anderen Antwort gemacht. Da er seinen Ansatz geändert hat, habe ich eine Erklärung hinzugefügt. Meine Vorschläge wären gewesen:

1. benutze '% d' * 64% tuple (x) anstelle von '' .join (map (str, x)
2. Verschieben Sie die Nullen, anstatt die Liste umzubrechen

was zu folgendem Code (93 Zeichen) geführt hätte:

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

Aber ich habe weiter optimiert, indem ich zuerst ein Longint anstelle eines Integer-Arrays verwendet und nur die binäre Darstellung (75 Zeichen) ausgedruckt habe:

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

Und schließlich durch Drucken der Oktaldarstellung, die bereits von der printf-Interpolation unterstützt wird (42 Zeichen):

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

Alle von ihnen werden drucken:

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

Natürlich gibt es auch eine grafische Lösung (131 Zeichen):

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 Maschinencode - 30 Bytes.

HINWEIS: Dies ist nicht mein Code und sollte nicht als Antwort akzeptiert werden . Ich habe dies festgestellt, als ich an einem anderen CG-Problem arbeitete , um eine 8086-CPU zu emulieren . Die beigefügte Textdatei schreibt David Stafford gut , aber das ist das Beste, was ich mir einfallen lassen konnte.

Ich poste das, weil es clever ist, kurz, und ich dachte, du würdest es sehen wollen.

Es werden überlappende Opcodes verwendet, um mehr Anweisungen auf kleinerem Raum zu packen. Erstaunlich schlau. Hier ist der Maschinencode:

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

Eine direkte Dekodierung sieht folgendermaßen aus:

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

Beachten Sie beim Ausführen, wenn der Sprung um 0x0115 erfolgt, dass der Sprung zurück zu 0x010C erfolgt, genau in der Mitte einer vorherigen Anweisung:

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]

Brillant! Ich hoffe, es macht euch nichts aus, wenn ich das teile. Ich weiß, dass es an sich keine Antwort ist, aber es ist für die Herausforderung von Interesse.

Hier ist es in Aktion:

C 127 119 116 108 65

Dieser verwendet den Trick der HTML-Antwort, ^ i & jdass es 1 Zeichen mehr kosten würde, um eine hübsche Ausgabe zu drucken (Sie können eine wirklich hässliche Ausgabe erhalten, indem Sie die opfern a^).

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

Um es zu drehen ziemlich (32^i&j)zu (32|!(i&j))und schalten Sie es aus ++i<azu ++i<=a. Allerdings scheint es mir ungolfisch, Zeichen für das Aussehen zu verschwenden.

Hässliche Ausgabe:

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

Eigentlich mag ich, wie es aussieht. Aber wenn Sie darauf bestehen, dass es hübsch ist, können Sie vier Zeichen andocken. Hübsche Ausgabe:

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

Die ältere Version mit 108 Zeichen für zellulare Automaten bleibt erhalten.

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

Also denke ich nicht, dass ich es viel kürzer machen werde, also erkläre ich den Code. Ich lasse diese Erklärung offen, da einige der Tricks nützlich sein könnten.

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
}

Einige Ausgabe

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

80x86 Code / MsDos - 10 Bytes

Als auf winzige Intros für MsDos spezialisierter Größenkodierer gelang es mir, ein Programm zu entwickeln, das nur 10 Bytes belegt.

in hex:

04 13 CD 10 20 E9 B4 0C E2 F6

in asm:

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

Die erste Version, die ich codiert habe, war "Colpinski", 16 Byte groß und sogar interaktiv, so dass Sie die Farbe mit der Tastatur und der Maus ändern können. Zusammen mit "Frag" - einem anderen Größenkodierer - haben wir diesen auf 13 Byte reduziert, was ein 10-Byte-Programm ermöglicht, das nur die Kernroutine enthält.

Es wird ein bisschen interessanter, wenn die Dinge animiert werden, also werde ich eine andere Version erwähnen, Zoompinski 64 - der versucht, das genaue Verhalten von "Zoompinski C64" in 512 Bytes nachzuahmen - auch für MsDos, 64 Bytes groß, wie der Name vermuten lässt.

Es ist möglich, diesen Rückgang auf 31 Byte zu optimieren und dabei Eleganz, Farben und Symmetrie zu verlieren (Quelle und ausführbare Datei unter dem obigen Link verfügbar).

Laden Sie das Original herunter und kommentieren Sie "Pouet"

PostScript, 120 Zeichen

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

Dies zeichnet die Figur, indem rekursiv verdreifacht wird, was bereits gezeichnet wurde.

Der erste Schritt ist das Zeichnen einer Linie. Die Linie wird als Benutzerpfad gespeichert, und der Benutzerpfad wird nach jeder Drehung um 120 Grad noch zweimal hinzugefügt. [2 0 0 2 7 4]concatVerschiebt den "Rotationspunkt" in die Mitte des nächsten großen weißen "Mittendreiecks", das von Replikationen des bereits vorhandenen Dreiecks eingeschlossen werden soll. Hier kehren wir zu Schritt 1 zurück (Erstellen eines Upaths, der durch Rotation verdreifacht wird).

Die Anzahl der Iterationen wird durch die erste Nummer in Zeile 3 gesteuert.

J (9 Zeichen)

Leicht das hässlichste, man muss wirklich schielen, um die Ausgabe zu sehen;)

2|!/~i.32

erzeugt die Ausgabe

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

Natürlich können Sie es grafisch darstellen:

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

APL, 37 32 ( 28 23)

Aufrechtes Dreieck ( 37, 32 Zeichen)

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

Erläuterung

• 1 2⍴'/\': Erstellen Sie eine 1 × 2-Zeichenmatrix /\
• {((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}: Eine Funktion, die das rechte Argument auf beiden Seiten mit Leerzeichen auffüllt, um eine Matrix zu erstellen, die doppelt so breit ist. Anschließend wird das rechte Argument selbst doppelt auf den unteren Rand laminiert. Würde
  zB /\werden

 / \ 
/ \ / \

• ⍣⎕: Wiederholen Sie die Funktion (Benutzereingabe) Zeiten.

Beispielausgabe

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

Verdrehtes Dreieck ( 28, 23 Zeichen)

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

Erklärung

• 1 1⍴'○': Erstellen Sie eine 1 × 1-Zeichenmatrix ○
• {(⍵,∊⍵)⍪⍵,⍵}: Eine Funktion, die das rechte Argument mit Leerzeichen auffüllt, um eine Matrix zu erstellen, die doppelt so breit ist, und dann das rechte Argument selbst doppelt auf den unteren Rand laminiert. Würde
  zB ○werden

○ 
○○

• ⍣⎕: Wiederholen Sie die Funktion (Benutzereingabe) Zeiten.

Beispielausgabe

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

Python (75)

Ich bin zwei Jahre zu spät zur Party, aber ich bin überrascht, dass noch niemand diesen Ansatz gewählt hat

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

Verwendet das Kronecker-Produkt , um eine Matrix durch mehrere Kopien von sich selbst zu ersetzen.

Ich könnte zwei Zeichen einsparen, indem ich x=kron(x,x);x=kron(x,x)in Zeile drei ein 16x16-Pixel-Bild mit drei sichtbaren Ebenen erzeuge oder dem Iterator ein weiteres Zeichen hinzufüge und am Ende ein 2 ^ 16 x 2 ^ 16 = 4,3-Gigapixel-Bild und 15 Dreiecks-Ebenen erhalte.

Logo, 75 Zeichen

59 Zeichen nur für die erste Funktion, die zweite ruft die erste mit der Größe und der Tiefe / Anzahl der Iterationen auf. Sie können also einfach die erste Funktion des Interpreters mit dem folgenden Befehl aufrufen: e 99 5 oder mit der Größe, die Sie ausgeben möchten

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

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

Ergebnis

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

Python (90 Zeichen)

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)

Probieren Sie es online aus

Zeichnen Sie eine fraktale Linie, die das Sierpinsky-Dreieck füllt

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 Bytes

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

Das Sierpinski-Tetraeder kann auf ähnliche Weise gezeichnet werden:

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

J , ^37-35 Bytes

-2 Bytes dank FrownyFrog

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

Probieren Sie es online!

Dies ist Peter Taylors ASCII-Kunstversion, die in J konvertiert wurde. Mit einer weniger hübschen Version könnten Bytes gespart werden, aber warum?

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

Lua- Skript in Golly , 54 Byte

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

Golly ist ein Simulator für zellulare Automaten mit Unterstützung für Lua- und Python-Skripte.

Dieses Skript setzt die Regel auf Wolfram-Regel 60, setzt die Zelle auf (0,0) auf 1 und führt 512 Schritte aus.

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

Das Umschreiben mit Zeichenfolgen und Rekursion erfolgt mit genau der gleichen Anzahl. Die Tiefenbegrenzungen des Makroansatzes sind jedoch überwunden.

Bearbeiten: fill ist kürzer als stroke.

Eingerückt und kommentiert.

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

Das Hinzufügen 0 setlinewidthgibt einen besseren Eindruck davon, wie tief dies geht.

APL (Dyalog Classic) , 12 Byte

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

Probieren Sie es online!

Asymptote, 152 Bytes

Ich füge dies hinzu, meistens, weil ich auf dieser Seite in der Asymptote mehr oder weniger keine Antworten gesehen habe. Ein paar verschwendete Bytes für eine gute Formatierung und Allgemeinheit, aber damit kann ich leben. Das Ändern von A, B und C ändert sich dort, wo sich die Ecken des Dreiecks befinden, aber wahrscheinlich nicht so, wie Sie denken. Erhöhen Sie die Zahl in der Ungleichung, um die Tiefe zu erhöhen.

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

oder ungolfed und lesbar

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

Asymptote ist also eine nette Vektorgrafiksprache mit etwas C-ähnlicher Syntax. Sehr nützlich für technische Diagramme. Die Ausgabe erfolgt natürlich standardmäßig im Vektorformat (eps, pdf, svg), kann aber in praktisch alles konvertiert werden, was imagemagick unterstützt. Ausgabe:

Haskell , 166 154 Bytes

(-12 Bytes dank Laikoni, (zip- und Listenverständnis statt zipWith und Lambda, bessere Möglichkeit, die erste Zeile zu generieren))

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)

Probieren Sie es online!

Erläuterung:

Die Funktion i#nzeichnet 2^nnach iIterationsschritten ein ASCII-Dreieck der Höhe .

Die intern verwendete Codierung codiert leere Positionen als 1und volle Positionen als 0. Daher wird die erste Zeile des Dreiecks codiert , wie [1,1,1..0..1,1,1]mit 2^n-1denen auf beiden Seiten der Null. Um diese Liste zu erstellen, beginnen wir mit der Liste x=1<$[2..2^n], dh der Liste, [2..2^n]auf die alles abgebildet ist 1. Dann erstellen wir die vollständige Liste alsx++0:x

Der Operator k!p(ausführliche Erläuterung unten) erzeugt bei gegebenem Zeilenindex kund einem entsprechenden peine unendliche Liste der folgenden Zeilen p. Wir rufen es mit 1und der oben beschriebenen Startzeile auf, um das gesamte Dreieck zu erhalten, und nehmen dann nur die ersten 2^nZeilen. Dann drucken wir einfach jede Zeile aus und ersetzen sie 1durch Leerzeichen und 0mit M(indem wir auf die Liste "M "am Standort 0oder zugreifen 1).

Der Operator k!pist wie folgt definiert:

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

Zuerst erzeugen wir drei Versionen von p: 1:pdie pmit einem 1vorangestellten, sich pselbst und tail p++[1]das alles andere als das erste Element von p, mit einem 1angehängten. Wir zippen dann diese drei Listen und geben uns effektiv alle Elemente pmit ihren linken und rechten Nachbarn wie (l,m,r). Wir verwenden ein Listenverständnis, um dann den entsprechenden Wert in der neuen Zeile zu berechnen:

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

Um diesen Ausdruck zu verstehen, müssen wir zwei grundlegende Fälle berücksichtigen: Entweder erweitern wir einfach die vorherige Zeile, oder wir befinden uns an einem Punkt, an dem eine leere Stelle im Dreieck beginnt. Im ersten Fall haben wir eine ausgefüllte Stelle, wenn eine der Stellen in der Nachbarschaft ausgefüllt ist. Dies kann wie folgt berechnet werden m*l*r; Wenn einer dieser drei Werte Null ist, ist der neue Wert Null. Der andere Fall ist etwas kniffliger. Hier benötigen wir grundsätzlich eine Kantenerkennung. Die folgende Tabelle gibt die acht möglichen Nachbarschaften mit dem resultierenden Wert in der neuen Zeile an:

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

Eine einfache Formel, um diese Tabelle zu erhalten, wäre, 1-m*r*(1-l)-m*l*(1-r)was vereinfacht m*(2*l*r-l-r)+1. Jetzt müssen wir zwischen diesen beiden Fällen wählen, in denen wir die Zeilennummer verwenden k. Wenn mod k (2^(n-i)) == 0wir den zweiten Fall verwenden müssen, verwenden wir den ersten Fall. Der Begriff 0^(mod k(2^n-i))lautet daher, 0ob wir den ersten Fall verwenden müssen und 1ob wir den zweiten Fall verwenden müssen. Als Ergebnis können wir verwenden

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

Insgesamt - wenn wir den ersten Fall verwenden, erhalten wir einfach m*l*r, während im zweiten Fall ein zusätzlicher Term hinzugefügt wird, der die Gesamtsumme von ergibt m*(2*l*r-l-r)+1.

C 106 Zeichen

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

(Es amüsiert mich immer noch, dass dies puts("")der kürzeste Weg ist, eine neue Zeile in C auszugeben.)

Beachten Sie, dass Sie größere (oder kleinere) Dichtungen erstellen können, indem Sie den Test 32in der forSchleife durch eine größere (kleinere) Zweierpotenz ersetzen, sofern Sie auch 33die mittlere durch die printf()Zweierpotenz plus ersetzen. einer.