La tâche est très simple, lorsqu'on lui donne une entrée, sortez l'une des spirales suivantes:

Input = 1donne une spirale avec la lettre Acommençant dans le coin supérieur gauche:

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 = 2donne une spirale avec la lettre Acommençant dans le coin supérieur droit:

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 = 3donne une spirale avec la lettre Acommençant dans le coin inférieur droit:

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 = 4donne une spirale avec la lettre Acommençant dans le coin inférieur gauche:

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

Comme vous pouvez le voir, la spirale va toujours dans le sens des aiguilles d'une montre et se déplace de l' extérieur vers l' intérieur .

Les règles sont simples:

• Vous devez fournir un programme complet en utilisant STDIN et STDOUT, ou l'équivalent le plus proche si ce n'est pas possible.
• Étant donné une entrée ( 1, 2, 3, 4), sortez la spirale associée.
• Les espaces de fin sont autorisés
• Les espaces blancs de tête sont autorisés lorsqu'ils sont utilisés de manière cohérente
• Vous devez utiliser des lettres majuscules pour la sortie, les lettres minuscules ne sont pas autorisées.
• C'est du code-golf , donc le programme avec le moins d'octets gagne!

CJam, 45 43 42 octets

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

Testez-le ici.

Explication

'[,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 octets 58 59 60

5 octets enregistrés grâce à @ETHproductions

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

Cela utilise la commande de rotation que je n'aurais jamais pensé être si utile

Explication && 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

Essayez-le en ligne

Mathematica 156 octets

Convertit la chaîne initiale de lettres "ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK", en un tableau. Nests'applique fà ce tableau n-1fois, où n est le numéro d'entrée. ffonctionne en Transpose-ing le tableau suivi par Reverseappliqué à chaque ligne. gconvertit le tableau final en chaîne.

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

Exemple

g[4]

Si la sortie pouvait être donnée sous forme de tableau, la fonction gne serait pas nécessaire.

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 "," P "}}

MATLAB, 61 89 octets

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

Je vais voir si je peux le descendre un peu. Pas sûr cependant.

Cela crée un tableau de toutes les lettres de A à Z suivi de 0 à 9, puis prend une spirale et l'utilise pour organiser les données dans le bon ordre. Le tableau est ensuite tourné de la quantité spécifiée par l'utilisateur, puis imprimé.

La sortie utilise systématiquement les espaces de début comme le permet la question (en fait, sans coût supplémentaire en octets, elle pourrait remplacer les espaces de fin). Voici un exemple:

 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

Comme j'ai vu que des espaces sont nécessaires, ce code d'origine (pour 61) n'est pas valide car il n'ajoute pas d'espace entre chaque caractère. Mais je vais l'ajouter ici pour référence.

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

et produit:

ABCDEF
TUVWXG
S567YH
R498ZI
Q3210J
PONMLK

JavaScript ES6, 165 172

Rotation simple, à partir d'une chaîne codée en dur

Remarque 1 octet enregistré 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`
`)

Extrait de test:

// 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 octets

Codez en dur la chaîne et utilise des opérations matricielles pour obtenir toutes les options.

jjL\ @[_CKc6"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"KC_K__MK)Q

Suite de tests .

Rubis, 173 octets

->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]]]}

Non 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]]]
}

Usage:

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

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