Bu, bir kase alfabe çorbası olarak adlandıracağımız şeydir - çevreyi oluşturmak için saat yönünde düzenlenen 26 büyük harfle (AZ) kabaca dairesel bir sanat şekli:

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

Bir tek harf karakterinde AZ alır programı ve alfabe çorbası aynı kase "döndürülmüş" çıkışları yazın tabiri caizse, yani nereye girdi harf görünene Ayukarıdaki örnekte yapar ve tam etrafında alfabe döngülerinin kalanı saat yönünde.

Böylece girdi için çıktı Aaynı orijinal alfabe çorbası kasesi olacaktır.

Ve giriş için çıktı Bbu olurdu:

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

Aynı şekilde çıktı Hşöyle olurdu:

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

Veya Z:

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

Bunun A'dan Z'ye tüm 26 harfinde çalışması gerekir.

Detaylar:

• Tek girişin A'dan Z'ye kadar tek bir harf olacağını varsayabilirsiniz.
• Uygunsa, giriş ve / veya çıkış için küçük harf az kullanabilirsiniz, hatta küçük ve büyük harfleri karıştırabilir ve eşleştirebilirsiniz.
• Alfabe düzeni saat yönünün tersine değil saat yönünde dönmelidir.
• Çorba kasesine girip doldurmak için başka bir şey değil, boşluk kullanmalısınız.
• Çorba kasesi uygun şekilde yerleştirildiği sürece, çıktının içinde önde gelen veya izleyen yeni çizgiler veya boşluklar olabilir.
• Kase şeklinin, metin olarak kabaca dairesel görünmesi için 7 boyunda 12 karakter genişliğinde olduğuna dikkat edin. Kaseleriniz aynı şekilde olmalı.

Bu kod golf yani en kısa kod kazanır!

05AB1E , 21 bayt

Bir programı tanımlar$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Kod:

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

Çevrimiçi deneyin!

Yıkmak:

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

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

Açıklama:

Tuval ( Λbu özel bağlamda) Aşağıdaki imzayla bir fonksiyonu olarak çalışır:

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

$\texttt{pattern}$ parametresi bu durumda yön tanımlayan bir sayıdır. Kodda , bu sayı, •1못*Ć,ãiDΣ•büyük sayının $2232344565666667670012122$ sıkıştırılmış bir sürümü olarak temsil edilir . Yol tarifleri aşağıdaki şekilde belirtilir:

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

Bu, büyük sayının aşağıdaki yol tarifini temsil ettiği anlamına gelir:

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

Bu imza, içerikle birlikte, tuval arasında dolaşır $\texttt{pattern}$ listesi ve yazar $\texttt{length}$ karakterleri $\texttt{filler}$ akım yönünde.

$\texttt{length}$ olarak kod belirtilen $2$ (kod başlangıcında). İçin $\texttt{filler}$ , bunun verilen giriş ile başlar, öyle ki alfabenin ters çevrilmiş halini gerekir. Bu, aşağıdaki kodla yapılır ( burada deneyin ):

AA¹k._

 A #k # Alfabedeki verilen giriş karakterinin <index> değerini bulun
A ._ # Alfabeyi <index> kere sola döndürün .

Sözde kodda bu, tuval işlevi tarafından yürütülür:

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

Son olarak, dolgu argüman 'döndürülmüş' olduğunu görebilirsiniz $\texttt{length} - 1$ tuval aşağıdaki (sağlanıncaya ve dolayısıyla sonsuz) listesi üzerinden yineleme olduğu anlamına gelen, sağa kez:

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

İstenilen alfabe çorbası ascii-sanat şeklinde sonuçlanır.

Perl 6 , 100 bayt

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

Çevrimiçi deneyin!

Dizideki tüm harfleri, kaydırılan eşleri ile değiştirirken, rakamları temsil ettikleri boşluk sayısı ile bir artı ile değiştirir.

açıklama

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

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

Çevrimiçi deneyin!

Geliştirilmiş sözdizimi "i".to_c-> 1i(Jordan tarafından önerildi)

