Genera fractales a partir de patrones de bits en ASCII

34

Visión general

Escriba un programa que imprima patrones fractales simples dado un patrón de bits que codifica el fractal, más el factor de escala por generación del fractal y el número de generaciones.

Explicación

Aquí hay una representación ASCII de la alfombra Sierpinski :

Generación 0:

#

Generación 1:

# # # 
#   # 
# # #

Generación 2:

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

La generación n + 1 de la alfombra ASCII Sierpinski está compuesta por una cuadrícula de 3x3 que contiene 8 copias de la generación n, con el elemento central de la cuadrícula ausente.

Entonces, debido a que se define usando una cuadrícula de 3x3 y aumenta 3 veces más en ancho y alto cada generación, podemos decir que tiene un factor de escala de 3.

Podríamos definir un patrón de bits para la alfombra Sierpinski numerando los elementos en la cuadrícula de 3x3 de 0 a 8, de arriba a abajo, de izquierda a derecha, y configurando el bit correspondiente de un entero si la generación n + 1 contiene un copia de la generación n en esa posición de la cuadrícula:

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

Para un factor de escala de 2, el patrón de bits se organizaría así:

0 1
2 3

y así.

Su tarea es escribir un programa que acepte un patrón de bits en esta forma, un factor de escala (por ejemplo, 3 para la alfombra Sierpinski) y un número de generación y genera un fractal ASCII.

Entrada

Su programa debe aceptar 3 enteros en el siguiente orden: un patrón de bits, un factor de escala (que va de 2 a 5, inclusive) y un conteo de generación (que va de 0 a 5, inclusive).

No necesita realizar ninguna validación de entrada en estos valores y está perfectamente bien si el programa funciona para valores mayores que los rangos especificados.

Las entradas se pueden pasar de cualquier forma (tuplas, listas separadas por comas / espacios, etc.)

Salida

El programa debe generar un fractal compuesto por el #carácter seguido de un espacio en las posiciones donde se define el fractal, espacios dobles donde no está, y un carácter de nueva línea al final de cada línea, ya sea imprimiéndolos o devolviendo una cadena de una función.

Ejemplos

Entrada:

495,3,3

Salida (Alfombra Sierpinski generación 3):

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

Entrada:

7,2,5

Salida ( Triángulo de Sierpinski ):

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

Entrada:

325,3,3

Salida ( Cantor Dust ):

#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 









#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   # 



#   #       #   #                   #   #       #   # 

#   #       #   #                   #   #       #   #

Entrada

186,3,3

Salida ( fractal de Vicsek ):

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

Entrada:

279,3,3

Salida (ejemplo de un fractal asimétrico):

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

etc.

Notas:

  • Este es el código de golf, por lo que gana la respuesta más corta en bytes
  • Su programa puede ser independiente o una función que se llama con los 3 parámetros de entrada y devuelve (o imprime) una cadena
  • La generación 0 se define como #( #seguida de un espacio) incluso para un patrón de bits de 0.
  • Una nueva línea final en la última línea es opcional pero está permitida, al igual que cualquier cantidad de espacio en blanco final en cada línea.
code-golf ascii-art fractal samgak
fuente
3
+1, me gustó esto en sandbox y me gusta más aquí, con el símbolo cambiado de "##"a "# ". Veo que el espacio final al final de la línea está incluido en sus ejemplos, ¿es obligatorio? . Según la última regla, supongo que es opcional, pero el hecho de que requiera un espacio final para la generación 0 me hace preguntarme. También creo que debe indicar el espacio en blanco máximo y las nuevas líneas (lo tiene en plural) permitido. Como ejemplo extremo, siempre podría comenzar con una matriz de 5 ^ 6 = 15625 líneas de 2 * 5 ^ 6 espacios y luego sustituir el #s. En la mayoría de los casos de entrada, es una enorme cantidad de espacio en blanco sin usar
Level River St
@steveverrill No necesito el espacio al final, cuando la salida de la generación 0, sin embargo, el espacio final es parte de su definición, que las generaciones posteriores se definen en términos de. El plural de las nuevas líneas era un error tipográfico, fijo.
samgak
¿Podría publicar el resultado esperado para algo menos simétrico, como 279,3,3?
aditsu
@aditsu seguro, vea la pregunta editada
samgak

