Oto, co nazwiemy miską zupy alfabetu - mniej więcej okrągły kształt ascii-art z 26 dużymi literami angielskimi (AZ) ułożonymi zgodnie z ruchem wskazówek zegara, aby utworzyć obwód:

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

Napisz program, który przyjmuje pojedynczy znak litery AZ i wyświetla tę samą miskę zupy alfabetu „obróconą”, że tak powiem, więc litera wejściowa pojawia się tam, gdzie Arobi to w powyższym przykładzie, a reszta alfabetu krąży wokół zgodnie z ruchem wskazówek zegara.

Tak więc wynikiem wyjściowym Abyłaby ta sama oryginalna miska zupy alfabetycznej.

Wyjście dla danych wejściowych Bbyłoby takie:

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

Podobnie dane wyjściowe dla H:

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

Lub dla Z:

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

To musi działać dla wszystkich 26 liter, od A do Z.

Detale:

• Możesz założyć, że jedyną wartością wejściową będzie pojedyncza litera od A do Z.
• Jeśli to wygodne, możesz używać małych liter az do wprowadzania i / lub wyjścia, możesz nawet miksować i dopasowywać małe i wielkie litery.
• Kolejność alfabetu musi być zmieniana zgodnie z ruchem wskazówek zegara, a nie przeciwnie do ruchu wskazówek zegara.
• Musisz użyć spacji, a nie czegoś innego, aby wciąć i napełnić miskę do zupy.
• Na wyjściu mogą znajdować się początkowe lub końcowe znaki nowej linii lub spacje, o ile miska zupy jest odpowiednio ułożona.
• Pamiętaj, że kształt misy ma 12 znaków szerokości i 7 wysokości, dzięki czemu wydaje się mniej więcej okrągły jako tekst. Twoje miski muszą mieć ten sam kształt.

To jest kod golfowy, więc wygrywa najkrótszy kod!

05AB1E , 21 bajtów

Definiuje program$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Kod:

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

Wypróbuj online!

Awaria:

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

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

Wyjaśnienie:

Płótno ( Λ) w tym konkretnym kontekście działa jako funkcja z następującym podpisem:

$$\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}}$$

Parametr jest w tej sytuacji liczbą określającą kierunki. W kodzie ten numer jest reprezentowany jako , co jest skompresowaną wersją dużej liczby . Wskazówki są oznaczone w następujący sposób:$\texttt{pattern}$ 2232344565666667670012122•1못*Ć,ãiDΣ•$2232344565666667670012122$

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

Oznacza to, że duża liczba reprezentuje następujący wzór kierunków:

$$[\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]$$

W tym kontekście sygnatury płótno przechodzi przez listę i zapisuje znaki z w bieżącym kierunku.$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

jest określona w kodzie jako (na początku kodu). Do potrzebujemy obróconej wersji alfabetu, która zaczyna się od podanego wejścia. Można to zrobić za pomocą następującego kodu ( wypróbuj tutaj ):$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # Znajdź <indeks> danego znaku wejściowego w alfabecie
A ._ # Obróć alfabet w lewo <index> razy.

W pseudokodzie byłoby to wykonywane przez funkcję canvas:

$\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}$

Na koniec widać, że argument wypełniający jest „obrócony” razy w prawo, co oznacza, że ​​płótno będzie iterowało przez następującą (cykliczną, a zatem nieskończoną) listę:$\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}}, ...$$

Co daje pożądany kształt zupy alfabetu ascii-art.

Perl 6 , 100 bajtów

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

Wypróbuj online!

Zamienia wszystkie litery w ciągu na ich przesunięte odpowiedniki, a cyfry zastępuje liczbą spacji, które reprezentują, plus jedną.

Wyjaśnienie

{                                                            }# 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

Rubin , 107 bajtów

->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*$/}

Wypróbuj online!

Poprawiona składnia "i".to_c-> 1i(Sugerowane przez Jordan)

