Voici ce que nous appellerons un bol de soupe à l'alphabet - une forme approximativement circulaire d'ascii-art avec les 26 lettres majuscules anglaises (AZ) disposées dans le sens des aiguilles d'une montre pour former le périmètre:

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

Ecrivez un programme qui prend une lettre, un AZ, et sort ce même bol de soupe à l'alphabet "pivoté", pour ainsi dire, de sorte que la lettre d'entrée apparaisse là où le Afait dans l'exemple ci-dessus et le reste de l'alphabet tourne complètement autour dans le sens des aiguilles d'une montre.

La sortie pour l'entrée Aserait donc ce même bol original de soupe à l'alphabet.

Et la sortie pour l'entrée Bserait celle-ci:

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

De même, le résultat pour Hserait:

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

Ou pour Z:

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

Cela doit fonctionner pour les 26 lettres, de A à Z.

Détails:

• Vous pouvez supposer que la seule entrée sera une seule lettre, de A à Z.
• Si cela vous convient, vous pouvez utiliser une lettre minuscule az pour entrée et / ou sortie, vous pouvez même mélanger des combinaisons de lettres minuscules et majuscules.
• L'ordre alphabet doit tourner dans le sens des aiguilles d'une montre et non dans le sens contraire.
• Vous devez utiliser des espaces, pas autre chose, pour mettre en retrait et remplir le bol à soupe.
• Il peut y avoir des nouvelles lignes ou des espaces dans la sortie tant que le bol de soupe est bien disposé.
• Notez que la forme du bol est large de 12 caractères sur 7 pour le rendre approximativement circulaire en tant que texte. Vos bols doivent avoir la même forme.

C'est du code golf donc le code le plus court gagne!

05AB1E , 21 octets

Définit un programme$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Code:

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

Essayez-le en ligne!

Panne:

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

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

Explication:

La toile ( Λ) dans ce contexte particulier fonctionne comme une fonction avec la signature suivante:

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

Le est dans cette situation un nombre définissant les directions. Dans le code, ce nombre est représenté sous la forme d' une version compressée du grand nombre . Les directions sont notées de la manière suivante:$\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}$$

Cela signifie que le grand nombre représente le modèle de directions suivant:

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

Avec ce contexte de signature, le canevas parcourt la liste et écrit les caractères de dans la direction actuelle.$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

Le est spécifié dans le code par (au début du code). Pour le , nous avons besoin d’une version pivotée de l’alphabet telle qu’elle commence par l’entrée donnée. Cela se fait avec le code suivant ( essayez-le ici ):$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # Trouver le <index> du caractère saisi dans l'alphabet
A ._ # Faites pivoter l’alphabet vers la gauche <index> fois.

En pseudocode, cela serait exécuté par la fonction 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}$

Enfin, vous pouvez voir que l'argument de remplissage est 'tourné' fois à droite, ce qui signifie que le canevas va parcourir la liste suivante (cyclée et donc infinie):$\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}}, ...$$

Ce qui donne la forme désirée de l'alphabet soupe ascii-art.

Perl 6 , 100 octets

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

Essayez-le en ligne!

Remplace toutes les lettres de la chaîne par leurs équivalents décalés, tout en remplaçant les chiffres par le nombre d'espaces qu'ils représentent plus un.

Explication

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

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

Essayez-le en ligne!

Amélioration de la syntaxe "i".to_c-> 1i(suggéré par la Jordanie)

Système de coordonnées modifié pour que 0 degrés soit à droite au lieu de haut. Cela permet 0.5->6

Multiplicateurs ajustés de jet kpour la brièveté

Plutôt que d’imprimer la sortie puts a, concaténez des éléments de tableau et renvoyez une chaînea*$/

Ruby , 119 octets

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

Utilise un nombre complexe élevé au pouvoir de mapper sur une ellipse. Un tour complet est 26, donc chaque quadrant est 6,5.

Cette approche repose sur le résultat requis, qui ressemble à une ellipse, suffisamment pour qu’un mappage valide puisse être réalisé.

Essayez-le en ligne!

Charbon de bois , 33 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＧＨ

Trace un chemin.

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

Décrivez le bol. Chacun se 7développe à ↙←.

²

Déplacer un caractère à la fois (cette API chevauche la fin de chaque ligne avec la suivante).

✂⁺αα⌕αＳ

Dessinez en utilisant l'alphabet doublé, mais en partant de la position du caractère saisi.

MATL , 49 octets

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

Quel bordel. Mais c'était amusant d'écrire. Il y a même un arctangent impliqué.

Essayez-le en ligne!

Explication

Le code

7I8*32tvB

crée un tableau de nombres et les convertit en binaire. Cela donne la matrice zéro-un

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

qui est le quadrant supérieur gauche d'une matrice spécifiant les positions des lettres.

[1b]&Zv

reflète ce quadrant verticalement sans répéter la dernière ligne, et horizontalement la dernière colonne pour produire la matrice complète:

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

Nous avons maintenant un masque avec les positions. Le code

c

convertit ceci en char, car le résultat final sera une matrice de caractères. Le caractère 0 est affiché sous forme d'espace et les entrées non nulles seront écrites avec les lettres appropriées.

2Y2

pousse la chaîne 'abc···xyz'qui contient les 26 lettres. Cette chaîne doit être déplacée de manière circulaire conformément à l'entrée. Pour faire ça,

j7+_YS

