Zeichne ein Sierpinski-Dreieck

43

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.

Bildbeschreibung hier eingeben

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.

Kibbee
quelle
1
Siehe auch die alte Stack Overflow-Version: stackoverflow.com/questions/1726698/…
dmckee
3
Die Idee dazu hatte ich, als ich die Dreiecksfrage von Pascal sah und mich an das Beispielprogramm in meinem TI-86-Handbuch erinnerte. Ich entschied mich, es in QBasic umzuwandeln und dann Golf zu programmieren.
Kibbee
Es ist kein Problem, hier eine Herausforderung auszuführen, die bereits auf Stack Overflow ausgeführt wurde, aber viele Benutzer möchten nicht dasselbe Material erneut präsentieren. Also verbinde ich sie zur Erbauung späterer Besucher.
dmckee
Um Doppelarbeit zu vermeiden, sollten Sie möglicherweise zu Regeln wechseln, um nur grafische Implementierungen zuzulassen.
Primo
Viele Ideen von wolfram: wolframscience.com/nksonline/page-931
luser droog

Antworten:

41

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.

Bildbeschreibung hier eingeben

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.

Kevin Reid
quelle
22
Es interessiert niemanden, ob Ihr HTML bei Codegolf validiert :-) Einige Verbesserungen: <canvas id=c>und dann c.getContext. Schleifen kürzen:for(x=k=128;x--;)for(y=k;y--;)
kopieren
4
Die Umwandlung von IDs in globale Variablen ist ein schrecklicher Fehler, den ich nicht anerkenne, und WebKit implementiert ihn nicht im Standardmodus. Danke für den Loop-Trick.
Kevin Reid
1
Kleinere Verbesserung: x&y?0:Kann durch eine x&y||ansonsten schöne Lösung ersetzt werden.
Primo
5
Bravo, das ist einfach wunderbar.
Stand
2
Da dies ein Skript enthält, würde ich empfehlen, es als HTML + Javascript zu bezeichnen . Das wird es jemandem klarer machen, welche Art von Antwort es ist.
30

GolfScript ( 43 42 Zeichen)

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

Ausgabe:

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

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

Peter Taylor
quelle
27

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.

Sierpinski-Dreieck

Oleh Prypin
quelle
1
import cairo as cWas würden Sie ein paar Zeichen sparen
Quasimodo
1
Diese Antwort braucht mehr Upvotes
ixtmixilix
26

Mathematica - 32 Zeichen

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

Bildbeschreibung hier eingeben

Mathematica - 37 Zeichen

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

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

Bildbeschreibung hier eingeben

