Dies wird eine Schüssel mit Buchstabensuppe genannt - eine ungefähr kreisförmige ASCII-Art-Form mit den 26 englischen Großbuchstaben (AZ), die im Uhrzeigersinn angeordnet sind, um den Umfang zu bilden:

   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK

Schreiben Sie ein Programm, das ein einzelnes Buchstabenzeichen (AZ) aufnimmt und dieselbe Schüssel Buchstabensuppe sozusagen "gedreht" ausgibt, sodass der eingegebene Buchstabe dort angezeigt wird, wo der A dies im obigen Beispiel Fall ist, und der Rest des Alphabets vollständig umläuft im Uhrzeigersinn.

Also die Ausgabe für die Eingabe A wäre also dieselbe originale Schüssel Alphabetsuppe.

Und die Ausgabe für die Eingabe Bwäre diese:

   YZABCD
 WX      EF
V          G
U          H
T          I
 SR      KJ
   QPONML

Ebenso wäre die Ausgabe für H:

   EFGHIJ
 CD      KL
B          M
A          N
Z          O
 YX      QP
   WVUTSR

Oder für Z:

   WXYZAB
 UV      CD
T          E
S          F
R          G
 QP      IH
   ONMLKJ

Dies muss für alle 26 Buchstaben von A bis Z funktionieren.

Einzelheiten:

• Sie können davon ausgehen, dass die einzige Eingabe ein einzelner Buchstabe von A bis Z ist.
• Wenn Sie die Eingabe und / oder Ausgabe in Kleinbuchstaben az vornehmen möchten, können Sie sogar Klein- und Großbuchstaben mischen und abgleichen.
• Die Alphabetreihenfolge muss im Uhrzeigersinn und nicht gegen den Uhrzeigersinn laufen.
• Sie müssen Leerzeichen verwenden, um die Suppenschüssel einzurücken und zu füllen.
• Wenn die Suppenschüssel richtig angeordnet ist, kann es vor- oder nachgestellte Zeilen oder Leerzeichen in der Ausgabe geben.
• Beachten Sie, dass die Schüsselform 12 Zeichen breit und 7 Zeichen hoch ist, damit sie als Text ungefähr kreisförmig erscheint. Ihre Schalen müssen die gleiche Form haben.

Dies ist Codegolf, also gewinnt der kürzeste Code!

05AB1E , 21 Bytes

Definiert ein Programm $f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Code:

2AA¹k._•1못*Ć,ãiDΣ•Λ

Probieren Sie es online!

Nervenzusammenbruch:

2AA¹k._•1못*Ć,ãiDΣ•Λ

2                       # <length>
 AA¹k._                 # <filler>
       •1못*Ć,ãiDΣ•    # <pattern>
                    Λ   # Invoke the canvas function.

Erläuterung:

Das canvas ( Λ) arbeitet in diesem speziellen Kontext als eine Funktion mit der folgenden Signatur:

$$\mathsf{\Lambda} : \left(\texttt{length}: \color{purple}{\texttt{Nat}},\ \texttt{filler}: \color{purple}{\texttt{String}},\ \texttt{pattern}: \color{purple}{\texttt{Nat}}\right) \rightarrow \color{purple}{\texttt{String}}$$

Der $\texttt{pattern}$ ist in dieser Situation eine Zahl, die die Richtungen definiert. Im Code wird diese Nummer als dargestellt •1못*Ć,ãiDΣ•, was eine komprimierte Version der großen Nummer $2232344565666667670012122$ . Anweisungen werden auf folgende Weise angegeben:

$$\begin{array}{l} 7 & & 0 & & 1 \\ & \nwarrow & \uparrow & \nearrow & \\ 6 & \leftarrow & \bullet & \rightarrow & 2 \\ & \swarrow & \downarrow & \searrow & \\ 5 & & 4 & & 3 \end{array}$$

Dies bedeutet, dass die große Zahl das folgende Richtungsmuster darstellt:

$$[\rightarrow, \rightarrow, \searrow, \rightarrow, \searrow, \downarrow, \downarrow, \swarrow, \leftarrow, \swarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \nwarrow, \leftarrow, \nwarrow, \uparrow, \uparrow, \nearrow, \rightarrow, \nearrow, \rightarrow, \rightarrow]$$

$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$ in der Stromrichtung.

$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # Finde den <Index> des eingegebenen Zeichens im Alphabet
A ._ # Drehen Sie das Alphabet nach links <index> mal .

