ASCII'de bit desenlerinden fraktallar üret


34

genel bakış

Fraktal kodlayan bir bit desen verilen artı basit fraktal kalıpları, artı fraktalın nesil başına ölçek faktörü ve kuşak sayısı yazdıran bir program yazın.

açıklama

İşte Sierpinski Halı'nın ASCII temsili :

Nesil 0:

# 

1. nesil:

# # # 
#   # 
# # # 

2. nesil:

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

ASCII Sierpinski Carpet'in n + 1 no'lu jenerasyonu, 8 no'lu n neslini içeren 3x3'lük bir ızgaradan oluşur;

Bu nedenle, 3x3 ızgarası kullanılarak tanımlandığından ve her nesildeki genişlik ve yükseklikten 3 kat daha büyük hale geldiğinden, 3'lük bir ölçek faktörüne sahip olduğunu söyleyebiliriz.

3x3 ızgarasındaki elemanları 0 - 8 arasında, yukarıdan aşağıya, soldan sağa doğru numaralandırarak ve eğer n + 1 nesli varsa bu grid konumundaki n neslinin kopyası:

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 ölçek faktörü için, bit deseni şöyle düzenlenir:

0 1
2 3

ve bunun gibi.

Göreviniz, bu formda bit deseni kabul eden bir program, ölçek faktörü (örneğin, Sierpinski Carpet için 3) ve bir üretim numarası yazıp bir ASCII fraktal çıktısı almaktır.

Giriş

Programınız aşağıdaki sırada 3 tam sayı kabul etmelidir: bit deseni, ölçek faktörü (2 ile 5 arasında, dahil) ve bir üretim sayısı (0 ile 5 arasında, dahil).

Bu değerler üzerinde herhangi bir giriş onayı yapmanız gerekmez ve program belirtilen aralıklardan daha büyük değerler için çalışıyorsa mükemmeldir.

Girişler herhangi bir biçimde iletilebilir (tuples, virgül / boşlukla ayrılmış liste, vb.)

Çıktı

Program, #karakterden oluşan bir fraktal ve ardından fraktalın tanımlandığı pozisyonlarda bir boşluk, olmadığı yerde çift boşluklar ve her satırın sonunda ya da dizgiyi döndüren yeni bir satır karakteri çıkarmalıdır. bir fonksiyondan.

Örnekler

Giriş:

495,3,3

Çıktı (Sierpinski Carpet nesil 3):

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

Giriş:

7,2,5

Çıktı ( Sierpinski Üçgeni ):

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

Giriş:

325,3,3

