34

अवलोकन

एक प्रोग्राम लिखें जिसमें फ्रैक्टल को थोड़ा सा पैटर्न देते हुए साधारण फ्रैक्टल पैटर्न को प्रिंट किया जाता है, साथ ही फ्रैक्टल और पीढ़ियों की संख्या के प्रति-पीढ़ी स्केल कारक।

व्याख्या

यहाँ Sierpinski कालीन का ASCII प्रतिनिधित्व है :

जनरेशन 0:

जनरेशन 1:

# # # 
#   # 
# # #

जनरेशन 2:

# # # # # # # # # 
#   # #   # #   # 
# # # # # # # # # 
# # #       # # # 
#   #       #   # 
# # #       # # # 
# # # # # # # # # 
#   # #   # #   # 
# # # # # # # # #

ASCII Sierpinski कालीन का जनरेशन n + 1 एक 3x3 ग्रिड से बना है जिसमें ग्रिड की केंद्रीय तत्व गायब होने के साथ, पीढ़ी n की 8 प्रतियां हैं।

इसलिए, क्योंकि यह एक 3x3 ग्रिड का उपयोग करके परिभाषित किया गया है और प्रत्येक पीढ़ी में 3 गुना बड़ा और ऊंचाई प्राप्त करता है, हम कह सकते हैं कि इसमें 3 का स्केल कारक है।

हम Sierpinski कालीन के लिए 0 से 8, ऊपर से नीचे, बाएँ-से-दाएँ, और पीढ़ी n + 1 समाहित होने पर एक पूर्णांक के संबंधित बिट सेट करने के लिए 3x3 ग्रिड में तत्वों की संख्या के द्वारा एक बिट पैटर्न को परिभाषित कर सकते हैं। उस ग्रिड स्थिति में पीढ़ी n की प्रतिलिपि:

bit:       place value:   bit pattern:   bit value:

0 1 2      1    2    4    1 1 1          1    2    4
3 4 5      8   16   32    1 0 1          8    0   32 
6 7 8      64 128  256    1 1 1          64 128  256 

integer value = 1 + 2 + 4 + 8 + 32 + 64 + 128 + 256 = 495

2 के स्केल फैक्टर के लिए, बिट पैटर्न को इस तरह व्यवस्थित किया जाएगा:

0 1
2 3

और इसी तरह।

आपका कार्य एक प्रोग्राम लिखना है जो इस रूप में थोड़ा पैटर्न स्वीकार करता है, एक स्केल फैक्टर (उदाहरण के लिए Sierpinski कारपेट के लिए 3) और एक पीढ़ी संख्या और एक ASCII भग्न को आउटपुट करता है।

इनपुट

आपके कार्यक्रम को निम्नलिखित क्रम में 3 पूर्णांक स्वीकार करना चाहिए: एक बिट पैटर्न, एक स्केल फैक्टर (2 से 5 तक, समावेशी) और एक पीढ़ी गणना (0 से 5 तक, समावेशी)।

आपको इन मूल्यों पर कोई इनपुट सत्यापन करने की आवश्यकता नहीं है और यह पूरी तरह से ठीक है यदि प्रोग्राम निर्दिष्ट सीमाओं से अधिक मान के लिए काम करता है।

आदानों को किसी भी रूप में पारित किया जा सकता है (ट्यूपल्स, अल्पविराम / अंतरिक्ष-अलग सूची, आदि)

उत्पादन

प्रोग्राम को एक फ्रैक्टल से बने #चरित्र का उत्पादन करना चाहिए, जिसके बाद उन स्थानों में एक स्थान होता है जहां फ्रैक्टल को परिभाषित किया जाता है, डबल-स्पेस जहां यह नहीं है, और प्रत्येक पंक्ति के अंत में एक नई लाइन वर्ण, या तो उन्हें प्रिंट करना या एक स्ट्रिंग वापस करना। एक समारोह से।

उदाहरण

इनपुट:

495,3,3

आउटपुट (Sierpinski कालीन पीढ़ी 3):

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #

इनपुट:

7,2,5

