Überblick
Schreiben Sie ein Programm, das einfache fraktale Muster mit einem Bitmuster, das das Fraktal codiert, plus dem Skalierungsfaktor pro Generation für das Fraktal und die Anzahl der Generationen druckt.
Erläuterung
Hier ist eine ASCII-Darstellung des Sierpinski-Teppichs :
Generation 0:
#
Generation 1:
# # #
# #
# # #
Generation 2:
# # # # # # # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # #
# # # # # #
# # # # # # # # #
# # # # # #
# # # # # # # # #
Die Generation n + 1 des ASCII-Sierpinski-Teppichs besteht aus einem 3x3-Raster mit 8 Kopien der Generation n, wobei das zentrale Element des Rasters fehlt.
Wir können also sagen, dass es einen Skalierungsfaktor von 3 hat, da es mit einem 3x3-Raster definiert wird und in Breite und Höhe bei jeder Generation dreimal größer wird.
Wir könnten ein Bitmuster für den Sierpinski-Teppich definieren, indem wir die Elemente im 3x3-Raster von 0 bis 8, von oben nach unten und von links nach rechts nummerieren und das entsprechende Bit einer Ganzzahl setzen, wenn die Generation n + 1 a enthält Kopie der Generation n an dieser Gitterposition:
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
Für einen Skalierungsfaktor von 2 würde das Bitmuster folgendermaßen angeordnet sein:
0 1
2 3
und so weiter.
Ihre Aufgabe ist es, ein Programm zu schreiben, das ein Bitmuster in dieser Form, einen Skalierungsfaktor (z. B. 3 für den Sierpinski-Teppich) und eine Generationsnummer akzeptiert und ein ASCII-Fraktal ausgibt.
Eingang
Ihr Programm sollte 3 Ganzzahlen in der folgenden Reihenfolge akzeptieren: ein Bitmuster, einen Skalierungsfaktor (von 2 bis einschließlich 5) und eine Generierungszahl (von 0 bis einschließlich 5).
Sie müssen für diese Werte keine Eingabevalidierung durchführen, und es ist vollkommen in Ordnung, wenn das Programm für Werte arbeitet, die über den angegebenen Bereichen liegen.
Die Eingaben können in beliebiger Form (Tupel, durch Kommas / Leerzeichen getrennte Liste usw.) übergeben werden.
Ausgabe
Das Programm sollte ein Fraktal ausgeben, das aus dem #Zeichen besteht, gefolgt von einem Leerzeichen an den Stellen, an denen das Fraktal definiert ist, doppelten Leerzeichen, an denen es nicht definiert ist, und einem Zeilenumbruchzeichen am Ende jeder Zeile, das entweder ausgedruckt oder eine Zeichenfolge zurückgegeben wird von einer Funktion.
Beispiele
Eingang:
495,3,3
Leistung (Sierpinski Carpet Generation 3):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
Eingang:
7,2,5
Ausgabe ( Sierpinski-Dreieck ):
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # #
# # # #
# #
# # # # # # # #
# # # #
# # # #
# #
# # # #
# #
# #
#
Eingang:
325,3,3
Leistung ( Cantor Dust ):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
Eingang
186,3,3
Ausgabe ( Vicsek-Fraktal ):
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
# # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # #
# # # # # # # # #
# # #
#
# # #
#
# # #
# # # # # # # # #
# # #
#
# # #
#
Eingang:
279,3,3
Ausgabe (Beispiel eines asymmetrischen Fraktals):
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
# # # # # # # # #
# # #
# # #
# # #
#
#
# # #
#
#
etc.
Anmerkungen:
- Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes
- Ihr Programm kann entweder ein eigenständiges Programm oder eine Funktion sein, die mit den drei Eingabeparametern aufgerufen wird und eine Zeichenfolge zurückgibt (oder ausgibt)
- Generation 0 ist definiert als
#(#gefolgt von einem Leerzeichen), auch für ein Bitmuster von 0. - Ein abschließender Zeilenumbruch in der letzten Zeile ist optional, aber zulässig, ebenso wie ein beliebiger Leerraum in jeder Zeile.
279,3,3.
"##"zu"# ". Ich sehe, dass das letzte Leerzeichen am Ende der Zeile in Ihren Beispielen enthalten ist. Ist es erforderlich? . Nach der letzten Regel würde ich annehmen, dass dies optional ist, aber die Tatsache, dass Sie für die Generation 0 einen nachgestellten Speicherplatz benötigen, wundert mich. Außerdem denke ich, dass Sie das maximale Leerzeichen und die erlaubten Zeilenumbrüche (Sie haben es im Plural) angeben sollten. Als extremes Beispiel könnte ich immer mit einem Array von 5 ^ 6 = 15625 Zeilen mit 2 * 5 ^ 6 Leerzeichen beginnen und dann das#s ersetzen . In den meisten Eingabefällen ist das eine enorme Menge an nicht verwendetem Leerzeichen