Die Aufgabe ist sehr einfach, wenn eine Eingabe gegeben ist, geben Sie eine der folgenden Spiralen aus:

Input = 1ergibt eine Spirale mit dem Buchstaben Abeginnend in der oberen linken Ecke:

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 = 2ergibt eine Spirale mit dem Buchstaben, der Ain der oberen rechten Ecke beginnt:

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 = 3ergibt eine Spirale mit dem Buchstaben, der Ain der unteren rechten Ecke beginnt:

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 = 4ergibt eine Spirale mit dem Buchstaben Abeginnend in der linken unteren Ecke:

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

Wie Sie sehen, bewegt sich die Spirale immer im Uhrzeigersinn von außen nach innen .

Die Regeln sind einfach:

• Sie müssen ein vollständiges Programm mit STDIN und STDOUT oder dem nächstgelegenen Äquivalent bereitstellen, falls dies nicht möglich ist.
• Bei einer Eingabe ( 1, 2, 3, 4) wird die zugehörige Spirale ausgegeben.
• Nachgestellte Leerzeichen sind zulässig
• Führende Leerzeichen sind zulässig, wenn sie konsistent verwendet werden
• Sie müssen für die Ausgabe Großbuchstaben verwenden, Kleinbuchstaben sind nicht zulässig.
• Das ist Code-Golf , also gewinnt das Programm mit der geringsten Anzahl von Bytes!

CJam, 45 43 42 Bytes

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

Teste es hier.

Erläuterung

'[,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

5 Bytes gespart dank @ETHproductions

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

Dabei wird der Befehl "Drehen" verwendet, von dem ich nie gedacht hätte, dass er so nützlich ist

Erklärung && 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

Probieren Sie es online aus

Mathematica 156 Bytes

Konvertiert die Anfangsbuchstabenfolge "ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"in ein Array. Nestgilt ffür diese Array- n-1Zeiten, wobei n die Eingangsnummer ist. fFunktioniert, indem Transposedas Array gefolgt von Reverseauf jede Zeile angewendet wird. gwandelt das endgültige Array in einen String um.

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

Beispiel

g[4]

Wenn die Ausgabe als Array angegeben werden könnte, wäre die Funktion gnicht erforderlich.

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 Bytes

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

Ich werde sehen, ob ich es ein bisschen runterholen kann. Bin mir aber nicht sicher.

Dadurch wird ein Array aller Buchstaben von A bis Z erstellt, gefolgt von 0 bis 9. Anschließend wird eine Spirale erstellt, mit der die Daten in der richtigen Reihenfolge angeordnet werden. Das Array wird dann um den vom Benutzer angegebenen Betrag gedreht und ausgedruckt.

Die Ausgabe verwendet konsistent führende Leerzeichen, wie in der Frage angegeben (ohne zusätzliche Bytekosten könnten stattdessen nachfolgende Leerzeichen verwendet werden). Hier ist ein Beispiel:

 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

Wie ich gesehen habe, dass Leerzeichen erforderlich sind, ist dieser ursprüngliche Code (für 61) ungültig, da zwischen den einzelnen Zeichen kein Leerzeichen eingefügt wird. Aber ich werde es hier als Referenz hinzufügen.

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

und produziert:

ABCDEF
TUVWXG
S567YH
R498ZI
Q3210J
PONMLK

JavaScript ES6, 165 172

Einfache Drehung ausgehend von einer fest codierten Zeichenfolge

Hinweis 1 Byte gespeichert dank @ 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`
`)

Testschnipsel:

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

Codiert die Zeichenfolge fest und verwendet Matrixoperationen, um alle Optionen abzurufen.

jjL\ @[_CKc6"ABCDEFTUVWXGS567YHR498ZIQ3210JPONMLK"KC_K__MK)Q

Test Suite .

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

Ungolfed:

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

Verwendung:

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