ASCII এ বিট নিদর্শনগুলি থেকে ফ্র্যাক্টালগুলি তৈরি করুন

Question

সংক্ষিপ্ত বিবরণ

একটি প্রোগ্রাম লিখুন যা ফ্র্যাক্টালকে এনকোডিং করার জন্য কিছুটা নিদর্শন দেওয়া, পাশাপাশি ফ্র্যাক্টাল এবং প্রজন্মের সংখ্যার প্রতি-প্রজন্মের স্কেল ফ্যাক্টর সহ সাধারণ ফ্র্যাক্টাল নিদর্শনগুলি মুদ্রণ করে।

ব্যাখ্যা

এখানে সিয়েরপিনস্কি কার্পেটের একটি ASCII উপস্থাপনা :

জেনারেশন 0:

# 

প্রজন্ম 1:

# # # 
#   # 
# # # 

প্রজন্ম 2:

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

এএসসিআইআই সিয়েরপিনস্কি কার্পেটের জেনারেশন এন + 1 গ্রিডের কেন্দ্রীয় উপাদানটি নিখোঁজ থাকা প্রজন্ম এন এর 8 কপি সম্বলিত একটি 3x3 গ্রিড দিয়ে তৈরি।

সুতরাং, কারণ এটি একটি 3x3 গ্রিড ব্যবহার করে সংজ্ঞায়িত হয়েছে এবং প্রতিটি প্রজন্মের প্রস্থ এবং উচ্চতায় 3 গুণ বড় হয়, তাই আমরা বলতে পারি এটির স্কেল ফ্যাক্টর 3।

আমরা সিয়েরপিনস্কি কার্পেটের জন্য বিট প্যাটার্নটি নির্ধারণ করতে পারি 3x3 গ্রিডে 0 থেকে 8 অবধি উপাদানগুলি শীর্ষে, নীচে থেকে নীচে, বাম থেকে ডানে, এবং প্রজন্মের এন + 1 এ যদি একটি পূর্ণসংখ্যার সংযুক্ত বিট সেট করে থাকে সেই গ্রিড পজিশনে প্রজন্মের এন এর অনুলিপি:

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

২ এর স্কেল ফ্যাক্টরের জন্য, বিট প্যাটার্নটি এভাবে সাজানো হবে:

0 1
2 3

ইত্যাদি।

আপনার কাজটি হ'ল এমন একটি প্রোগ্রাম লিখুন যা এই ফর্মটিতে কিছুটা প্যাটার্ন গ্রহণ করে, একটি স্কেল ফ্যাক্টর (যেমন সিয়েরপিনস্কি কার্পেটের জন্য 3) এবং একটি জেনারেশন নম্বর এবং একটি এএসসিআইআই ফ্র্যাক্টালকে আউটপুট দেয়।

ইনপুট

আপনার প্রোগ্রামটি নিম্নলিখিত ক্রমে 3 টি পূর্ণসংখ্যা গ্রহণ করবে: কিছুটা প্যাটার্ন, একটি স্কেল ফ্যাক্টর (2 থেকে 5 এর মধ্যে অন্তর্ভুক্ত) এবং একটি প্রজন্মের গণনা (0 থেকে 5 অবধি অন্তর্ভুক্ত)।

আপনাকে এই মানগুলিতে কোনও ইনপুট বৈধতা দেওয়ার দরকার নেই এবং যদি প্রোগ্রামটি নির্দিষ্ট রেঞ্জের চেয়ে বড় মানের জন্য কাজ করে তবে তা পুরোপুরি ঠিক আছে।

ইনপুটগুলি যে কোনও ফর্মে পাস করা যেতে পারে (টিপলস, কমা / স্থান-পৃথক তালিকা ইত্যাদি)

আউটপুট

প্রোগ্রামটি #অক্ষরের একটি ফ্র্যাক্টাল আউটপুট তৈরি করতে পারে তারপরে এমন একটি স্থান যেখানে ফ্র্যাক্টাল সংজ্ঞায়িত করা হয়, ডাবল-স্পেস যেখানে এটি নেই এবং প্রতিটি লাইনের শেষে একটি নিউলাইন অক্ষর হয় সেগুলি প্রিন্ট করে বা স্ট্রিং ফিরিয়ে দেয় একটি ফাংশন থেকে

উদাহরণ

ইনপুট:

495,3,3

আউটপুট (সিয়েরপিনস্কি কার্পেট উত্পাদন 3):

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

ইনপুট:

7,2,5

আউটপুট ( Sierpinski ট্রায়াঙ্গেল ):

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

ইনপুট:

325,3,3