Respuestas:

4

APL (Dyalog Unicode) , SBCS de 37 bytes

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

Pruébalo en línea!

ngn
fuente
11

Lisp común, 248 242 bytes

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

Sin golf

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

Explicación

  • Entrada:
    • N es el patrón codificado
    • R es el tamaño del patrón
    • G es la generación
  • La salida es una matriz cuadrada implícita de longitud S = R G
  • Repetimos cada fila y , columna x (anidada dotimes) y calculamos si cada celda debe dibujarse (enfoque similar a la emisión de rayos). Esto se hace mirando recursivamente dentro del fractal con la ffunción auxiliar.
  • Si el fractal en la posición (x, y) se dibujará, imprimirá "# "o imprimirá " ". Por supuesto, también imprimimos nuevas líneas al final de cada fila.

Por ejemplo, el triángulo de Sierpinsky está representado por S=7y R=2. En la generación 3, el tamaño del cuadrado es 2 3 = 8. Para cada celda (x, y) , sucede lo siguiente:

  • fse llama con x , y , g unido a 3 ys unido a 4 (8/2)
  • Truncamos x por s , para saber si x pertenece al lado izquierdo o derecho de la matriz implícita. truncatedevuelve tanto el cociente como el resto, que están vinculados respectivamente a px y x (reutilizamos el mismo símbolo x , pero esto no es un problema).
  • Lo mismo ocurre con y que da py y nueva y .
  • En este ejemplo, px y py pueden ser 0 o 1 (porque el patrón es un cuadrado de longitud 2). Identifican dónde está (x, y) en el patrón del fractal: cuando el bit en la posición py.R + px de N es 0, x e y representan una posición donde no se debe dibujar nada.
  • De lo contrario, debemos "acercar" a la parte correspondiente del fractal y llamamos frecursivamente con los nuevos enlaces para x e y . Esas son ahora la posición relativa dentro del fractal interno. Pasamos G-1 para la generación y s / 2 para representar la longitud media del fractal.
  • El caso base de la recursión se encuentra cuando G es cero, en cuyo caso se debe dibujar la posición actual (x, y) .

Ejemplo

(fractal 186 3 3)

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

Calcular la octava generación de la Alfombra Sierpinski usando (fractal 495 3 8)toma 24.7 segundos y genera un archivo de texto de salida de 83 MB. Escribí una versión ligeramente modificada que genera una imagen. Para los mismos parámetros, el archivo GIF pesa 1.5 MB (mismo tiempo de cálculo):

Alfombra de Sierpinsky, generación 8

Vicsek (haga clic para ver el tamaño original):

Vicsek fractal

volcado de memoria
fuente
1
+1 para lo que parece un programa conciso en un lenguaje horriblemente detallado. 8 anidados )en una fila!
Level River St
@steveverrill Nunca gano golf de código ... pero aún así, creo que la sintaxis vale la pena para programas más grandes. Y honestamente, ya casi no veo paréntesis, solo un bonito árbol.
coredump
Esa imagen gif en realidad bloquea el navegador web de mi teléfono ... Gran golf con un lenguaje más inusual
Glenn Smith
@ Hola Hola. ¿CodeGolf tiene una insignia para bloquear el navegador de otras personas? Debería :-)
coredump
5

Pyth, 38 bytes

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

Pruébelo en línea: Regular Input / Test Suite

La explicación sigue más tarde.

Jakube
fuente
1+ Todavía estoy esperando la salida de 186 3 5(intérprete en línea), pero aparte de eso, estoy realmente impresionado por lo breve que es.
coredump
1
@coredump No creo que obtenga un resultado tan grande con el intérprete en línea. Si quieres probarlo, deberías descargar el compilador Pyth . Tarda unos 10 segundos en mi computadora portátil.
Jakube
4

Rubí, 154

La puntuación es solo para la función. Presentado sin golf en el siguiente programa de prueba. El único juego de golf que estoy reclamando en este momento es la eliminación de comentarios y sangrías. Jugaré golf más tarde. Por el momento, me estoy divirtiendo jugando con el programa.

