Panoramica
Scrivi un programma che stampa semplici schemi di frattali con uno schema di bit che codifica il frattale, oltre al fattore di scala per generazione del frattale e al numero di generazioni.
Spiegazione
Ecco una rappresentazione ASCII del tappeto Sierpinski :
Generazione 0:
#
Prima generazione:
# # #
# #
# # #
Seconda generazione:
# # # # # # # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # # # # # # #
La generazione n + 1 del tappeto ASCII Sierpinski è costituita da una griglia 3x3 contenente 8 copie della generazione n, con l'elemento centrale della griglia mancante.
Quindi, poiché è definito utilizzando una griglia 3x3 e diventa 3 volte più grande in larghezza e altezza ogni generazione, possiamo dire che ha un fattore di scala di 3.
Potremmo definire un modello di bit per il tappeto Sierpinski numerando gli elementi nella griglia 3x3 da 0 a 8, dall'alto verso il basso, da sinistra a destra e impostando il bit corrispondente di un numero intero se la generazione n + 1 contiene un copia della generazione n in quella posizione della griglia:
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
Per un fattore di scala di 2, il modello di bit sarebbe organizzato in questo modo:
0 1
2 3
e così via.
Il tuo compito è scrivere un programma che accetta un modello di bit in questa forma, un fattore di scala (ad es. 3 per il tappeto Sierpinski) e un numero di generazione e genera un frattale ASCII.
Ingresso
Il tuo programma dovrebbe accettare 3 numeri interi nel seguente ordine: un modello di bit, un fattore di scala (compreso tra 2 e 5, inclusi) e un conteggio di generazione (compreso tra 0 e 5, inclusi).
Non è necessario eseguire alcuna convalida dell'input su questi valori ed è perfettamente corretto se il programma funziona per valori superiori agli intervalli specificati.
Gli input possono essere passati in qualsiasi forma (tuple, elenco separato da virgole / spazi, ecc.)
Produzione
Il programma dovrebbe generare un frattale composto dal #personaggio seguito da uno spazio in posizioni in cui è definito il frattale, doppi spazi dove non lo è e un carattere di nuova riga alla fine di ogni riga, stampandoli o restituendo una stringa da una funzione.
Esempi
Ingresso:
495,3,3
Uscita (Sierpinski Carpet generazione 3):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
Ingresso:
7,2,5
Uscita ( triangolo di Sierpinski ):
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # #
# # # #
# # # #
# #
# # # #
# #
# #
#
Ingresso:
325,3,3
Uscita ( Cantor Dust ):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
Ingresso
186,3,3
Uscita ( frattale Vicsek ):
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
# # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
Ingresso:
279,3,3
Uscita (esempio di un frattale asimmetrico):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
eccetera.
Gli appunti:
- Questo è code-golf quindi vince la risposta più breve in byte
- Il programma può essere autonomo o una funzione chiamata con i 3 parametri di input e restituisce (o stampa) una stringa
- La generazione 0 è definita come
#(a#seguita da uno spazio) anche per un modello di bit di 0. - Una nuova riga finale sull'ultima riga è facoltativa ma consentita, così come qualsiasi quantità di spazio vuoto finale su ciascuna riga.
279,3,3?
"##"a"# ". Vedo che uno spazio finale alla fine della riga è incluso nei tuoi esempi, è necessario? . Per l'ultima regola, suppongo che sia facoltativo, ma il fatto che tu abbia bisogno di uno spazio finale per la generazione 0 mi fa meravigliare. Inoltre penso che dovresti indicare il massimo spazio bianco e le nuove righe (lo hai plurale) consentito. Come esempio estremo potrei sempre iniziare con una matrice di 5 ^ 6 = 15625 linee di 2 * 5 ^ 6 spazi quindi sostituire la#s. Nella maggior parte dei casi di input è un'enorme quantità di spazi bianchi inutilizzati