Schreiben Sie das kleinste Programm, das Sie können, um affine Fraktale zu erstellen. Sie können jede Methode verwenden, die Ihrer Meinung nach die gleichen Ergebnisse wie die folgenden Regeln liefert. Sie müssen keine Ideen aus den vorgeschlagenen Methoden verwenden!

Ihr Programm verwendet zwei Eingaben, die erste, um das Muster in dem 074dreistelligen Format von 0 bis 7 zu definieren. Die zweite Eingabe definiert die Größe, 3ist 8x8, 4ist 16x16 und so weiter (2 ^ n). Ihr Programm muss für alle Größen von 0 (1x1) bis mindestens 5 (32x32) das richtige Ergebnis ausgeben. Wenn es eine Ausgabe für höhere Zahlen erzeugt, muss es korrekt sein, dh es muss die korrekte Ausgabe bis zu einer bestimmten Größe erzeugen, aber keine Ausgabe über dieser Größe erzeugen, wenn es falsch wäre. Sie können eine maximale Größe von 15 (32768x32768) annehmen, da dies bereits eine verrückte Größe für ASCII-Grafiken (1 GB) ist!

Ein 8x8-Muster sieht ungefähr so ​​aus wie unten (Regel 160). Die am weitesten links stehende Ziffer ist für Block A, die mittlere Ziffer (bitte keine unhöflichen Gedanken!) Für Block Bund die am weitesten rechts stehende Ziffer für Block C. Um das Fraktal zu konstruieren, verkleinern Sie es in beiden Dimensionen um die Hälfte und wenden Sie die Rotations- / Spiegelungsregel für den Block an. Um das Muster zu verkleinern, teilen Sie es gleichmäßig in 2x2 Bereiche. In jedem Bereich sind entweder 3 Zeichen sichtbar oder keine. Wenn sichtbare Zeichen vorhanden sind, platzieren Sie ein Zeichen an der entsprechenden Stelle im kleineren Block, andernfalls platzieren Sie ein Leerzeichen. Regeln 0- 3werden nicht gespiegelt, Regeln 4- 7werden gespiegelt. Regeln 0und 4werden nicht gedreht 1und 5werden um 90 Grad im Uhrzeigersinn gedreht, 2und6werden um 180 Grad 3und 7um 270 Grad im Uhrzeigersinn gedreht. Nähen Sie die drei Blöcke in der angegebenen Reihenfolge Ain der oberen linken Ecke, Bunten links und Cunten rechts zusammen.

 AAA    
AA A    
AA      
A       
BBB CC  
B BBC   
  BBCCC 
   B CCC

Geschrumpft, gedreht und gespiegelt durch die Regelnummer:

 0       1       2       3       4       5       6       7  
----    ----    ----    ----    ----    ----    ----    ----
AA       BAA    CCB        C    C        BCC    AAB       AA
A       BB A     CBB      CC    CC      BBC     A BB       A
BBC     CC         A    A BB    BB A    A         CC     CBB
 BCC    C         AA    AAB      BAA    AA         C    CCB 

Regeln:

1. Nicht gespiegelt, um 90 Grad im Uhrzeigersinn gedreht
2. Nicht gespiegelt, um 180 Grad im Uhrzeigersinn gedreht
3. Nicht gespiegelt, um 270 Grad im Uhrzeigersinn gedreht
4. Gespiegelt, aber nicht gedreht
5. Gespiegelt und dann um 90 Grad im Uhrzeigersinn gedreht
6. Gespiegelt und dann um 180 Grad im Uhrzeigersinn gedreht
7. Gespiegelt und dann um 270 Grad im Uhrzeigersinn gedreht
8. Regel 0: Nicht gespiegelt, nicht gedreht

Die Spiegelung erfolgt immer zuerst und diagonal durch die leere Ecke, zB Regel 0 gegen Regel 4:

 0       4  
----    ----
AA /    C  /
A /     CC/ 
BBC     BB A
/BCC    /BAA

Nur Regeln 1, 6und 0sind in dem obigen Muster, in dieser Reihenfolge verwendet. Nachdem die Transformationen angewendet und die Blöcke zusammengefügt wurden, sieht es wie folgt aus, außer dass ich jeden Block um ein Leerzeichen voneinander entfernt habe. Ihr Code enthält keinen zusätzlichen Speicherplatz. Wenn Sie es mit dem "übergeordneten" Bild vergleichen, werden Sie sehen, dass es sichtbare Zeichen an denselben Positionen hat.

 BAA
BB A
CC  
C   

AAB  AA  
A BB A   
  CC BBC 
   C  BCC

Eine andere Möglichkeit, das Bild zu erzeugen, ohne es zu verkleinern, ist folgende: Beginnen Sie mit einem Zeichen:

X

Wenden Sie die Transformationen für jeden der drei Blöcke an (keiner, da es sich nur um ein Zeichen handelt) und nähen Sie die Blöcke zusammen:

X
XX

Wenden Sie die Transformationen für jeden der drei Blöcke erneut an:

1 
--
XX
X 

6     0 
--    --
XX    X 
 X    XX

Nähen Sie sie zusammen:

XX
X 
XXX 
 XXX

Wenden Sie die Transformationen für jeden der drei Blöcke erneut an:

 1  
----
 XXX
XX X
XX  
X   

 6       0  
----    ----
XXX     XX  
X XX    X   
  XX    XXX 
   X     XXX

Nähen Sie sie zusammen:

 XXX    
XX X    
XX      
X       
XXX XX  
X XXX   
  XXXXX 
   X XXX

Sie können für den sichtbaren Teil des Musters beliebige druckbare Zeichen (0x21 - 0x7E) verwenden, für die Leerzeichen jedoch nur das Leerzeichen (0x20). Nachgestellte Leerzeichen sind zulässig, es dürfen jedoch keine Leerzeichen außerhalb des gesamten Quadrats vorhanden sein (dh für ein 8 x 8-Quadrat dürfen nach Spalte 8 keine Zeichen stehen).

Es gibt 512 verschiedene Regeln, aber einige von ihnen erzeugen das gleiche Muster. Als Randnotiz: Jedes Muster, das nur das Sierpinski-Dreieck enthält 0und 4erzeugt (8 verschiedene Regeln).

Sie können optional Ihr Lieblingsmuster und die Regel, die es generiert, veröffentlichen. Wenn Sie dies tun, stellen Sie sicher, dass die Größe mindestens 3 (8 x 8) beträgt, um sie von ähnlichen Regeln zu unterscheiden.

CJam, 63 57 54 52 Bytes

0aarari*{\f{\~7"W%z"a*3"Wf%"t<s~}({__Ser+}%\~.++}/N*

Wie es funktioniert :

Die Grundidee ist, dass Sie eine Schleife ausführen, die zweite Eingabe mehrmals. In jeder Schleife erstellen wir ausgehend von einem einzelnen Array von Arrays, die 0( [[0]]) enthalten, das Fraktal für den nächsten Schritt unter Verwendung der drei Regeln, füllen den leeren Quadranten und bereiten die Quadranten für die nächste Schleife vor.

0aa                           e# Starting condition, equivalent to a single A
   ra                         e# Read the rule string and wrap it in an array
     ri*                      e# Repeat the rule array, second input number of times
        { ...  }/             e# Loop for each rule in the rule array
                              e# In each loop, we will have the current fractal and
                              e# then the rule on stack
\f{\~7"W%z"a*3"Wf%"t<s~}      
\f{                    }      e# Move the rule on top of stack and for each of the rule
                              e# character, run this loop on the current fractal
   \~                         e# Move the rule char on top and convert to int by face value
     7"W%z"a*3"Wf%"t          e# This is the array which has the logic to perform the rules
                              e# ["W%z" "W%z" "W%z" "Wf%" "W%z" "W%z" "W%z"]
                    <s        e# Based on the rule number value, take that many first items
                              e# from the above array and do a toString on the array
                              e# For rule 0 through 7, you will get the following strings:
                              e# 0: "", 1: "W%z", 2: "W%zW%z", 3: "W%zW%zW%z",
                              e# 4: "W%zW%zW%zWf%", 5: "W%zW%zW%zWf%W%z",
                              e# 6: "W%zW%zW%zWf%W%zW%z", 7: "W%zW%zW%zWf%W%zW%zW%z"
                              e# This works because each W%z will rotate the block of
                              e# fractal 90 degrees in clockwise direction.
                              e# For rule 4, where we need to mirror diagonally, we first
                              e# rotate it 279 degrees clock wise and then reverse each row
                              e# of the block. The rest of the rules after 4 take that
                              e# mirroring as base and rotate 90 degrees additionally
                      ~       e# Simply evaluate the string to apply the rule.
\f{ ... }                     e# After this for each loop, we get 3 copies of the fractal
                              e# block before the for loop. Each copy gets each one of the
                              e# three rule gets applied.
         ({      }%           e# We take out the first part corresponding to the 1st
                              e# quadrant and run each row through this loop to fill the
                              e# second quadrant with spaces
           __Ser              e# Take a copy of the row and replace everything in the
                              e# copy with spaces
                +             e# Append it to the original row
                   \~         e# Bring the last two quadrant array on top and unwrap it
                     .+       e# Append corresponding rows from the 4th quadrant to 3rd
                       +      e# Append the rows from lower half to the upper half
                              e# Now we have a full block ready to be run through
                              e# the next iteration which will double its size
                          N*  e# Finally, we join the rows of final fractal block with
                              e# newlines and automatically print the result

Probieren Sie es hier online aus

APL (Dyalog Classic) , 47 Bytes

⊃(⊂⍪⍕#){,/⍪⌿↑1 ¯2↑¨⊂⍺{⍉∘⊖⍣⍺⌽⍉⍣(⍺>3)⌽⍵}¨⍵}⍣⎕⍨⍎¨⍞

Probieren Sie es online aus!