lit la lettre d'entrée, ajoute 7 à son code ASCII et annule le résultat. Pour l'entrée, 'a'cela donne −104, ce qui est un multiple de 26, donc un déplacement circulaire de ce montant ne fera rien. Si l'entrée est, bcela donne -105, ce qui décale la chaîne d'un pas vers la gauche pour produire 'bcd···yza'; etc.

L'étape suivante consiste à définir l'ordre dans lequel la chaîne décalée sera écrite dans les entrées non nulles de la matrice. À cette fin,

y&f

crée une copie de la matrice et pousse deux vecteurs contenant les positions de ligne et de colonne basées sur 1 du nonzer. ensuite

7-w4-_

soustrait 7 de ce dernier, amène le premier au sommet, en soustrait 4 et le nie. Les 7 et 4 spécifient une origine de coordonnées, de sorte que les angles des vecteurs de position des entrées non nulles par rapport à cette origine définissent l'ordre souhaité.

Z;YPE\

calcule l'arctangent modulo 2 * pi à deux arguments pour produire ces angles. Maintenant, le plus petit angle, qui est 0, correspond à l'entrée où la première lettre doit être insérée, et le reste avance dans le sens anti-horaire.

,&S])

réorganise les lettres dans la chaîne en fonction de ces angles, afin que le résultat soit correct lorsque les lettres sont écrites dans les entrées non nulles de la matrice dans l’ordre ordre principal des colonnes (bas, puis en regard). Ceci est fait par

yg(

Par exemple, si l'entrée est 'a'la chaîne n'a pas été déplacée de manière circulaire:

abcdefghijklmnopqrstuvwxyz

Le réarrangement selon les angles transforme cela en

utsvrwqxpyoznamblckdjeifgh

donc cela 'u'ira correctement à la première entrée non nulle (en ordre de colonne, ordre majeur), qui est (3,1) en notation matricielle; 't'ira à (4,1), 's'à (5,1); 'v'à (2,2) etc:

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

Python 2 , 129 octets

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

Essayez-le en ligne!

R , 139 122 octets

-17 octets grâce à Giuseppe

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

Explication:

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

Construit une boîte vide d'espaces

u(" &3@LKWVUTSRDC5(")

est un ensemble d'indices pour les positions de lettres correspondant à:

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 octets

2 octets sauvés grâce à @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]))

Essayez-le en ligne!

Comment?

Ce code permet Bufferd’extraire les codes ASCII de la lettre type et de la lettre et de les reconvertir en lettre cible.$x$$c$

Exemple avec et$c=$x ="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 octets

Invites pour le personnage

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

Essayez-le en ligne! Coutesy de Dyalog Classic

R , 218 197 octets

-21 octets grâce à 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='')

Essayez-le en ligne!

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

Crée un vecteur de lettre pivoté et utilise catpour remplir le bord du bol avec ce vecteur.

Java 11, 134 octets

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

Essayez-le en ligne.

Version de 136 octets avec le potentiel d'être joué au 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))

Essayez-le en ligne.

Explication (de la première réponse)

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 octets

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

Essayez-le en ligne!

Haskell, 127 octets

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

Essayez-le en ligne!

Chaque caractère de la chaîne codée est décodé par fonction ?dans une chaîne:

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 octets

Suppression des parenthèses supplémentaires pour -2
Chaîne brute remplacée pour -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'}}

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 126 118 octets

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

Sauvegardé 8 octets grâce à @quelqu'un. Oui, c'est en fait son nom d'utilisateur.

Essayez-le en ligne!

Requête TSQL, 238 octets

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 @

Le lien de test pour cette réponse a cassé les sauts de ligne et exclu les espaces. J'ai remplacé les espaces par des points et remplacé car (13) par car (13) + car (10) afin d'afficher un résultat lisible.

Essayez-le en ligne

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 octets

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

Essayez-le en ligne!

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

Explication:

En utilisant, ordnous convertissons en un entier compris entre 0 et 255. A est égal à 65 et Z à 90.
En utilisant cette connaissance, nous prenons l'entrée et la réduisons de 65 pour obtenir une valeur d'ajustement.
Nous parcourons ensuite tous les personnages, appelons- ordles, réduisons-les de 65, augmentons-les de notre valeur d'ajustement. En utilisant modulo, nous rediffusons à 0 s'ils dépassent 26.
Nous les augmentons ensuite de 65 et les convertissons en lettres avec chr.

Malheureusement, php: // stdin ne peut être interogé qu’une fois. Nous devons donc passer l’entrée à la fonction dans notre boucle, nous empêchant de sauvegarder des octets use($a)et de devoir déclarer une variable en dehors de la fonction nous empêche d’utiliser proprement la <?=méthode echo - nous devons tout emballer dans un ternaire géant.

C (GCC) 286 octets

Pas exactement le golf le plus court, mais ça marche

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

Essayez-le en ligne

Rouge , 139 octets

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

Essayez-le en ligne!

Une solution vraiment naïve.

Perl 5 -p , 110 octets

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

Essayez-le en ligne!

Javascript (V8), 316 octets

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

Essayez-le en ligne

Première fois que vous essayez le code de golf. Apprécier les conseils / commentaires.

Code original avant de minifier:

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 octets

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

Essayez-le en ligne!

C (gcc) , 200 198 197 octets

-3 octets grâce à 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);}

Essayez-le en ligne!

PHP , 131 octets

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

Essayez-le en ligne!