Guarda la seguente stringa. Notare uno schema?

ABEFNOPEFGH
DC GQI
MHRJ
LKJI SK
DTL
CUM
BAZYXWV N
EO
DP
CQ
BAZYXWVUTSR

Come alcuni potrebbero aver notato, è fondamentalmente una spirale dell'alfabeto, in cui le distanze tra righe / colonne aumentano gradualmente di 1 spazio / newline.

Definizione rigorosa

• Diamo un contatore c , che inizialmente è 0.
• Scriviamo la prima c + 1 lettere dell'alfabeto da sinistra a destra: A.

• Poi, dall'alto verso il basso il prossimo (c + 1) (c + 2) / 2 lettere (add B): AB.

• Da sinistra a destra, il prossimo (c + 1) (c + 2) / 2 (aggiungi C):

  AB
   C
  

• E dal basso verso l'alto, le successive c + 1 lettere (aggiungi D):

  AB
  DC
  

• Raggiunta la fine del ciclo. Quindi, incrementiamo c (che diventa 1). Quindi, inizia dal primo passaggio, l'unica differenza è che invece di usare le prime lettere dell'alfabeto c + 1 , usiamo le lettere successive c + 1 , a partire dall'ultimo elemento di questo ciclo ( Din questo caso, quindi continuiamo con EFG...). Quando Zviene raggiunto, ritorna da A.

Compito

Dato un numero intero N (che è positivo per 1-indicizzazione o non negativo per 0-indicizzazione), emette i primi N cicli della spirale.

Regole

• Puoi usare l'alfabeto minuscolo o maiuscolo, ma la tua scelta deve essere coerente (usane solo uno, il mixaggio non è permesso).

• Puoi prendere input e fornire output attraverso uno qualsiasi dei metodi standard , in qualsiasi linguaggio di programmazione , osservando che queste scappatoie sono proibite per impostazione predefinita.

• Formati di output accettabili: stringa multilinea, un elenco di stringhe che rappresentano linee, un elenco contenente più elenchi di caratteri, ognuno dei quali rappresenta una riga o qualsiasi altra cosa ritenga appropriata. Nel caso in cui non si scelga il primo formato, sarebbe bello includere una versione stampata del proprio codice.

• Questo è code-golf , quindi vince il codice più breve in byte (in ogni lingua) che soddisfa i requisiti!

Casi test

L'intero di input verrà separato dall'output corrispondente tramite una nuova riga e i test verranno separati mediante trattini. Si noti che questi sono 1 indicizzati.

1

AB
DC

--------

2

ABEF
DC G
MH
LKJI 

--------

3

ABEFNOP
DC GQ
MHR
LKJI S
DT
CU
BAZYXWV

-------

4

ABEFNOPEFGH
DC GQI
MHRJ
LKJI SK
DTL
CUM
BAZYXWV N
EO
DP
CQ
BAZYXWVUTSR

-------
5

ABEFNOPEFGHFGHIJ
DC GQIK
MHRJL
LKJI SKM
DTLN
CUMO
BAZYXWV NP
EOQ
DPR
CQS
BAZYXWVUTSR T
RU
QV
PW
BUE
NMLKJIHGFEDCBAZY

------

6

ABEFNOPEFGHFGHIJSTUVWX
DC GQIKY
MHRJLZ
LKJI SKMA
DTLNB
CUMOC
BAZYXWV NPD
EOQE
DPRF
CQSG
BAZYXWVUTSR TH
RUI
QVJ
PWK
OXL
NMLKJIHGFEDCBAZY M
SN
RO
QP
PQ
O 
NMLKJIHGFEDCBAZYXWVUTS

Carbone , 31 byte

Ｆ⮌…⁰ＮＢ⁺²⊘×ι⁺³ι⭆α§α⁺λ÷×ι⊕×ι⁺⁹⊗ι⁶

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: il deverbosificatore emette un separatore finale per qualche motivo. Spiegazione:

Ｆ⮌…⁰ＮＢ

Disegna le caselle in ordine inverso rispetto alle dimensioni (dal più grande al più piccolo).

⁺²⊘×ι⁺³ι

Calcola la dimensione della scatola.

⭆α§α⁺λ

Disegna il bordo della scatola usando un alfabeto ruotato.

÷×ι⊕×ι⁺⁹⊗ι⁶

