เขียนโปรแกรมที่เล็กที่สุดที่คุณสามารถสร้างเลียนแบบแฟร็กทัลได้ คุณอาจใช้วิธีการใด ๆ ที่คุณรู้สึกว่าสร้างผลลัพธ์เช่นเดียวกับกฎด้านล่าง คุณไม่จำเป็นต้องใช้ความคิดใด ๆ จากวิธีการที่แนะนำ!

โปรแกรมของคุณจะรับสองอินพุตเป็นคนแรกที่กำหนดรูปแบบในรูปแบบที่074ทำจากตัวเลขสามหลักจาก 0 ถึง 7 อินพุตที่สองจะกำหนดขนาด3จะเป็น 8x8 4จะเป็น 16x16 และอื่น ๆ (2 ^ n) โปรแกรมของคุณจะต้องแสดงผลลัพธ์ที่ถูกต้องสำหรับทุกขนาดตั้งแต่ 0 (1x1) ถึงอย่างน้อย 5 (32x32) ถ้ามันสร้างผลลัพธ์ใด ๆ สำหรับตัวเลขที่สูงกว่ามันจะต้องถูกต้องนั่นคือมันจะต้องสร้างผลลัพธ์ที่ถูกต้องจนถึงขนาดที่กำหนด แต่จะไม่สร้างผลลัพธ์ที่เกินขนาดนั้นถ้ามันผิด คุณอาจสันนิษฐานว่าขนาดสูงสุด 15 (32768x32768) เนื่องจากเป็นขนาดที่บ้าสำหรับศิลปะ ASCII (1GB)!

รูปแบบ 8x8 จะมีลักษณะดังนี้ (กฎ160) ซ้ายสุดหลักจะเป็นบล็อกA, กลางหลัก (ไม่คิดหยาบคายโปรด!) สำหรับบล็อกและหลักขวาสุดสำหรับบล็อกB 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)⌽⍵}¨⍵}⍣⎕⍨⍎¨⍞

ลองออนไลน์!