Im Pseudocode würde dies von der Canvas-Funktion ausgeführt:

$\begin{array}{l} 1. & \text{Write } \color{blue}{\texttt{ab}} \text{ in the direction} \rightarrow \\ 2. & \text{Write } \color{blue}{\texttt{bc}} \text{ in the direction} \rightarrow \\ 3. & \text{Write } \color{blue}{\texttt{cd}} \text{ in the direction} \searrow \\ 4. & \text{Write } \color{blue}{\texttt{de}} \text{ in the direction} \rightarrow \\ 5. & \text{Write } \color{blue}{\texttt{ef}} \text{ in the direction} \searrow \\ 6. & \text{Write } \color{blue}{\texttt{fg}} \text{ in the direction} \downarrow \\ \dots \end{array}$

$\texttt{length} - 1$

$$[\color{blue}{\texttt{ab}}, \color{blue}{\texttt{bc}}, \color{blue}{\texttt{cd}}, \color{blue}{\texttt{de}}, \color{blue}{\texttt{ef}}, \color{blue}{\texttt{fg}}, \color{blue}{\texttt{gh}}, \color{blue}{\texttt{hi}}, \color{blue}{\texttt{ij}}, \color{blue}{\texttt{jk}}, ...$$

Daraus ergibt sich die gewünschte Buchstabensuppe in ASCII-Art Form.

Perl 6 , 100 Bytes

{"2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK".trans(/\S/=>{(try ' 'x$/+1)||chr ($/.ord+.ord)%26+65})}

Probieren Sie es online!

Ersetzt alle Buchstaben in der Zeichenfolge durch ihre verschobenen Gegenstücke, während die Ziffern durch die Anzahl der von ihnen dargestellten Leerzeichen plus eins ersetzt werden.

Erläuterung

{                                                            }# Anonymous code block
 "...".trans(/\S/=>{                                       }) # Translate non-whitespace
                    (try ' 'x$/+1)      # If digits, the amount of spaces plus one
                                  ||chr ($/.ord+.ord)%26+64  # Else the shifted letter

Ruby , 107 Bytes

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=(1i**((i.ord-n.ord-6)/6.5)).rect;a[3.5*k+=1][5.2*j+6]=i}
a*$/}

Probieren Sie es online!

Verbesserte Syntax "i".to_c->1i (Vorgeschlagen von Jordan)

Das Koordinatensystem wurde so geändert, dass 0 Grad rechts statt oben ist. Dies ermöglicht 0.5->6

Angepasste Multiplikatoren von jundk für Kürze

puts aVerketten Sie Array-Elemente und geben Sie eine Zeichenfolge zurück, anstatt die Ausgabe zu druckena*$/

Ruby , 119 Bytes

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=("i".to_c**((i.ord-n.ord+0.5)/6.5)).rect;a[3.5-j*3.3][6+k*5.17]=i}
puts a}

Verwendet eine komplexe Zahl, die auf eine Potenz angehoben wird, um eine Ellipse abzubilden. Eine komplette Runde ist 26, also ist jeder Quadrant 6,5.

Dieser Ansatz beruht darauf, dass die erforderliche Ausgabe einer Ellipse so ähnlich ist, dass eine gültige Abbildung erzielt werden kann.

Probieren Sie es online!

Holzkohle , 33 Bytes

ＧＨ→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αＳ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＧＨ

Verfolge einen Pfad.

→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→

Umreißen Sie die Schüssel. Jeder 7erweitert um ↙←.

²

Verschieben Sie jeweils ein Zeichen (diese API überlappt das Ende jeder Zeile mit dem nächsten).

✂⁺αα⌕αＳ

Zeichnen Sie mit dem doppelten Alphabet, wobei Sie an der Position des eingegebenen Zeichens beginnen.

MATL , 49 Bytes

