Escriba un programa o función que, cuando se proporcione n, imprima ncaracteres en espiral formados por el alfabeto latino que se ABCDEFGHIJKLMNOPQRSTUVWXYZrepite según sea necesario. Esta espiral debe pasar por el alfabeto solo hacia adelante.

Relacionado con Alphabet Spiral , aunque la espiral atraviesa el alfabeto hacia adelante y hacia atrás, y la espiral es constante.

Casos de prueba

4   AB
    DC

40   UVWXYZ
     TGHIJA
    NSFABKB
    MREDCLC
    LQPONMD
    KJIHGFE

0

10  GHIJ
    FAB
    EDC

1000    UVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ
        TGHIJKLMNOPQRSTUVWXYZABCDEFGHIJA
        SFABCDEFGHIJKLMNOPQRSTUVWXYZABKB
        REZCDEFGHIJKLMNOPQRSTUVWXYZABCLC
        QDYBMNOPQRSTUVWXYZABCDEFGHIJCDMD
        PCXALEFGHIJKLMNOPQRSTUVWXYZKDENE
        OBWZKDEFGHIJKLMNOPQRSTUVWXALEFOF
        NAVYJCDMNOPQRSTUVWXYZABCDYBMFGPG
        MZUXIBCLCDEFGHIJKLMNOPQREZCNGHQH
        LYTWHABKBABCDEFGHIJKLMNSFADOHIRI
        KXSVGZAJAZGHIJKLMNOPQROTGBEPIJSJ
        JWRUFYZIZYFUVWXYZABCDSPUHCFQJKTK
        IVQTEXYHYXETQRSTUVWXETQVIDGRKLUL
        HUPSDWXGXWDSPUVWXYZYFURWJEHSLMVM
        GTORCVWFWVCROTGHIJAZGVSXKFITMNWN
        FSNQBUVEVUBQNSFABKBAHWTYLGJUNOXO
        ERMPATUDUTAPMREDCLCBIXUZMHKVOPYP
        DQLOZSTCTSZOLQPONMDCJYVANILWPQZQ
        CPKNYRSBSRYNKJIHGFEDKZWBOJMXQRAR
        BOJMXQRARQXMLKJIHGFELAXCPKNYRSBS
        ANILWPQZQPWVUTSRQPONMBYDQLOZSTCT
        ZMHKVOPYPONMLKJIHGFEDCZERMPATUDU
        YLGJUNOXONMLKJIHGFEDCBAFSNQBUVEV
        XKFITMNWVUTSRQPONMLKJIHGTORCVWFW
        WJEHSLMLKJIHGFEDCBAZYXWVUPSDWXGX
        VIDGRKJIHGFEDCBAZYXWVUTSRQTEXYHY
        UHCFQPONMLKJIHGFEDCBAZYXWVUFYZIZ
        TGBEDCBAZYXWVUTSRQPONMLKJIHGZAJA
        SFAZYXWVUTSRQPONMLKJIHGFEDCBABKB
        REDCBAZYXWVUTSRQPONMLKJIHGFEDCLC
        QPONMLKJIHGFEDCBAZYXWVUTSRQPONMD
                                LKJIHGFE

Reglas

• Su entrada será un número entero no negativo 0 <= n <= 1000, pero su código debería manejar teóricamente cualquier número entero no negativo.
• Su formato de salida puede estar en cualquier formato correcto, con delimitadores si es necesario.
• Las rotaciones y los reflejos son equivalentes.
• Su alfabeto puede ser mayúscula o minúscula.
• Los espacios vacíos en su espiral pueden llenarse con cualquier nulo no alfabético que considere adecuado.
• La espiral en sí misma puede tener cualquier forma que le parezca adecuada. Las espirales rectangulares funcionan mejor con soluciones ASCII, pero las soluciones gráficas pueden ser más cortas con espirales circulares.
• Se permiten espacios iniciales y finales y líneas nuevas.
• Este es el código de golf. La respuesta más corta en bytes (o equivalente) gana.

Como siempre, si algo no está claro o es incorrecto, hágamelo saber en los comentarios. ¡Buena suerte y buen golf!

Logotipo, 129 87 bytes

Solución gráfica, implementada como función

Esto fue construido sobre el intérprete de Logo de Calormen.com . La Sfunción toma el número de caracteres como parámetro y los dibuja en espiral. La Tfunción genera letras en posición vertical para evitar que giren con la espiral. . Decidí que se veía mejor (y jugué 42 bytes ) para omitir la corrección de la orientación de la letra. También apreté el espacio que no cambió el recuento de bytes. Si realmente enrollas un alfabeto, de todos modos se vería más así.

Versión actualizada (rollo de letras)

TO S:r
PU IF:r[REPEAT:r[LABEL CHAR((REPCOUNT-1)%26)+65
RT 99/SQRT(REPCOUNT)FD 12]]END

Invocación

