ภาพรวม

เขียนโปรแกรมที่พิมพ์รูปแบบแฟร็กทัลแบบง่ายโดยให้บิตเป็นรูปแบบการเข้ารหัสแฟร็กทัลรวมถึงตัวประกอบสเกลต่อรุ่นของเศษส่วนและจำนวนรุ่น

คำอธิบาย

นี่คือตัวแทน ASCII ของSierpinski Carpet :

รุ่น 0:

# 

รุ่นที่ 1:

# # # 
#   # 
# # # 

รุ่นที่ 2:

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

การสร้าง n + 1 ของพรม ASCII Sierpinski ประกอบด้วยตาราง 3x3 ที่ประกอบด้วย 8 รุ่นของสำเนา n โดยที่องค์ประกอบกลางของตารางหายไป

ดังนั้นเนื่องจากมันถูกกำหนดโดยใช้กริด 3x3 และเพิ่มความกว้างและความสูงให้ใหญ่ขึ้น 3 เท่าในแต่ละรุ่นเราสามารถพูดได้ว่ามันมีสเกลแฟกเตอร์ที่ 3

เราสามารถกำหนดรูปแบบบิตสำหรับพรม Sierpinski โดยกำหนดหมายเลของค์ประกอบในตาราง 3x3 จาก 0 ถึง 8, จากบนลงล่าง, จากซ้ายไปขวา, และตั้งค่าบิตที่สอดคล้องกันของจำนวนเต็มถ้า generation n + 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

สำหรับสเกลแฟคเตอร์ที่ 2 รูปแบบบิตจะถูกจัดเรียงดังนี้:

0 1
2 3

และอื่น ๆ

งานของคุณคือการเขียนโปรแกรมที่ยอมรับรูปแบบบิตในรูปแบบนี้ปัจจัยขนาด (เช่น 3 สำหรับพรม Sierpinski) และหมายเลขรุ่นและส่งออกเศษส่วน ASCII

อินพุต

โปรแกรมของคุณควรยอมรับจำนวนเต็ม 3 จำนวนตามลำดับต่อไปนี้: รูปแบบบิต, ตัวคูณสเกล (ตั้งแต่ 2 ถึง 5, รวม) และจำนวนการสร้าง (ตั้งแต่ 0 ถึง 5, รวม)

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

อินพุตสามารถส่งผ่านในรูปแบบใดก็ได้ (tuples, รายการจุลภาค / เว้นวรรค, ฯลฯ )

เอาท์พุต

โปรแกรมควรส่งออกเศษส่วนที่ประกอบด้วย#อักขระตามด้วยช่องว่างในตำแหน่งที่กำหนดเศษส่วนสองช่องว่างที่ไม่อยู่และอักขระขึ้นบรรทัดใหม่ที่ท้ายบรรทัดแต่ละบรรทัดไม่ว่าจะพิมพ์ออกหรือคืนสตริง จากฟังก์ชั่น

ตัวอย่าง

การป้อนข้อมูล:

495,3,3

เอาท์พุท (Sierpinski Carpet generation 3):

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

การป้อนข้อมูล:

7,2,5

เอาท์พุท ( สามเหลี่ยม Sierpinski ):

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

การป้อนข้อมูล:

325,3,3

เอาท์พุท ( ฝุ่นคันทอร์ ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

อินพุต

186,3,3

เอาท์พุท ( เศษส่วน Vicsek ):

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

การป้อนข้อมูล:

279,3,3

เอาท์พุท (ตัวอย่างของเศษส่วนอสมมาตร):

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

เป็นต้น

หมายเหตุ:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
• โปรแกรมของคุณสามารถเป็นแบบสแตนด์อโลนหรือฟังก์ชั่นที่ถูกเรียกด้วยพารามิเตอร์อินพุต 3 ตัวและส่งคืน (หรือพิมพ์) สตริง
• Generation 0 ถูกกำหนดเป็น#( #ตามด้วยช่องว่าง) แม้กระทั่งสำหรับรูปแบบบิตที่ 0
• การขึ้นบรรทัดใหม่ของบรรทัดสุดท้ายเป็นทางเลือก แต่อนุญาตให้ใช้ซึ่งเท่ากับจำนวนช่องว่างสีขาวต่อท้ายในแต่ละบรรทัด

APL (Dyalog Unicode) , 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

ลองออนไลน์!

เสียงกระเพื่อมสามัญ 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))))

คำอธิบาย

• การป้อนข้อมูล:
  • Nคือรูปแบบการเข้ารหัส
  • Rคือขนาดของลวดลาย
  • Gคือยุค
• เอาต์พุตเป็นเมทริกซ์จตุรัสโดยนัยของความยาวS = R ^G
• เราวนซ้ำแต่ละแถวy , คอลัมน์x (ซ้อนกันdotimes) และคำนวณว่าควรดึงแต่ละเซลล์หรือไม่ ทำได้โดยการมองเข้าไปในเศษส่วนซ้ำด้วยfฟังก์ชั่นเสริม
• หากเศษส่วนที่ตำแหน่ง(x, y)จะได้รับการวาดพิมพ์"# "หรืออื่น ๆ " "การพิมพ์ แน่นอนว่าเรายังพิมพ์บรรทัดใหม่ขึ้นที่ส่วนท้ายของแต่ละแถว

ยกตัวอย่างเช่นสามเหลี่ยม Sierpinsky ถูกแทนด้วยและS=7 R=2ที่รุ่น 3 ขนาดสี่เหลี่ยมจัตุรัสคือ 2 ³ = 8 สำหรับแต่ละเซลล์(x, y)จะเกิดสิ่งต่อไปนี้:

• fถูกเรียกด้วยx , y , gถึง 3 และsถูกผูกไว้กับ 4 (8/2)
• เราตัดทอนxด้วยsเพื่อให้ทราบว่าxเป็นของด้านซ้ายหรือด้านขวาของเมทริกซ์โดยนัย truncateส่งกลับทั้งผลหารและส่วนที่เหลือซึ่งถูกผูกไว้ตามลำดับเพื่อpxและx (เรานำสัญลักษณ์เดียวกันxกลับมาใช้ใหม่แต่นี่ไม่ใช่ปัญหา)
• เดียวกันจะไปสำหรับปีซึ่งจะช่วยให้PYและใหม่Y
• ในตัวอย่างนี้pxและpyสามารถเป็น 0 หรือ 1 ได้ (เนื่องจากรูปแบบเป็นสี่เหลี่ยมจัตุรัสยาว 2) พวกเขาระบุตำแหน่งที่อยู่(x, y)ในรูปแบบเศษส่วน: เมื่อบิตที่ตำแหน่งpy.R + pxของNคือ 0, xและyแสดงถึงตำแหน่งที่ไม่ควรวาดอะไร
• มิฉะนั้นเราจะต้อง "ซูม" ในส่วนที่เกี่ยวข้องของเศษส่วนและเราเรียกfซ้ำกับการผูกใหม่สำหรับXและY สิ่งเหล่านี้คือตำแหน่งสัมพัทธ์ภายในเศษส่วนด้านใน เราผ่านG-1สำหรับรุ่นและs / 2เพื่อเป็นตัวแทนของความยาวครึ่งหนึ่งของเศษส่วน
• กรณีพื้นฐานของการเรียกซ้ำเกิดขึ้นเมื่อGเป็นศูนย์ซึ่งในกรณีนี้ตำแหน่งปัจจุบัน(x, y)ควรถูกวาด

ตัวอย่าง

(fractal 186 3 3)

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

การคำนวณ Sierpinski Carpet รุ่นที่ 8 ใช้(fractal 495 3 8)เวลา 24.7 วินาทีและสร้างไฟล์ข้อความเอาต์พุต 83 MB ฉันเขียนเวอร์ชันที่ปรับเปลี่ยนเล็กน้อยซึ่งส่งภาพออกมา สำหรับพารามิเตอร์เดียวกันไฟล์ GIF น้ำหนัก 1.5MB (เวลาการคำนวณเดียวกัน):

Vicsek (คลิกเพื่อดูขนาดเดิม):

Pyth, 38 ไบต์

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

ลองใช้ออนไลน์: อินพุตปกติ / ชุดทดสอบ

คำอธิบายติดตามในภายหลัง

ทับทิม 154

คะแนนสำหรับฟังก์ชั่นเท่านั้น นำเสนอ ungolfed ด้านล่างในโปรแกรมทดสอบ การเล่นกอล์ฟเดียวที่ฉันอ้างในขณะนี้คือการลบความคิดเห็นและการเยื้อง ฉันจะตีกอล์ฟทีหลัง ตอนนี้ฉันสนุกกับการเล่นรายการ

ฟังก์ชั่นใช้เวลาหกข้อโต้แย้ง แต่ในการโทรเริ่มต้นเพียง 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)

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

CJam, 45

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

การดำเนินการตามความคิดแรกของฉัน ลองออนไลน์

โดยพื้นฐานแล้วมันจะเริ่มต้นด้วยเมทริกซ์ 1 * 1 ที่มี 3 (ความแตกต่างระหว่าง '#' และ '') จากนั้นคูณจำนวนแต่ละจำนวนในเมทริกซ์ด้วยรูปแบบบิต (0/1 เมทริกซ์) ซ้ำ ๆ กันและรวมเมทริกซ์ที่ได้ เมทริกซ์ที่ใหญ่กว่า ในตอนท้ายจะเพิ่มช่องว่างให้กับแต่ละหมายเลขและรวมกับช่องว่างและบรรทัดใหม่

แนวคิดที่ 2, 49

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

ลองออนไลน์

สิ่งนี้สร้างพิกัดทั้งหมดของเมทริกซ์เอาต์พุตเป็นอาร์เรย์ของคู่ <generation count> ตัวเลขที่เล็กกว่าตัวประกอบสเกล (รวมกันทั้งหมด) จากนั้นสำหรับแต่ละคู่ของตัวเลขจะได้รับบิตที่สอดคล้องกันจากรูปแบบและสำหรับอาร์เรย์พิกัดแต่ละชุด มันคูณบิตและคูณด้วย 3 การประมวลผลสุดท้ายเหมือนกัน

อาจมีห้องสำหรับเล่นกอล์ฟมากขึ้น

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

ยกเลิกแข็งแรงเล่นกอล์ฟ:

#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;
}

สกาลา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))
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
                    #       #                     
                      #   #                       
                        #                         
                      #   #                       
                    #       #                     
          #       #           #       #           
            #   #               #   #             
              #                   #               
            #   #               #   #             
          #       #           #       #           
#       #                               #       # 
  #   #                                   #   #   
    #                                       #     
  #   #                                   #   #   
#       #                               #       # 

ตัดครั้งแรกอาจจะ golfed อีกเล็กน้อย ...

Matlab, 115 ไบต์

kronผลิตภัณฑ์Kronecker ทำให้ทุกอย่างง่ายขึ้นมาก:

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,''])

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

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

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