Çıkış ( Cantor Dust ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 

Giriş

186,3,3

Çıktı ( Vicsek fraktal ):

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

Giriş:

279,3,3

Çıktı (asimetrik fraktal örneği):

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

vb.

Notlar:

  • Bu yani bayt cinsinden en kısa cevap kazanır
  • Programınız tek başına veya 3 giriş parametresiyle çağrılan ve bir dize döndüren (veya yazdırır) bir işlev olabilir
  • Jenerasyon 0, 0 bitlik bir model için bile #(bir #boşluk tarafından takip edilir) olarak tanımlanır .
  • Son satırdaki takip eden bir yeni satır isteğe bağlıdır ancak her satırdaki sondaki beyaz boşluk miktarında olduğu gibi izin verilir.

3
1, ben sanal alanda bunu beğendi ve sembol olarak değiştirildi ile ben, daha burayı seviyorum "##"etmek "# ". Satır sonundaki bir boşlukun örneklerinde yer aldığını görüyorum, gerekli mi? . Son kurala göre, isteğe bağlı olduğunu varsaymak isterim, ancak 0 kuşak için son derece boş bir alana ihtiyaç duymanız beni meraklandırıyor. Ayrıca izin verilen maksimum boşluk ve newlines (çoğul var) belirtmeniz gerektiğini düşünüyorum. Aşırı bir örnek olarak, her zaman 5 ^ 6 = 15625 satır 2 * 5 ^ 6 boşluktan oluşan bir diziyle başlayabilir, ardından #s'yi kullanabilirsiniz. Çoğu girdi vakasında, çok fazla kullanılmayan beyaz boşluk var
Level River St

zaman @steveverrill I sonunda boşluk gerektirmeyen çıkış oluşturma 0 ancak sonunda boşluk sonraki kuşaklar açısından tanımlandığı gibidir, tanımı bir parçasıdır. Birden fazla satırsonu yazım hatası oldu, düzeltildi.
Samgak

Beklenen çıktıyı daha az simetrik bir şey için gönderir misiniz, örneğin 279,3,3?
aditsu 10:15

@aditsu emin, düzenlenmiş soruya bakın
samgak

Yanıtlar:


4

APL (Dyalog Unicode) , 37 bayt SBCS

'# '{⊃⍪/,/⍺\⍤1⊂⍉⍪⍉⍵}⍣⎕⍨(2⍴⎕)⍴⌽⎕⊤⍨992
                                      input the bit pattern
                               ⊤⍨992  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

Çevrimiçi deneyin!


11

Ortak Lisp, 248 242 bayt

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

açıklama

  • Giriş:
    • N , kodlanmış kalıptır
    • R , desenin boyutudur
    • G nesildir
  • Çıktı S = R G uzunluğunda bir kare kare matristir
  • Her satırın y , x sütunu (iç içe geçmiş dotimes) üzerinde yinelenir ve her hücrenin çizilip çizilmeyeceğini hesaplarız (raycasting benzeri yaklaşım). Bu fraktal içine fyardımcı fonksiyon ile tekrar tekrar bakılarak yapılır .
  • Fraktal (x, y) konumunda çizilirse, yazdırın "# "veya başka bir şekilde yazdırın " ". Tabii ki her satırın sonunda yeni satırlar da basıyoruz.

Örneğin, Sierpinski üçgeni ile temsil edilir S=7ve R=2. 3. nesilde kare büyüklüğü 2 3 = 8'dir. Her hücre için (x, y) , aşağıdakiler gerçekleşir:

  • fçağrılır x , y , g 3 bağlı ve s (8/2), 4 bağlanan
  • Biz trankulatı x tarafından s , eğer bilmek için x örtülü matrisin sol veya sağ tarafına aittir. truncatesırasıyla px ve x'e bağlı olan hem bölümü hem de kalanı döndürür (aynı sembol x'i tekrar kullanırız , ancak bu bir problem değildir).
  • Aynı şey y verir py ve yeni y .
  • Bu örnekte, px ve py 0 veya 1 olabilir (çünkü model bir uzunluk 2 karedir). Bunlar burada tespit (x, y) fraktal desen: konum bit zaman py.R + px arasında N 0 olduğu X ve Y hiçbir çizilmesi gereken bir konumunu temsil eder.
  • Aksi takdirde, fraktalın karşılık gelen kısmını "yakınlaştırmalı" ve ftekrar tekrar x ve y için yeni bağlamalar ile çağırıyoruz . Bunlar şimdi iç fraktal içindeki göreceli konumdur. Jenerasyonun G- 1'ini ve f / f'nin yarı uzunluğunu temsil etmek için s / 2'yi geçtik .
  • Özyinelemenin temel durumu G sıfır olduğunda karşılaşılır , bu durumda geçerli (x, y) konumu çizilmelidir.

Örnek

(fractal 186 3 3)

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

Sierpinski Carpet'in 8. neslinin kullanılmasının hesaplanması (fractal 495 3 8)24.7 saniye sürüyor ve 83 MB çıktı metin dosyası üretiyor. Resim çıktısı olan biraz değiştirilmiş bir versiyon yazdım. Aynı parametreler için GIF dosyası 1,5 MB'dir (aynı hesaplama süresi):

Sierpinsky's Halı, 8. nesil

Vicsek (orjinal boyutunu görmek için tıklayın):

Vicsek fraktal


1
Korkunç derecede ayrıntılı bir dilde özlü bir programa benzeyen şey için +1. 8 )üst üste iç içe !
Level River St

@ steveverrill Asla kod golf kazanamadım ... ama yine de, sözdiziminin daha büyük programlar için para ödediğini düşünüyorum. Ve dürüst olmak gerekirse, artık parantez göremiyorum, sadece hoş bir ağaç.
coredump

Bu gif görüntüsü telefonumun web tarayıcısını gerçekten etkiliyor ... Daha alışılmadık bir dilde golf
Glenn Smith

@HiGuy Teşekkürler. CodeGolf'un başkalarının tarayıcısını çökertmesi için bir rozeti var mı? Olması gereken :-)
coredump

5

Pyth, 38 bayt

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

Çevrimiçi deneyin: Normal Giriş / Test Paketi

Açıklama daha sonra takip eder.


1+ Hala 186 3 5(çevrimiçi tercüman) çıktısını bekliyorum , ancak bunun dışında bunun ne kadar kısa olduğundan gerçekten etkilendim.
coredump

1
@coredump Online tercümanı kullanarak çok büyük bir çıktı elde edeceğinizi sanmıyorum. Test etmek istiyorsanız, Pyth derleyicisini indirmeniz gerekir . Dizüstü bilgisayarımda yaklaşık 10 saniye sürüyor.
Jakube,

4

Yakut, 154

