Sierpinski Teppiche

23

Wer liebt nicht ein gutes Fraktal? Der Sierpinski-Teppich ist ein klassisches Beispiel für ein Fraktal.

Um diese Aufgabe abzuschließen, müssen Sie einen Teppich vom Typ generieren nund das resultierende Bild auf den stdout(siehe Beispiel unten für die Formatierung) n, der den ebenen Teppich darstellt, drucken . Schritte finden Sie in diesem Wikipedia- Artikel.

Dieser Wert wird von stdinoder gleichwertig genommen.

Zum Beispiel würde eine Eingabe von 4 einen Teppich der Stufe 4 erzeugen:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

Eine Eingabe von 3 würde einen Teppich der Stufe 3 erzeugen:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

Eine Eingabe von 2 würde einen Teppich der Stufe 2 erzeugen:

■ ■ ■
■   ■ 
■ ■ ■

Und eine Eingabe von 1 würde einen Teppich der Stufe 1 erzeugen (nur ein Quadrat):

■

Beachten Sie die Leerzeichen zwischen den Spalten.

Die Idee ist, das ■ Zeichen für Blöcke und den Platz für Lücken zu verwenden

Die Zeile beginnt mit dem Zeichen ■.

Wie immer gewinnt die kleinste Lösung durch die Anzahl der Zeichen (aufgrund von Sonderzeichen).

Alternativ kann in Sprachen, die Unicode nicht unterstützen, anstelle des ■ Zeichens # verwendet werden.

code-golf  ascii-art  fractal 
— Paul Clavier
quelle
1
Ist das erste Beispiel nicht eine dritte statt eine zweite Ebene?
— Optimierer
6
Schöne Frage, aber müssen sie diese Charaktere sein? Das sind keine ASCII-Dateien, was viele Sprachen ausschließt. Können sie nur Leerzeichen und X oder O sein? Ich denke tatsächlich, dass Ihr Bild mit Leerzeichen anstelle von leeren Quadraten besser aussehen würde.
— Level River St
Schwamm in Teppiche verwandelt, danke.
— Paul Clavier
Was ist, wenn Ihre Sprache keine Unicode-Ausgabe unterstützt? Gibt es auch eine ASCII-Alternative?
— Fehler
1
Können die Zeilen nachgestellte Leerzeichen enthalten?
— Dennis

Antworten:

15

CJam, 38 37 31 30 28 Zeichen

Na ja, wir zählen nach Zeichen, also lasst uns ein bisschen Unicode entpacken:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

Teste es hier. Geben Sie einfach den gewünschten Pegel in das Eingabefeld ein.

Erläuterung

Nach der Basiskonvertierung ist dies

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

Das ist das Gleiche wie das Folgende, nur mit dem Unicode-Zeichen geschrieben als 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

Dieser Code wird auf die folgende Beobachtung zugrunde: Wenn wir den Koordinaten betrachten (x, y) jeder Zelle, wir eine leere Zelle dann erhalten, wenn beide x und y haben einen 1an der gleichen Position in ihrer Basis-3 - Darstellung. Wenn Sie darüber nachdenken, ist das sich wiederholende Muster im kleinen Maßstab die signifikante Basis-3-Ziffer, dann bestimmt die nächstgrößere Ziffer die nächstgrößere Wiederholung und so weiter.

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

Der Inhalt des resultierenden Arrays wird automatisch gedruckt.

Vielen Dank an Dennis für das Abschneiden von drei Bytes.

— Martin Ender
quelle
2
#0<'■S-> #~S'■speichert 1 Zeichen.
— Optimierer
Sie können ersetzen [1_]a#~mit 3Yba&.
— Dennis
@ Tennis ordentlich. Danke dir!
— Martin Ender
@Dennis Ich vergesse immer wieder, dass &ein wahrer / falscher Wert entsteht (oder sogar, dass er existiert). Könnte einen Beitrag in den CJam-Tipps wert sein, um auf kanonische Weise zu testen, ob ein Array ein Element enthält.
— Martin Ender
1
@Ypnypn Nein. Es sieht länger aus, aber das liegt daran, dass die Unicode-Zeichen keine Monospaces sind. Der entpackte Code hat 30 Zeichen.
— Martin Ender
7

