Questo è ciò che chiameremo una scodella di zuppa di alfabeto - una forma ascii-arte approssimativamente circolare con le 26 lettere inglesi maiuscole (AZ) disposte in senso orario per formare il perimetro:

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

Scrivi un programma che includa un carattere di una sola lettera, AZ, e produca la stessa scodella di minestra dell'alfabeto "ruotata", per così dire, così la lettera di input appare dove Afa l'esempio sopra e il resto dell'alfabeto scorre ciclicamente attorno senso orario.

Quindi l'output per l'input Asarebbe la stessa ciotola originale di zuppa di alfabeto.

E l'output per l'input Bsarebbe questo:

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

Allo stesso modo l'output per Hsarebbe:

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

O per Z:

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

Questo deve funzionare per tutte le 26 lettere, dalla A alla Z.

Dettagli:

• Puoi presumere che l'unico input sarà una singola lettera, dalla A alla Z.
• Se conveniente, puoi usare az minuscole per input e / o output, puoi anche mescolare e abbinare maiuscole e minuscole.
• L'ordine alfabetico deve scorrere in senso orario, non in senso antiorario.
• È necessario utilizzare gli spazi, non qualcos'altro, per rientrare e riempire la scodella.
• Potrebbero esserci delle righe o linee guida iniziali o finali nell'output, purché la ciotola per zuppa sia disposta correttamente.
• Si noti che la forma della ciotola è larga 12 caratteri per 7 per farla apparire approssimativamente circolare come testo. Le tue ciotole devono avere la stessa forma.

Questo è il codice golf, quindi vince il codice più corto!

05AB1E , 21 byte

Definisce un programma $f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Codice:

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

Provalo online!

Abbattersi:

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

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

Spiegazione:

Il canvas ( Λ) in questo particolare contesto funziona come una funzione con la seguente 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}}$$

Il parametro $\texttt{pattern}$ è in questa situazione un numero che definisce le direzioni. Nel codice, questo numero è rappresentato come •1못*Ć,ãiDΣ•, che è una versione compressa del numero grande $2232344565666667670012122$ . Le indicazioni sono indicate nel modo seguente:

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

Ciò significa che il grande numero rappresenta il seguente modello di indicazioni:

$$[\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 questo contesto caratteristico, la tela scorre attraverso il $\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

La $\texttt{length}$ è specificata nel codice come$2$$\texttt{filler}$

AA¹k._

 A¹k # Trova l'alfabeto <indice> del dato carattere di input
A ._ # Ruota l'alfabeto a sinistra <indice> volte.

In pseudocodice, questo verrebbe eseguito dalla funzione 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}$

Infine, puoi vedere che l'argomento filler è 'ruotato' $\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}}, ...$$

Il risultato è la forma desiderata di zuppa di alfabeto ascii-art.

Perl 6 , 100 byte

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

Provalo online!

Sostituisce tutte le lettere nella stringa con le loro controparti spostate, sostituendo le cifre con il numero di spazi che rappresentano più uno.

Spiegazione

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

Rubino , 107 byte

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

Provalo online!

Sintassi migliorata "i".to_c-> 1i(suggerita dalla Giordania)

Sistema di coordinate modificato in modo che 0 gradi sia a destra anziché in alto. Questo abilita 0.5->6

Moltiplicatori rettificati di je kper mancanza

Anziché stampare l'output puts a, concatenare gli elementi dell'array e restituire una stringaa*$/

Rubino , 119 byte

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

Utilizza un numero complesso elevato a una potenza per mappare un'ellisse. Un giro completo è 26, quindi ogni quadrante è 6.5.

Questo approccio si basa sull'output richiesto che assomiglia a un'ellisse sufficientemente da poter ottenere una mappatura valida.

Provalo online!

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＧＨ

Traccia un percorso.

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

Delinea la ciotola. Ognuno si 7espande a ↙←.

²

Sposta un carattere alla volta (questa API si sovrappone alle estremità di ogni riga con la successiva).

✂⁺αα⌕αＳ

Disegna usando l'alfabeto raddoppiato, ma partendo dalla posizione del carattere di input.

MATL , 49 byte

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

Che casino. Ma è stato divertente scrivere. C'è anche un arctangent coinvolto.

Provalo online!

Spiegazione

Il codice

7I8*32tvB

crea una matrice di numeri e li converte in binari. Questo dà la matrice zero-one

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

che è il quadrante in alto a sinistra di una matrice che specifica le posizioni delle lettere.

[1b]&Zv

riflette quel quadrante verticalmente senza ripetere l'ultima riga e ripetendo orizzontalmente l'ultima colonna per produrre la matrice 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

Ora abbiamo una maschera con le posizioni. Il codice

c

converte questo in carattere, perché il risultato finale sarà una matrice di caratteri. Il carattere 0 viene visualizzato come spazio e le voci diverse da zero verranno scritte con le lettere appropriate.

2Y2

spinge la stringa 'abc···xyz', che contiene le 26 lettere. Questa stringa deve essere spostata in modo circolare secondo l'input. Fare quello,

