visão global
Escreva um programa que imprima padrões simples de fractal, com um padrão de bits que codifica o fractal, mais o fator de escala por geração do fractal e o número de gerações.
Explicação
Aqui está uma representação ASCII do tapete Sierpinski :
Geração 0:
#
Geração 1:
# # #
# #
# # #
Geração 2:
# # # # # # # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # # # # # # #
A geração n + 1 do tapete ASCII Sierpinski é composta de uma grade 3x3 contendo 8 cópias da geração n, com o elemento central da grade ausente.
Portanto, como é definido usando uma grade 3x3 e fica 3 vezes maior em largura e altura a cada geração, podemos dizer que possui um fator de escala de 3.
Poderíamos definir um padrão de bits para o tapete de Sierpinski numerando os elementos na grade 3x3 de 0 a 8, de cima para baixo, da esquerda para a direita e definindo o bit correspondente de um número inteiro se a geração n + 1 contiver um cópia da geração n nessa posição da grade:
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 um fator de escala de 2, o padrão de bits seria organizado assim:
0 1
2 3
e assim por diante.
Sua tarefa é escrever um programa que aceite um padrão de bits dessa forma, um fator de escala (por exemplo, 3 para o tapete Sierpinski) e um número de geração e que produza um fractal ASCII.
Entrada
Seu programa deve aceitar três números inteiros na seguinte ordem: um padrão de bits, um fator de escala (variando de 2 a 5, inclusive) e uma contagem de geração (variando de 0 a 5, inclusive).
Você não precisa executar nenhuma validação de entrada nesses valores e é perfeitamente aceitável se o programa funcionar com valores maiores que os intervalos especificados.
As entradas podem ser passadas de qualquer forma (tuplas, lista separada por vírgula / espaço, etc.)
Saída
O programa deve gerar um fractal composto pelo #caractere seguido por um espaço nas posições em que o fractal é definido, espaços duplos onde não está e um caractere de nova linha no final de cada linha, imprimindo-os ou retornando uma string de uma função.
Exemplos
Entrada:
495,3,3
Saída (geração 3 do tapete Sierpinski):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
Entrada:
7,2,5
Saída ( triângulo de Sierpinski ):
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # #
# # # #
# # # #
# #
# # # #
# #
# #
#
Entrada:
325,3,3
Saída ( Poeira Cantor ):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
Entrada
186,3,3
Saída ( fractal Vicsek ):
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
# # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
Entrada:
279,3,3
Saída (exemplo de um fractal assimétrico):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
etc.
Notas:
- Isso é código-golfe, então a resposta mais curta em bytes vence
- Seu programa pode ser autônomo ou uma função chamada com os 3 parâmetros de entrada e retorna (ou imprime) uma string
- A geração 0 é definida como
#(a#seguida por um espaço), mesmo para um padrão de bits 0. - Uma nova linha à direita na última linha é opcional, mas permitida, assim como qualquer quantidade de espaço em branco à direita em cada linha.
279,3,3?
"##"para"# ". Vejo que um espaço à direita no final da linha está incluído em seus exemplos, é necessário? . Pela última regra, eu diria que é opcional, mas o fato de você precisar de um espaço à direita para a geração 0 me faz pensar. Também acho que você deve indicar o espaço em branco máximo e as novas linhas (você o tem no plural) permitido. Como exemplo extremo, eu sempre poderia começar com uma matriz de 5 ^ 6 = 15625 linhas de 2 * 5 ^ 6 espaços e depois substituir#s. Na maioria dos casos de entrada que é uma enorme quantidade de espaço em branco não utilizado