Matlab (113) (110) (99) (85)

Sie können es hier ausprobieren (Sie müssen es durch input('')Ihre gewünschte Eingabe ersetzen .)

Jetzt 99 danke an feersum! Und jetzt auf 85 dank RTL!

Golf gespielt: 

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Ungolfed:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))


d=[c,c]*0;  %this is all just for adding the additional spaces
d(:,1:2:end)=c;
disp(char(d*3+32));    %converting to spaces (32) and # (35)

Erläuterung:

Ich missbrauche das kronecker-Produkt für diese Aufgabe. (Es handelt sich um ein spezielles Produkt, das für zwei beliebig große Matrizen definiert ist. Beispiel:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

Dann 

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

Hier ist ein Beispiel für n = 5 (in der alten Zählmethode ist es 4);

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
— Fehler
quelle
Danke, ich habe nicht bemerkt, dass sich die Anforderungen geändert haben. Ich habe auch den Code aktualisiert (ich musste nur den Startwert der for-Schleife ändern.)
— flawr
Stattdessen d=zeros(size([c,c]))solltest du verwenden d=[c c]*0.
— Feersum
schön, ein Vorschlag: Die Variable dkann durch Missbrauch vermieden wird kroneinmal mehr: disp(char(kron(c,[1,0])*3+32));,
— RTL
6

Haskell, 114 108

s 1=["# "]
s n=k j++k(map(>>" ")j)++k j where j=s$n-1;k i=j%i%j
(%)=zipWith(++)
main=interact$unlines.s.read
— stolzer haskeller
quelle
5

Python - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)
— Wrzlprmft
quelle
5

Perl 5: 68 Zeichen

n auf stdin.

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

Eine dezimalcodierte ternäre Darstellung der Koordinatenliste wird zuerst unter Verwendung der Ziffern 0, 1 und 3 in @,(Name so gewählt, dass kein Leerzeichen zwischen @,und erforderlich ist) generiert. Das forHinzufügen von x- und y-Koordinaten in der Dezimaldomäne hat nun eine 2 im Ergebnis nur dann, wenn zwei übereinstimmende Positionen hatten. //wird verwendet, um die Standardvariable $_von der äußeren Schleife ( for) an die Postmatch-Variable weiterzugeben, $'wenn sie von der Standardvariablen mapin der inneren Schleife abgeschattet wird .

— nutki
quelle
4

Java, 330 283 Zeichen

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

Param ist die gewünschte Größe. Sofern es keine Optimierung für den Algorithmus gibt, habe ich versucht, alles zu zerquetschen.

Dank @StretchManiac, das die iMethode entfernt und die Deklarationen bereinigt hat, ging das ein bisschen schief.

Lesbarer Code

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}
— Kompass
quelle
Sie können "public" vor dem Unterricht loswerden, wie Sie es als Hauptargument tun können String[]a, und wenn Sie nur ieinmal verwenden, ist es besser, die Methode loszuwerden.
— Stretch Maniac
@StretchManiac danke für die Tipps. Ich werde sie gleich implementieren.
— Kompass
3
Warum um alles ""+sin der Welt machst du deine pMethode? Das sind drei zusätzliche Zeichen für absolut keinen Zweck. Selbst wenn die Art von setwas anderes Stringwäre, wäre es immer noch völlig unnötig.
— David Conrad
1
Ändern Sie ihn auf static void p(int s){System.out.print((char)s);}und in Haupt machen es int s=35;, s=32;und p(10);(statt p("\n");) und speichern ein paar mehr Zeichen.
— David Conrad
Sie können sieben Zeichen speichern , indem Sie Integer.valueOfaufnew Byte
— Ypnypn
4

Schläger 230 229 225 220

Nicht Schlägers schönste Stunde zum Golfen.

Golf gespielt:

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Ungolfed:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))
— Matthew Butterick
quelle
4

C: 123 118 111 104 Zeichen