7I8*32tvB[1b]&Zvc2Y2j7+_YSy&f7-w4-_Z;YPE\,&S])yg(

Was für ein Chaos. Aber es hat Spaß gemacht zu schreiben. Es ist sogar ein Arkustangens beteiligt.

Probieren Sie es online!

Erläuterung

Der Code

7I8*32tvB

Erstellt ein Array von Zahlen und wandelt sie in Binärdaten um. Dies ergibt die Null-Eins-Matrix

0 0 0 1 1 1
0 1 1 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0

Dies ist der obere linke Quadrant einer Matrix, die die Positionen der Buchstaben angibt.

[1b]&Zv

spiegelt diesen Quadranten vertikal wider, ohne die letzte Zeile und horizontal die letzte Spalte zu wiederholen, um die vollständige Matrix zu erzeugen:

0 0 0 1 1 1 1 1 1 0 0 0
0 1 1 0 0 0 0 0 0 1 1 0
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 1 1 0 0 0 0 0 0 1 1 0
0 0 0 1 1 1 1 1 1 0 0 0

Wir haben jetzt eine Maske mit den Positionen. Der Code

c

konvertiert dies in char, da das Endergebnis eine char-Matrix ist. Zeichen 0 wird als Leerzeichen angezeigt und die Nicht-Null-Einträge werden mit den entsprechenden Buchstaben geschrieben.

2Y2

drückt den String 'abc···xyz', der die 26 Buchstaben enthält. Diese Zeichenfolge muss gemäß der Eingabe zirkular verschoben werden. Das zu tun,

j7+_YS

Liest den eingegebenen Buchstaben, fügt seinem ASCII-Code 7 hinzu und negiert das Ergebnis. Für die Eingabe 'a'ergibt dies -104, was ein Vielfaches von 26 ist, sodass eine zirkuläre Verschiebung um diesen Betrag nichts bewirkt. Wenn die Eingabe ist, bergibt dies -105, wodurch der String 1 Schritt nach links verschoben wird, um zu produzieren 'bcd···yza'. usw.

Der nächste Schritt besteht darin, die Reihenfolge zu definieren, in der die verschobene Zeichenfolge in die Nicht-Null-Einträge der Matrix geschrieben wird. Zu diesem Zweck,

y&f

Erstellt eine Kopie der Matrix und verschiebt zwei Vektoren, die die 1-basierten Zeilen- und Spaltenpositionen der Nonzeros enthalten. Dann

7-w4-_

subtrahiert 7 von letzterer, bringt die erstere nach oben, subtrahiert 4 von ihr und negiert sie. Die 7 und 4 geben einen Koordinatenursprung an, so dass die Winkel der Positionsvektoren der Nicht-Null-Einträge in Bezug auf diesen Ursprung die gewünschte Reihenfolge definieren.

Z;YPE\

berechnet den aus zwei Argumenten bestehenden Arkustangens Modulo 2 * pi, um diese Winkel zu erzeugen. Jetzt entspricht der kleinste Winkel, der 0 ist, der Eingabe, in die der erste Buchstabe gehen soll, und der Rest rückt gegen den Uhrzeigersinn vor.

,&S])

Ordnet die Buchstaben in der Zeichenfolge entsprechend diesen Winkeln neu an, so dass das Ergebnis korrekt ist, wenn die Buchstaben in Spalten-Hauptreihenfolge (abwärts, dann quer) in die Nicht-Null-Einträge der Matrix geschrieben werden. Dies geschieht durch

