Đây là những gì chúng ta sẽ gọi là một bát súp bảng chữ cái - một hình dạng nghệ thuật ascii hình tròn với 26 chữ cái viết hoa (AZ) được sắp xếp theo chiều kim đồng hồ để tạo thành chu vi:

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

Viết một chương trình lấy một ký tự chữ cái đơn, AZ và xuất ra cùng một bát súp bảng chữ cái "xoay", để nói, do đó, chữ cái đầu vào xuất hiện trong Ađó ví dụ ở trên và phần còn lại của bảng chữ cái xoay quanh chiều kim đồng hồ.

Vì vậy, đầu ra cho đầu vào Asẽ là cùng một bát súp bảng chữ cái ban đầu.

Và đầu ra cho đầu vào Bsẽ là cái này:

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

Tương tự, đầu ra cho Hsẽ là:

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

Hoặc cho Z:

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

Điều này cần phải làm việc cho tất cả 26 chữ cái, từ A đến Z.

Chi tiết:

• Bạn có thể giả sử đầu vào duy nhất sẽ là một chữ cái duy nhất, từ A đến Z.
• Nếu thuận tiện, bạn có thể sử dụng chữ thường az cho đầu vào và / hoặc đầu ra, thậm chí bạn có thể trộn và kết hợp chữ thường và chữ hoa.
• Thứ tự bảng chữ cái phải quay theo chiều kim đồng hồ, không ngược chiều kim đồng hồ.
• Bạn phải sử dụng không gian, không phải cái gì khác, để thụt và đổ đầy bát súp.
• Có thể có hàng đầu hoặc dấu cách hàng đầu hoặc dấu cách trong đầu ra miễn là bát súp được sắp xếp hợp lý.
• Lưu ý rằng hình dạng bát có 12 ký tự rộng 7 ký tự để làm cho nó xuất hiện gần như tròn như văn bản. Bát của bạn cần phải có hình dạng tương tự.

Đây là mã golf nên mã ngắn nhất sẽ thắng!

05AB1E , 21 byte

Xác định chương trình$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

Mã số:

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

Hãy thử trực tuyến!

Phá vỡ:

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

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

Giải trình:

Các canvas ( Λ) trong bối cảnh đặc biệt này hoạt động như một chức năng với các chữ ký sau:

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

Tham số trong tình huống này là một số xác định hướng. Trong mã, số này được biểu thị dưới dạng , là phiên bản nén của số lớn . Hướng dẫn được ký hiệu theo cách sau:$\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}$$

Điều này có nghĩa là số lớn biểu thị mẫu hướng sau:

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

Với ngữ cảnh chữ ký này, khung vẽ lặp lại thông qua danh sách và viết các ký tự từ theo hướng hiện tại.$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

Các được xác định trong mã như (ở phần đầu của mã). Đối với , chúng ta cần một phiên bản xoay của bảng chữ cái sao cho bắt đầu với đầu vào đã cho. Điều đó được thực hiện với đoạn mã sau ( thử tại đây ):$\texttt{length}$$2$$\texttt{filler}$

K._

 A¹k # Tìm <index> của ký tự đầu vào đã cho trong bảng chữ cái
A ._ # Xoay bảng chữ cái sang trái <index> lần.

Trong mã giả, điều này sẽ được thực hiện bởi hàm 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}$

Cuối cùng, bạn có thể thấy rằng đối số phụ được 'xoay' lần sang phải, có nghĩa là khung vẽ sẽ lặp qua danh sách sau (theo chu kỳ và do đó là vô hạn):$\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}}, ...$$

Mà kết quả trong bảng chữ cái súp ascii-art mong muốn.

Perl 6 , 100 byte

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

Hãy thử trực tuyến!

Thay thế tất cả các chữ cái trong chuỗi bằng các đối tác được dịch chuyển của chúng, trong khi thay thế các chữ số bằng số khoảng trắng mà chúng đại diện cho một.

Giải trình

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

Hãy thử trực tuyến!

Cú pháp được cải thiện "i".to_c-> 1i(Được đề xuất bởi Jordan)