আউটপুট ( ক্যান্টোর ডাস্ট ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

ইনপুট

186,3,3

আউটপুট ( ভিসেক ফ্র্যাক্টাল ):

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

ইনপুট:

279,3,3

আউটপুট (একটি অসামান্য ফ্র্যাক্টাল উদাহরণ):

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

প্রভৃতি

নোট:

• এটি কোড-গল্ফ তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর
• আপনার প্রোগ্রামটি একা একা বা এমন কোনও ফাংশন হতে পারে যা 3 ইনপুট পরামিতি এবং একটি স্ট্রিং (বা মুদ্রণ) দিয়ে ডাকা হয়
• জেনারেশন 0 হিসাবে সংজ্ঞায়িত করা হয় #(এ# বিট প্যাটার্নের জন্যও একটি স্থান দ্বারা অনুসরণ করা) ।
• শেষ লাইনে একটি ট্রেলিং করা নিউলাইন optionচ্ছিক তবে অনুমোদিত, প্রতিটি লাইনে সাদা-স্পেসের পরিমাণের পরিমাণ।

Comments

+1 টি, আমি স্যান্ডবক্সের মধ্যে এটি পছন্দ করেছেন এবং আমি তা এখানে পছন্দ করি, চিহ্ন থেকে পরিবর্তিত "##"করা "# "। আমি দেখতে পাচ্ছি লাইনের শেষে থাকা একটি স্থানের স্থানটি আপনার উদাহরণগুলিতে অন্তর্ভুক্ত রয়েছে, এটি কি প্রয়োজনীয়? । সর্বশেষ বিধি অনুসারে আমি এটি alচ্ছিকভাবে ধরে নেব, তবে 0 প্রজন্মের জন্য আপনার পিছনে স্থানের প্রয়োজনের বিষয়টি আমাকে বিস্মিত করে। এছাড়াও আমি মনে করি আপনার সর্বাধিক শ্বেতস্পেস এবং নিউলাইনগুলি (আপনার এটি বহুবচন রয়েছে) নির্দেশিত হওয়া উচিত। চূড়ান্ত উদাহরণ হিসাবে আমি সর্বদা 2 * 5 space 6 স্পেসের 5 ^ 6 = 15625 লাইনের অ্যারে দিয়ে শুরু করতে পারি তারপরে এর বিকল্পগুলি রাখি #। বেশিরভাগ ইনপুট ক্ষেত্রে এটি অপ্রত্যাশিত শ্বেতক্ষেত্রের একটি বিশাল পরিমাণ

— স্তর নদী সেন্ট

@ স্টিভেরিলিল প্রজন্ম ০ আউটপুট করার সময় আমার পিছনে স্থানের প্রয়োজন নেই , তবে চলমান স্থানটি তার সংজ্ঞাটির অংশ, যা পরবর্তী প্রজন্মের অনুসারে সংজ্ঞায়িত হয়। নিউলাইনগুলির বহুবচনটি একটি টাইপো ছিল, স্থির ছিল।

— সামগাক

আপনি কি কম সিমিত্রিকের মতো প্রত্যাশিত আউটপুট পোস্ট করতে পারেন 279,3,3?

— aditsu

@ অদিতসু নিশ্চিত, সম্পাদিত প্রশ্ন দেখুন

— সামগাক

Answer 1

এপিএল (ডায়ালগ ইউনিকোড) , 37 বাইট ^{এসবিসিএস}

'# '{⊃⍪/,/⍺\⍤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

এটি অনলাইন চেষ্টা করুন!

Answer 2

সাধারণ লিপ, 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))))

ব্যাখ্যা

• ইনপুট:
  • এন হ'ল এনকোডেড প্যাটার্ন
  • আর প্যাটার্নের আকার
  • জি প্রজন্ম
• আউটপুটটি দৈর্ঘ্যের এস = আর ^জি এর একটি অন্তর্ভুক্ত বর্গ ম্যাট্রিক্স
• আমরা প্রতিটি সারিতে y , কলাম x এর উপরে পুনরাবৃত্তি করব (নেস্টেড dotimes) এবং প্রতিটি ঘর আঁকা উচিত কিনা তা গণনা করি (রাইকাস্টিং-এর মতো পদ্ধতির)। এটি fঅক্জিলিয়ারী ক্রিয়াকলাপের সাথে ফ্র্যাক্টালের ভিতরে পুনরাবৃত্তভাবে অনুসন্ধান করে করা হয় ।
• যদি ফ্র্যাক্টাল পজিশনে থাকে (x, y) আঁকতে হবে, মুদ্রণ করুন "# "বা অন্যটি মুদ্রণ করুন" " । অবশ্যই আমরা প্রতিটি সারির শেষে নিউলাইনগুলি মুদ্রণ করি।

উদাহরণস্বরূপ, সিয়েরপিনস্কির ত্রিভুজটি প্রতিনিধিত্ব করেছেন S=7এবং দ্বারা R=2। প্রজন্ম 3 এ বর্গাকার আকার 2 ³ = 8 হয়। প্রতিটি কক্ষের জন্য (x, y) , নিম্নলিখিতটি ঘটে:

• fসঙ্গে বলা হয় এক্স , Y , G থেকে 3 আবদ্ধ এবং র 4 আবদ্ধ (8/2)
• আমরা আরোপ এক্স দ্বারা গুলি , যাতে জানতে তাহলে এক্স অন্তর্নিহিত ম্যাট্রিক্স বাম বা ডান দিকে জন্যে। truncateভাগফল এবং বাকী উভয়ই প্রদান করে, যা যথাক্রমে px এবং x এর সাথে আবদ্ধ হয় (আমরা একই প্রতীক x পুনরায় ব্যবহার করি , তবে এটি কোনও সমস্যা নয়)।
• একই y এর জন্য যায় যা পাই এবং নতুন y দেয় ।
• এই উদাহরণে, px এবং py হয় 0 বা 1 হতে পারে (কারণ প্যাটার্নটি 2 দৈর্ঘ্যের বর্গ)। তারা চিহ্নিত কোথায় (X, Y) ফ্র্যাক্টাল এর প্যাটার্ন: অবস্থানে বিট যখন py.R + + px আকারে এর এন হয় 0, এক্স এবং ওয়াই একটি অবস্থান যেখানে কিছুই আকৃষ্ট করা উচিত প্রতিনিধিত্ব করে।
• অন্যথায়, আমরা ফ্র্যাক্টাল সংশ্লিষ্ট অংশে "জুম" এবং আমরা কল fজন্য নতুন বাইন্ডিং সঙ্গে যাও recursively এক্স এবং ওয়াই । এগুলি এখন অভ্যন্তরীণ ফ্র্যাক্টালের অভ্যন্তরে আপেক্ষিক অবস্থান। আমরা প্রজন্মের জন্য জি -1 এবং এস / 2 পাস করি ফ্র্যাক্টালের অর্ধ-দৈর্ঘ্যের প্রতিনিধিত্ব করতে ।
• জি শূন্য হলে পুনরাবৃত্তির বেস কেসটি সম্মুখীন হয়, সেক্ষেত্রে বর্তমান (x, y) অবস্থানটি আঁকতে হবে।

উদাহরণ

(fractal 186 3 3)

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

সিয়েরপিনস্কি কার্পেটের ব্যবহার করে অষ্টম প্রজন্মের গণনা করতে (fractal 495 3 8)24.7 সেকেন্ড সময় লাগে এবং 83 মেগাবাইটের একটি আউটপুট পাঠ্য ফাইল উত্পন্ন করে। আমি কিছুটা সংশোধিত সংস্করণ লিখেছিলাম যা একটি চিত্রকে আউটপুট করে। একই পরামিতিগুলির জন্য, জিআইএফ ফাইলের ওজন 1.5MB (একই গণনার সময়):

ভিসেক (মূল আকার দেখতে ক্লিক করুন):

Comments

মারাত্মক ভার্ভোজ ভাষায় সংক্ষিপ্ত প্রোগ্রামের মতো দেখতে +1। একসাথে 8 বাসা )!

— স্তর নদী সেন্ট

@ স্টিভেভারিল আমি কোড গল্ফগুলি কখনই জিততে পারি না ... তবে তবুও, আমি মনে করি সিনট্যাক্সটি বৃহত্তর প্রোগ্রামগুলির জন্য অর্থ প্রদান করে। এবং সত্যই, আমি প্রায় প্রথম বন্ধনী দেখতে পাচ্ছি না, কেবল একটি দুর্দান্ত গাছ।

— coredump

সেই জিআইএফ চিত্রটি আসলে আমার ফোনের ওয়েব ব্রাউজারটিকে ক্র্যাশ করেছে ... আরও অস্বাভাবিক ভাষার সাথে দুর্দান্ত গল্ফ করছে

— গ্লেন স্মিথ

@ হাইগুই ধন্যবাদ অন্যান্য লোকের ব্রাউজার ক্রাশ করার জন্য কোডগল্ফের কি ব্যাজ রয়েছে? এটি হওয়া উচিত :-)

— coredump

Answer 3

পাইথ, 38 বাইট

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

এটি অনলাইনে ব্যবহার করে দেখুন: নিয়মিত ইনপুট / টেস্ট স্যুট

ব্যাখ্যা পরে অনুসরণ।

Comments

1+ আমি এখনও 186 3 5(অনলাইন দোভাষী) এর আউটপুটটির জন্য অপেক্ষা করছি , তবে এগুলি বাদে আমি সত্যিই এটি কত সংক্ষিপ্ত তা দ্বারা মুগ্ধ।

— coredump

