Vue d'ensemble
Ecrivez un programme qui imprime des motifs fractals simples à partir d'un motif de bits codant pour la fractale, plus le facteur d'échelle par génération de la fractale et le nombre de générations.
Explication
Voici une représentation ASCII du tapis de Sierpinski :
Génération 0:
#
Génération 1:
# # #
# #
# # #
Génération 2:
# # # # # # # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # # # # # # #
La génération n + 1 du tapis de Sierpinski ASCII est composée d’une grille 3x3 contenant 8 copies de la génération n, l’élément central de la grille faisant défaut.
Donc, comme il est défini en utilisant une grille 3x3 et qu'il est 3 fois plus grand en largeur et en hauteur à chaque génération, on peut dire qu'il a un facteur d'échelle de 3.
Nous pourrions définir un motif de bits pour le tapis de Sierpinski en numérotant les éléments de la grille 3x3 de 0 à 8, de haut en bas, de gauche à droite, et en définissant le bit correspondant d'un entier si la génération n + 1 contient un copie de la génération n à cette position de la grille:
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
Pour un facteur d'échelle de 2, le modèle de bits serait organisé comme suit:
0 1
2 3
etc.
Votre tâche consiste à écrire un programme qui accepte un modèle de bits sous cette forme, un facteur d’échelle (par exemple, 3 pour le tapis de Sierpinski) et un numéro de génération, puis génère une fractale ASCII.
Contribution
Votre programme doit accepter 3 nombres entiers dans l'ordre suivant: un modèle de bits, un facteur d'échelle (allant de 2 à 5 inclus) et un nombre de générations (allant de 0 à 5 inclus).
Vous n'avez pas besoin d'effectuer de validation d'entrée sur ces valeurs et c'est parfaitement correct si le programme fonctionne pour des valeurs supérieures aux plages spécifiées.
Les entrées peuvent être passées sous n’importe quelle forme (tuples, liste séparée par des virgules / espaces, etc.)
Sortie
Le programme doit afficher une fractale composée du #caractère suivi d'un espace dans les positions où elle est définie, de doubles espaces où il ne l'est pas et d'un caractère de nouvelle ligne à la fin de chaque ligne, en les imprimant ou en renvoyant une chaîne. à partir d'une fonction.
Exemples
Contribution:
495,3,3
Sortie (génération de tapis Sierpinski 3):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
Contribution:
7,2,5
Sortie ( triangle de Sierpinski ):
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # #
# # # #
# # # #
# #
# # # #
# #
# #
#
Contribution:
325,3,3
Sortie ( poussière de cantor ):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
Contribution
186,3,3
Sortie ( fractale de Vicsek ):
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
# # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
Contribution:
279,3,3
Sortie (exemple d'une fractale asymétrique):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
etc.
Remarques:
- C’est du code-golf donc la réponse la plus courte en octets gagne
- Votre programme peut être une fonction autonome ou une fonction appelée avec les 3 paramètres d’entrée et renvoyant (ou imprimant) une chaîne.
- La génération 0 est définie comme
#(un#suivi d'un espace) même pour un motif binaire de 0. - Une nouvelle ligne de fin sur la dernière ligne est facultative mais autorisée, de même que toute quantité d’espace blanc de fin sur chaque ligne.
279,3,3?
"##"à"# ". Je vois que l'un des espaces de fin de ligne est inclus dans vos exemples, est-il nécessaire? . Selon la dernière règle, je suppose que c'est facultatif, mais le fait que vous ayez besoin d'un espace de fin pour la génération 0 m'étonne. Aussi, je pense que vous devriez indiquer le maximum d'espaces et de nouvelles lignes (vous l'avez au pluriel) autorisé. Comme exemple extrême, je pourrais toujours commencer avec un tableau de 5 ^ 6 = 15625 lignes de 2 * 5 ^ 6 espaces, puis substituer le#s. Dans la plupart des cas, il s'agit d'une quantité énorme d'espaces non utilisés