j7+_YS

legge la lettera di input, aggiunge 7 al suo codice ASCII e annulla il risultato. Per input 'a'questo dà −104, che è un multiplo di 26, quindi lo spostamento circolare di questo importo non farà nulla. Se l'input è bquesto, si ottiene −105, che sposta la stringa di 1 passo verso sinistra per produrre 'bcd···yza'; eccetera.

Il prossimo passo è definire l'ordine in cui la stringa spostata verrà scritta nelle voci diverse da zero della matrice. A questa fine,

y&f

crea una copia della matrice e invia due vettori contenenti le posizioni di riga e colonna basate su 1 dei nonzeros. Poi

7-w4-_

sottrae 7 da quest'ultimo, porta in primo piano il primo, ne sottrae 4 e lo annulla. 7 e 4 specificano un'origine di coordinate, in modo che gli angoli dei vettori di posizione delle voci diverse da zero rispetto a quell'origine definiscano l'ordine desiderato.

Z;YPE\

calcola il modulo arctangent a due argomenti 2 * pi per produrre quegli angoli. Ora l'angolo più piccolo, che è 0, corrisponde alla voce in cui dovrebbe andare la prima lettera e il resto avanza in senso antiorario.

,&S])

riorganizza le lettere nella stringa in base a quegli angoli, in modo che quando le lettere sono scritte nelle voci diverse da zero della matrice in ordine di colonna maggiore (verso il basso, poi attraverso) il risultato sarà corretto. Questo è fatto da

yg(

Ad esempio, se l'input è 'a'la stringa non è stata spostata in modo circolare:

abcdefghijklmnopqrstuvwxyz

Il riordino secondo gli angoli lo trasforma in

utsvrwqxpyoznamblckdjeifgh

così 'u'andrà correttamente alla prima voce (in ordine maggiore di colonna) diversa da zero, che è (3,1) in notazione matriciale; 't'andrà a (4,1), 's'a (5,1); 'v'a (2,2) ecc:

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

Python 2 , 129 byte

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

Provalo online!

R , 139 122 byte

-17 byte grazie a Giuseppe

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

Spiegazione:

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

Costruisce una scatola vuota di spazi

u(" &3@LKWVUTSRDC5(")

è un insieme di indici per le posizioni delle lettere corrispondenti 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 byte

Salvato 2 byte grazie 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]))

Provalo online!

Come?

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 byte

Richiede il personaggio

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

Provalo online! Coutesy di Dyalog Classic

R , 218 197 byte

-21 byte grazie 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='')

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

Creato vettore lettera ruotata e utilizza catper riempire l'orlo della ciotola con quel vettore.

Java 11, 134 byte

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

Provalo online.

136 byte versione con possibilità di 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))

Provalo online.

Spiegazione (della prima risposta)

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

Provalo online!

Haskell, 127 byte

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

Provalo online!

Ogni carattere nella stringa codificata viene decodificato dalla funzione ?in una stringa:

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 byte

Rimosse parentesi extra per -2
Sostituite stringa non elaborata per -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'}}

Provalo online!

C # (compilatore interattivo Visual C #) , 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 byte salvati grazie a @someone. Sì, questo è in realtà il suo nome utente.

Provalo online!

Query TSQL, 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 @

Il collegamento di prova per questa risposta ha interrotto le interruzioni di riga ed escluso gli spazi. Ho sostituito gli spazi con punto e ho sostituito char (13) con char (13) + char (10) per mostrare un risultato leggibile.

Provalo 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 byte

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

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

Spiegazione:

Usando ordconvertiamo in un numero intero compreso tra 0 e 255. A è 65 e Z è 90.
Usando questa conoscenza, prendiamo l'input e lo riduciamo di 65, quindi abbiamo un valore di aggiustamento.
Quindi ripetiamo tutti i personaggi, ordli chiamiamo , li riduciamo di 65, li aumentiamo del nostro valore di regolazione. Usando il modulo torniamo indietro a 0 se superano i 26.
Quindi li aumentiamo di nuovo di 65 e li convertiamo nuovamente in lettere con chr.

Purtroppo php: // stdin può essere interogato una sola volta, quindi dobbiamo passare l'input nella funzione nel nostro loop, impedendoci di salvare byte use($a)e dover dichiarare una variabile esterna alla funzione ci impedisce di usare in modo pulito il <?=metodo echo - dobbiamo avvolgere tutto in un gigantesco ternario.

C (GCC) 286 byte

Non è esattamente il golf più corto, ma funziona

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

Provalo online

Rosso , 139 byte

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

Provalo online!

Una soluzione davvero ingenua.

Perl 5 -p , 110 byte

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

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

Provalo online

La prima volta che provo a giocare a golf. Apprezzo qualsiasi suggerimento / feedback.

Codice originale prima di minimizzare:

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

Provalo online!

C (gcc) , 200 198 197 byte

-3 byte grazie 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);}

Provalo online!

PHP , 131 byte

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

Provalo online!