yg(

Wenn es sich bei der Eingabe beispielsweise um 'a'eine Zeichenfolge handelt, die nicht zirkulär verschoben wurde:

abcdefghijklmnopqrstuvwxyz

Die Umordnung nach den Winkeln transformiert dies in

utsvrwqxpyoznamblckdjeifgh

Damit 'u'wird der erste Eintrag (in der Reihenfolge der Spalten), der nicht Null ist (3,1), in der Matrixnotation korrekt angegeben. 't'geht zu (4,1), 's'zu (5,1); 'v'zu (2,2) etc:

   ······   
 v·      ·· 
u          ·
t          ·
s          ·
 ··      ·· 
   ······   

Python 2 , 129 Bytes

lambda x:''.join((i,chr((ord(x)+ord(i))%26+65),' '*5)[ord(i)/46]for i in'''   XYZABC
 VW] DE
U]]F
T]]G
S]]H
 RQ] JI
   PONMLK''')

Probieren Sie es online!

R , 139 122 Bytes

-17 Bytes dank Giuseppe

u=utf8ToInt;`*`=rep;o=c(' '*12,'
')*7;o[u("  &3@LKWVUTSRDC5(")]=LETTERS[(13:38+u(scan(,'')))%%26+1];cat(o,sep='')

Erläuterung:

o=rep(c(rep(' ',12),'
'),7) 

Erstellt eine leere Kiste mit Leerzeichen

u(" &3@LKWVUTSRDC5(")

ist eine Reihe von Indizes für Buchstabenpositionen, die entsprechen:

c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)

TIO

JavaScript (Node.js) ,  121  119 Bytes

2 Bytes dank @tsh gespeichert

c=>`2XYZABC
0VW5DE
U9F
T9G
S9H
0RQ5JI
2PONMLK`.replace(/./g,x=>''.padEnd(+x+1)||(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))

Probieren Sie es online!

Wie?

Buffer$x$$c$

$c=$"H"$x=$"B"

// extracting the ASCII codes
Buffer(c + x) → Buffer("HB") → <Buffer 48 42>

// assigning them to variables
[a, b] = Buffer(c + x) → a = 0x48 (72) and b = 0x42 (66)

// computing the ASCII code of the target letter
65 + ((a + b) % 26) → 65 + (138 % 26) → 65 + 8 → 73

// turning it back into a character
Buffer([73]) → <Buffer 49> → implicitly coerced to "I" by replace()

APL + WIN, 72 Bytes

Fordert zur Eingabe des Charakters auf

m←7 12⍴' '⋄n←(7⍴2)⊤v,⌽v←(⍳3)/28 34 65⋄((,n)/,m)←(22+s⍳⎕)⌽s←⎕av[65+⍳26]⋄m

Probieren Sie es online! Coutesy von Dyalog Classic

R , 218 197 Bytes

-21 Bytes dank Giuseppe

function(t,l=letters,`*`=rep,s=" ",n="
",`~`=`[`,r=c(l~l>=t,l))cat(s*3,r~24:26,r~1:3,n,s,r~22:23,q<-s*6,r~4:5,n,r~21,u<-s*10,r~6,n,r~20,u,r~7,n,r~19,u,r~8,n,s,r~17:18,q,r~10:9,n,s*3,r~16:11,sep='')

Probieren Sie es online!

Ungolfed:

alphasoup <- function(startlet){
  startnum <- which(l == startlet)
  rotatedletters <- c(letters[startnum:26], letters[1:(startnum -1)])[1:26]
  cat('   ',rotatedletters[24:26],rotatedletters[1:3], '\n ', 
      rotatedletters[22:23], s6 <- '      ', rotatedletters[4:5], '\n',
      rotatedletters[21], s10 <- rep(' ', 10), rotatedletters[6], '\n',
      rotatedletters[20], s10, rotatedletters[7], '\n',
      rotatedletters[19], s10, rotatedletters[8], '\n ',
      rotatedletters[17:18], s6, rotatedletters[10:9], '\n   ',
      rotatedletters[16:11],
      sep = '')
}

Erstellt gedrehten Buchstaben Vektor und verwendet cat, um Rand der Schüssel mit diesem Vektor auszufüllen.

Java 11, 134 Bytes

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.print(i<59?" ".repeat(i-47):(char)(i>90?10:(c+i)%26+65)))

Probieren Sie es online aus.

136-Byte-Version mit Potenzial zum Golfen?

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.printf("%"+(i<59?i-47:"")+"c",i>90?10:i<59?32:(c+i)%26+65))

Probieren Sie es online aus.

Erklärung (der ersten Antwort)

c->                          // Method with character parameter and no return-type
  "2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK"
                             //  Template-String
    .chars().forEach(i->     //  Loop over the unicode values of its characters:
    System.out.print(        //   Print:
     i<59?                   //    If the value is below 59 (so a digit character):
      " ".repeat(i-47)       //     Repeat a space that digit + 1 amount of times
     :(char)(i>90?           //    Else-if the value is above 90 (an underscore character):
              10             //     Print a newline
             :               //    Else:
              (c+i)          //     Add the current value and the input together
                   %26       //     Take modulo-26 of it to get the index in the alphabet
                      +65))) //     And add 65 to make it an uppercase letter

Wolfram Language (Mathematica) , 258 Byte

(t[x_]:=Table[" ",x];w=RotateRight[Alphabet[],4-LetterNumber@#];j=Join;a[x_,y_]:=j[{w[[x]]},t@10,{w[[y]]}];b[m_,n_]:=j[t@1,w[[m;;m+1]],t@6,w[[n;;n+1]],t@1];""<>#&/@{j[t@3,w[[1;;6]]],b[25,7],a[24,9],a[23,10],a[22,11],Reverse@b[12,20],j[t@3,w[[19;;14;;-1]]]})&

Probieren Sie es online!

Haskell, 127 Bytes

("cXYZABC aVWfDE UjF TjG SjH aRQfJI cPONMLK">>=).(?)
t?c|c>'Z'=' '<$['a'..c]|c<'!'="\n"|t<'B'=[c]|c>'Y'=t?'@'|1<2=pred t?succ c

Probieren Sie es online!

Jedes Zeichen in der codierten Zeichenfolge wird von der Funktion ?in eine Zeichenfolge decodiert :

t?c                             -- 't' is the starting char,
                                -- 'c' the char from the encoded string
   |c>'Z'=' '<$['a'..c]         -- if 'c' is a lowercase letter, return some spaces
                                -- 'a': one, 'b': two, etc
   |c<'!'="\n"                  -- if 'c' is a space, return a newline
   |t<'B'=[c]                   -- if 't' is the letter A, return 'c'
   |c>'Y'=t?'@'                 -- wrap around Z
   |1<2=pred t?succ c           -- else the result is the same as starting one letter
                                -- earlier (pred t) but looking at the successor of 'c'

Kotlin , 148 146 145 Bytes

Zusätzliche Klammern für -2 entfernt.
Rohe Zeichenfolge für -1 ersetzt

{l:Char->"2XYZABC 0VW5DE U9F T9G S9H 0RQ5JI 2PONMLK".map{c->if(c>'@')((c-'A'+(l-'A'))%26+65).toChar()
else if(c>' ')" ".repeat(c-'/')
else '\n'}}

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 126 118 Byte

n=>$@"   XYZABC
 VW{"",6}DE
U {"",9}F
T {"",9}G
S {"",9}H
 RQ{"",6}JI
   PONMLK".Select(b=>b<65?b:(char)((b+n)%26+65))

8 Bytes dank @someone gespeichert. Ja, das ist eigentlich sein Benutzername.

Probieren Sie es online!

TSQL-Abfrage, 238 Byte

DECLARE @y char='G'

,@ char(91)=3;WITH C as(SELECT'5585877636333330301125255'z,8a,ascii(@y)x
UNION ALL
SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65FROM
C WHERE''<z)SELECT
@=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))FROM
C PRINT @

Der Testlink für diese Antwort hat die Zeilenumbrüche gebrochen und die Leerzeichen ausgeschlossen. Ich habe die Leerzeichen durch Punkt und char (13) durch char (13) + char (10) ersetzt, um ein lesbares Ergebnis zu erhalten.

Probieren Sie es online aus

Ungolfed:

DECLARE @y char='G'

-- @ is the string being printed last. 
-- @ is populated with 3 to save a byte
-- the number 3 gets replaced later
-- (this could have been any 1 digit value), 
-- @ is automatically filled with spaces, because
-- it is declared as a char(x) and assigned a value
,@ char(91)=3;
-- recursive query
WITH C as
(
-- z string containing digits for the direction of next letter
-- z should not contain 4 because it will point to same position.
-- values in z 0,1,2,3,4,5,6,7,8 can logally convert to 
-- (-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)
-- a is the starting position
  SELECT'5585877636333330301125255'z,8a,ascii(@y)x
  UNION ALL
-- stuff remove first character from the z string
-- a calculate next position of the next letter
-- x cycle the input letter
  SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65
-- repeat recursive until long string is empty
  FROM C
  WHERE''<z
)
SELECT
-- 1st stuff replace the character to created the start of a 
--   logical line in the string @ this is where 3 gets overwritten
-- 2nd stuff replaces a character(space if coded correct) 
--  with the letter at the calculated position.
  @=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))
