이것을 우리는 알파벳 수프 그릇이라고 부릅니다. 26 개의 대문자 영문 AZ가 시계 방향으로 배열되어 둘레를 형성하는 대략 원형의 아스키 아트 모양입니다.

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

단일 문자 문자 AZ를 사용하고 동일한 알파벳 수프 그릇이 "회전 된"출력되도록하는 프로그램을 작성하십시오. 따라서 입력 문자는 A위 예제에서 수행 한 위치에 나타나고 나머지 알파벳은 완전히 순환됩니다. 시계 방향.

입력에 대한 출력 A은 알파벳 수프의 원래 그릇과 같습니다.

그리고 입력 출력 B은 다음과 같습니다.

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

마찬가지로 출력 H은 다음과 같습니다.

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

또는를위한 Z:

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

이것은 A부터 Z까지 26 글자 모두에 적용되어야합니다.

세부:

• 유일한 입력은 A에서 Z까지의 단일 문자라고 가정 할 수 있습니다.
• 편리한 경우 입력 및 / 또는 출력에 소문자 az를 사용할 수 있으며 소문자와 대문자를 혼합하여 일치시킬 수도 있습니다.
• 알파벳 순서는 시계 반대 방향이 아니라 시계 방향으로 순환해야합니다.
• 수프 그릇을 들여 쓰고 채우려면 다른 공간이 아닌 공백을 사용해야합니다.
• 수프 보울이 올바르게 배열되어 있으면 출력물에 줄 바꿈 또는 공백이있을 수 있습니다.
• 그릇 모양은 텍스트로 대략 원형으로 표시되도록 폭이 12 자, 키가 7 자입니다. 그릇의 모양이 같아야합니다.

이것은 코드 골프이므로 가장 짧은 코드가 승리합니다!

05AB1E , 21 바이트

프로그램 정의$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

암호:

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

온라인으로 사용해보십시오!

고장:

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

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

설명:

캔버스 ( Λ이 특정 상황에서)는 다음 서명을 함수로 작동합니다 :

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

이는 큰 숫자는 다음과 같은 방향의 패턴을 나타냅니다.

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

이 서명 컨텍스트를 사용하여 캔버스는 목록을 반복 하고 에서 문자를 현재 방향으로 씁니다 .$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

로 지정 코드 (코드의 시작). 를 들어 , 우리는 주어진 입력을 시작하도록 알파벳의 회전 된 버전이 필요합니다. 다음 코드로 수행됩니다 ( 여기에서 시도하십시오 ).$\texttt{length}$$2$$\texttt{filler}$

AA¹k._

 A¹k # 알파벳으로 주어진 입력 문자 의 <index> 를 찾습니다
._ # 알파벳을 왼쪽의 <인덱스> 번으로 돌 립니다.

의사 코드에서 이것은 캔버스 함수에 의해 실행됩니다.

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

마지막으로, 필러 인수가 오른쪽 으로 '회전' 회 반복되는 것을 볼 수 있습니다. 즉, 캔버스는 다음 (순환 된 무한 순환) 목록을 반복합니다.$\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}}, ...$$

원하는 알파벳 수프 ascii-art 모양을 만듭니다.

펄 6 , 100 바이트

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

온라인으로 사용해보십시오!

문자열의 모든 문자를 이동 된 문자로 바꾸고 숫자를 나타내는 공백 수에 1을 더합니다.

설명

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

루비 , 107 바이트

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

온라인으로 사용해보십시오!

개선 된 구문 "i".to_c-> 1i(요르단 추천)

0 도가 위 대신 오른쪽이되도록 좌표계를 변경했습니다. 이를 통해 0.5->6

조정 된 승수 j및 k부족

print 출력 대신 puts a배열 요소를 연결하고 문자열을 반환a*$/

루비 , 119 바이트

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

복소수를 거듭 제곱하여 타원에 매핑합니다. 완전한 턴은 26이므로 각 사분면은 6.5입니다.

이 방법은 타원과 유사한 필수 출력을 사용하여 유효한 매핑을 달성 할 수 있습니다.

온라인으로 사용해보십시오!

숯 , 33 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＧＨ

경로를 추적하십시오.

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

그릇을 개설하십시오. 각각으로 7확장됩니다 ↙←.

²

한 번에 한 문자 씩 이동합니다 (이 API는 각 줄의 끝을 다음 줄과 겹칩니다).

✂⁺αα⌕αＳ

입력 문자 위치에서 시작하여 이중 알파벳을 사용하여 그립니다.

MATL , 49 바이트

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

엉망이야 그러나 재미있는 글쓰기였습니다. 아크 탄젠트도 포함됩니다.

온라인으로 사용해보십시오!

설명

코드

7I8*32tvB

숫자 배열을 만들고 이진수로 변환합니다. 이것은 제로원 매트릭스를 제공합니다

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

문자의 위치를 ​​지정하는 행렬의 왼쪽 상단 사분면입니다.

[1b]&Zv

마지막 행을 반복하지 않고 수직으로 사분면을 반영하고 마지막 행렬을 수평으로 반복하여 전체 행렬을 생성합니다.

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

이제 위치가있는 마스크가 있습니다. 코드

c

최종 결과는 char 행렬이기 때문에 이것을 char로 변환합니다. 문자 0은 공백으로 표시되며 0이 아닌 항목은 해당 문자로 작성됩니다.

2Y2

'abc···xyz'26자를 포함 하는 문자열을 푸시합니다 . 이 문자열은 입력에 따라 원형으로 이동해야합니다. 하기 위해서,

j7+_YS

