Esto es lo que llamaremos un tazón de sopa de letras, una forma de arte ascii más o menos circular con las 26 letras en inglés mayúsculas (AZ) dispuestas en sentido horario para formar el perímetro:

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

Escriba un programa que tome un solo carácter de letra, AZ, y muestre el mismo tazón de sopa de letras "rotado", por así decirlo, de modo que la letra de entrada aparezca donde aparece Aen el ejemplo anterior y el resto del alfabeto se desplaza por completo agujas del reloj.

Entonces, la salida para la entrada Asería el mismo tazón original de sopa de letras.

Y la salida para la entrada Bsería esta:

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

Del mismo modo, la salida para Hsería:

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

O para Z:

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

Esto debe funcionar para las 26 letras, de la A a la Z.

Detalles:

• Puede suponer que la única entrada será una sola letra, de la A a la Z.
• Si es conveniente, puede usar minúsculas az para la entrada y / o salida, incluso puede mezclar y combinar minúsculas y mayúsculas.
• El orden alfabético debe circular en sentido horario, no en sentido antihorario.
• Debes usar espacios, no otra cosa, para sangrar y llenar el tazón de sopa.
• Puede haber nuevas líneas o espacios iniciales o finales en la salida, siempre que el tazón de sopa esté dispuesto correctamente.
• Tenga en cuenta que la forma del cuenco tiene 12 caracteres de ancho por 7 de alto para que parezca más o menos circular como texto. Tus cuencos deben tener la misma forma.

Este es el código de golf, por lo que gana el código más corto.

05AB1E , 21 bytes

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

Código:

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

Pruébalo en línea!

Descompostura:

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

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

Explicación:

El lienzo ( Λ) en este contexto particular funciona como una función con la siguiente firma:

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

El es en esta situación un número que define las direcciones. En el código, este número se representa como , que es una versión comprimida del número grande . Las indicaciones se indican de la siguiente manera:$\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}$$

Esto significa que el número grande representa el siguiente patrón de direcciones:

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

Con este contexto de firma, el lienzo itera a través de la lista y escribe caracteres desde el en la dirección actual.$\texttt{pattern}$relleno de $\texttt{length}$patrón$\texttt{filler}$

El se especifica en el código como (al comienzo del código). Para el , necesitamos una versión rotada del alfabeto de manera que comience con la entrada dada. Eso se hace con el siguiente código ( pruébalo aquí ):$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # Encuentra el <índice> del carácter de entrada dado en el alfabeto
A ._ # Gire el alfabeto a la izquierda <índice> veces.

En pseudocódigo, esto sería ejecutado por la función de lienzo:

$\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, puede ver que el argumento de relleno está 'girado' veces a la derecha, lo que significa que el lienzo iteraría a través de la siguiente lista (ciclada y, por lo tanto, infinita):$\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}}, ...$$

Lo que da como resultado la forma de arte ascii de la sopa de letras deseada.

Perl 6 , 100 bytes

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

Pruébalo en línea!

Reemplaza todas las letras en la cadena con sus contrapartidas desplazadas, mientras reemplaza los dígitos con el número de espacios que representan más uno.

Explicación

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

Pruébalo en línea!

Sintaxis mejorada "i".to_c-> 1i(Sugerido por Jordan)

Se cambió el sistema de coordenadas para que 0 grados estén a la derecha en lugar de arriba. Esto permite 0.5->6

Multiplicadores ajustados de jy kpara acortar

En lugar de imprimir la salida puts a, concatene los elementos de la matriz y devuelva una cadenaa*$/

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}

Utiliza un número complejo elevado a una potencia para mapear a una elipse. Un turno completo es 26, por lo que cada cuadrante es 6.5.

Este enfoque se basa en la salida requerida que se asemeja a una elipse lo suficiente como para lograr una asignación válida.

Pruébalo en línea!

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＧＨ

Traza un camino.

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

Esboza el tazón. Cada uno se 7expande a ↙←.

²

Mueva un carácter a la vez (esta API se superpone a los extremos de cada línea con la siguiente).

✂⁺αα⌕αＳ

Dibuje usando el alfabeto duplicado, pero comenzando en la posición del carácter de entrada.

MATL , 49 bytes

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

Que desastre. Pero fue divertido escribir. Incluso hay un arcotangente involucrado.

Pruébalo en línea!

Explicación

El código

7I8*32tvB

crea una matriz de números y los convierte a binarios. Esto le da a la matriz cero uno

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 es el cuadrante superior izquierdo de una matriz que especifica las posiciones de las letras.

[1b]&Zv

refleja ese cuadrante verticalmente sin repetir la última fila y horizontalmente la última columna para producir la 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

Ahora tenemos una máscara con las posiciones. El código

c

convierte esto a char, porque el resultado final será una matriz char. El carácter 0 se muestra como espacio, y las entradas distintas de cero se escribirán con las letras apropiadas.

2Y2

