आप छोटे भग्न प्रोग्राम बना सकते हैं, जिसमें सबसे छोटा प्रोग्राम लिखें। आप किसी भी विधि का उपयोग कर सकते हैं जो आपको लगता है कि नीचे दिए गए नियमों के समान परिणाम उत्पन्न करता है। आपको सुझाए गए तरीकों से किसी भी विचार का उपयोग करने की आवश्यकता नहीं है!

आपका प्रोग्राम दो इनपुट लेगा, पहला पैटर्न 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और 590 डिग्री पर दक्षिणावर्त घुमाए जाते हैं, 2और6180 डिग्री घुमाए जाते हैं, 3और 7270 डिग्री दक्षिणावर्त घुमाए जाते हैं। दिखाए गए क्रम में तीन ब्लॉकों को एक साथ सिलाई करें, 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

नियम:

प्रतिबिंबित नहीं, 90 डिग्री पर घुमाया गया
प्रतिबिंबित नहीं, घुमाया गया 180 डिग्री दक्षिणावर्त
प्रतिबिंबित नहीं, 270 डिग्री घुमाया गया
मिरर किया लेकिन घुमाया नहीं गया
मिरर किया गया तो 90 डिग्री दक्षिणावर्त घुमाया गया
मिरर किया गया तो 180 डिग्री दक्षिणावर्त घुमाया गया
मिरर किया गया तो 270 डिग्री दक्षिणावर्त घुमाया गया
नियम ०: दर्पण नहीं, घुमाया नहीं गया

मिररिंग हमेशा पहले किया जाता है और तिरछे कोने के माध्यम से किया जाता है जैसे नियम 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
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सिरिंपस्की त्रिकोण (8 अलग-अलग नियम) का उत्पादन करेगा।

आप वैकल्पिक रूप से अपने पसंदीदा पैटर्न और इसे बनाने वाले नियम को पोस्ट कर सकते हैं। यदि आप करते हैं, तो सुनिश्चित करें कि समान नियमों से इसे अलग करने के लिए आकार कम से कम 3 (8x8) है।

code-golf ascii-art fractal

— सीजे डेनिस
स्रोत

@trichoplax आप पूरी तरह से भरे वर्ग या एक वर्ग के साथ शुरू कर सकते हैं जिसमें केवल 1 दृश्यमान चरित्र है। किसी भी तरह से, नियमों को एन बार दोहराते हुए , जहां n इनपुट आकार है, वही परिणाम की गारंटी देगा। हालाँकि, आपको इस तरह से पैटर्न उत्पन्न करने की आवश्यकता नहीं है, केवल उसी तरह से पैटर्न को उत्पन्न करना है।

— CJ डेनिस

@trichoplax मैं आपके इनपुट की सराहना करता हूं। जिस तरह से मैं चीजों को देखता हूं जरूरी नहीं कि जिस तरह से दूसरे लोग चीजों को देखते हैं और मुझे नहीं पता कि मैं उनके लिए मुश्किल बना रहा हूं!

— सीजे डेनिस

+1 धन्यवाद, आपने स्पष्टीकरण बहुत स्पष्ट कर दिया है! भविष्य में, मैं आपको हमारे सैंडबॉक्स के माध्यम से चीजों को चलाने की सलाह दूंगा ताकि लोग आपके द्वारा समय से पहले पूछ रहे एक स्पष्ट चित्र प्राप्त कर सकें। मैं जल्द ही इस चुनौती पर काम

— करूंगा

हाँ हर कोई चीजों को अलग तरह से देखता है। प्रतिक्रिया देने में खुशी - एक अच्छा सवाल स्पष्ट करने के लायक है। यह अब अच्छी तरह से पढ़ता है।

— ट्राइकोप्लाक्स

@BrainSteel धन्यवाद, करेंगे! मैं कई वर्षों के लिए एसई के आसपास रहा हूं, लेकिन मैं अभी भी पीसीजी के लिए अपेक्षाकृत नया हूं!

— सीजे डेनिस

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

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

बहुत सुन्दर! यदि पैटर्न शुरू होता है 0और जेम्स बॉन्ड के पास मारने का लाइसेंस है, तो यह बहुत कम मुद्रण योग्य पात्रों का उत्पादन करता है । 007: IndexOutOfBoundsException

— सीजे डेनिस

@CJDennis प्रमुख शून्य के साथ एक बग हैं। अब तय हो गया।

— ऑप्टिमाइज़र

बहुत बढ़िया! उत्पादन अब सही लग रहा है!

— सीजे डेनिस

APL (Dyalog Classic) , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

ASCII कला वर्ग परिधीय भग्न

CJam, 63 57 54 52 बाइट्स

APL (Dyalog Classic) , 47 बाइट्स