Це те, що ми будемо називати мискою з алфавітним супом - приблизно круглою формою ascii-art з 26 великими англійськими літерами (AZ), розташованими за годинниковою стрілкою, щоб утворити периметр:

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

Напишіть програму, яка містить символи однієї літери, AZ, і виводить ту саму миску супу з алфавітом "повернутий", так би мовити, так що введення букви з’являється там, де Aв наведеному вище прикладі, а решта алфавіту цикли повністю за годинниковою стрілкою.

Таким чином, вихідним для введення Aбуде та сама оригінальна миска з алфавітним супом.

А вихід для введення Bбуде таким:

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

Так само вихід для H:

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

Або для Z:

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

Для цього потрібно працювати на всі 26 літер, від A до Z.

Деталі:

• Можна припустити, що єдиним введенням буде одна літера, від A до Z.
• Якщо вам зручно, ви можете використовувати малі літери az для введення та / або виведення, ви навіть можете змішувати та поєднувати малі та великі регістри.
• Порядок алфавіту повинен рухатись за годинниковою стрілкою, а не проти годинникової стрілки.
• Ви повинні використовувати пробіли, а не щось інше, для відступу та наповнення чаші для супу.
• У виході можуть бути провідні або зворотні нові рядки або пробіли, якщо миска супу розташована належним чином.
• Зауважте, що форма чаші шириною 12 символів на 7 заввишки, щоб вона виглядала приблизно круглою як текст. Ваші миски повинні бути однакової форми.

Це кодовий гольф, тому найкоротший код виграє!

05AB1E , 21 байт

Визначає програму$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Код:

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

Спробуйте в Інтернеті!

Зламатися:

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

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

Пояснення:

Полотно ( Λ) в даному контексті працює як функція з наступною підписом:

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

Параметр в цій ситуації є числом, що визначає напрямки. У коді це число представлено як , що є стислою версією великого числа . Напрямки позначаються таким чином:$\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}$$

Це означає, що велика кількість представляє таку схему напрямків:

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

задається в коді як (на початку коду). Для нам потрібна повернута версія алфавіту, яка починається з заданого вводу. Це робиться за допомогою наступного коду ( спробуйте тут ):$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # Знайдіть <index> заданого символу введення в алфавіті
A ._ # Поверніть алфавіт вліво <index> разів.

У псевдокоді це буде виконуватися функцією 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}$

Нарешті, ви бачите, що аргумент наповнювача 'повертається' раз праворуч, це означає, що полотно повторюється через наступний (циклічний і, таким чином, нескінченний) список:$\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}}, ...$$

Це призводить до отримання бажаної форми алфавітного супу ascii-art.

Perl 6 , 100 байт

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

Спробуйте в Інтернеті!

Замінює всі літери в рядку зі зміщеними аналогами, замінюючи цифри кількістю пробілів, які вони представляють плюс один.

Пояснення

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

Рубін , 107 байт

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

Спробуйте в Інтернеті!

Покращений синтаксис "i".to_c-> 1i(Запропоновано Йорданом)

Змінена система координат, тому 0 градусів знаходиться праворуч замість верху. Це дозволяє 0.5->6

Налагоджені множники jта kна короткість

Замість того, щоб виводити друк puts a, об'єднуйте елементи масиву та повертайте рядокa*$/

Рубін , 119 байт

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

Використовує складне число, підняте на потужність для відображення на еліпс. Повна черга - 26, тому кожен квадрант - 6,5.

Цей підхід покладається на необхідний вихід, що нагадує еліпс, достатньо, щоб можна було досягти дійсного відображення.

Спробуйте в Інтернеті!

Вугілля деревне , 33 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

ＧＨ

Простежте шлях.

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

Накресліть миску. Кожен 7розширюється до ↙←.

²

Перемістіть по одному символу (цей API перекриває кінці кожного рядка з наступним).

✂⁺αα⌕αＳ

Малюйте за допомогою подвоєного алфавіту, але починаючи з позиції вхідного символу.

MATL , 49 байт

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

Який безлад. Але писати було весело. Тут навіть задіяний арктангент.

Спробуйте в Інтернеті!

Пояснення

Код

7I8*32tvB

створює масив чисел і перетворює їх у двійкові. Це дає матрицю нуля-один

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

який є лівим у верхньому квадранті матриці із зазначенням позицій літер.

[1b]&Zv

відображає цей квадрант вертикально, не повторюючи останній рядок, а горизонтально повторюючи останній стовпець, щоб отримати повну матрицю:

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

Тепер у нас є маска з позиціями. Код

c

перетворює це в char, оскільки кінцевим результатом буде матриця char. Символ 0 відображається як пробіл, а ненульові записи будуть записані відповідними літерами.

2Y2

висуває рядок 'abc···xyz', що містить 26 букв. Цю рядок потрібно зрушити по колу відповідно до вводу. Для цього

j7+_YS

читає вхідний лист, додає 7 до свого коду ASCII і заперечує результат. Для введення 'a'це дає −104, що кратно 26, тому круговий зсув на цю суму не дасть нічого. Якщо вхідний, bце дає -105, який зміщує рядок 1 крок вліво для отримання 'bcd···yza'; тощо.