FROM C

PRINT @

PHP , 236 229 226 Bytes

<?=($a=ord(file_get_contents('php://stdin'))-65)?preg_replace_callback('~\w~',function($m)use($a){return chr((ord($m[0])-65+$a)%26+65);},'   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK'):'';

Probieren Sie es online!

Pre-Golf:

<?php
$adjust = ord(file_get_contents('php://stdin')) - 65;
echo preg_replace_callback('~\w~', function($match) use ($adjust) {
    $new = ord($match[0]) - 65;
    $new = ($new + $adjust) % 26;
    $new += 65;
    return chr($new);
}, '   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK');

Erläuterung:

Mit ordkonvertieren wir in eine Ganzzahl zwischen 0 und 255. A ist 65 und Z ist 90.
Mit diesem Wissen nehmen wir die Eingabe und reduzieren sie um 65, so dass wir einen Anpassungswert haben.
Wir iterieren dann über alle Zeichen, rufen ordsie auf, reduzieren sie um 65 und erhöhen sie um unseren Anpassungswert. Mit modulo schleifen wir auf 0 zurück, wenn sie 26 überschreiten.
Dann erhöhen wir sie wieder um 65 und wandeln sie mit wieder in Buchstaben um chr.

Leider kann php: // stdin nur einmal abgefragt werden, daher müssen wir die Eingabe an die Funktion in unserer Schleife übergeben, um zu verhindern, dass wir Bytes einsparen use($a)und eine Variable außerhalb der Funktion deklarieren müssen. Dies hindert uns daran, die <?=Echo-Methode sauber zu verwenden. wir müssen alles in einen riesigen Dreiklang wickeln.