Vitaliy Kaurov
quelle
2
Bei einem Aufpreis von 5 zusätzlichen Zeichen wird Ihre zweite Lösung mit ArrayPlot@CellularAutomaton[90, {{1}, 0}, 31]oder besser angezeigt MatrixPlot@CellularAutomaton[90, {{1}, 0}, 31].
DavidC
1
... oder mit ReliefPlot@...
DavidC
Ich verstehe das . Wie haben Sie die Ausgabe ohne alle Klammern erhalten?
Mr.Wizard
@ Mr.Wizard hmm ... woher in der Welt sind Klammern? Hier funktioniert es sogar: mathics.net. Versuchen Sie es und lassen Sie es mich wissen.
Vitaliy Kaurov
1
@Vitaliy Kaurov Die primäre (32 Zeichen) Lösung ist erstaunlich. Können Sie die "Fractal Tree" -Herausforderung (anderswo auf PCG) mit der gleichen Technik durchführen?
Michael Stern
22

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:

                               Δ                               
                              Δ Δ                              
                             Δ   Δ                             
                            Δ Δ Δ Δ                            
                           Δ       Δ                           
                          Δ Δ     Δ Δ                          
                         Δ   Δ   Δ   Δ                         
                        Δ Δ Δ Δ Δ Δ Δ Δ                        
                       Δ               Δ                       
                      Δ Δ             Δ Δ                      
                     Δ   Δ           Δ   Δ                     
                    Δ Δ Δ Δ         Δ Δ Δ Δ                    
                   Δ       Δ       Δ       Δ                   
                  Δ Δ     Δ Δ     Δ Δ     Δ Δ                  
                 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ                 
                Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ                
               Δ                               Δ               
              Δ Δ                             Δ Δ              
             Δ   Δ                           Δ   Δ             
            Δ Δ Δ Δ                         Δ Δ Δ Δ            
           Δ       Δ                       Δ       Δ           
          Δ Δ     Δ Δ                     Δ Δ     Δ Δ          
         Δ   Δ   Δ   Δ                   Δ   Δ   Δ   Δ         
        Δ Δ Δ Δ Δ Δ Δ Δ                 Δ Δ Δ Δ Δ Δ Δ Δ        
       Δ               Δ               Δ               Δ       
      Δ Δ             Δ Δ             Δ Δ             Δ Δ      
     Δ   Δ           Δ   Δ           Δ   Δ           Δ   Δ     
    Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ         Δ Δ Δ Δ    
   Δ       Δ       Δ       Δ       Δ       Δ       Δ       Δ   
  Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ     Δ Δ  
 Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ   Δ 
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
boothby
quelle
Das sieht echt cool aus: D
beary605 11.06.12
Mit diesem U + 0394 Hauptstadt Delta ist eine wirklich nette Geste.
David Conrad
16

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

Gareth
quelle
1
Könnten Sie kurz erklären, wie es funktioniert? Ich bin nicht vertraut mit J
Aditsu
1
|.(,~,.~)^:6,'o'ist kürzer und ohne zusätzliche Leerzeichen. Und (,~,.~)^:6,1gibt auch eine anständige Eingabe in nur 12 Zeichen!
Randomra
@Aditsu Ich habe eine Erklärung hinzugefügt.
Gareth
Also, wenn ich es bekomme, verkettet dieser Operator zwei 2D-Arrays?
MaiaVictor
13

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:

                                 ○                                 
                                ○ ○                                
                               ○ ○                               
                              ○ ○ ○ ○                              
                             ○ ○                             
                            ○ ○ ○ ○                            
                           ○ ○ ○ ○                           
                          ○ ○ ○ ○ ○ ○ ○ ○                          
                         ○ ○                         
                        ○ ○ ○ ○                        
                       ○ ○ ○ ○                       
                      ○ ○ ○ ○ ○ ○ ○ ○                      
                     ○ ○ ○ ○                     
                    ○ ○ ○ ○ ○ ○ ○ ○                    
                   ○ ○ ○ ○ ○ ○ ○ ○                   
                  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○                  
                 ○ ○                 
                ○ ○ ○ ○                
               ○ ○ ○ ○               
              ○ ○ ○ ○ ○ ○ ○ ○              
             ○ ○ ○ ○             
            ○ ○ ○ ○ ○ ○ ○ ○            
           ○ ○ ○ ○ ○ ○ ○ ○           
          ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○          
         ○ ○ ○ ○         
        ○ ○ ○ ○ ○ ○ ○ ○        
       ○ ○ ○ ○ ○ ○ ○ ○       
      ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○      
     ○ ○ ○ ○ ○ ○ ○ ○     
    ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○    
   ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○   
  ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○  
Marinus
quelle
1
Huch. Ich habe erwartet, dass dies 4 Zeichen sein werden, mit Binomials Mod 2 ... (ok ... vielleicht ein bisschen länger als das)
Stand
13

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:

               /\
              /__\
             /\  /\
            /__\/__\
           /\      /\
          /__\    /__\
         /\  /\  /\  /\
        /__\/__\/__\/__\
       /\              /\
      /__\            /__\
     /\  /\          /\  /\
    /__\/__\        /__\/__\
   /\      /\      /\      /\
  /__\    /__\    /__\    /__\
 /\  /\  /\  /\  /\  /\  /\  /\
