Isso é o que chamaremos de tigela de sopa de letrinhas - uma forma aproximada de arte ascii-circular com as 26 letras maiúsculas em inglês (AZ) dispostas no sentido horário para formar o perímetro:

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

Escreva um programa que use um único caractere de letra, AZ, e produza a mesma tigela de sopa de letrinhas "girada", por assim dizer, para que a letra de entrada apareça onde Aocorre no exemplo acima e o resto do alfabeto circule completamente ao redor sentido horário.

Portanto, a saída para entrada Aseria a mesma tigela original de sopa de letrinhas.

E a saída para entrada Bseria esta:

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

Da mesma forma, a saída Hseria:

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

Ou para Z:

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

Isso precisa funcionar para todas as 26 letras, de A a Z.

Detalhes:

• Você pode assumir que a única entrada será uma única letra, de A a Z.
• Se for conveniente, você pode usar az minúsculo para entrada e / ou saída, você pode até misturar e combinar minúsculas e maiúsculas.
• A ordem do alfabeto deve circular no sentido horário, não no sentido anti-horário.
• Você deve usar espaços, e não outra coisa, para recuar e encher a tigela de sopa.
• Pode haver novas linhas ou espaços iniciais ou finais na saída, desde que a tigela de sopa esteja organizada corretamente.
• Observe que a forma da tigela tem 12 caracteres de largura por 7 de altura para fazer com que pareça mais ou menos circular como texto. Suas tigelas precisam ter a mesma forma.

Este é o código de golfe, então o código mais curto vence!

05AB1E , 21 bytes

Define um programa $f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Código:

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

Experimente online!

Demolir:

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

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

Explicação:

A tela ( Λ) neste contexto específico funciona como uma função com a seguinte assinatura:

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

O parâmetro $\texttt{pattern}$ é nessa situação um número que define as direções. No código, esse número é representado como •1못*Ć,ãiDΣ•, que é uma versão compactada do grande número $2232344565666667670012122$ . As instruções são indicadas da seguinte maneira:

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

Isso significa que o grande número representa o seguinte padrão de instruções:

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

Com esse contexto de assinatura, a tela percorre a lista de $\texttt{pattern}$ e grava caracteres de $\texttt{length}$ do $\texttt{filler}$ na direção atual.

O $\texttt{length}$ é especificado no código como $2$ (no início do código). Para o $\texttt{filler}$ , precisamos de uma versão rotacionada do alfabeto para que comece com a entrada especificada. Isso é feito com o seguinte código ( tente aqui ):

AA¹k._

 Todos # Encontre o <índice> do caractere de entrada fornecido no alfabeto
A ._ # Gire o alfabeto para a esquerda <índice> vezes.

No pseudocódigo, isso seria executado pela função 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}$

Por último, você pode ver que o argumento de enchimento é 'girado' $\texttt{length} - 1$ vezes para a direita, o que significa que a tela iria percorrer a seguinte (ciclo e, portanto, infinita) lista:

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

O que resulta na forma ascii-art da sopa do alfabeto desejada.

Perl 6 , 100 bytes

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

Experimente online!

Substitui todas as letras da cadeia de caracteres por suas contrapartes deslocadas, enquanto substitui os dígitos pelo número de espaços que representam mais um.

Explicação

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

Experimente online!

Sintaxe aprimorada "i".to_c-> 1i(Sugerido por Jordan)

Sistema de coordenadas alterado para que 0 graus fique à direita em vez de em cima. Isso permite 0.5->6

Multiplicadores ajustados de je kpara encurtamento

Em vez de imprimir a saída puts a, concatene os elementos da matriz e retorne uma sequênciaa*$/

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}

Usa um número complexo elevado a uma potência para mapear para uma elipse. Uma volta completa é 26, então cada quadrante é 6,5.

Essa abordagem baseia-se na saída necessária, semelhante a uma elipse, o suficiente para que um mapeamento válido possa ser alcançado.

Experimente online!

Carvão , 33 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

ＧＨ

Traçar um caminho.

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

Contorne a tigela. Cada um se 7expande para ↙←.

²

Mova um caractere de cada vez (essa API se sobrepõe às extremidades de cada linha pela seguinte).

✂⁺αα⌕αＳ

Desenhe usando o alfabeto dobrado, mas começando na posição do caractere de entrada.

MATL , 49 bytes

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

Que bagunça. Mas foi divertido escrever. Existe até um arco tangente envolvido.

Experimente online!

Explicação

O código

7I8*32tvB

cria uma matriz de números e os converte em binário. Isso fornece a matriz zero-um

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

que é o quadrante superior esquerdo de uma matriz que especifica as posições das letras.

[1b]&Zv

reflete esse quadrante verticalmente sem repetir a última linha e horizontalmente a última coluna para produzir a matriz completa:

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

Agora temos uma máscara com as posições. O código

c