empuja la cuerda 'abc···xyz', que contiene las 26 letras. Esta cadena debe desplazarse circularmente según la entrada. Para hacer eso,

j7+_YS

lee la letra de entrada, agrega 7 a su código ASCII y niega el resultado. Para la entrada, 'a'esto da −104, que es un múltiplo de 26, por lo que el desplazamiento circular por esta cantidad no hará nada. Si la entrada es besto da −105, que desplaza la cadena 1 paso hacia la izquierda para producir 'bcd···yza'; etc.

El siguiente paso es definir el orden en que la cadena desplazada se escribirá en las entradas distintas de cero de la matriz. Para tal fin,

y&f

crea una copia de la matriz y empuja dos vectores que contienen las posiciones de fila y columna basadas en 1 de los nonzeros. Entonces

7-w4-_

resta 7 de este último, lleva el primero a la parte superior, resta 4 de él y lo niega. Los puntos 7 y 4 especifican un origen de coordenadas, de modo que los ángulos de los vectores de posición de las entradas distintas de cero con respecto a ese origen definen el orden deseado.

Z;YPE\

calcula el módulo arcotangente de dos argumentos 2 * pi para producir esos ángulos. Ahora el ángulo más pequeño, que es 0, corresponde a la entrada donde debe ir la primera letra, y el resto avanza en sentido antihorario.

,&S])

reorganiza las letras en la cadena de acuerdo con esos ángulos, de modo que cuando las letras se escriben en las entradas distintas de cero de la matriz en orden de columna mayor (abajo, luego a través) el resultado será correcto. Esto se hace por

yg(

Por ejemplo, si la entrada es 'a'la cadena no se desplazó circularmente:

abcdefghijklmnopqrstuvwxyz

La reorganización según los ángulos transforma esto en

utsvrwqxpyoznamblckdjeifgh

así que 'u'irá correctamente a la primera entrada (en orden de columna) diferente de cero, que es (3,1) en notación matricial; 't'irá a (4,1), 's'a (5,1); 'v'a (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''')

Pruébalo en línea!

R , 139 122 bytes

-17 bytes gracias a Giuseppe

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

Explicación:

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

Construye una caja vacía de espacios.

u(" &3@LKWVUTSRDC5(")

es un conjunto de índices para posiciones de letras correspondientes 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 gracias 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]))

Pruébalo en línea!

¿Cómo?

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

Indicaciones para el personaje

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

Pruébalo en línea Coutesy of Dyalog Classic

R , 218 197 bytes

-21 bytes gracias 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='')

Pruébalo en línea!

Sin golf:

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

Se creó un vector de letra girada y se usa catpara llenar el borde del tazón con ese vector.

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

Pruébalo en línea.

¿Versión de 136 bytes con potencial para jugar al golf?

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

Pruébalo en línea.

Explicación (de la primera respuesta)

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

Pruébalo en línea!

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

Pruébalo en línea!

Cada carácter en la cadena codificada se decodifica por función ?en una cadena:

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

Se eliminaron paréntesis adicionales para -2
Cadena sin procesar reemplazada para -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'}}

Pruébalo en línea!

C # (compilador interactivo de 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))

Guardado 8 bytes gracias a @someone. Sí, ese es en realidad su nombre de usuario.

Pruébalo en línea!

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 @

El enlace de prueba para esta respuesta rompió los saltos de línea y excluyó los espacios. He reemplazado los espacios con punto y he reemplazado char (13) con char (13) + char (10) para mostrar un resultado legible.

Pruébalo en línea

Sin golf:

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

Pruébalo en línea!

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

Explicación:

Usando ord, convertimos a un número entero entre 0 y 255. A es 65 y Z es 90.
Usando este conocimiento, tomamos la entrada y la reducimos en 65 para tener un valor de ajuste.
Luego iteramos sobre todos los caracteres, los llamamos ord, los reducimos en 65, los incrementamos en nuestro valor de ajuste. Usando el módulo volvemos a 0 si exceden 26.
Luego los incrementamos en 65 nuevamente y los convertimos nuevamente en letras con chr.

Lamentablemente, php: // stdin solo se puede interogar una vez, por lo que debemos pasar la entrada a la función en nuestro bucle, evitando que guardemos bytes use($a)y tener que declarar una variable fuera de la función nos impide usar limpiamente el <?=método echo - Tenemos que envolver todo en un ternario gigante.

C (GCC) 286 bytes

No es exactamente el golf más corto, pero 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);}

Pruébalo en línea

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

Pruébalo en línea!

Una solución realmente ingenua.

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

Pruébalo en línea!

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

Pruébalo en línea

Primera vez probando el código de golf. Agradezco cualquier sugerencia / comentario.

Código original antes de minificar:

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

Pruébalo en línea!

C (gcc) , 200 198 197 bytes

-3 bytes gracias a 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);}

Pruébalo en línea!

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

Pruébalo en línea!