Invoque de la siguiente manera: S iteraciones

Salida de muestra

S 1000

Versión anterior (letras siempre en posición vertical)

TO T:l:h
RT:h
LABEL CHAR(:l%26)+65
LT:h
END
TO S:r
PU IF:r[REPEAT:r[T REPCOUNT-1 90-HEADING
RT 95/SQRT(REPCOUNT)FD 15]]END

Salida anterior eliminada para ahorrar espacio. Véalo aquí .

Javascript (ES6), 203 201 bytes

n=>{for(a=[],i=d=k=z=0,p=526,j=1;i<n;){p+=[1,32,-1,-32][d&3];j--||(((z^=1)||k++),j=k,d++);(a[y=p>>5]=(a[y]||Array(32).fill` `))[p&31]=String.fromCharCode(65+(i++%26))}return a.map(r=>r.join``).join`
`}

Manifestación

La demostración a continuación debe ejecutarse preferiblemente en página completa.

let f =

n=>{for(a=[],i=d=k=z=0,p=526,j=1;i<n;){p+=[1,32,-1,-32][d&3];j--||(((z^=1)||k++),j=k,d++);(a[y=p>>5]=(a[y]||Array(32).fill` `))[p&31]=String.fromCharCode(65+(i++%26))}return a.map(r=>r.join``).join`
`}

function draw(n) {
  document.getElementById('v').innerHTML = n;
  document.getElementById('o').innerHTML = f(n);
}
draw(500);

pre {font-size:10px}

<input type="range" min="1" max="1000" oninput="draw(this.value)" style="width:500px"><span id="v"></span><pre id="o"></pre>

R, 46 o 51 bytes, dependiendo del espaciado

s=1:scan();plot(s*sin(s),s*cos(s),pch=letters)

(versión actualizada de la trama: la espiral gris no se traza de manera predeterminada, pero la agregué después para mostrar que las letras realmente se encuentran en una espiral).

La espiral no tiene un espaciado constante, así que espero que esté bien. Si se requiere un espaciado constante, comience con s=(1:scan())^.5y agregue 5 bytes al total. Entonces la salida es la siguiente (n = 150):

Python 3.5, 180 157 152 147 141 bytes

-6 debido a Sherlock9

r=[[]]
for x in range(int(input())):
 r=len(r[-1])<len(r[0])and r or[*zip(*r[::-1]),[]];r[-1]+=[chr(x%26+65)]
print(*map(''.join,r),sep='\n')

-5 debido a Kap.

R=range
def g(n):
 r=[[]]
 for x in R(n):
  if len(r[-1])==len(r[0]):r=[*zip(*r[::-1]),[]]
  r[-1]+=[chr(x%26+65)]
 print(*map(''.join,r),sep='\n')

Solución revisada, python 3.x:

R=range
def g(n):
 r=[[]]
 for x in R(n):
  if len(r[-1])==len(r[0]):r=list(zip(*r[::-1]))+[[]]
  r[-1]+=[chr(x%26+65)]
 print(*map(''.join,r),sep='\n')

Solución anterior:

R=range
def g(n):
 r=[]
 for x,f in zip(R(n),(j<1for i in R(n)for j in R(i//2+1))):
  if f:r=list(zip(*r[::-1]))+[[]]
  r[-1].append(chr(x%26+65))
 print(*map(''.join,r),sep='\n')

Explicación

res una lista de listas que contiene la espiral. La idea básica es que se agregan nuevas letras a la fila inferior de la espiral ( r[-1].append(chr(x%26+65))). Cuando se llena la fila inferior, la espiral se gira 90 en sentido horario y se agrega una nueva fila vacía al fondo ( r = list(zip(*r[::-1]))+[[]]).

El truco es descubrir cuándo rotar la espiral. En la primera solución, el generador (j<1for i in R(n)for j in R(i//2+1))produce una secuencia de valores Verdadero / Falso que indica cuándo rotar la espiral. En la solución revisada, cambié la forma en que rse inicializa. Ahora, cuando la longitud de la fila inferior es igual a la longitud de la fila superior, la espiral debe rotarse.

MATL , 21 18 bytes

X^Xk1YL1Y2y)wG>~*c

La entrada 0sale con un error (que está permitido por defecto ).

Pruébalo en línea!

Explicación

X^Xk   % Input n implicitly. Take square root and round up
1YL    % Square matrix of that size containing a spiral of numbers
1Y2    % Predefined literal: string "AB···YZ"
y      % Duplicate the spiral matrix onto the top
)      % Apply as an index inth the string. Gives 2D array of chars
w      % Swap: move copy of the spiral matrix to top
G>~    % Set entries that exceed the input to 0, and the rest to 1 
*      % Multiply. This makes unwanted entries equal to 0
c      % Convert to char. 0 is shown as a space. Display implicitly

Python 2, 84 82 bytes

Estoy usando Turtle nuevamente. ¡Es tan divertido! :RE

from turtle import*
up()
for i in range(input()):write(chr(i%26+65));rt(9);fd(9+i)

Pruébalo en línea

Desafortunadamente, Trinket.io tiene un lienzo horriblemente pequeño. He cambiado 9+ia 9+i/9y se ajustó el punto de partida de la tortuga con el propósito de pantalla de captura esta imagen, de modo que más de la salida encajaría:

Pyth, 32 bytes

JS@Q2ju+.t_G)Hc<*GQQ.u+NY.iJJZ]Y

Un programa que imprime una espiral ASCII rectangular en minúsculas. Dependiendo de la entrada, puede estar presente una fila o columna de espacios en blanco iniciales o finales.

Pruébalo en línea

Cómo funciona

JS@Q2ju+.t_G)Hc<*GQQ.u+NY.iJJZ]Y  Program. Input: Q
  @Q2                             Yield sqrt(Q)