converte isso em char, porque o resultado final será uma matriz de char. O caractere 0 é exibido como espaço e as entradas diferentes de zero serão gravadas com as letras apropriadas.

2Y2

empurra a string 'abc···xyz', que contém as 26 letras. Essa sequência precisa ser deslocada circularmente conforme a entrada. Fazer isso,

j7+_YS

lê a letra de entrada, adiciona 7 ao seu código ASCII e nega o resultado. Para entrada, 'a'isso dá −104, que é um múltiplo de 26, portanto, o deslocamento circular dessa quantidade não fará nada. Se a entrada é bisso, obtém -105, que desloca a corda 1 passo para a esquerda para produzir 'bcd···yza'; etc.

O próximo passo é definir a ordem em que a sequência deslocada será gravada nas entradas diferentes de zero da matriz. Para este fim,

y&f

cria uma cópia da matriz e envia dois vetores contendo as posições de linha e coluna com base em 1 dos nonzeros. Então

7-w4-_

subtrai 7 do último, coloca o primeiro no topo, subtrai 4 dele e o nega. Os 7 e 4 especificam uma origem de coordenadas, de modo que os ângulos dos vetores de posição das entradas diferentes de zero em relação a essa origem definam a ordem desejada.

Z;YPE\

calcula o módulo arctangente de dois argumentos 2 * pi para produzir esses ângulos. Agora, o menor ângulo, que é 0, corresponde à entrada para onde a primeira letra deve ir e o restante avança no sentido anti-horário.

,&S])

reorganiza as letras na string de acordo com esses ângulos, para que, quando as letras forem escritas nas entradas diferentes de zero da matriz, na ordem das colunas principais (para baixo e depois para o outro lado), o resultado esteja correto. Isso é feito por

yg(

Por exemplo, se a entrada for 'a'a sequência não foi deslocada circularmente:

abcdefghijklmnopqrstuvwxyz

A reorganização de acordo com os ângulos transforma isso em

utsvrwqxpyoznamblckdjeifgh

de modo que 'u'irá corretamente para a primeira entrada (em ordem de coluna maior) diferente de zero, que é (3,1) na notação de matriz; 't'irá para (4,1), 's'para (5,1); 'v'para (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''')

Experimente online!

R , 139 122 bytes

-17 bytes graças a Giuseppe

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

Explicação:

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

Constrói uma caixa vazia de espaços

u(" &3@LKWVUTSRDC5(")

é um conjunto de índices para as posições das letras correspondentes a:

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

Guardado 2 bytes graças a @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]))

Experimente online!

Quão?

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

Solicita caracteres

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

Experimente online Coutesy of Dyalog Classic

R , 218 197 bytes

-21 bytes graças a 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='')

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

Criou o vetor de letra girada e usa-o catpara preencher a borda da tigela com esse vetor.

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

Experimente online.

Versão de 136 bytes com potencial para jogar golfe?

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

Experimente online.

Explicação (da primeira resposta)

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 bytes

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

Experimente 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

Experimente online!

Cada caractere na cadeia codificada é decodificado por função ?em uma cadeia:

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

Parênteses extras removidos para -2
Sequência bruta substituída por -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'}}

Experimente online!

C # (compilador interativo do Visual C #) , 126 118 bytes

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

Economizou 8 bytes graças a @someone. Sim, esse é realmente o nome de usuário dele.

Experimente online!

Consulta TSQL, 238 bytes

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 @

O link de teste para esta resposta quebrou as quebras de linha e excluiu os espaços. Substituí os espaços por ponto e substitui char (13) por char (13) + char (10) para mostrar um resultado legível.

Experimente online

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

Experimente online!

Pré-golfe:

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

Explicação:

Usando ordconvertemos para um número inteiro entre 0 e 255. A é 65 e Z é 90.
Usando esse conhecimento, pegamos a entrada e a reduzimos em 65 para termos um valor de ajuste.
Nós iteramos sobre todos os caracteres, os chamamos ord, reduzimos em 65, aumentamos em nosso valor de ajuste. Usando o módulo, retornamos a 0 se excederem 26.
Em seguida, aumentamos em 65 novamente e os convertemos novamente em letras com chr.

Infelizmente, php: // stdin só pode ser interogitado uma vez, portanto, precisamos passar a entrada para a função em nosso loop, impedindo-nos de salvar bytes use($a)e ter que declarar uma variável fora da função para impedir o uso correto do <?=método echo - temos que embrulhar tudo em um ternário gigante.

C (GCC) 286 bytes

Não é exatamente o menor golfe, mas funciona

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

Experimente online

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

Experimente online!

Uma solução realmente ingênua.

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

Experimente online!

Javascript (V8), 316 bytes

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

Experimente online

Primeira vez tentando código de golfe. Aprecie todas as dicas / feedback.

Código original antes da minificação:

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 bytes

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

Experimente online!

C (gcc) , 200 198 197 bytes

-3 bytes graças ao 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);}

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

Experimente online!