Basierend auf einer ähnlichen Idee wie meine Perl-Lösung. Nach dem Hinzufügen einiger Leerzeichen:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

Verwendet ein ternäres System, das jede Ziffer mit 2 Bits codiert. Unzulässige Werte (mit zwei Werten in gerader-ungerader Position) werden mit gefiltert x & (x>>1) & 0b01010101. Beide Koordinaten werden in einem Wert gespeichert, sodass die Pixelfarbe überprüft werden muss x & (x >> 2 * n) & 0b01010101. nwird aus Bequemlichkeitsgründen als Zweierpotenz gespeichert.

Bearbeiten

Ersetzt definedurch eine einfache Konstante m.

Bearbeiten 2

0x5555555Maske kann mit dargestellt werden (1LL<<32)/3, aber wir brauchen nur ndiese Bits, also n/3ist es ausreichend.

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

Bearbeiten 3

Kleine Verbesserungen. Ein Gewinn von 2 Zeichen, der darauf beruht, dass scanf ausgeführt wird, bevor der Ladewert von nfür die Ausführung von ausgeführt wird --n. Das Eol kann nur folgen #, duh.

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}
— nutki
quelle
3

HTML / JavaScript, 205 Zeichen

Obfuscatweet , 205 Zeichen

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

HTML / JS, 298 Zeichen

Aufgrund der Art und Weise, wie HTML mit Leerzeichen spielt, mussten einige Zeichen dem nbsp-Zeichen zugewiesen werden. Außerdem ist die Standardschriftart der meisten Browser nicht Courier, weshalb ich sie auch darauf einstellen musste. Etwa 20 Zeichen im Wert von Styling. Wenn dies eine direkte Eingabemethode erfordert, kann ich sie hinzufügen, aber wenn Sie die Eingabe derzeit ändern, wird n auf einen anderen Wert gesetzt.

Demo

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

Lesbares HTML / JS

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"
— Kompass
quelle
3

CJam, 38 35 32 31 Zeichen

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

Probieren Sie es online aus.

Beispiellauf

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■

Wie es funktioniert

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

konvertiert die Unicode-Zeichenfolge von der Basis 60.000 ( 6e4b) in die Basis 128 ( 128b), wandelt sie in Character ( :c) um und wertet die resultierende Zeichenfolge ( ~) aus.

Als Ergebnis wird der folgende Code ausgeführt:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";
— Dennis
quelle
3

Python 3 - 116 113 Zeichen

EDIT: Nun, habe den Trick benutzt, den ich selbst nicht besonders mag und den Code um 3 Bytes komprimiert. Keine Ahnung, ob das der bestmögliche Weg ist, aber ich werde damit weitermachen.

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫潦⁲湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

Es kann einige nicht druckbare Zeichen enthalten. Hier ist eine druckbare Version der Zeichenfolge.

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

Nicht allzu toll, schlägt aber zumindest einige Sprachen.

Was es erweitert:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

Etwas ungolfed für den Fall, dass jemand nicht sehen kann, wie es funktioniert:

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)
— PurkkaKoodari
quelle
Wow Python, das ist beeindruckend
— Paul Clavier
2

Bash + Coreutils, 105 Unicode-Zeichen

Da wir Zeichen und nicht Bytes zählen:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

In seiner dekodierten Form:

Pure Bash, 143 Bytes

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

Die Eingabe erfolgt über Befehlszeilenargumente:

Ausgabe:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$
— Digitales Trauma
quelle
2

C #

Volles Programm - 237:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

LINQPad - 166+ Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}
— William Barbosa
quelle
Ich weiß, es sind fast drei Jahre vergangen, aber Sie können ein paar Dinge wie das folgende spielen: using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}( 229 Bytes / 227 Zeichen ) ( ■= 3 Bytes, also könnten Sie es durch ersetzen #, um auch 2 Bytes zu sparen). Ich habe hauptsächlich alles innerhalb der for-Schleifen platziert, sodass keine Klammern mehr erforderlich sind.
— Kevin Cruijssen
2

C - 154

Eingabe von stdin. Ich habe versucht, eine zusätzliche Funktion zu umgehen, konnte mir aber keine einfallen lassen.

Die Zeichenanzahl enthält nur die erforderlichen Leerzeichen.

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}
— Allbeert
quelle
1