Zmieniono układ współrzędnych, więc 0 stopni jest po prawej stronie zamiast na górze. Umożliwia to 0.5->6

Skorygowano mnożniki ji kdla skrócenia

Zamiast drukować dane wyjściowe puts a, konkatenuj elementy tablicy i zwróć ciąga*$/

Ruby , 119 bajtów

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

Używa liczby zespolonej podniesionej do potęgi w celu odwzorowania na elipsę. Pełny obrót wynosi 26, więc każdy kwadrant ma 6,5.

Podejście to opiera się na wymaganym wyjściu przypominającym elipsę w stopniu wystarczającym do uzyskania prawidłowego odwzorowania.

Wypróbuj online!

Węgiel drzewny , 33 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

ＧＨ

Śledź ścieżkę.

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

Zarys miski. Każdy 7rozwija się do ↙←.

²

Przenieś jeden znak na raz (ten interfejs API zachodzi na końce każdej linii na następny).

✂⁺αα⌕αＳ

Rysuj używając podwójnego alfabetu, ale zaczynając od pozycji znaku wejściowego.

MATL , 49 bajtów

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

Co za bałagan. Ale pisanie było fajne. W grę wchodzi nawet arcus tangens.

Wypróbuj online!

Wyjaśnienie

Kod

7I8*32tvB

tworzy tablicę liczb i konwertuje je na binarne. Daje to macierz zerową

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

który jest lewą górną ćwiartką macierzy określającej pozycje liter.

[1b]&Zv

odzwierciedla tę ćwiartkę w pionie bez powtarzania ostatniego wiersza i powtarzanie w poziomie ostatniej kolumny w celu uzyskania pełnej macierzy:

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

Mamy teraz maskę z pozycjami. Kod

c

konwertuje to na char, ponieważ końcowym wynikiem będzie macierz char. Znak 0 jest wyświetlany jako spacja, a niezerowe wpisy zostaną zapisane za pomocą odpowiednich liter.

2Y2

wypycha ciąg 'abc···xyz', który zawiera 26 liter. Ten ciąg musi być przesunięty kołowo zgodnie z danymi wejściowymi. Aby to zrobić,

j7+_YS

odczytuje literę wejściową, dodaje 7 do kodu ASCII i neguje wynik. Dla danych wejściowych 'a'daje to -104, czyli wielokrotność 26, więc przesunięcie o tę wartość w kółko nic nie da. Jeśli wejściowy jest, bdaje to -105, co przesuwa łańcuch o 1 krok w lewo, aby wytworzyć 'bcd···yza'; itp.

Następnym krokiem jest zdefiniowanie kolejności, w jakiej przesunięty ciąg zostanie zapisany w niezerowych pozycjach matrycy. Do końca,

y&f

tworzy kopię macierzy i wypycha dwa wektory zawierające pozycje wierszy i kolumn oparte na 1 nonzeros. Następnie

7-w4-_

odejmuje 7 od drugiego, przenosi ten pierwszy na szczyt, odejmuje 4 od niego i neguje go. 7 i 4 określają początek współrzędnych, tak że kąty wektorów pozycji niezerowych wpisów względem tego początku określają pożądaną kolejność.

Z;YPE\

oblicza dwuargumentowy arcus tangens modulo 2 * pi, aby uzyskać te kąty. Teraz najmniejszy kąt, który wynosi 0, odpowiada wpisowi, w którym powinna iść pierwsza litera, a reszta przesuwa się w lewo.

,&S])

zmienia kolejność liter w łańcuchu zgodnie z tymi kątami, tak że gdy litery są zapisywane w niezerowych pozycjach matrycy w porządku głównym kolumny (w dół, a potem w poprzek) wynik będzie prawidłowy. Odbywa się to przez