La función toma seis argumentos, pero en la llamada inicial solo se proporcionan los primeros 3 según la especificación. Esto hace que los tres argumentos restantes se establezcan en valores predeterminados y, en particular, la cadena adonde se almacena la salida se crea e inicializa en líneas de espacios terminadas por nuevas líneas. Como efecto secundario, $wtambién se crea la variable global , que indica el número de símbolos por línea.

Cuando la función se llama a sí misma de forma recursiva, proporciona los seis argumentos, incluida la cadena ay las coordenadas x e y de la esquina superior izquierda de la siguiente recursión

El resto del programa es bastante sencillo, como se indica en los comentarios.

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

Salida

Aquí hay un conjunto de fractales basados ​​libremente en la forma de las letras de la palabra GOLF. Se podrían lograr letras más realistas con mapas de bits más grandes. Como muestra el último ejemplo, los fractales más interesantes se descubren por accidente.

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)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
  #     #     #     #     #     #     #     #     #  
#   # #   # #   # #   # #   # #   # #   # #   # #   #
      # # #             # # #             # # #      
        #                 #                 #        
      #   #             #   #             #   #      
# # #       # # # # # #       # # # # # #       # # #
  #           #     #           #     #           #  
#   #       #   # #   #       #   # #   #       #   #
                  # # # # # # # # #                  
                    #     #     #                    
                  #   # #   # #   #                  
                        # # #                        
                          #                          
                        #   #                        
                  # # #       # # #                  
                    #           #                    
                  #   #       #   #                  
# # # # # # # # #                   # # # # # # # # #
  #     #     #                       #     #     #  
#   # #   # #   #                   #   # #   # #   #
      # # #                               # # #      
        #                                   #        
      #   #                               #   #      
# # #       # # #                   # # #       # # #
  #           #                       #           #  
#   #       #   #                   #   #       #   #
Level River St
fuente
3

CJam, 45

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

Implementación de mi primera idea. Pruébalo en línea

Básicamente, comienza con una matriz 1 * 1 que contiene 3 (la diferencia entre '#' y ''), luego multiplica repetidamente cada número en la matriz con el patrón de bits (matriz 0/1), y combina las matrices resultantes en una matriz más grande Al final, agrega un espacio a cada número y se une con espacios y líneas nuevas.

2da idea, 49

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

Pruébalo en línea

Esto genera todas las coordenadas de la matriz de salida como matrices de <número de generación> pares de números más pequeños que el factor de escala (todas esas combinaciones), luego para cada par de números obtiene el bit correspondiente del patrón, y para cada matriz de coordenadas multiplica los bits y multiplica por 3. El procesamiento final es el mismo.

Probablemente haya espacio para más golf.

aditsu
fuente
2

C, 316 bytes

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

Sin golf:

#include <stdio.h>

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

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

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

    char *out=malloc(width*width);

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


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

    int x,y;
    for (y=0; y<width; ++y) {
        for (x=0; x<width; ++x)
            printf("%c ",out[y*width+x]);
        printf("\n");
    }
    return 0;
}
LambdaBeta
fuente
3
De acuerdo con los puntos al final de la especificación, se permite una función en lugar de un programa. Cámbielo a una función y simplemente pásele los tres parámetros de entrada, eso eliminaría todo ese atoi y le ahorraría unos 40 bytes.
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")}

sin golf:

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

ejemplos:

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

primer corte, probablemente se pueda jugar un poco más ...

gilad hoch
fuente
Te falta un espacio entre cada uno de los tuyos #. Además de ser requerido por la especificación, realmente mejora la apariencia de su salida.
Level River St
@steveverrill tienes razón. No me di cuenta de eso al principio. Edité con una solución rápida. gracias :)
gilad hoch
2

Matlab, 115 bytes

El kronproducto Kronecker hace que todo sea mucho más fácil:

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


# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #
falla
fuente
Aunque de2bisolo funciona si tiene la Caja de herramientas de sistemas de comunicaciones. No funciona sin eso. Sería necesario dec2bin.
Tom Carpenter
Parece que esta caja de herramientas está incluida en mi versión estándar para estudiantes, así que creo que es aceptable. (Tenga en cuenta que de2bino es lo mismo que dec2bin.)
error
2

C, 158 bytes

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

K5, 70 bytes

Es un comienzo:

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

En acción:

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