Tulis program terkecil yang Anda bisa untuk membuat frakta afin. Anda dapat menggunakan metode apa pun yang Anda rasa menghasilkan hasil yang sama seperti aturan di bawah ini. Anda tidak harus menggunakan ide apa pun dari metode yang disarankan!

Program Anda akan mengambil dua input, yang pertama untuk menentukan pola dalam format yang 074terbuat dari tiga digit dari 0 hingga 7. Input kedua akan menentukan ukuran, 3akan menjadi 8x8, 4akan menjadi 16x16 dan seterusnya (2 ^ n). Program Anda harus menampilkan hasil yang benar untuk semua ukuran mulai dari 0 (1x1) hingga minimal 5 (32x32). Jika menghasilkan output untuk angka yang lebih tinggi, itu harus benar, yaitu harus menghasilkan output yang benar hingga ukuran tertentu tetapi tidak menghasilkan output di atas ukuran itu jika itu salah. Anda dapat mengasumsikan ukuran maksimum 15 (32768x32768) karena itu sudah merupakan ukuran gila untuk ASCII art (1GB)!

Pola 8x8 akan terlihat seperti di bawah ini (aturan 160). Digit paling kiri adalah untuk blok A, digit tengah (tidak ada pikiran kasar!) Untuk blok Bdan digit paling kanan untuk blok C. Untuk membangun fraktal, mengecilkannya setengah di kedua dimensi, dan menerapkan aturan rotasi / mirroring untuk blok. Untuk mengecilkan pola, bagilah secara merata menjadi area 2x2. Akan ada 3 karakter yang terlihat atau tidak ada di setiap area. Jika ada karakter yang terlihat, letakkan karakter di tempat yang sesuai di blok yang lebih kecil, jika tidak tempatkan spasi. Aturan 0- 3tidak dicerminkan, aturan 4- 7dicerminkan. Aturan 0dan 4tidak diputar, 1dan 5diputar 90 derajat searah jarum jam, 2dan6diputar 180 derajat, 3dan 7diputar 270 derajat searah jarum jam. Jahit tiga blok bersamaan dalam urutan yang ditunjukkan, Adi sudut kiri atas, Bkiri Cbawah dan kanan bawah.

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

Menyusut, diputar dan dicerminkan oleh nomor aturan:

 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 

Aturan:

1. Tidak dicerminkan, Diputar 90 derajat searah jarum jam
2. Tidak dicerminkan, Diputar 180 derajat searah jarum jam
3. Tidak dicerminkan, Diputar 270 derajat searah jarum jam
4. Dicerminkan tetapi tidak diputar
5. Dicerminkan lalu Putar 90 derajat searah jarum jam
6. Dicerminkan kemudian Diputar 180 derajat searah jarum jam
7. Dicerminkan kemudian Diputar 270 derajat searah jarum jam
8. Aturan 0: Tidak dicerminkan, Tidak diputar

Mirroring selalu dilakukan terlebih dahulu dan dilakukan secara diagonal melalui sudut kosong misalnya aturan 0 vs aturan 4:

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

Hanya aturan 1, 6dan 0digunakan dalam pola di atas, dalam urutan itu. Setelah transformasi diterapkan dan blok dijahit bersama akan terlihat seperti di bawah ini kecuali saya telah menempatkan setiap blok dari satu sama lain dengan satu spasi. Kode Anda tidak akan memiliki ruang ekstra di dalamnya. Jika Anda membandingkannya dengan gambar "induk" Anda akan melihat bahwa ia memiliki karakter yang terlihat di posisi yang sama.

 BAA
BB A
CC  
C   

AAB  AA  
A BB A   
  CC BBC 
   C  BCC

Cara lain untuk menghasilkan gambar tanpa menyusut adalah sebagai berikut: Mulai dengan satu karakter:

X

Terapkan transformasi untuk masing-masing dari tiga blok (tidak ada karena hanya satu karakter) dan jahit bersama-sama:

X
XX

Terapkan transformasi untuk masing-masing dari tiga blok lagi:

1 
--
XX
X 

6     0 
--    --
XX    X 
 X    XX

Jahit bersama-sama:

XX
X 
XXX 
 XXX

Terapkan transformasi untuk masing-masing dari tiga blok lagi:

 1  
----
 XXX
XX X
XX  
X   

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

Jahit bersama-sama:

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

Anda dapat menggunakan karakter atau karakter apa pun yang dapat dicetak (0x21 - 0x7E) untuk bagian pola yang terlihat tetapi hanya karakter spasi (0x20) untuk bagian yang kosong. Spasi spasi diperbolehkan tetapi tidak boleh ada kosong di luar seluruh kotak (yaitu untuk kotak 8x8 tidak boleh ada karakter di atas kolom 8).

Ada 512 aturan yang berbeda, tetapi beberapa dari mereka menghasilkan pola yang sama. Sebagai catatan tambahan, pola apa pun yang hanya berisi 0dan 4akan menghasilkan segitiga Sierpinski (8 aturan berbeda).

Anda dapat memposting pola favorit Anda dan aturan yang menghasilkannya. Jika ya, pastikan ukurannya minimal 3 (8x8) untuk membedakannya dari aturan yang sama.

CJam, 63 57 54 52 byte

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

Cara kerjanya :

Ide dasarnya adalah Anda menjalankan perulangan, jumlah input kedua kali. Di setiap loop, mulai dari array tunggal array yang berisi 0( [[0]]), kami membuat fraktal untuk langkah berikutnya menggunakan tiga aturan, mengisi kuadran kosong dan menyiapkan kuadran untuk loop berikutnya.

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

Cobalah online di sini

APL (Dyalog Classic) , 47 byte

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

Cobalah online!