Thay đổi hệ tọa độ để 0 độ ở bên phải thay vì trên cùng. Điều này cho phép 0.5->6

Điều chỉnh bội số của jvà kcho ngắn

Thay vì in đầu ra puts a, nối các phần tử mảng và trả về một chuỗia*$/

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

Sử dụng một số phức được nâng lên thành sức mạnh để ánh xạ tới hình elip. Một lượt hoàn thành là 26, vì vậy mỗi góc phần tư là 6,5.

Cách tiếp cận này dựa vào đầu ra cần thiết giống như hình elip đủ để có thể đạt được ánh xạ hợp lệ.

Hãy thử trực tuyến!

Than , 33 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＧＨ

Theo dõi một con đường.

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

Phác thảo bát. Mỗi 7mở rộng đến ↙←.

²

Di chuyển một ký tự tại một thời điểm (API này chồng lấp mỗi đầu của dòng với dòng tiếp theo).

✂⁺αα⌕αＳ

Vẽ bằng cách sử dụng bảng chữ cái nhân đôi, nhưng bắt đầu từ vị trí của ký tự đầu vào.

MATL , 49 byte

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

Thật là một mớ hỗn độn. Nhưng đó là niềm vui viết. Thậm chí còn có một arctangent liên quan.

Hãy thử trực tuyến!

Giải trình

Mật mã

7I8*32tvB

tạo ra một mảng các số và chuyển đổi chúng thành nhị phân. Điều này đưa ra ma trận 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

đó là góc phần tư phía trên bên trái của một ma trận xác định vị trí của các chữ cái.

[1b]&Zv

phản ánh góc phần tư theo chiều dọc mà không lặp lại hàng cuối cùng và lặp lại theo chiều ngang của cột cuối cùng để tạo ra ma trận đầy đủ:

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

Bây giờ chúng ta có một mặt nạ với các vị trí. Mật mã

c

chuyển đổi nó thành char, vì kết quả cuối cùng sẽ là một ma trận char. Ký tự 0 được hiển thị dưới dạng khoảng trắng và các mục nhập khác sẽ được viết bằng các chữ cái thích hợp.

2Y2

đẩy chuỗi 'abc···xyz', trong đó có 26 chữ cái. Chuỗi này cần phải được dịch chuyển theo vòng tròn theo đầu vào. Để làm việc đó,

j7+_YS

đọc chữ cái đầu vào, thêm 7 vào mã ASCII của nó và phủ nhận kết quả. Đối với đầu vào, giá trị 'a'này là −104, là bội số của 26, do đó việc dịch chuyển vòng tròn theo số tiền này sẽ không làm gì cả. Nếu đầu vào là giá trị b−105, sẽ dịch chuyển chuỗi 1 bước sang trái để tạo 'bcd···yza'; Vân vân.

Bước tiếp theo là xác định thứ tự mà chuỗi dịch chuyển sẽ được ghi vào các mục nhập khác của ma trận. Để kết thúc này,

y&f

tạo một bản sao của ma trận và đẩy hai vectơ chứa các vị trí hàng và cột dựa trên 1 của các giá trị khác. Sau đó

7-w4-_

trừ 7 từ cái sau, đưa cái trước lên trên, chất nền 4 từ nó và phủ nhận nó. 7 và 4 chỉ định nguồn gốc của tọa độ, sao cho các góc của vectơ vị trí của các mục nhập khác không liên quan đến điểm gốc đó xác định thứ tự mong muốn.

Z;YPE\

tính toán modulo 2 * pi hai đối số để tạo ra các góc đó. Bây giờ góc nhỏ nhất là 0, tương ứng với mục nhập mà chữ cái đầu tiên sẽ đi và phần còn lại tiến ngược chiều kim đồng hồ.

,&S])

sắp xếp lại các chữ cái trong chuỗi theo các góc đó, để khi các chữ cái được ghi vào các mục nhập khác của ma trận theo thứ tự chính cột (xuống, sau đó qua) thì kết quả sẽ chính xác. Điều này được thực hiện bởi