/__\/__\/__\/__\/__\/__\/__\/__\
saeedn
quelle
13

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

Bildbeschreibung hier eingeben

Kibbee
quelle
Könnten Sie das Maß beschreiben, unter dem dieses Programm 129 Zeichen umfasst? Ich bekomme 151, wenn ich alle wahrscheinlich unnötigen Leerzeichen entferne. (Ich bin nicht mit QBasic vertraut.)
Kevin Reid
Ich habe das gesamte Leerzeichen für meine Zählung entfernt. Ich glaube, ich konnte nur nicht essentielle Leerzeichen zählen. Ich bin nicht sicher, was die "offizielle" Regel für Code Golf ist.
Kibbee
4
Sie sollten die tatsächliche Anzahl der Zeichen, einschließlich Leerzeichen, in einem Programm zählen, das ausgeführt wird und die richtige Ausgabe erzeugt . Natürlich möchten Sie kein unnötiges Leerzeichen verwenden.
Kevin Reid
1
Die Anzahl meiner Charaktere wurde korrigiert.
Kibbee
13

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

sehr kleines sierpinsky Dreieck : D

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

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:

Laufen

JoeFish
quelle
11

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

                             # #                               
                            #   #                              
                           # # # #                             
                          #       #                            
                         # #     # #                           
                        #   #   #   #                          
                       # # # # # # # #                         
                      #               #                        
                     # #             # #                       
                    #   #           #   #                      
                   # # # #         # # # #                     
                  #       #       #       #                    
                 # #     # #     # #     # #                   
                #   #   #   #   #   #   #   #                  
               # # # # # # # # # # # # # # # #                 
              #                               #                
             # #                             # #               
            #   #                           #   #              
           # # # #                         # # # #             
          #       #                       #       #            
         # #     # #                     # #     # #           
        #   #   #   #                   #   #   #   #          
       # # # # # # # #                 # # # # # # # #         
      #               #               #               #        
     # #             # #             # #             # #       
    #   #           #   #           #   #           #   #      
   # # # #         # # # #         # # # #         # # # #     
  #       #       #       #       #       #       #       #    
 # #     # #     # #     # #     # #     # #     # #     # #   
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #  
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
walpen
quelle
1
Dies scheint kein Sierpinski-Dreieck zu sein. es teilt sich in drei statt in zwei untergeordnete Dreiecke (abwärts verlaufend), und es ist zu sehen, dass dies kein großes leeres zentrales Dreieck ergibt.
Kevin Reid
1
Das liegt daran, dass ich die falsche Regel verwendet habe: O. Behoben und ein paar Zeichen rasiert.
Walpen
9

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

Bildbeschreibung hier eingeben

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"

Höllenstimmung
quelle
2
Sie sollten einen Hex-Dump Ihres Codes veröffentlichen, damit wir die tatsächlichen Bytes sehen können.
mbomb007
8

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:

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

Thomas W.
quelle
+1 Sehr schön. Ich hatte keine Ahnung, ob ich so etwas gebrauchen könnte.
Luser Droog
Hey, du hast den Repräsentanten, der das Bild jetzt hinzufügt!
Luser Droog
@luserdroog: Das stimmt (auch teilweise dank dir)!
Thomas W.
7

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

Bild

Mark Allen
quelle
wie zum ... was?
Akolyth
4
Der Code nutzt die Eigenschaft von Pascals Dreieck aus: Wenn Sie alle ungeraden (geraden) Zahlen schwarz (weiß) färben, erhalten Sie das Sierpinski-Dreieck. (siehe dieses Bild). i.32 erzeugt die Liste 0 1 2 ... 31. Dann berechnet! / ~ die Binomialkoeffizienten jedes Elements in der Liste gegen sich selbst, dh es wird eine 32 x 32-Matrix erzeugt, in die das Pascalsche Dreieck eingebettet ist. Dann 2 | ist einfach jedes Element in dieser Matrix Mod 2, das Sierpinskis Dreieck erzeugt.
Mark Allen
4

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

