Hacer un plato de sopa de letras

55

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.

Juegos discretos
fuente
12
¡Gran reto! Inicialmente parece fácil, pero no lo es
Luis Mendo

Respuestas:

22

05AB1E , 21 bytes

Define un programaf:AlphabeticCharString

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:

Λ:(length:Nat, filler:String, pattern:Nat)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:pattern 2232344565666667670012122•1못*Ć,ãiDΣ•2232344565666667670012122


70162543


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

[,,,,,,,,,,,,,,,,,,,,,,,,]

Con este contexto de firma, el lienzo itera a través de la lista y escribe caracteres desde el en la dirección actual.patternrelleno de lengthpatrónfiller

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í ):length2filler

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:

1.Write ab in the direction2.Write bc in the direction3.Write cd in the direction4.Write de in the direction5.Write ef in the direction6.Write fg in the direction

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

[ab,bc,cd,de,ef,fg,gh,hi,ij,jk,...

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

Adnan
fuente
Esta bien me rindo. Intenté encontrar alternativas más cortas, pero no lo veo. AA¹k._puede ser alternativamente A¹¡RJ«, pero es el mismo número de bytes. •1못*Ć,ãiDΣ•puede ser alternativamente •õÕ₆qηµñ–†f•·, pero es el mismo número de bytes. Ah bueno. ¡Buena respuesta!
Kevin Cruijssen
11

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
Jo King
fuente
9

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!

Level River St
fuente
@ Jordan gracias, no he visto esa sintaxis antes!
Nivel River St
8

Carbón , 33 bytes

GH→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αS

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

GH

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

✂⁺αα⌕αS

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

Neil
fuente
8

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          ·
 ··      ·· 
   ······   
Luis Mendo
fuente
@EriktheOutgolfer Finalmente encontré tiempo para agregar una explicación
Luis Mendo
1
Woah ... en realidad pensé que abandonaste esto porque borraste ese comentario. : P
Erik the Outgolfer
7

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!

Erik el Outgolfer
fuente
7

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

Aaron Hayman
fuente
1
nunca se usa, intToUtf8por lo que son bytes extraños, pero si lo usa *en lugar de rep, puede guardar 2 bytes y llegar a 125 bytes
Giuseppe
1
Ah, y usando los caracteres de bajo byte en lugar de ascii imprimibles, puede eliminar el -32, por 122 bytes . Puede generarlos usted mismo utilizando cat(intToUtf8(bytes)).
Giuseppe
@Giuseppe Estaba bastante seguro de que ya había eliminado las intToUtf8demasiadas versiones de la función abiertas a la vez, supongo. Nice guarda todas las rondas, gracias
Aaron Hayman
6

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?

Bufferxc

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()
Arnauld
fuente
119 bytes
tsh
4

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.

CT Hall
fuente
203 bytes si no le importan las monstruosidades de una línea; La mayor mejora probablemente fue eliminar whichy usar l>=tcomo índice directamente, lo que valía 12 bytes.
Giuseppe
2
198 bytes aliasing [con ~. Esta es una respuesta genial; Estaba gastando alrededor de 250 bytes en mis primeros intentos con un enfoque mucho más complejo.
Giuseppe
Ah, eso es inteligente, me olvido de las comparaciones de cuerdas.
CT Hall
3

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
Kevin Cruijssen
fuente
¿Por qué no reemplazar los dígitos con no imprimibles? De esa manera, podrías omitir lai-47
Encarnación de la ignorancia
@EmbodimentofIgnorance Me temo que no guardaría ningún byte. Los números de espacios son 3, 1, 6 y 10. El 10 se usa tres veces y tiene 2 bytes cada uno como carácter ( \n). Entonces, ya sea que use no imprimibles y 3x \ncon io digitos-1 con i-47, ambos son el mismo recuento de 134 bytes. Y desafortunadamente no puedo tener una no imprimible 0, de lo contrario podría haber usado 2,0,5,9 en su lugar, y usar i+1para guardar 1 byte en total.
Kevin Cruijssen
2

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!

J42161217
fuente
2

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'
nimi
fuente
2

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!

JohnWells
fuente
2

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!

Encarnación de la ignorancia
fuente
Interpolación de cadenas para 118 bytes . Es probable que sea aceptable devolver una matriz de códigos de acceso (ahorrando ~ 8 bytes), pero no estoy seguro.
alguien
@someone Nice, se olvidó de la interpolación de cuerdas
Encarnación de la ignorancia
2

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 @
t-clausen.dk
fuente
@MickyT ok, gracias por tus comentarios, lo arreglaré más tarde hoy si puedo obtener acceso a un db
t-clausen.dk
@MickyT debería solucionarse ahora
t-clausen.dk
1
se ve bien ahora.
MickyT
1

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.

Scoots
fuente
1

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

rtpax
fuente
274 bytes
ceilingcat
0

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.

Galen Ivanov
fuente
0

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!

Xcali
fuente
$ b es innecesario. -24 bytes: TIO .
Grimmy
-2 bytes TIO
Nahuel Fouilleul
0

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]}`)
}
Edwin Chua
fuente
Hola y bienvenidos a PPCG. Tal como está, su envío es un fragmento, que es una E / S no válida. Por favor, corrija su respuesta para que sea un programa completo o una función, como en su versión no minimizada.
Jonathan Frech
@ Jonathan Fresch gracias! ¿Sería suficiente?
Edwin Chua
1
Sí, ahora es una presentación válida.
Jonathan Frech
0

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!

gastropner
fuente
0

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!

Noche2
fuente