입력 문자를 읽고 ASCII 코드에 7을 더한 다음 결과를 무시합니다. 입력의 'a'경우, 이것은 -104 (26의 배수)를 제공하므로이 양만큼 원형으로 이동하면 아무런 효과가 없습니다. 입력이 b-105이면 문자열 1 단계를 왼쪽으로 이동하여 생성합니다 'bcd···yza'. 기타

다음 단계는 시프트 된 문자열이 행렬의 0이 아닌 항목에 기록되는 순서를 정의하는 것입니다. 이를 위해

y&f

행렬의 복사본을 만들고 0이 아닌 1 기반 행 및 열 위치를 포함하는 두 벡터를 푸시합니다. 그때

7-w4-_

후자를 7에서 빼고, 전자를 맨 위로 가져오고 4를 빼고 무효화합니다. 7 및 4는 좌표의 원점을 지정하여 해당 원점에 대한 0이 아닌 항목의 위치 벡터의 각도가 원하는 순서를 정의합니다.

Z;YPE\

이러한 각도를 생성하기 위해 두 개의 인수 아크 탄젠트 모듈로 2 * pi를 계산합니다. 이제 가장 작은 각도 인 0은 첫 번째 문자가 들어가야하는 항목에 해당하고 나머지는 시계 반대 방향으로 진행됩니다.

,&S])

문자열의 문자를 해당 각도에 따라 재 배열하므로 문자가 행렬의 0이 아닌 항목에 열 주요 순서 (아래로, 가로로)로 기록 될 때 결과가 정확합니다. 이것은에 의해 수행

yg(

예를 들어, 입력이 'a'문자열 인 경우 순환 적으로 이동하지 않은 경우 :

abcdefghijklmnopqrstuvwxyz

각도에 따라 재정렬하면

utsvrwqxpyoznamblckdjeifgh

따라서 'u'행렬 표기법에서 (3,1) 인 첫 번째 (열 주요 순서로) 0이 아닌 항목으로 올바르게 이동합니다. 't'(4,1), 's'(5,1) 로 갈 것입니다 . 'v'(2,2) 등으로 :

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

파이썬 2 , 129 바이트

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

온라인으로 사용해보십시오!

R , 139122 바이트

주세페 덕분에 -17 바이트

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

설명:

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

빈 공간 상자를 만듭니다.

u(" &3@LKWVUTSRDC5(")

다음에 해당하는 문자 위치에 대한 색인 세트입니다.

c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)

TIO

자바 스크립트 (Node.js를) ,  (121)  119 바이트

@tsh 덕분에 2 바이트 절약

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

온라인으로 사용해보십시오!

어떻게?

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 바이트

캐릭터를위한 프롬프트

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

온라인으로 사용해보십시오!

R , 218 197 바이트

주세페 덕분에 -21 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

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

회전 문자 벡터를 생성 cat하고 그 벡터로 그릇의 테두리를 채우는 데 사용 합니다.

자바 11, 134 바이트

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

온라인으로 사용해보십시오.

골프를 칠 가능성이있는 136 바이트 버전 ?

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

온라인으로 사용해보십시오.

설명 (첫 번째 답변)

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 바이트

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

온라인으로 사용해보십시오!

하스켈, 127 바이트

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

온라인으로 사용해보십시오!

인코딩 된 문자열의 각 문자는 함수 ?에 의해 문자열로 디코딩됩니다 .

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'

코 틀린 , 148 (146) 145 바이트

-2에 대한 추가 괄호를 제거
했습니다. -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'}}

온라인으로 사용해보십시오!

C # (Visual C # 대화 형 컴파일러) , 126118 바이트

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 덕분에 8 바이트를 절약했습니다. 예, 실제로는 그의 사용자 이름입니다.

온라인으로 사용해보십시오!

TSQL 쿼리, 238 바이트

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 @

이 답변의 테스트 링크는 줄 바꿈을 끊고 공백을 제외했습니다. 읽을 수있는 결과를 표시하기 위해 공백을 마침표로 바꾸고 char (13)을 char (13) + char (10)으로 바꿨습니다.

온라인으로 사용해보십시오

언 골프 드 :

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 바이트

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

온라인으로 사용해보십시오!

프리 골프 :

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

설명:

를 사용하여 ord0에서 255 사이의 정수로 변환합니다. A는 65이고 Z는 90입니다.
이 지식을 사용하여 입력 값을 가져 와서 65만큼 줄이므로 조정 값을 갖습니다.
그런 다음 모든 문자를 반복하고 호출 ord하여 65만큼 줄이고 조정 값만큼 증가시킵니다. 모듈로를 사용하면 26을 초과하면 0으로 되돌아갑니다.
그런 다음 다시 65 씩 늘리고을 사용하여 문자로 다시 변환합니다 chr.

안타깝게도 php : // stdin은 한 번만 인터 로깅 될 수 있으므로 입력을 루프의 함수에 전달해야합니다. 따라서 바이트를 절약 use($a)할 수없고 함수 외부에서 변수를 선언하지 않아도 <?=echo 메소드를 사용하여 깨끗하게 중지 할 수 있습니다. 우리는 거대한 삼항으로 모든 것을 포장해야합니다.

C (GCC) 286 바이트

가장 짧은 골프는 아니지만 작동합니다.

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

온라인으로 사용해보십시오

빨강 , 139 바이트

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

온라인으로 사용해보십시오!

정말 순진한 솔루션.

펄 5 -p , 110 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (V8), 316 바이트

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

온라인으로 사용해보십시오

코드 골프를 처음 시도하십시오. 모든 팁 / 피드백을 감사하십시오.

축소하기 전에 원래 코드 :

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 바이트

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

온라인으로 사용해보십시오!

C (GCC) , 200 (198) 197 바이트

ceilingcat 덕분에 -3 바이트

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

온라인으로 사용해보십시오!

PHP , 131 바이트

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

온라인으로 사용해보십시오!