○               
○○              
○ ○             
○○○○            
○   ○           
○○  ○○          
○ ○ ○ ○         
○○○○○○○○        
○       ○       
○○      ○○      
○ ○     ○ ○     
○○○○    ○○○○    
○   ○   ○   ○   
○○  ○○  ○○  ○○  
○ ○ ○ ○ ○ ○ ○ ○ 
○○○○○○○○○○○○○○○○
TwiNight
quelle
4

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)

level7

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.

DenDenDo
quelle
3

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
hal9000w
quelle
+1 Ich habe über Logo gelesen. Welchen Dolmetscher benutzen Sie? ... Logo ist möglicherweise eine natürliche Ergänzung für meine L-System-Herausforderung .
Luser Droog
Wenn Sie nur die to fund endum entfernen e 99 5, haben Sie ein vollständiges ausführbares Programm in weniger Zeichen. Außerdem können Sie in UCBLogo (wenn auch nicht in anderen Versionen) die Doppelpunkte für die Variablen verlieren, um mehr Zeichen zu sparen.
Mark Reed
3

matlab 56

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

Bildbeschreibung hier eingeben

Chyanog
quelle
3

J (18 Zeichen)

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

Ergebnis

*                               
**                              
* *                             
****                            
*   *                           
**  **                          
* * * *                         
********                        
*       *                       
**      **                      
* *     * *                     
****    ****                    
*   *   *   *                   
**  **  **  **                  
* * * * * * * *                 
****************                
*               *               
**              **              
* *             * *             
****            ****            
*   *           *   *           
**  **          **  **          
* * * *         * * * *         
********        ********        
*       *       *       *       
**      **      **      **      
* *     * *     * *     * *     
****    ****    ****    ****    
*   *   *   *   *   *   *   *   
**  **  **  **  **  **  **  **  
* * * * * * * * * * * * * * * * 
********************************
Vivek Ramanujan
quelle
3

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

AMK
quelle
Vor dem Ausführen empfehle ich das Einfügen ht();speed(0);up();goto(20-window_width()/2, 20-window_height()/2);down()nach dem Import. Dadurch wird es viel schneller ausgeführt und sichergestellt, dass die Ausgabe auf die Zeichenfläche passt.
mbomb007
3

Mathematica 67

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

Bildbeschreibung hier eingeben

Mathematica 92

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

Bildbeschreibung hier eingeben

Chyanog
quelle
3

Mathematica , 29 Bytes

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

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

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

Alephalpha
quelle
3

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?

       /\       
      /__\      
     /\  /\     
    /__\/__\    
   /\      /\   
  /__\    /__\  
 /\  /\  /\  /\ 
/__\/__\/__\/__\
Jona
quelle
@]^:[-> @[&0und ' /\ '->' /\'
FrownyFrog
Wissen Sie zufällig, wo &0Trick dokumentiert ist?
Jona
1
Erwähnt hier am unteren Rand der Seite. Während ein Byte gespeichert wird, kann die Anzahl der Wiederholungen nicht mehr negativ sein.
FrownyFrog
Oh, Sie sollten in der Lage sein, die Operanden zu vertauschen ,~.
FrownyFrog
3

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.

Bildbeschreibung hier eingeben

Alephalpha
quelle
2

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.

Bild mit <code> fill </ code> überarbeiten (so ziemlich das Gleiche)

Luser Droog
quelle
Das ist mein Favorit.
cjfaure
Es gibt eine Möglichkeit, es mit dieser externen Bibliothek , die ich nachträglich geschrieben habe und nicht verwenden kann , kürzer zu machen . : P
luser droog
2

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:

Sierpinski-Dreieck

Algmyr
quelle
2

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.

Sacchan
quelle
1
154 Bytes: Probieren Sie es online! Übrigens nette Erklärung!
Laikoni
@Laikoni Ooh, da gibt es einige sehr schöne Verbesserungen!
Sacchan
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.

Brot-Box
quelle