Наступним кроком є ​​визначення порядку, в якому зміщена рядок буде записана в ненульові записи матриці. До цього кінця,

y&f

створює копію матриці і висуває два вектори, що містять на основі 1 рядка та позиції стовпців ненульових знаків. Тоді

7-w4-_

віднімає 7 з останнього, приводить перше до верху, віднімає від нього 4 і заперечує його. 7 і 4 задають початок координат, щоб кути векторів позиції ненульових записів щодо цього початку визначали бажаний порядок.

Z;YPE\

обчислює двоаргументний модуль арктангенту 2 * pi для отримання цих кутів. Тепер найменший кут, який дорівнює 0, відповідає запису, куди повинна йти перша буква, а решта просуватися проти годинникової стрілки.

,&S])

переставляє літери в рядку відповідно до цих кутів, щоб, коли букви були записані в ненульові записи матриці в порядку основного стовпця (вниз, потім поперек), результат буде правильним. Це робиться шляхом

yg(

Наприклад, якщо введення 'a'рядка не було зміщене по колу:

abcdefghijklmnopqrstuvwxyz

Перестановка за кутами перетворює це на

utsvrwqxpyoznamblckdjeifgh

так що 'u'правильно перейде до першого (у стовпці основного порядку) ненульового запису, який є (3,1) у матричній нотації; 't'перейде до (4,1), 's'до (5,1); 'v'до (2,2) тощо:

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

Python 2 , 129 байт

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

Спробуйте в Інтернеті!

R , 139 122 байти

-17 байт завдяки Джузеппе

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

Пояснення:

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

Створює порожнє поле пробілів

u(" &3@LKWVUTSRDC5(")

- це набір індексів для літерних позицій, що відповідають:

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

ТІО

JavaScript (Node.js) ,  121  119 байт

Збережено 2 байти завдяки @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]))

Спробуйте в Інтернеті!

Як?

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 байти

Підказки до характеру

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

Спробуйте в Інтернеті! Люб'язність Dyalog Classic

R , 218 197 байт

-21 байт завдяки Джузеппе

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

Спробуйте в Інтернеті!

Безголівки:

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

Створений обертовий векторний лист та використовує catдля заповнення ободу чаші цим вектором.

Java 11, 134 байти

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

Спробуйте в Інтернеті.

136- байтна версія з потенціалом для гольфу?

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

Спробуйте в Інтернеті.

Пояснення (першої відповіді)

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

Мова Вольфрама (Mathematica) , 258 байт

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

Спробуйте в Інтернеті!

Haskell, 127 байт

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

Спробуйте в Інтернеті!

Кожен символ кодованого рядка декодується функцією ?в рядок:

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'

Котлін , 148 146 145 байт

Вилучені додаткові дужки для -2
Замінений рядок для -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'}}

Спробуйте в Інтернеті!

C # (Visual C # Interactive Compiler) , 126 118 байт

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 байт завдяки @someone. Так, це власне його ім'я користувача.

Спробуйте в Інтернеті!

Запит TSQL, 238 байт

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 @

Тестове посилання на цю відповідь порушило розриви рядків та виключило пробіли. Я замінив пробіли періодом і замінив char (13) на char (13) + char (10), щоб показати читабельний результат.

Спробуйте в Інтернеті

Безголівки:

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 байт

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

Спробуйте в Інтернеті!

До гольфу:

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

Пояснення:

Використовуючи, ordми перетворюємо в ціле число від 0 до 255. А - це 65, а Z - 90.
Використовуючи ці знання, ми беремо вхід і зменшуємо його на 65, щоб у нас було значення коригування.
Потім ми повторюємо всі символи, дзвонимо ordїм, зменшуємо їх на 65, збільшуємо їх на наше значення коригування. Використовуючи модуль, ми петлюємо назад до 0, якщо вони перевищують 26.
Потім їх знову збільшуємо на 65 і перетворюємо їх назад в літери з chr.

На жаль, php: // stdin може бути інтегрований лише один раз, тому нам потрібно передати вхід у функцію в нашому циклі, не дозволяючи нам зберігати байти use($a)і необхідність оголосити змінну за межами функції не заважає нам чисто використовувати <?=метод echo - ми повинні загортати все в гігантський трійник.

C (GCC) 286 байт

Не зовсім найкоротший гольф, але він працює

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

Спробуйте в Інтернеті

Червоний , 139 байт

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

Спробуйте в Інтернеті!

Справді наївне рішення.

Perl 5 -p , 110 байт

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

Спробуйте в Інтернеті!

Javascript (V8), 316 байт

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

Спробуйте в Інтернеті

Перший раз пробуйте код гольф. Вдячні за будь-які поради / відгуки.

Оригінальний код перед мінімізацією:

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 байт

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

Спробуйте в Інтернеті!

C (gcc) , 200 198 197 байт

-3 байти завдяки стельовій коті.

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

Спробуйте в Інтернеті!

PHP , 131 байт

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

Спробуйте в Інтернеті!