Puan sadece fonksiyon içindir. Test programında aşağıda ungolfed sundu. Şu anda iddia ettiğim tek golf yorumların ve girintilerin kaldırılması. Sonra golf oynarım. Şu anda, programla oynarken eğleniyorum.

İşlev altı argüman alır, ancak ilk aramada her özellik için yalnızca ilk 3 sağlanır. Bu, kalan üç argümanın varsayılan değerlere ayarlanmasına neden olur ve özellikle açıktının depolandığı dize , yeni satırlarla sonlandırılan boşluk satırlarına oluşturulur ve başlatılır. Bir yan etki olarak, küresel değişken $wde yaratılır ve bu da satır başına sembol sayısını gösterir.

İşlev özyinelemeli olarak çağırdığında, sonraki özyinelimin asol üst köşesinin dizesi ve x ve y koordinatları dahil olmak üzere altı argümanın tümünü sağlar.

Programın geri kalanı, yorumlarda belirtildiği gibi oldukça kolaydır.

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

Çıktı

İşte GOLF kelimesinin harflerinin şeklini temel alan gevşek bir dizi fraktal. Daha büyük bitmapler ile daha gerçekçi harfler elde edilebilir. Son örnekte gösterildiği gibi, en ilginç fraktallar kazayla keşfedilir.

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*

İlk fikrimin uygulanması. Çevrimiçi deneyin

Temel olarak, 3 içeren bir 1 * 1 matrisle başlar ('#' ve '' arasındaki fark), daha sonra matristeki her sayıyı bit deseni (0/1 matris) ile art arda çarpar ve elde edilen matrisleri bir taneye birleştirir daha büyük matris. Sonunda her sayıya bir boşluk ekler ve boşluklarla ve yeni satırlarla birleşir.

2. fikir, 49

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

Çevrimiçi deneyin

Bu, çıktı matrisinin tüm koordinatlarını, ölçek faktöründen daha küçük sayıların çiftleri dizileri (tüm bu tür kombinasyonlar) dizileri olarak oluşturur, daha sonra her sayı çifti için, desenden karşılık gelen bit ve her koordinat dizisi için bitleri çarpar ve 3 ile çarpar. Son işlem aynıdır.

Daha fazla golf oynamak için muhtemelen yer var.


2

C, 316 bayt

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

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

3
Spesifikasyonun sonundaki mermi noktalarına göre, program yerine bir fonksiyona izin verilir. Bir işleve değiştirin ve sadece üç giriş parametresini iletin - bu tüm atoi işlerinden kurtulacak ve yaklaşık 40 bayttan tasarruf sağlayacaktır.
Level River St

2

Scala 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")
}

örnekler:

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

ilk kesim, muhtemelen biraz daha golf oynayabilir ...


Her birinin arasında bir boşluk eksik #. Spesifikasyonun gerektirdiği yanı sıra, çıktınızın görünümünü de gerçekten arttırır.
Seviye Nehri St

@steveverrill sizin hakkınız. Bunu ilk başta fark etmedim. Hızlı bir düzeltme ile düzenleme yaptım. teşekkürler :)
gilad hoch,

2

Matlab, 115 bayt

Kronecker kronürünü her şeyi çok daha kolaylaştırıyor:

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

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

Ancak de2bi, Communications Systems Toolbox'ınız varsa çalışır. Onsuz çalışmıyor. Gerekirdi dec2bin.
Tom Carpenter,

Görünüşe göre bu araç kutusu standart öğrenci sürümüme dahil edilmiş, bu yüzden kabul edilebilir. ( de2biAynı olmadığını unutmayın dec2bin.)
kusur

2

C, 158 bayt

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

1

K5, 70 bayt

Bu bir başlangıç:

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

Eylemde:

{,/'("  ";"# ")$[z;(z-1){,/'+,/'+x@y}[(0*t;t)]/t:(2#y)#|(25#2)\x;,,1]}[186;3]'!4
(,"# "
 ("  #   "
  "# # # "
  "  #   ")
 ("        #         "
  "      # # #       "
  "        #         "
  "  #     #     #   "
  "# # # # # # # # # "
  "  #     #     #   "
  "        #         "
  "      # # #       "
  "        #         ")
 ("                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "  #     #     #     #     #     #     #     #     #   "
  "# # # # # # # # # # # # # # # # # # # # # # # # # # # "
  "  #     #     #     #     #     #     #     #     #   "
  "        #                 #                 #         "
  "      # # #             # # #             # # #       "
  "        #                 #                 #         "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "
  "                    #     #     #                     "
  "                  # # # # # # # # #                   "
  "                    #     #     #                     "
  "                          #                           "
  "                        # # #                         "
  "                          #                           "))
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.