@ কর্ড্প্প আমি মনে করি না আপনি অনলাইন দোভাষী ব্যবহার করে এত বড় আউটপুট পাবেন। আপনি যদি এটি পরীক্ষা করতে চান তবে আপনাকে পাইথ সংকলকটি ডাউনলোড করতে হবে । এটি আমার ল্যাপটপে প্রায় 10 সেকেন্ড সময় নেয়।

— জাকুব

Answer 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)

আউটপুট

জিওএলএফ শব্দের অক্ষরের ফর্মের ভিত্তিতে আলগাভাবে ফ্র্যাক্টালগুলির একটি সেট loose বৃহত্তর বিটম্যাপের সাহায্যে আরও বাস্তববাদী বর্ণগুলি অর্জন করা যেতে পারে। শেষ উদাহরণটি দেখায় যে, সবচেয়ে আকর্ষণীয় ফ্র্যাক্টালগুলি দুর্ঘটনার দ্বারা আবিষ্কার করা হয়েছিল।

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)

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

Answer 5

সিজেম, 45

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

আমার প্রথম ধারণা বাস্তবায়ন। এটি অনলাইনে চেষ্টা করুন

মূলত, এটি 1 * 1 ম্যাট্রিক্স দিয়ে 3 ('#' এবং '' এর মধ্যে পার্থক্য) দিয়ে শুরু হয়, তারপরে ম্যাট্রিক্সের প্রতিটি সংখ্যাকে বারবার বিট প্যাটার্ন (0/1 ম্যাট্রিক্স) দিয়ে গুণিত করে এবং ফলাফলটি ম্যাট্রিকগুলিকে একটিতে সংযুক্ত করে বড় ম্যাট্রিক্স। শেষে, এটি প্রতিটি সংখ্যায় একটি স্থান যুক্ত করে এবং স্পেস এবং নিউলাইনগুলির সাথে যোগ দেয়।

দ্বিতীয় ধারণা, 49

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

এটি অনলাইনে চেষ্টা করুন

এটি স্কেল ফ্যাক্টর (এই জাতীয় সমস্ত সংমিশ্রণ) এর চেয়ে ছোট সংখ্যার জোড় <জেনার গণনা> এর অ্যারে হিসাবে আউটপুট ম্যাট্রিক্সের সমস্ত স্থানাঙ্ক উত্পন্ন করে, তবে প্রতিটি জোড় সংখ্যার জন্য এটি প্যাটার্ন থেকে সংশ্লিষ্ট বিট পায় এবং প্রতিটি সমন্বিত অ্যারের জন্য এটি বিটগুলি এবং 3 দিয়ে গুণ করে The চূড়ান্ত প্রক্রিয়াজাতকরণটি একই।

আরও গল্ফ করার জন্য সম্ভবত জায়গা আছে।

Answer 6

সি, 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;
}

Comments

স্পেকের শেষে বুলেট পয়েন্ট অনুসারে একটি প্রোগ্রামের পরিবর্তে একটি ফাংশন অনুমোদিত হয়। এটি একটি ফাংশনে পরিবর্তন করুন এবং কেবলমাত্র এতে তিনটি ইনপুট প্যারামিটারগুলি পাস করুন - এটি এতই সমস্ত জিনিস থেকে মুক্তি পাবে এবং আপনাকে প্রায় 40 বাইট সংরক্ষণ করবে।

— স্তর নদী সেন্ট

Answer 7

স্কালা 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))
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
                    #       #                     
                      #   #                       
                        #                         
                      #   #                       
                    #       #                     
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 

প্রথম কাটা, সম্ভবত কিছুটা আরও গল্ফ করা যেতে পারে ...

Comments

আপনি নিজের প্রতিটির মধ্যে একটি জায়গা মিস করছেন #। অনুমান দ্বারা প্রয়োজনীয় হওয়া ছাড়াও এটি আপনার আউটপুটটির উপস্থিতিটি বাড়িয়ে তোলে।

— শ্রেনী নদী সেন্ট

পছন্দ করুন আমি প্রথমে তা লক্ষ করিনি। আমি দ্রুত সমাধান সহ সম্পাদনা করেছি। ধন্যবাদ :)

— গিলাদ হচ

Answer 8

মতলব, ১১৮ বাইট

ক্রোনেকার 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,''])

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

Comments

যদিও de2biআপনার যদি যোগাযোগ সিস্টেমস টুলবক্স থাকে কেবল তখনই কাজ করে। এটি ছাড়া কাজ করে না। এটি প্রয়োজন হবে dec2bin।

— টম কার্পেন্টার

দেখে মনে হচ্ছে এই সরঞ্জামদ্বারটি আমার স্ট্যান্ডার্ড ছাত্র সংস্করণে অন্তর্ভুক্ত রয়েছে, তাই আমি মনে করি এটি গ্রহণযোগ্য। (দ্রষ্টব্য যা এর মতো de2biহয় না dec2bin))

— flawr

Answer 9

সি, 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");}}

Answer 10

কে 5, 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
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))