Değişen koordinat sistemi, üst yerine 0 derece sağda. Bu sağlar 0.5->6

Düzeltilmiş çarpanları jve kdarlığı için

Çıktıdan ziyade puts a, dizi öğelerini birleştirin ve bir dize döndürüna*$/

Ruby , 119 bayt

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

Bir elips ile eşleşme gücüne yükseltilmiş karmaşık bir sayı kullanır. Tam bir dönüş 26, bu nedenle her kadran 6,5.

Bu yaklaşım, geçerli bir haritalamanın elde edilebileceği kadar elips benzeri bir çıktıya dayanır.

Çevrimiçi deneyin!

Kömür , 33 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

ＧＨ

Bir yolu takip et.

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

Kaseyi özetle. Her biri 7genişler ↙←.

²

Bir seferde bir karakter hareket ettirin (bu API her satırın bitişi ile biter).

✂⁺αα⌕αＳ

İkili alfabeyi kullanarak çizin, ancak giriş karakterinin konumundan başlayın.

MATL , 49 bayt

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

Ne dağınıklık. Ama eğlenceli yazı yazmaktı. İçinde bir savaşçı bile var.

Çevrimiçi deneyin!

açıklama

Kod

7I8*32tvB

bir sayı dizisi yaratır ve bunları ikiliye dönüştürür. Bu sıfır bir matris verir

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

Harflerin konumlarını belirten bir matrisin sol üst kadranı.

[1b]&Zv

tam kadranı tekrarlamadan ve tam matrisi üretmek için son sütunu yatay olarak tekrarlamadan, bu kadranı dikey olarak yansıtır:

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

Artık pozisyonları olan bir maskemiz var. Kod

c

Bunu karaktere dönüştürür, çünkü nihai sonuç bir karakter matrisi olacaktır. 0 karakteri boşluk olarak görüntülenir ve sıfır olmayan girdiler uygun harflerle yazılır.

2Y2

'abc···xyz'26 harfi içeren dizeyi iter . Bu dizgenin girişe göre dairesel olarak kaydırılması gerekir. Bunu yapmak için,

j7+_YS

giriş harfini okur, ASCII koduna 7 ekler ve sonucu olumsuzlar. Girdi için 'a'bu, 26'nın katı olan −104'ü verir, bu nedenle dairesel olarak bu miktarın kaydırılması hiçbir şey yapmaz. Girdi bbu gives105 verirse, bu, dizgeyi 1 adım sola kaydırır 'bcd···yza'; vb.

Bir sonraki adım, kaydırılan dizginin matrisin sıfır olmayan girdilerine yazılacağı sırayı tanımlamaktır. Bu amaçla,

y&f

matrisin bir kopyasını yaratır ve sıfır olmayanların 1 tabanlı sıra ve sütun konumlarını içeren iki vektörü iter. Sonra

7-w4-_

ikincisini (7) çıkarır, birinciyi en üste getirir, 4'ü alttan çıkarır ve olumsuzlar. 7 ve 4 koordinatların bir kökenini belirtir, böylece sıfır olmayan girişlerin konum vektörlerinin o kökene göre açıları istenen sırayı tanımlar.

Z;YPE\

Bu açıların üretilmesi için iki argümanlı arctangent modulo 2 * pi'yi hesaplar. Şimdi 0 olan en küçük açı, ilk harfin gitmesi gereken girişe karşılık gelir ve gerisi saat yönünün tersine ilerler.

,&S])

dizedeki harfleri bu açılara göre yeniden düzenler; böylece, harfler matrisin sıfır olmayan girişlerine sütun ana düzeninde (aşağı, sonra) yazıldığında sonuç doğru olur. Bu tarafından yapılır