आउटपुट ( Sierpinski त्रिकोण ):

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #   
# #     # #     # #     # #     # #     # #     # #     # #     
#       #       #       #       #       #       #       #       
# # # #         # # # #         # # # #         # # # #         
#   #           #   #           #   #           #   #           
# #             # #             # #             # #             
#               #               #               #               
# # # # # # # #                 # # # # # # # #                 
#   #   #   #                   #   #   #   #                   
# #     # #                     # #     # #                     
#       #                       #       #                       
# # # #                         # # # #                         
#   #                           #   #                           
# #                             # #                             
#                               #                               
# # # # # # # # # # # # # # # #                                 
#   #   #   #   #   #   #   #                                   
# #     # #     # #     # #                                     
#       #       #       #                                       
# # # #         # # # #                                         
#   #           #   #                                           
# #             # #                                             
#               #                                               
# # # # # # # #                                                 
#   #   #   #                                                   
# #     # #                                                     
#       #                                                       
# # # #                                                         
#   #                                                           
# #                                                             
#

इनपुट:

325,3,3

आउटपुट ( कैंटर डस्ट ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   #

इनपुट

186,3,3

आउटपुट ( विसेक फ्रैक्टल ):

                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
  #     #     #     #     #     #     #     #     #   
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #

इनपुट:

279,3,3

आउटपुट (एक विषम भग्न का उदाहरण):

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
    #     #     #     #     #     #     #     #     # 
      # # #             # # #             # # #       
        #                 #                 #         
          #                 #                 #       
            # # #             # # #             # # # 
              #                 #                 #   
                #                 #                 # 
                  # # # # # # # # #                   
                    #     #     #                     
                      #     #     #                   
                        # # #                         
                          #                           
                            #                         
                              # # #                   
                                #                     
                                  #                   
                                    # # # # # # # # # 
                                      #     #     #   
                                        #     #     # 
                                          # # #       
                                            #         
                                              #       
                                                # # # 
                                                  #   
                                                    #

आदि।

टिप्पणियाँ:

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है
आपका कार्यक्रम या तो एक स्टैंड-अलोन या एक फ़ंक्शन हो सकता है जिसे 3 इनपुट मापदंडों और रिटर्न (या प्रिंट) के साथ एक स्ट्रिंग कहा जाता है
जनरेशन 0 को 0 के एक बिट पैटर्न के लिए भी #(एक #स्थान के बाद) के रूप में परिभाषित किया गया है।
अंतिम पंक्ति पर एक अनुगामी न्यूलाइन वैकल्पिक है, लेकिन अनुमत है, जैसा कि प्रत्येक पंक्ति पर श्वेत-स्थान के अनुगामी की कोई भी राशि है।

code-golf ascii-art fractal

— Samgak
स्रोत

3

+1, मुझे सैंडबॉक्स में यह पसंद आया और मुझे यह यहां और अधिक पसंद आया, जिसमें से प्रतीक बदल "##"गया "# "। मुझे लगता है कि पंक्ति के अंत में एक अनुगामी स्थान आपके उदाहरणों में शामिल है, क्या इसकी आवश्यकता है? । अंतिम नियम के अनुसार, मैं इसे वैकल्पिक मानूंगा, लेकिन यह तथ्य कि आपको पीढ़ी 0 के लिए एक अनुगामी स्थान की आवश्यकता है, मुझे आश्चर्यचकित करता है। इसके अलावा, मुझे लगता है कि आपको अधिकतम व्हाट्सएप और नईलाइन्स (आपको यह बहुवचन है) की अनुमति देनी चाहिए। एक चरम उदाहरण के रूप में मैं हमेशा 5 ^ 6 = 15625 लाइनों के 2 * 5 ^ 6 स्थानों की एक सरणी के साथ शुरू कर सकता हूं फिर एस को स्थानापन्न कर सकता हूं #। अधिकांश इनपुट मामलों में अप्रयुक्त व्हाट्सएप की एक बड़ी मात्रा है

— स्तर नदी सेंट

@steveverrill मैं जब पीछे अंतरिक्ष की आवश्यकता नहीं है outputting पीढ़ी 0, तथापि अनुगामी अंतरिक्ष इसकी परिभाषा, जो आने वाली पीढियों के संदर्भ में परिभाषित कर रहे हैं का हिस्सा है। न्यूलाइन्स का बहुवचन एक टाइपो था, जो तय किया गया था।

— samgak

क्या आप कुछ कम सममित के लिए अपेक्षित आउटपुट पोस्ट कर सकते हैं, जैसे कि 279,3,3?

— aditsu

@aditsu यकीन है, संपादित प्रश्न देखें

— samgak

4

एपीएल (Dyalog यूनिकोड) , 37 बाइट्स ^SBCS

'# '{⊃⍪/,/⍺\⍤1⊂⍉⍪⍉⍵}⍣⎕⍨(2⍴⎕)⍴⌽⎕⊤⍨99⍴2
                              ⎕       ⍝ input the bit pattern
                               ⊤⍨99⍴2 ⍝ decode 99 binary digits from it
                                      ⍝  (53 is the limit for floating point)
                             ⌽        ⍝ reverse, least significant bit goes first
                          ⎕           ⍝ input the scale factor
                       (2⍴ )          ⍝ twice, to use as dimensions of a matrix
                            ⍴         ⍝ reshape bit pattern into such a matrix
                     ⎕                ⍝ input the number of generations
'# '{              }⍣ ⍨               ⍝ apply that many times, starting from '# '
               ⍉⍪⍉⍵                   ⍝ make sure the argument is a matrix
              ⊂                       ⍝ enclose
          ⍺\⍤1                        ⍝ expand using rows of bit-pattern matrix
                                      ⍝  (1 for identical copy, 0 for zeroed out)
     ⊃⍪/,/                            ⍝ concat all horizontally and vertically

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

— NGN
स्रोत

11

आम लिस्प, 248 242 बाइट्स

(lambda(n r g &aux(s(expt r g)))(labels((f(g x y s)(or(= g 0)(#2=multiple-value-bind(q x)(floor x s)(#2#(p y)(floor y s)(if(logbitp(+ q(* p r))n)(f(1- g)x y(/ s r))))))))(#3=dotimes(y s)(#3#(x s)(princ(if(f g x y(/ s r))"# ""  ")))(terpri))))

Ungolfed

(defun fractal (n r g &aux (s (expt r g)))
  (labels((f(g x y s)
            (or(= g 0)
               (multiple-value-bind (px x) (truncate x s)
                 (multiple-value-bind (py y) (truncate y s)
                   (and
                    (logbitp (+ px (* py r)) n)
                    (f (1- g) x y (/ s r))))))))
    (fresh-line)
    (dotimes(y s)
      (dotimes(x s)
        (princ
         (if (f g x y(/ s r))
             "# "
             "  ")))
      (terpri))))

व्याख्या

इनपुट:
- एन एन्कोडेड पैटर्न है
- आर पैटर्न का आकार है
- जी पीढ़ी है
आउटपुट लंबाई = S का एक अंतर्निहित वर्ग मैट्रिक्स है^G
हम प्रत्येक पंक्ति y , कॉलम x (नेस्टेड) पर पुनरावृति करते हैंdotimes ) और गणना करते हैं कि क्या प्रत्येक सेल को खींचा जाना चाहिए (रीकास्टिंग-जैसे दृष्टिकोण)। यह fसहायक कार्य के साथ भग्न के अंदर पुनरावर्ती रूप से देखने के द्वारा किया जाता है ।
यदि स्थिति (x, y) पर भग्न खींचा जाएगा, तो प्रिंट करें "# ", अन्यथा प्रिंट करें " "। निश्चित रूप से हम प्रत्येक पंक्ति के अंत में नए अंक भी छापते हैं।

उदाहरण के लिए, Sierpinsky के त्रिकोण द्वारा S=7और का प्रतिनिधित्व किया जाता है R=2। पीढ़ी 3 में वर्ग आकार 2 ³ = 8 है। प्रत्येक सेल (x, y) के लिए , निम्नलिखित होते हैं:

fx , y , g से 3 और s से 4 (8/2) से बंधे को कहा जाता है
हम x को s द्वारा काटते हैं , ताकि यह पता चल सके कि x निहितार्थ मैट्रिक्स के बाईं या दाईं ओर है। truncateभागफल और शेष दोनों को लौटाता है, जो क्रमशः px और x के लिए बाध्य होते हैं (हम एक ही प्रतीक x का पुन: उपयोग करते हैं , लेकिन यह कोई समस्या नहीं है)।
वही y के लिए जाता है जो py और new y देता है ।
इस उदाहरण में, px और py 0 या 1 हो सकता है (क्योंकि पैटर्न लंबाई 2 का एक वर्ग है)। वे पहचानते हैं कि भग्न पैटर्न में कहां (x, y) है: जब स्थिति में बिट py.R + px का N 0, x और है y ऐसी स्थिति का प्रतिनिधित्व करते हैं जहां कुछ भी नहीं खींचा जाना चाहिए।
अन्यथा, हमें भग्न के संगत हिस्से में "ज़ूम" करना चाहिए और हम एक्स और वाई केf लिए नए बाइंडिंग के साथ पुनरावर्ती कॉल करते हैं । वे अब आंतरिक भग्न के अंदर सापेक्ष स्थिति हैं। हम पीढ़ी के लिए जी -1 पास करते हैं और भग्न की आधी लंबाई का प्रतिनिधित्व करने के लिए एस / 2 ।
जी के शून्य होने पर पुनरावर्तन का आधार मामला सामने आता है, इस स्थिति में वर्तमान (x, y) स्थिति को खींचा जाना चाहिए।

उदाहरण

(fractal 186 3 3)

                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #                           
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
  #     #     #     #     #     #     #     #     #   
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
  #     #     #     #     #     #     #     #     #   
        #                 #                 #         
      # # #             # # #             # # #       
        #                 #                 #         
                          #                           
                        # # #                         
                          #                           
                    #     #     #                     
                  # # # # # # # # #                   
                    #     #     #                     
                          #                           
                        # # #                         
                          #

Sierpinski कालीन की 8 वीं पीढ़ी का उपयोग करके (fractal 495 3 8)24.7 सेकंड का समय लगता है और 83 एमबी का आउटपुट टेक्स्ट फ़ाइल उत्पन्न करता है। मैंने थोड़ा संशोधित संस्करण लिखा है जो एक छवि को आउटपुट करता है। समान मापदंडों के लिए, GIF फ़ाइल का वजन 1.5MB (समान गणना समय):

विसेक (मूल आकार देखने के लिए क्लिक करें):

— कोर निपात
स्रोत

1

+1 जो कि एक भयानक क्रिया भाषा में संक्षिप्त कार्यक्रम जैसा दिखता है। )एक पंक्ति में 8 नेस्टेड !

— लेवल रिवर सेंट

@steveverrill मैं कभी कोड गोल्फ नहीं जीतता ... लेकिन फिर भी, मुझे लगता है कि सिंटैक्स बड़े कार्यक्रमों के लिए भुगतान करता है। और ईमानदारी से, मैं लगभग कोष्ठक नहीं देखता, बस एक अच्छा पेड़।

— coredump

यह gif छवि वास्तव में मेरे फोन के वेब ब्राउजर को क्रैश कर देती है ... एक अधिक असामान्य भाषा के साथ ग्रेट गोल्फिंग

— ग्लेन स्मिथ

@HiGuy धन्यवाद। क्या CodeGolf के पास अन्य लोगों के ब्राउज़र को क्रैश करने के लिए बैज है? इसे :-)

— coredump

5

पायथ, 38 बाइट्स

VJ^UQvwjdm@" #".A@L_.[0^Q2jvz2+V*RQNdJ

इसे ऑनलाइन आज़माएं: नियमित इनपुट / टेस्ट सूट

व्याख्या बाद में।

— Jakube
स्रोत

1+ मैं अभी भी 186 3 5(ऑनलाइन दुभाषिया) के उत्पादन की प्रतीक्षा कर रहा हूं , लेकिन इसके अलावा मैं वास्तव में इससे बहुत प्रभावित हूं।

— coredump

1

@coredump मुझे नहीं लगता कि ऑनलाइन इंटरप्रेटर का उपयोग करके आपको इतना बड़ा आउटपुट मिलेगा। यदि आप इसका परीक्षण करना चाहते हैं, तो आपको Pyth संकलक को डाउनलोड करना होगा । मेरे लैपटॉप पर लगभग 10 सेकंड लगते हैं।

— जकुब 16

4

रूबी, 154

स्कोर केवल फ़ंक्शन के लिए है। परीक्षण कार्यक्रम में नीचे दिए गए अपुष्ट प्रस्तुत। इस समय मैं जो एकमात्र गोल्फ दावा कर रहा हूं, वह टिप्पणियों और इंडेंट को हटा रहा है। मैं बाद में गोल्फ करूंगा। फिलहाल, मुझे कार्यक्रम के साथ खेलने में मज़ा आ रहा है।

फ़ंक्शन छह तर्क लेता है, लेकिन प्रारंभिक कॉल पर केवल पहले 3 को युक्ति के अनुसार प्रदान किया जाता है। यह तीन शेष तर्कों को डिफ़ॉल्ट मानों और विशेष रूप से स्ट्रिंग में सेट करने का कारण बनता हैa जहां आउटपुट संग्रहीत किया जाता है और नए सिरे से समाप्त रिक्त स्थान की रेखाओं के लिए आरंभिक होता है। वैश्विक चर के साइड इफेक्ट के रूप में$w भी बनाया गया है, जो प्रति पंक्ति प्रतीकों की संख्या को दर्शाता है।

जब फ़ंक्शन खुद को पुनरावर्ती कहता है, तो यह स्ट्रिंग सहित सभी छह तर्क प्रदान करता है a और x और y अगले पुनरावृत्ति के ऊपरी बाएँ कोने के निर्देशांक शामिल हैं

कार्यक्रम का बाकी हिस्सा बहुत सीधा है, जैसा कि टिप्पणियों में दिखाया गया है।

#function
f=->b,s,g,x=0,y=0,a=(' '*(-1+2*$w=s**g)+'
')*$w{                                         #accept arguments, if x,y,a are not provided create them. $w = number of symbols per row 
  v=s**g/s                                     #v=width of blocks for this recursion depth
  if g==0
    a[2*y*$w+2*x]=?#                           #if g==0 plot a #
  else                                         #else iterate s*s times through the bits of b, and recurse as necessary
    (s*s).times{|i|b>>i&1>0&&f.call(b,s,g-1,x+i%s*v,y+i/s*v,a)} 
  end
  a
}

#test program (requires 3 input numbers separated by newlines)
b=gets.to_i
s=gets.to_i
g=gets.to_i
#get return value and output to stdout
puts f.call(b,s,g)

उत्पादन

यहाँ GOLF शब्द के अक्षरों के रूप में शिथिल रूप से भग्न का एक सेट है। अधिक यथार्थवादी पत्र बड़े बिटमैप के साथ प्राप्त किए जा सकते हैं। जैसा कि पिछले उदाहरण से पता चलता है, दुर्घटना से सबसे दिलचस्प फ्रैक्चर की खोज की जाती है।

63775,4,2 (G)

# # # # # # # # # # # # # # # #
#       #       #       #      
#     # #     # #     # #     #
# # # # # # # # # # # # # # # #
# # # #                        
#                              
#     #                        
# # # #                        
# # # #                 # # # #
#                       #      
#     #                 #     #
# # # #                 # # # #
# # # # # # # # # # # # # # # #
#       #       #       #      
#     # #     # #     # #     #
# # # # # # # # # # # # # # # #

495,3,3 (O, sierpinski carpet)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # #       # # # # # #       # # # # # #       # # #
#   #       #   # #   #       #   # #   #       #   #
# # #       # # # # # #       # # # # # #       # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #                   # # # # # # # # #
#   # #   # #   #                   #   # #   # #   #
# # # # # # # # #                   # # # # # # # # #
# # #       # # #                   # # #       # # #
#   #       #   #                   #   #       #   #
# # #       # # #                   # # #       # # #
# # # # # # # # #                   # # # # # # # # #
#   # #   # #   #                   #   # #   # #   #
# # # # # # # # #                   # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # #       # # # # # #       # # # # # #       # # #
#   #       #   # #   #       #   # #   #       #   #
# # #       # # # # # #       # # # # # #       # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
#   # #   # #   # #   # #   # #   # #   # #   # #   #
# # # # # # # # # # # # # # # # # # # # # # # # # # #

457,3,3 (L)

#                                                    
#                                                    
# # #                                                
#                                                    
#                                                    
# # #                                                
#     #     #                                        
#     #     #                                        
# # # # # # # # #                                    
#                                                    
#                                                    
# # #                                                
#                                                    
#                                                    
# # #                                                
#     #     #                                        
#     #     #                                        
# # # # # # # # #                                    
#                 #                 #                
#                 #                 #                
# # #             # # #             # # #            
#                 #                 #                
#                 #                 #                
# # #             # # #             # # #            
#     #     #     #     #     #     #     #     #    
#     #     #     #     #     #     #     #     #    
# # # # # # # # # # # # # # # # # # # # # # # # # # #

7967,4,2 (F)

# # # # # # # # # # # # # # # #
#       #       #       #      
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # #                        
#                              
# # # #                        
#                              
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # # # # # # # # # # # # # #
#       #       #       #      
# # # #                        
#                              
# # # #                        
#      

1879,3,3 (skull and crossbones discovered by accident)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
  #     #     #     #     #     #     #     #     #  
#   # #   # #   # #   # #   # #   # #   # #   # #   #
      # # #             # # #             # # #      
        #                 #                 #        
      #   #             #   #             #   #      
# # #       # # # # # #       # # # # # #       # # #
  #           #     #           #     #           #  
#   #       #   # #   #       #   # #   #       #   #
                  # # # # # # # # #                  
                    #     #     #                    
                  #   # #   # #   #                  
                        # # #                        
                          #                          
                        #   #                        
                  # # #       # # #                  
                    #           #                    
                  #   #       #   #                  
# # # # # # # # #                   # # # # # # # # #
  #     #     #                       #     #     #  
#   # #   # #   #                   #   # #   # #   #
      # # #                               # # #      
        #                                   #        
      #   #                               #   #      
# # #       # # #                   # # #       # # #
  #           #                       #           #  
#   #       #   #                   #   #       #   #

— स्तर नदी सेंट
स्रोत

3

CJam, 45

3aaq~@2b2$_*0e[W%@/a*{ffff*:.+:.+}/' ff+Sf*N*

मेरे पहले विचार का कार्यान्वयन। इसे ऑनलाइन आज़माएं

असल में, यह 1 * 1 मैट्रिक्स से शुरू होता है जिसमें 3 ('#' और '' के बीच का अंतर) होता है, फिर बार-बार मैट्रिक्स में प्रत्येक संख्या को बिट पैटर्न (0/1 मैट्रिक्स) से गुणा करता है, और परिणामी मैट्रिक्स को एक में जोड़ता है। बड़ा मैट्रिक्स। अंत में, यह प्रत्येक संख्या के लिए एक स्थान जोड़ता है, और रिक्त स्थान और newlines के साथ जुड़ता है।

दूसरा विचार, ४ ९

q~@2bW%2$/z@@m*_,\_m*:z@f{3@@f{\~@==*}~' +}/Sf*N*

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

यह आउटपुट मैट्रिक्स के सभी निर्देशांक उत्पन्न करता है जैसा कि <जेनेरेशन काउंट> संख्याओं के जोड़े स्केल फैक्टर (सभी ऐसे कॉम्बिनेशन) से छोटा होता है, फिर प्रत्येक जोड़ी संख्याओं के लिए इसे पैटर्न से संबंधित बिट मिलता है, और प्रत्येक निर्देशांक सरणी के लिए। यह बिट्स को गुणा करता है और 3 से गुणा करता है। अंतिम प्रसंस्करण समान है।

संभवतः अधिक गोल्फ के लिए जगह है।

— aditsu
स्रोत

2

सी, 316 बाइट्स

main(a,_,b,s,g,i,w,o,z,x,y)char**_,*o;{b=atoi(_[1]);s=atoi(_[2]);g=atoi(_[3]);w=1;for(i=0;i<g;++i){w*=s;}o=malloc(w*w);for(i=0;i<w*w;++i)o[i]=35;z=w/s;while(z){for(y=0;y<w;++y)for(x=0;x<w;++x)if(!((b>>((y/z)%s*s+(x/z)%s))&1))o[y*w+x]=32;z/=s;}for(y=0;y<w;++y){for(x=0;x<w;++x)printf("%c ",o[y*w+x]);printf("\n");}}

संयुक्त राष्ट्र के golfed:

#include <stdio.h>

int main(int argc, char *argv[]) 
{
    int bitpattern;
    int scale;
    int generation;

    bitpattern = atoi(argv[1]);
    scale = atoi(argv[2]);
    generation = atoi(argv[3]);

    int i;
    int width = 1;
    for (i=0; i<generation; ++i) {width*=scale;}

    char *out=malloc(width*width);

    for (i=0; i<width*width; ++i) out[i]='#';


    int blocksize = width/scale;
    for (i=0; i<generation; ++i) {
        int x,y;
        for (y=0; y<width; ++y) {
            for (x=0; x<width; ++x) {
                int localX = x/blocksize;
                localX %= scale;
                int localY = y/blocksize;
                localY %= scale;
                int localPos = localY*scale+localX;
                if (!((bitpattern>>localPos)&1))out[y*width+x]=' ';
            }
        }
        blocksize/=scale;
    }

    int x,y;
    for (y=0; y<width; ++y) {
        for (x=0; x<width; ++x)
            printf("%c ",out[y*width+x]);
        printf("\n");
    }
    return 0;
}

— LambdaBeta
स्रोत

3

युक्ति के अंत में बुलेट बिंदुओं के अनुसार एक कार्यक्रम के बजाय एक फ़ंक्शन की अनुमति है। इसे एक फ़ंक्शन में बदलें और बस तीन इनपुट मापदंडों को पास करें - जो कि सभी अटोई सामान से छुटकारा दिलाएगा और आपको लगभग 40 बाइट्स बचाएगा।

— लेवल रिवर सेंट

2

स्काला 293 299

(e:Int,s:Int,g:Int)=>{def b(x:Int,y:Int)=(1<<x*s+y&e)>0;def f(n:Int):Seq[Seq[Char]]=if(n<1)Seq(Seq('#'))else if(n<2)Seq.tabulate(s,s)((i,j)=>if(b(i,j))'#'else' ')else{val k=f(n-1);val t=k.size;Seq.tabulate(t*s,t*s)((i,j)=>if(b(i/t,j/t))k(i%t)(j%t)else' ')};f(g).map(_.mkString(" ")).mkString(" \n")}

ungolfed:

//create an anonymous function
(encoded: Int, size: Int, generation: Int) => {

  // method will return true if coords (x,y) should be drawn as '#'
  def isBlackInPattern(x: Int, y: Int): Boolean = (1 << x * size + y & encoded) > 0

  // recurse until generation is 1
  def fillRecursively(gen: Int): Seq[Seq[Char]] = {

    // this is just to satisfy OP requirements.
    // if the stopping condition were generation = 1,
    // I could have spared this line...
    if(gen < 1) Seq(Seq('#'))

    //actual stopping condition (generation 1). 
    // fill a matrix of characters with spaces
    // and hashes acording to the pattern.
    else if(gen < 2) Seq.tabulate(size, size)((i, j) => 
      if (isBlackInPattern(i,j)) '#' 
      else ' '
    )

    // recurse, and use previously created fractals to fill
    // the current generation according to the `isBlackInPattern` condition
    else {
      val previousGeneration = fillRecursively(gen-1)
      val previousSize = previousGeneration.size
      // create the current matrix and fill it
      Seq.tabulate(previousSize*size,previousSize*size)((i,j)=>
        if(isBlackInPattern(i/previousSize,j/previousSize))
          previousGeneration(i%t)(j%t)
        else ' '
      )
    }
  }
  // call to recursive function and format matrix of characters to string
  fillRecursively(generation).map(_.mkString(" ")).mkString(" \n")
}

उदाहरण:

val f = (e:Int,s:Int,g:Int)=>{def b(x:Int,y:Int)=(1<<x*s+y&e)>0;def f(n:Int):Seq[Seq[Char]]=if(n<1)Seq(Seq('#'))else if(n<2)Seq.tabulate(s,s)((i,j)=>if(b(i,j))'#'else' ')else{val k=f(n-1);val t=k.size;Seq.tabulate(t*s,t*s)((i,j)=>if(b(i/t,j/t))k(i%t)(j%t)else' ')};f(g).map(_.mkString(" ")).mkString(" \n")}
f: (Int, Int, Int) => String = <function3>

scala> println(f(495,3,3))
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #

scala> println(f(7,2,5))
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   #   #   #   #   #   #   #   #   #   #   #   #   #   #   #   
# #     # #     # #     # #     # #     # #     # #     # #     
#       #       #       #       #       #       #       #       
# # # #         # # # #         # # # #         # # # #         
#   #           #   #           #   #           #   #           
# #             # #             # #             # #             
#               #               #               #               
# # # # # # # #                 # # # # # # # #                 
#   #   #   #                   #   #   #   #                   
# #     # #                     # #     # #                     
#       #                       #       #                       
# # # #                         # # # #                         
#   #                           #   #                           
# #                             # #                             
#                               #                               
# # # # # # # # # # # # # # # #                                 
#   #   #   #   #   #   #   #                                   
# #     # #     # #     # #                                     
#       #       #       #                                       
# # # #         # # # #                                         
#   #           #   #                                           
# #             # #                                             
#               #                                               
# # # # # # # #                                                 
#   #   #   #                                                   
# #     # #                                                     
#       #                                                       
# # # #                                                         
#   #                                                           
# #                                                             
# 

scala> println(f(18157905,5,2))
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
                    #       #                     
                      #   #                       
                        #                         
                      #   #                       
                    #       #                     
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       #

पहली कटौती, शायद थोड़ा आगे गोल्फ हो सकता है ...

— गिलाद होच
स्रोत

आप अपने प्रत्येक के बीच एक स्थान याद कर रहे हैं #। युक्ति द्वारा आवश्यक होने के अलावा, यह वास्तव में आपके आउटपुट की उपस्थिति को बढ़ाता है।

— लेवल रिवर सेंट

@steveverrill अपने अधिकार को। मैंने उस पर ध्यान नहीं दिया। मैंने जल्दी ठीक किया। धन्यवाद :)

— गिल्ड होच

2

मतलाब, 115 बाइट्स

क्रोनकर kronउत्पाद सब कुछ बहुत आसान बनाता है:

function f(p,f,g);z=nan(f);z(:)=de2bi(p,f*f);x=3;for k=1:g;x=kron(x,z);end;disp([reshape([x;0*x],f^g,2*f^g)+32,''])

# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #

— flawr
स्रोत

हालांकि de2biकेवल तभी काम करता है जब आपके पास संचार प्रणाली टूलबॉक्स हो। इसके बिना काम नहीं करता है। इसकी आवश्यकता होगी dec2bin।

— टॉम कारपेंटर

ऐसा लगता है कि यह टूलबॉक्स मेरे मानक छात्र संस्करण में शामिल है, इसलिए मुझे लगता है कि यह स्वीकार्य है। (ध्यान दें कि de2biऐसा नहीं है dec2bin।)

— दोष

2

सी, 158 बाइट्स

f(p,s,g,h,i,j,c){for(j=1;g--;j*=s);for(h=j;h;){h--;for(i=j;i;){i--;for(c=35,g=j/s;g;g/=s)c=!((p>>((h/g)%s*s+(i/g)%s))&1)?32:c;printf("%c ",c);}printf("\n");}}

— Neoheurist
स्रोत

1

K5, 70 बाइट्स

यह एक शुरुआत है:

{,/'("  ";"# ")$[z;(z-1){,/'+,/'+x@y}[(0*t;t)]/t:(2#y)#|(25#2)\x;,,1]}

कार्रवाई में:

{,/'("  ";"# ")$[z;(z-1){,/'+,/'+x@y}[(0*t;t)]/t:(2#y)#|(25#2)\x;,,1]}[186;3]'!4
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))

— JohnE
स्रोत

ASCII में बिट पैटर्न से फ्रैक्चर उत्पन्न करें

एपीएल (Dyalog यूनिकोड) , 37 बाइट्स SBCS

आम लिस्प, 248 242 बाइट्स

Ungolfed

व्याख्या

उदाहरण

पायथ, 38 बाइट्स

रूबी, 154

CJam, 45

सी, 316 बाइट्स

संयुक्त राष्ट्र के golfed:

स्काला 293 299

मतलाब, 115 बाइट्स

K5, 70 बाइट्स

एपीएल (Dyalog यूनिकोड) , 37 बाइट्स ^SBCS