yg(

Ví dụ: nếu đầu vào là 'a'chuỗi không được dịch chuyển vòng tròn:

abcdefghijklmnopqrstuvwxyz

Việc sắp xếp lại theo các góc biến đổi điều này thành

utsvrwqxpyoznamblckdjeifgh

do đó, 'u'sẽ chính xác đi đến mục nhập khác không đầu tiên (theo thứ tự chính cột), đó là (3,1) trong ký hiệu ma trận; 't'sẽ đi đến (4,1), 's'đến (5,1); 'v'đến (2,2), v.v .:

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

Hãy thử trực tuyến!

R , 139 122 byte

-17 byte nhờ Giuseppe

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

Giải trình:

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

Xây dựng một hộp trống của không gian

u(" &3@LKWVUTSRDC5(")

là một bộ chỉ số cho các vị trí chữ cái tương ứng với:

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

Đã lưu 2 byte nhờ @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]))

Hãy thử trực tuyến!

Làm sao?

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 + THẮNG, 72 byte

Lời nhắc cho nhân vật

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

Dùng thử trực tuyến! Coutesy of Dyalog Classic

R , 218 197 byte

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

Hãy thử trực tuyến!

Ung dung:

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

Tạo vectơ chữ xoay và sử dụng catđể điền vào vành bát với vectơ đó.

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

Hãy thử trực tuyến.

Phiên bản 136 byte có tiềm năng để được chơi 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))

Hãy thử trực tuyến.

Giải thích (của câu trả lời đầu tiê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

Ngôn ngữ Wolfram (Mathicala) , 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]]]})&

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Mỗi ký tự trong chuỗi được mã hóa được giải mã theo hàm ?thành một chuỗi:

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

Đã xóa dấu ngoặc đơn bổ sung cho -2
Chuỗi thô được thay thế cho -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'}}

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác 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))

Đã lưu 8 byte nhờ @someone. Vâng, đó thực sự là tên người dùng của anh ấy.

Hãy thử trực tuyến!

Truy vấn 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 @

Liên kết kiểm tra cho câu trả lời này đã phá vỡ các ngắt dòng và loại trừ khoảng trắng. Tôi đã thay thế khoảng trắng bằng dấu chấm và thay thế char (13) bằng char (13) + char (10) để hiển thị kết quả có thể đọc được.

Dùng thử trực tuyến

Ung dung:

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

Hãy thử trực tuyến!

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

Giải trình:

Sử dụng ordchúng tôi chuyển đổi thành một số nguyên trong khoảng từ 0 đến 255. A là 65 và Z là 90.
Sử dụng kiến ​​thức này, chúng tôi lấy đầu vào và giảm nó xuống 65 để chúng tôi có giá trị điều chỉnh.
Sau đó, chúng tôi lặp lại tất cả các ký tự, gọi ordchúng, giảm chúng 65, tăng chúng theo giá trị điều chỉnh của chúng tôi. Sử dụng modulo, chúng tôi lặp lại xuống 0 nếu vượt quá 26.
Sau đó, chúng tôi tăng thêm 65 lần nữa và chuyển đổi chúng thành các chữ cái với chr.

Đáng buồn là php: // stdin chỉ có thể được xen kẽ một lần, vì vậy chúng ta cần chuyển đầu vào vào hàm trong vòng lặp của chúng ta, ngăn chúng ta lưu byte use($a)và phải khai báo một biến bên ngoài hàm ngăn chúng ta sử dụng sạch <?=phương thức echo - chúng ta phải bọc mọi thứ trong một con chim nhạn khổng lồ.

C (GCC) 286 byte

Không chính xác là golf ngắn nhất, nhưng nó hoạt động

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

Dùng thử trực tuyến

Màu đỏ , 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]]

Hãy thử trực tuyến!

Một giải pháp thực sự ngây thơ.

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

Hãy thử trực tuyến!

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

Dùng thử trực tuyến

Lần đầu tiên thử chơi golf code. Đánh giá cao bất kỳ lời khuyên / phản hồi.

Mã gốc trước khi rút gọn:

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

Hãy thử trực tuyến!

C (gcc) , 200 198 197 byte

-3 byte nhờ vào trần nhà.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!