yg(

Na przykład, jeśli wejście jest 'a'ciągiem, nie został on przesunięty cyklicznie:

abcdefghijklmnopqrstuvwxyz

Zmiana układu według kątów przekształca to w

utsvrwqxpyoznamblckdjeifgh

tak, że 'u'poprawnie przejdzie do pierwszego (w kolejności głównej kolumny) niezerowego wpisu, którym jest (3,1) w notacji macierzowej; 't'przejdzie do (4,1), 's'do (5,1); 'v'do (2,2) itd .:

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

Python 2 , 129 bajtów

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

Wypróbuj online!

R , 139 122 bajtów

-17 bajtów dzięki Giuseppe

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

Wyjaśnienie:

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

Buduje puste pole spacji

u(" &3@LKWVUTSRDC5(")

to zestaw wskaźników dla pozycji literowych odpowiadający:

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 bajtów

Zaoszczędzono 2 bajty dzięki @tsh

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

Wypróbuj online!

W jaki sposób?

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 bajty

Monity o postać

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

Wypróbuj online! Coutesy of Dyalog Classic

R , 218 197 bajtów

-21 bajtów dzięki 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='')

Wypróbuj online!

Nie golfowany:

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 = '')
}

Utworzono obrócony literowy wektor i używa się catdo wypełnienia obręczy miski tym wektorem.

Java 11, 134 bajty

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

Wypróbuj online.

Wersja 136 bajtów z możliwością gry w golfa?

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

Wypróbuj online.

Wyjaśnienie (pierwszej odpowiedzi)

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 bajtów

(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]]]})&

Wypróbuj online!

Haskell, 127 bajtów

("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

Wypróbuj online!

Każdy znak w zakodowanym ciągu jest dekodowany przez funkcję ?na ciąg:

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 bajtów

Usunięto dodatkowe nawiasy dla -2
Zastąpiono nieprzetworzony ciąg dla -1

{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'}}

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 126 118 bajtów

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

Zaoszczędzono 8 bajtów dzięki @someone. Tak, to właściwie jego nazwa użytkownika.

Wypróbuj online!

Zapytanie TSQL, 238 bajtów

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 @

Łącze testowe dla tej odpowiedzi złamało podział linii i wykluczyło spacje. Zastąpiłem spacje kropką i zastąpiłem char (13) char (13) + char (10), aby pokazać czytelny wynik.

Wypróbuj online

Nie golfowany:

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 bajtów

<?=($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'):'';

Wypróbuj online!

Przed golfem:

<?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');

Wyjaśnienie:

Używając ordkonwertujemy na liczbę całkowitą od 0 do 255. A to 65, a Z to 90.
Korzystając z tej wiedzy, pobieramy dane wejściowe i zmniejszamy je o 65, więc mamy wartość dostosowania.
Następnie iterujemy wszystkie postacie, wzywamy ordje, zmniejszamy o 65, zwiększamy o naszą wartość dopasowania. Używając modulo, zapętlamy z powrotem do 0, jeśli przekraczają 26.
Następnie zwiększamy je ponownie o 65 i przekształcamy z powrotem w litery za pomocą chr.

Niestety, php: // stdin można przesłuchać tylko raz, więc musimy przekazać dane wejściowe do funkcji w naszej pętli, uniemożliwiając nam zapisanie bajtów use($a)i zadeklarowanie zmiennej poza funkcją powstrzymuje nas przed czystym użyciem <?=metody echa - musimy zawinąć wszystko w gigantyczny trójskładnik.

C (GCC) 286 bajtów

Niezupełnie najkrótszy golf, ale działa

#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);}

Wypróbuj online

Czerwony , 139 bajtów

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

Wypróbuj online!

Naprawdę naiwne rozwiązanie.

Perl 5 -p , 110 bajtów

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

Wypróbuj online!

JavaScript (V8), 316 bajtów

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

Wypróbuj online

Po raz pierwszy wypróbuj kod golfa. Doceń wszelkie wskazówki / opinie.

Oryginalny kod przed zminimalizowaniem:

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 bajtów

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

Wypróbuj online!

C (gcc) , 200 198 197 bajtów

-3 bajty dzięki pułapce cat.

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

Wypróbuj online!

PHP , 131 bajtów

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

Wypróbuj online!