Calcola la lettera che apparirebbe in alto a sinistra nel riquadro (indicizzato 0).

Python 2 , 176 byte

n=input()
k=n*-~n/2+1
a=eval(`[[' ']*k]*k`)
x=y=z=0
for s in range(4*n+4):exec s/4*(s/4+1)/2*"if'!'>a[y][x]:a[y][x]=chr(z%26+65);z+=1\nx+=abs(2-s%4)-1;y+=s%2-s%4/3*2\n"
print a

Provalo online!

Spiegazione

Costruiamo una matrice vuota di spazi della giusta dimensione, quindi ci spostiamo su di essa in questo modo, iniziando nell'angolo in alto a sinistra:

• 1 passo →, 1 passo ↓, 1 passo ←, 1 passo ↑

• 3 passaggi →, 3 passaggi ↓, 3 passaggi ←, 3 passaggi ↑

• 6 passi →, 6 passi ↓, 6 passi ←, 6 passi ↑

• 10 passi →, 10 passi ↓, 10 passi ←, 10 passi ↑

• ...

Ogni volta che troviamo una cella vuota, mettiamo lì una lettera e passiamo alla lettera successiva dell'alfabeto.

Nel codice, s%4è la direzione (→ ↓ ← ↑), e lo facciamo molte volte:

TriangularNumber(s/4) = s/4*(s/4+1)/2.

Opportunità golf

• C'è un modo più breve per mappare s%4a 1,0,-1,0che abs(2-s%4)-1?

• C'è un modo più breve per mappare s%4a 0,1,0,-1che s%2-s%4/3*2?

Titoli di coda

• Il signor Xcoder ha salvato un byte.

C,  305  281 byte

Grazie a @Mr. Xcoder per il salvataggio di quattro byte!

#define L(x,y)l[x][y]=a++%26+65;
#define F for(
c,i,j,a,p;f(n){char**l=calloc(8,i=a=n*n*4);F;i--;memset(l[i],32,a))l[i]=malloc(a);F c=a=p=i=0;c<n;++c){F i=p;i<c+p+!c;)L(j=0,c+i++)F p=i;j<=-~c*(c+2)/2;)L(j++,c+i)F;c+i-1;)L(j-1,c+--i)F i=0;i<=c;)L(j+~i++,0)}F i=0;i<j;)puts(l[i++]);}

Provalo online!

Python 2 , 262 260 254 245 byte

lambda n:[[[' ',chr(65+(4*(i<j)+sum((i<j)*8+2+I*[5,9][i<j]+sum(2*R(I))for I in R(S(i,j)-1))+[i+j,-i-j][i<j])%26)][max(i,j)==S(i,j)*-~S(i,j)/2or i*j<1]for i in R(1+n*-~n/2)]for j in R(1+n*-~n/2)]
R=range
S=lambda x,y:int((8*max(x,y)+1)**.5+.99)/2

Provalo online!

Nuovo metodo con più matematica!

Restituisce un elenco di elenchi di caratteri.

Vecchia versione:

Python 2 , 322 321 308 298 byte

R=range
n=input()
w=1+n*-~n/2;r=[w*[' ']for _ in R(w)];r[0][0]='A';l=R(1,w*w*9);c=lambda:chr(65+l.pop(0)%26)
for i in R(n+1):
 w=1+i*-~i/2;W=w-i
 for x in R(W,w):r[0][x]=c()
 for y in R(1,w):r[y][w-1]=c()
 for x in R(1,w):r[w-1][w+~x]=c()
 for x in R(1,w-W):r[w+~x][0]=c()
for l in r:print`l`[2::5]

Provalo online!

Perl 5, 177 +2 (-nl) = 179 byte

2 byte salvati grazie a Xcali

sub n{chr 65+$c++%26}@O=(n);while($,++<$_){$_.=$"x$,for@O;push@O,($"x length$O[0])x$,;$O[0]=~s/ /n/eg;s/ $/n/e for@O;1while$O[-1]=~s/.*\K /n/e;s/^ /n/e for reverse@O}print for@O

Provalo online

APL (Dyalog Classic) , 47 byte

(⎕a⍴⍨≢i)@i⍴∘''⊃⌈/i←∪+\↓1⍪⊃⍪⌿(+\⍳⎕)⌿¨⊂⍪∘-⍨∘.≠⍨⍳2

Provalo online!