PHP, 194 Zeichen

Das nals erstes Argument in der Kommandozeile erhaltene.

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

Lesbar

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}
— Gedrox
quelle
1
Wenn Sie das Zeichen ■anstelle von verwenden #, können Sie 2 Zeichen sparen, indem Sie die Anführungszeichen entfernen.
— Ismael Miguel
1

Scala 230 Zeichen

Golf Code:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

Ungolfed-Code:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

Es sind nur die erforderlichen Leerzeichen enthalten.

— Mathill
quelle
1

V , 21 Bytes (nicht konkurrierend)

é*Àñ}yPgvr PGï3pyGHP

Probieren Sie es online!

Hexdump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

V ist neuer als die Herausforderung, daher muss es als nicht konkurrierend markiert werden. Trotzdem ist es schön zu sehen, dass diese Antwort kürzer ist als alle anderen, selbst wenn in Bytes anstatt in Zeichen gezählt wird.

— DJMcMayhem
quelle
Nur eine Erinnerung; Es ist nicht mehr konkurrenzlos
— RedClover
1

ok, 40 bytes

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

Probieren Sie es online aus.

Es beginnt mit 1und zeichnet es dann in ein Raster (1 1 1;1 0 1;1 1 1), das es dann auf die gleiche Weise in ein Raster zeichnet, usw., und wiederholt die erforderliche Anzahl von Malen.

— zgrep
quelle
1

C # (.NET Core) , 162 Byte

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

Probieren Sie es online!

Entgolft

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}
— Ayb4btu
quelle
0

R , 92 Zeichen

94 Bytes mit dem Sonderzeichen.

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

Probieren Sie es online!

— Giuseppe
quelle
Ich bin nur erstaunt, dass die Leute das noch 4 Jahre später tun
— Paul Clavier
1
@ PaulClavier es ist eine große Herausforderung; du solltest stolz sein :)
— Giuseppe
0

Canvas , 17 16 17 Zeichen

■；╷［⌐ ＋２×；┌∔∔；３＊＋

Probieren Sie es hier aus!

-1: Wird ［verwendet ｛, um den ersten ；innerhalb der Schleife zu löschen .
+1: Behobenes fehlerhaftes Verhalten: Entspricht ■jetzt Level 1, wie im ursprünglichen Beitrag angegeben.

— hakr14
quelle
Es ist im Wettbewerb, pro einem neueren Konsens.
— Erik der Outgolfer
@EriktheOutgolfer oh, danke, dass du mich informiert hast!
— Hakr14
Und ja, in diesem Fall das Ergebnis ist 17, aber wir Lösungen in Bytes zählen, nicht Zeichen (Canvas hat eine Codepage).
— Erik der Outgolfer
@EriktheOutgolfer normalerweise ja, aber bei dieser Herausforderung werden Zeichen verwendet, da ■sie aus mehreren Bytes bestehen . Sagt so nach unten in den ursprünglichen Beitrag.
— hakr14
Sie müssen eine zu allen Ihren Eingaben hinzufügen. 1 sollte ein Quadrat zurückgeben (dh, was 0 hier zurückgibt)
— Paul Clavier
0

Pip -S , 30 Zeichen

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

Probieren Sie es online!

Die Grundidee: Betrachten Sie ein Koordinatengitter in der Basis 3. Die Löcher im Teppich treten auf, wenn 1) ein Trit in der x-Koordinate 1und 2) der Trit in der gleichen Position in der y-Koordinate ist1 .

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

Ähnliche Lösung, gleiche Anzahl von Zeichen, aber -2 Bytes: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
quelle
0

K (ngn / k) , 50 Bytes

danke @DLosc für die Erinnerung, ich sollte Leerzeichen zwischen den Spalten ausgeben

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

Probieren Sie es online!

— ngn
quelle
@ DLosc danke, andere seltsame Anforderungen wurden ebenfalls behoben: stdin / stdout anstelle von arg / result; off-by-one "level"
— ngn
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.