La tarea es muy simple, cuando se le da una entrada, genera una de las siguientes espirales:

Input = 1da una espiral con la letra que Acomienza en la esquina superior izquierda:

A B C D E F
T U V W X G
S 5 6 7 Y H
R 4 9 8 Z I
Q 3 2 1 0 J
P O N M L K

Input = 2da una espiral con la letra que Acomienza en la esquina superior derecha:

P Q R S T A
O 3 4 5 U B
N 2 9 6 V C
M 1 8 7 W D
L 0 Z Y X E
K J I H G F

Input = 3da una espiral con la letra que Acomienza en la esquina inferior derecha:

K L M N O P
J 0 1 2 3 Q
I Z 8 9 4 R
H Y 7 6 5 S
G X W V U T
F E D C B A

Input = 4da una espiral con la letra que Acomienza en la esquina inferior izquierda:

F G H I J K
E X Y Z 0 L
D W 7 8 1 M
C V 6 9 2 N
B U 5 4 3 O
A T S R Q P

Como puede ver, la espiral siempre va en sentido horario y se mueve desde afuera hacia adentro .

Las reglas son simples:

• Debe proporcionar un programa completo utilizando STDIN y STDOUT, o el equivalente más cercano si no es posible.
• Dada una entrada ( 1, 2, 3, 4), da salida a la espiral relacionada.
• Se permiten espacios en blanco al final
• Se permiten espacios en blanco iniciales cuando se usan de manera consistente
• Debe usar letras mayúsculas para la salida, no se permiten letras minúsculas.
• Este es el código de golf , por lo que gana el programa con la menor cantidad de bytes.

CJam, 45 43 42 bytes

'[,65>A,+W%(s{W%z_,@s/(@.+}A*ri{W%z}*Sf*N*

Pruébalo aquí.

Explicación

'[,65>  e# Push the upper-case alphabet.
A,+     e# Append the digits.
W%      e# Reverse everything.
(s      e# Pull off the 9 and turn it into a string.
{       e# Repeat this 10 times to roll the string up in a spiral...
  W%z   e#   Rotate the existing grid clockwise.
  _,    e#   Duplicate grid so far and get the number of rows.
  @s    e#   Pull up the list of characters and flatten it into one string.
  /     e#   Split the string into chunks of the size of the number of rows.
  (     e#   Pull off the first chunk.
  @.+   e#   Pull up the grid so far and prepend the chunk as a new column.
}A*     e# We now have the spiral as desired, with the A in the bottom left corner.
ri      e# Read input and convert to integer.
{       e# Repeat this code that often..
  W%z   e#   Rotate the spiral clockwise.
}*
Sf*     e# Join each line with spaces.
N*      e# Join the lines with linefeeds.

Japt , 53 bytes 58 59 60

Guardado 5 bytes gracias a @ETHproductions

"FGHIJK EXYZ0L DW781M CV692N BU543O ATSRQP"¸zU ®¬¸} ·

Esto usa el comando rotar que nunca pensé que sería tan útil

Explicación && Ungolfed

"FGHIJK EXYZ0L DW781M CV692N BU543O ATSRQP"qS zU m_q qS} qR

             // Implicit: U = input
"FGH...SRQP" // String, " " represent newlines
qS           // Split   " "
zU           // Rotate
m_           // Loop the lines
  q qS}      // Insert spaces
qR           // Join by newlines

Pruébalo en línea

Mathematica 156 bytes

Convierte una cadena inicial de letras,, "ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"en una matriz. Nestse aplica fa los n-1tiempos de esa matriz , donde n es el número de entrada. ffunciona haciendo Transpose-ing la matriz seguida de Reverseaplicada a cada fila. gconvierte la matriz final en una cadena.

s=StringJoin;r=Riffle;f=Nest[Reverse/@Transpose@#&,Partition[Characters@"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK",6],#-1]&;
g@n_:=s@r[s/@(r[#," "]&/@f[n]),"\n"]

Ejemplo

g[4]

Si la salida pudiera darse como una matriz, la función gsería innecesaria.

f[4]

{{"F", "G", "H", "I", "J", "K"}, {"E", "X", "Y", "Z", "0", "L "}, {" D "," W "," 7 "," 8 "," 1 "," M "}, {" C "," V "," 6 "," 9 "," 2 ", "N"}, {"B", "U", "5", "4", "3", "O"}, {"A", "T", "S", "R", "Q ", "PAGS"}}

MATLAB, 61 89 bytes

b=[65:90 48:57];n=zeros(12,6);n(2:2:end)=rot90(b(37-spiral(6)),input('')-2);disp([n' ''])

Veré si puedo bajarlo un poco. Aunque no estoy seguro.

Esto crea una matriz de todas las letras de la A a la Z seguidas de 0 a 9, luego toma una espiral y la usa para organizar los datos en el orden correcto. La matriz se gira según la cantidad que especifica el usuario y luego se imprime.

El resultado utiliza constantemente espacios iniciales según lo permitido por la pregunta (de hecho, sin costo adicional de bytes, podría hacer espacios finales en su lugar). Aquí hay un ejemplo:

 F G H I J K
 E X Y Z 0 L
 D W 7 8 1 M
 C V 6 9 2 N
 B U 5 4 3 O
 A T S R Q P

Como vi que se requieren espacios, este código original (para 61) no es válido porque no agrega un espacio entre cada carácter. Pero lo agregaré aquí como referencia.

b=['A':'Z' '0':'9'];disp(rot90(b(37-spiral(6)'),6-input('')))

y produce:

ABCDEF
TUVWXG
S567YH
R498ZI
Q3210J
PONMLK

JavaScript ES6, 165 172

Rotación simple, comenzando desde una cadena codificada

Nota 1 byte guardado thx @ user81655

p=prompt();alert("ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK".split` `.map((r,y,a)=>[...r].map((c,x)=>p<2?c:a[p<3?5-x:p<4?5-y:x][p<3?y:p<4?5-x:5-y]).join` `).join`
`)

Fragmento de prueba:

// Test: redefine alert to write inside the snippet
alert=x=>P.innerHTML=x

p=prompt();
alert(
  "ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK"
  .split` `
  .map(
    (r,y,a)=>
    [...r].map(
      (c,x)=>p<2?c:
      a
       [p<3?5-x:p<4?5-y:x]
       [p<3?y:p<4?5-x:5-y]
    ).join` `
  ).join`\n`
)

<pre id=P></pre>

Pyth - 60 bytes

Codifica la cadena y usa operaciones matriciales para obtener todas las opciones.

jjL\ @[_CKc6"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"KC_K__MK)Q

Test Suite .

Rubí, 173 bytes

->i{_,r,o=->s{s.map{|i|i*' '}},->s{s.transpose.map{|i|i.reverse}},%W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars);puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]}

Sin golf:

-> i {
  _ = -> s { s.map{|i| i*' ' } }
  r = -> s { s.transpose.map{|i| i.reverse } }
  o = %W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars)
  puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]
}

Uso:

->i{_,r,o=->s{s.map{|i|i*' '}},->s{s.transpose.map{|i|i.reverse}},%W(ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK).map(&:chars);puts i<2?_[o]:i<3?_[t=r[o]]:i<4?_[r[t]]:_[r[r[t]]]}[4]
F G H I J K
E X Y Z 0 L
D W 7 8 1 M
C V 6 9 2 N
B U 5 4 3 O
A T S R Q P

Python, 152 bytes

s=[r for r in "ABCDEF TUVWXG S567YH R498ZI Q3210J PONMLK".split(" ")]
for i in range(1,int(input())):s=zip(*list(s)[::-1])
for x in s:print(" ".join(x))