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.
279,3,3?
"##"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