C (GCC) 286 Bytes

Nicht gerade das kürzeste Golf, aber es funktioniert

#define r(a)(a+c)%26+65
#define R(a)for(i=10;i;a[--i]<33?:(a[i]=r(a[i])));
i;f(c){char*S="          ",T[]="   XYZABC\n",E[]="VW      DE\n",F[]="RQ      JI\n",B[]="   PONMLK";R(T)R(E)R(F)R(B)printf("%s %s%c%s%c\n%c%s%c\n%c%s%c\n %s%s",T,E,r(85),S,r(70),r(84),S,r(71),r(83),S,r(72),F,B);}

Probieren Sie es online aus

rot , 139 Bytes

func[a][foreach c{   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK}[if c > sp[c: c + a % 26 + 65]prin c]]

Probieren Sie es online!

Eine wirklich naive Lösung.

Perl 5 -p , 110 Bytes

$b=/A/?Z:chr(-1+ord);$_=eval("'2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK'=~y/A-Z/$_-ZA-$b/r");s/\d/$".$"x$&/eg

Probieren Sie es online!

Javascript (V8), 316 Byte

function a(b){n="abcdefghijklmnopqrstuvwxyz".split(b);n=b+n[1]+n[0],console.log(`   ${n[23]+n[24]+n[25]+n[0]+n[1]+n[2]}\n ${n[21]+n[22]}      ${n[3]+n[4]}\n${n[20]}          ${n[5]}\n${n[19]}          ${n[6]}\n${n[18]}          ${n[7]}\n ${n[17]+n[16]}      ${n[9]+n[8]}\n   ${n[15]+n[14]+n[13]+n[12]+n[11]+n[10]}`)}

Probieren Sie es online aus

Zum ersten Mal Code Golf ausprobieren. Schätzen Sie alle Tipps / Feedback.

Originalcode vor dem Verkleinern:

function a(b){
    var c = ("abcdefghijklmnopqrstuvwxyz").split(b);
    c = b+c[1]+c[0]
    console.log(`   ${c[23]+c[24]+c[25]+c[0]+c[1]+c[2]}\n ${c[21]+c[22]}      ${c[3]+c[4]}\n${c[20]}          ${c[5]}\n${c[19]}          ${c[6]}\n${c[18]}          ${c[7]}\n ${c[17]+c[16]}      ${c[9]+c[8]}\n   ${c[15]+c[14]+c[13]+c[12]+c[11]+c[10]}`)
}

APL (Dyalog Classic) , 50 Byte

⎕a@((-⎕a⍳⍞)⌽∪⌊.5+{3 5.5×1-2 1○○⍵÷¯19}¨⍳38)⊢7 12⍴''

Probieren Sie es online!

C (GCC) , 200 198 197 Bytes

-3 Bytes dank ceilingcat.

x,z;f(c){char*y,t[27],i=0;for(c-=46;i<14;t[13+i++]=(c-i)%26+65)t[i]=(c+i)%26+65;for(i=-4;++i<4;printf("%*.*s%*.*s\n",3273>>x*3&7,x?:1,y,z,x?:1,y+2*!i+z))z="--*%"[x=abs(i)]-34,y=t+x+(x>2)+13*(i>0);}

Probieren Sie es online!

PHP , 131 Bytes

for(;$s='2YZABCD
 WX5EF
V9G
U9H
T9I
 SR5KJ
2QPONML'[$i++];)echo$s<A?$s<'0'?$s:str_pad('',$s+1,' '):chr(65+(ord($s)+ord($argn))%26);

Probieren Sie es online!