Considérez cette spirale

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

Départ au centre:

• La première ligne (vers le haut) comporte 3 caractères.
• La deuxième ligne a le même nombre de caractères (3)
• Ensuite, nous ajoutons deux caractères (5) pour les deux côtés suivants.
• Ce motif se poursuit, deux côtés de la même longueur puis augmentez la longueur de 2.

Je veux générer cette spirale pour N lignes.

• Écrivez dans n'importe quelle langue.
• L'entrée / argument, etc. est le nombre de lignes dans votre spirale.
• Chaque ligne commence par le caractère de fin de la ligne précédente dans le sens des 90 degrés dans le sens horaire de la ligne précédente.
• Je me fiche de la quantité d'espace blanc avant ou après chaque ligne, tant que les éléments de la spirale s'alignent.
• Texte de sortie pour dessiner la spirale avec n'importe quel caractère non blanc que vous choisissez.
• Essayez de le faire dans le plus petit nombre d'octets.

Cas de test (en utilisant un hachage en sortie):

N = 1

#
#
#

N = 2

###
#
#

N = 3

###
# #
# #
  #
  #

N = 10

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

05AB1E , 13 11 octets

Code:

Merci à Emigna d' avoir économisé deux octets!

LDÈ-Ì'#3Ý·Λ

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication

Les longueurs de chaque bord individuel sur la spirale commencent par la longueur 3 et augmentent progressivement toutes les deux étapes par deux:

$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

Cela nous donne essentiellement la liste souhaitée des longueurs.

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

Le canevas fonctionne comme une fonction qui fait apparaître trois paramètres (où le paramètre le plus à droite est sauté en premier): <longueur (s)> , <caractère (s)> , <direction (s)> . Le paramètre directions est dans ce cas une liste de nombres. Les nombres qui correspondent aux directions sont:

Dans ce cas, [0, 2, 4, 6] correspond à la liste des directions [↑, →, ↓, ←]. Le canevas parcourt chaque longueur extraite de la liste des longueurs, utilise le caractère «#» et parcourt cycliquement la liste des directions.

Python 2 , 176 170 165 165 161 157 octets

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)

Essayez-le en ligne!

À plusieurs reprises: permet gde faire pivoter l' nitération de la spirale dans une position `` canonique '' (similaire à N = 3 ou N = 7), ajoute un nouveau segment en ajoutant 2 espaces à gauche de chaque ligne existante, puis en remplaçant la dernière ligne avec tous les '#'s (résultant en une position comparable à N = 4 ou N = 8), et enfin en utilisant à gnouveau pour le faire revenir à la position correcte. Faire mousser, rincer, répéter.

Fusain , 16 15 14 octets

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

-2 octets grâce à @Neil .

Essayez-le en ligne (verbeux) ou essayez-le en ligne (pur) .

Explication:

La direction d'impression est vers la droite par défaut, et nous voulons commencer vers le haut, nous commençons donc par une rotation de 45 degrés dans le sens antihoraire:

PivotLeft();
↶

Bouclez ensuite idans la plage [0, input):

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

Imprimez une nouvelle ligne pour imiter l'effet de reculer d'une position:

Print("\n");
¶

Imprimer "#" xfois dans la direction actuelle:

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

Où xest 3 + i // 2 * 2::

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

Et puis faites pivoter de 45 degrés dans le sens horaire pour la prochaine itération de la boucle:

PivotRight();
↷

Python 2 , 179 178 octets

merci à Kevin Cruijssen pour -1 octet.

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)

Essayez-le en ligne!

Python 2 , 179 octets

Dans cette approche, les formules sont utilisées pour xet ydeltas au lieu d'une liste de recherche.

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)

Essayez-le en ligne!

JavaScript (ES6), 185 octets

Bien sûr, cela peut être joué davantage, peut-être avec du curry, mais voici ma très humble tentative. Sauts de ligne ajoutés pour plus de lisibilité sauf avant-dernier caractère

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`
`

Utilisation: d(10)retourne une chaîne selon l'exemple de défi N = 10.

Définit une fonction r(a,n)pour faire tourner un tableau tour aà ntour; une fonction s(n)pour générer un réseau bidimensionnel représentant une spirale de taille nen tournant et en ajoutant récursivement de l'espacement et des lignes (non retourné à la position de départ); et une fonction d(n)pour dessiner une spirale de taille n, tournée de manière cohérente selon le défi, et rendue sous forme de chaîne retournée.

Ce fut un défi vraiment amusant: ¬)