yg(

Örneğin, giriş girdiyse, 'a'dairesel olarak kaydırılmadı:

abcdefghijklmnopqrstuvwxyz

Açılara göre yeniden düzenleme, bunu dönüştürür.

utsvrwqxpyoznamblckdjeifgh

böylece 'u'doğru (ilk sıradaki sütun sırası) sıfır girişine (matris notasyonu ile (3,1)) girilir; 't'(4,1) 'e, 's'(5,1)' e gidecektir ; 'v'(2,2) vb.

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

Python 2 , 129 bayt

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

Çevrimiçi deneyin!

R , 139 122 bayt

Giuseppe sayesinde -17 bayt

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

Açıklama:

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

Boş bir boşluk kutusu oluşturur

u(" &3@LKWVUTSRDC5(")

aşağıdakilere karşılık gelen harf konumları için bir indeks kümesidir:

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 bayt

@Tsh sayesinde 2 bayt kaydedildi

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

Çevrimiçi deneyin!

Nasıl?

Buffer$x$$c$

ile örnek$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 bayt

Karakter için bilgi istemi

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

Çevrimiçi deneyin! Dyalog Klasik Coutesy

R , 218, 197 bayt

Giuseppe sayesinde -21 bayt

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

Çevrimiçi deneyin!

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

Döndürülmüş harf vektörü oluşturulur ve catkasenin kenarını bu vektörle doldurmak için kullanılır.

Java 11, 134 bayt

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

Çevrimiçi deneyin.

Golf oynama potansiyeli olan 136 bayt sürümü ?

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

Çevrimiçi deneyin.

Açıklama (ilk cevabın)

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 Dili (Mathematica) , 258 bayt

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

Çevrimiçi deneyin!

Haskell, 127 bayt

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

Çevrimiçi deneyin!

Kodlanmış dizgideki her karakter, işlev tarafından ?bir dizgeye dönüştürülür:

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 bayt

-2 için fazladan parantez kaldırıldı
-1 yerine ham dizge eklendi

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

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 126 118 bayt

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

@Someone sayesinde 8 bayt kaydedildi. Evet, aslında onun kullanıcı adı.

Çevrimiçi deneyin!

TSQL sorgusu, 238 bayt

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 @

Bu cevap için test bağlantısı satır sonlarını kırdı ve boşlukları dışladı. Boşlukları nokta ile değiştirdim ve okunabilir bir sonuç göstermek için char (13) 'ü char (13) + char (10) ile değiştirdim.

Çevrimiçi deneyin

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 bayt

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

Çevrimiçi deneyin!

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

Açıklama:

Kullanarak ord0 ile 255 arasında bir tamsayıya dönüştürüyoruz. A 65 ve Z, 90'dır
. Bu bilgiyi kullanarak, girişi aldık ve 65 azalttık, böylece bir ayar değerimiz var.
Daha sonra tüm karakterleri tekrar ordeder, onları çağırır , 65 oranında azaltır, ayar değerimizle arttırırız. Modulo kullanarak, eğer 26'yı geçerse 0'a geri döneriz.
Onları tekrar 65 ile arttırır ve tekrar harflere dönüştürürüz chr.

Ne yazık ki php: // stdin yalnızca bir kez sorgulanabilir, bu yüzden girdiyi fonksiyonumuzda fonksiyona geçirmemiz gerekir, bu sayede baytları kaydetmemizi önler use($a)ve fonksiyonun dışında bir değişken ilan etmek zorunda kalırsak <?=echo metodunu temiz bir şekilde kullanmamızı önler - her şeyi dev bir üçlü halinde sarmalıyız.

C (GCC) 286 bayt

Tam olarak değil en kısa golf, ama işe yarıyor

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

Çevrimiçi deneyin

Kırmızı , 139 bayt

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

Çevrimiçi deneyin!

Gerçekten saf bir çözüm.

Perl 5 -p , 110 bayt

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

Çevrimiçi deneyin!

Javascript (V8), 316 bayt

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

Çevrimiçi deneyin

İlk kez kod golfünü deniyorum. Herhangi bir ipucu / geribildirim için teşekkür ederiz.

Küçültmeden önce orijinal kod:

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 Klasik) , 50 bayt

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

Çevrimiçi deneyin!

C (gcc) , 200 198 197 bayt

Ceilingcat sayesinde -3 bayt.

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

Çevrimiçi deneyin!

PHP , 131 bayt

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

Çevrimiçi deneyin!