JS                                Unary range, J=[1, 2, 3, ..., floor(sqrt(q))]
                         .iJJ     Interleave J with itself, yielding [1, 1, 2, 2, 3, 3, ...
                                  floor(sqrt(Q)), floor(sqrt(Q))]
                    .u+NY    Z    Cumulatively reduce by addition with base case 0,
                                  yielding [0, 1, 2, 4, 6, 9, 12, 16, 20...]
                *GQ               Repeat the lower-case alphabet Q times
               <   Q              Truncate to legth Q
              c                   Split the above at the indices in the above list
      u                       ]Y  Reduce the above, with base case [[]]:
          _G                       Reverse
        .t  )                      Transpose
       +     H                     Add the next arm of the spiral
     j                            Join on newlines and implicitly print

TSQL, 386 362 358 306 bytes

Tenga en cuenta que TSQL no tiene una forma de rotar texto. Este script comienza desde A y calcula en qué dirección se debe colocar la siguiente letra. (derecha, abajo, izquierda, izquierda, izquierda, arriba, arriba, derecha ...)

El script puede manejar un máximo de 7744 letras.

Golfizado:

DECLARE @z INT = 7744

DECLARE @ INT=2+SQRT(@z-1)DECLARE @o varchar(max)=REPLICATE(SPACE(@-1)+char(10),@-1);WITH C as(SELECT 0i,@/2a,@/2b UNION ALL SELECT i+1,a+z/2,b+z%2FROM(SELECT*,IIF(a>@/2*2-b,IIF(a<b,2,-1),IIF(a>b,-2,1))z FROM C)t WHERE i<@z-1)SELECT @o=STUFF(@o,@*a-@+b,1,char(i%26+65))FROM c OPTION(maxrecursion 0)PRINT @o

Sin golf:

DECLARE @z INT = 7744

DECLARE @ INT=2+SQRT(@z-1)
DECLARE @o varchar(max)=REPLICATE(SPACE(@-1)+char(10),@-1)

;WITH C as
(
  SELECT
    0i,@/2a,@/2b
  UNION ALL
  SELECT
    i+1,a+z/2,b+z%2
    FROM 
      (SELECT*,
         IIF(a>@/2*2-b,
           IIF(a<b,2,-1),
             IIF(a>b,-2,1))z FROM C)t
  WHERE
    i<@z-1
)
SELECT 
  @o=STUFF(@o,@*a-@+b,1,char(i%26+65))
FROM c  
OPTION(maxrecursion 0)

PRINT @o

Violín

Python 2, 243 bytes

r=range(input())
a=[1j**int((4*i+1)**.5)for i in r]
b=[map(int,(-sum(a[:i]).real,sum(a[:i]).imag))for i in r]
c,d=zip(*b)
for i in range(min(c),max(c)+1):print''.join([i,j]in b and chr(b.index([i,j])%26+65)or' 'for j in range(min(d),max(d)+1))

Ideone it!

PHP , 219 bytes

for($q=ceil(sqrt($a=$argn))**2,$d=1,$x=$y=$w=0;$i<$q;$i++,${yx[$w%2]}+=[-1,1][$d&1],$i%$d?:$d+=$w++&1)$e[$c[]=$x-!($a&1)][$l[]=$y]=$i<$a?chr(65+$i%26):" ";for($k=min($c);$e[$k];print join($e[+$k++])."\n")ksort($e[+$k]);

Pruébalo en línea!

PHP, 260 bytes

Versión antigua

for($y=$x=$d=$i=0;$i<$m=ceil(sqrt($n=$argv[1]))**2;$i++){$a[$y][$x]=$i<$n?chr($i%26+65):" ";$d=$y==$x&$y<1?0:(1-$y==$x&$x>0?1:($y==$x&$y>0?2:($y==-$x&$x<0?3:$d)));$d>2?$y--:($d>1?$x--:($d>0?$y++:$x++));}ksort($a);foreach($a as$r){ksort($r);echo join($r)."\n";}