Betrachten Sie diese Spirale

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

Ausgehend von der Mitte:

• Die erste Zeile (nach oben) besteht aus 3 Zeichen.
• Die zweite Zeile hat die gleiche Anzahl von Zeichen (3)
• Als nächstes fügen wir zwei Zeichen (5) für die nächsten beiden Seiten hinzu.
• Dieses Muster setzt sich fort, zwei Seiten gleicher Länge erhöhen dann die Länge um 2.

Ich möchte diese Spirale für N Linien erzeugen.

• Schreiben Sie in einer beliebigen Sprache.
• Die Eingabe / das Argument usw. ist die Anzahl der Zeilen in Ihrer Spirale.
• Jede Zeile beginnt mit dem Endzeichen der vorherigen Zeile im Uhrzeigersinn um 90 Grad gegenüber der vorherigen Zeile.
• Es ist mir egal, wie viel Leerzeichen vor oder nach jeder Zeile stehen, solange die Elemente der Spirale in einer Linie stehen.
• Geben Sie Text aus, um die Spirale mit einem von Ihnen ausgewählten Nicht-Leerzeichen zu zeichnen.
• Versuchen Sie dies in der kleinsten Anzahl von Bytes zu tun.

Testfälle (mit einem Hash als Ausgabe):

N = 1

#
#
#

N = 2

###
#
#

N = 3

###
# #
# #
  #
  #

N = 10

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

05AB1E , 13 11 Bytes

Code:

Vielen Dank an Emigna für das Speichern von zwei Bytes!

LDÈ-Ì'#3Ý·Λ

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

Die Länge jeder einzelnen Kante der Spirale beginnt mit der Länge 3 und erhöht sich schrittweise alle zwei Schritte um zwei:

$n$$n$

L                # Create a list from [1 .. input]
 DÈ              # Duplicate and check for each number if even
   -             # Subtract that from the first list
    Ì            # Add 2

Dies gibt uns im Grunde die gewünschte Liste von Längen.

     '#          # Push the '#' character
       0246S     # Push the array [0, 2, 4, 6]
            Λ    # Write to canvas

Die Zeichenfläche fungiert als eine Funktion, die drei Parameter einblendet (wobei der am weitesten rechts stehende Parameter zuerst eingeblendet wird): <Länge (n)> , <Zeichen (n)> , <Richtung (en)> . Der directions-Parameter ist in diesem Fall eine Liste von Zahlen. Die Nummern, die den Richtungen entsprechen, sind:

In diesem Fall entspricht [0, 2, 4, 6] der Richtungsliste [↑, →, ↓, ←]. Die Zeichenfläche iteriert über jede Länge, die aus der Längenliste abgerufen wurde, verwendet das Zeichen '#' und iteriert zyklisch über die Richtungsliste.

Python 2 , 176 170 165 161 157 Bytes

g=lambda a,r:r and g(map(''.join,zip(*a))[::-1],r-1)or a
R=['#']
n=1
exec"R=g(['  '+l for l in g(R,n)][:-1]+[(n+2)*'#'],3*n);n+=1;"*input()
print'\n'.join(R)

Probieren Sie es online!

Wiederholt: Dreht gdie nIteration der Spirale in eine 'kanonische' Position (ähnlich N = 3 oder N = 7), fügt ein neues Segment hinzu, indem links von jeder vorhandenen Zeile 2 Leerzeichen hinzugefügt werden und dann die letzte Zeile ersetzt wird mit allen '#'s (was zu einer Position führt, die mit N = 4 oder N = 8 vergleichbar ist), und schließlich gerneut verwenden, um sie zurück in die richtige Position zu drehen. Aufschäumen, ausspülen, wiederholen.

Kohle , 16 15 14 Bytes

↶ＦＮ«¶×#⁺³⊗÷ι²↷

-2 Bytes dank @Neil .

Probieren Sie es online (ausführlich) oder online (rein) .

Erläuterung:

Die Druckrichtung ist standardmäßig rechts und wir möchten nach oben starten, also drehen wir uns zunächst um 45 Grad gegen den Uhrzeigersinn:

PivotLeft();
↶

Dann Schleife i im Bereich [0, input):

For(InputNumber()){ ... }
ＦＮ« ...

Drucken Sie eine neue Zeile, um den Effekt des Zurückrückens um eine Position nachzuahmen:

Print("\n");
¶

Drucken "#" x Höhe der Zeit in der Stromrichtung:

Print(Times("#", ... ));
×# ...

Wo x ist 3 + i // 2 * 2:

Add(3,Doubled(IntegerDivide(i,2))
⁺³⊗÷ι²

Und drehen Sie dann 45 Grad im Uhrzeigersinn für die nächste Iteration der Schleife:

PivotRight();
↷

Python 2 , 179 178 Bytes

Danke an Kevin Cruijssen für -1 Byte.

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
M=[1,0,-1,0]*n
exec'exec k/2*2*"x+=M[~k];y+=M[k];m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

Probieren Sie es online!

Python 2 , 179 Bytes

Bei diesem Ansatz werden Formeln für xund yDeltas anstelle einer Nachschlageliste verwendet.

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
exec'exec k/2*2*"x+=k%-2+k%4/3*2;y-=(k%2or k%4)-1;m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

Probieren Sie es online!

JavaScript (ES6), 185 Byte

Natürlich kann man mehr Golf spielen, vielleicht mit Curry, aber hier ist mein sehr bescheidener Versuch. Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt, mit Ausnahme des vorletzten Zeichens

r=(a,n=1)=>n?r(a.reduce((_,c)=>c).map((_,i)=>a.map(e=>e[i])).reverse(),n-1):a,
s=n=>n?r(s(n-1)).map((r,i)=>[...r,w,w].map(x=>i?x:'#')):[[w=' ']],
d=n=>r(s(n),1-i).map(r=>r.join``).join`
`

Verwendung: d(10)Gibt eine Zeichenfolge gemäß dem N = 10-Abfragebeispiel zurück.

Definiert eine Funktion r(a,n)eine Anordnung zum Drehen avon nUmdrehungen; eine Funktion s(n)zum Erzeugen eines zweidimensionalen Arrays, das eine Spirale von Größe darstellt, ndurch rekursives Drehen und Hinzufügen von Abständen und Linien (nicht zurück in die Ausgangsposition gedreht); und eine Funktion, d(n)um eine Spirale der Größe zu zeichnenn , die gemäß der Herausforderung gleichmäßig gedreht und als zurückgegebene Zeichenfolge gerendert wird.

Das war eine sehr lustige Herausforderung: ¬)