编写可以创建仿射形的最小程序。您可以使用任何会产生与以下规则相同的结果的方法。您不必使用建议方法中的任何想法！

您的程序将有两个输入，第一个输入以074从0到7的三位数组成的格式定义模式。第二个输入将定义大小，3将为8x8，4将为16x16，依此类推（2 ^ n）。您的程序必须为从0（1x1）到至少5（32x32）的所有大小输出正确的结果。如果它为更高的数字生成任何输出，则它必须是正确的，即，它必须在达到一定大小之前生成正确的输出，但是如果出现错误，则不会生成超出该大小的输出。您可能会假定最大大小为15（32768x32768），因为对于ASCII艺术作品（1GB）而言，这已经是疯狂的大小！

8x8模式将如下所示（规则160）。最左边的数字代表Block A，中间的数字代表Block （请不要粗鲁！），B最右边的数字代表Block C。要构建分形，请将其在两个维度上缩小一半，然后对块应用旋转/镜像规则。要缩小图案，请将其均匀分成2x2区域。每个区域中将只有3个可见字符或无。如果有可见的字符，则在较小的块中的适当位置放置一个字符，否则放置一个空格。规则0- 3未镜像，规则4- 7已镜像。规则0和4不旋转，1并且5顺时针旋转90度，2并且6旋转180度，3然后7顺时针旋转270度。按所示顺序将三个块缝在一起，分别A在左上角，B左下角和C右下角。

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

按规则编号缩小，旋转和镜像：

 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 

规则：

1. 未镜像，顺时针旋转90度
2. 未镜像，顺时针旋转180度
3. 未镜像，顺时针旋转270度
4. 镜像但不旋转
5. 镜像然后顺时针旋转90度
6. 镜像然后顺时针旋转180度
7. 镜像然后顺时针旋转270度
8. 规则0：不镜像，不旋转

镜像始终首先完成，并且通过空白角沿对角线进行，例如规则0与规则4：

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

只有规则1，6和0在上述模式中使用，在这个顺序。在应用了变换并将块缝合在一起之后，除了我将每个块彼此隔开一个空格之外，它看起来如下图所示。您的代码将没有多余的空间。如果将其与“父”图像进行比较，您将看到它在相同位置具有可见字符。

 BAA
BB A
CC  
C   

AAB  AA  
A BB A   
  CC BBC 
   C  BCC

另一种不缩小图像的方法如下：以一个字符开始：

X

对三个块中的每个块应用转换（由于只有一个字符，因此不进行任何转换）并将块缝合在一起：

X
XX

再次对三个模块中的每个模块应用转换：

1 
--
XX
X 

6     0 
--    --
XX    X 
 X    XX

将它们缝在一起：

XX
X 
XXX 
 XXX

再次对三个模块中的每个模块应用转换：

 1  
----
 XXX
XX X
XX  
X   

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

将它们缝在一起：

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

您可以将任何可打印字符（0x21-0x7E）用于图案的可见部分，但只能将空格字符（0x20）用于空白。允许使用尾随空格，但在整个正方形外面不能有空格（例如，对于8x8正方形，第8列之后不能有字符）。

有512个不同的规则，但是其中一些规则产生相同的模式。附带说明一下，任何仅包含0和的模式4都会产生Sierpinski三角形（8个不同的规则）。

您可以选择发布您喜欢的模式及其生成规则。如果这样做，请确保大小至少为3（8x8），以将其与类似规则区分开。

CJam，63 57 54 52字节

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

运作方式：

基本思想是运行循环，第二次输入次数。在每个循环中，从包含0（[[0]]）的单个阵列数组开始，我们使用三个规则为下一步构建分形，填充空白象限，并为下一个循环准备象限。

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

在这里在线尝试

APL（Dyalog Classic），47字节

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

在线尝试！