This is what we'll call a bowl of alphabet soup - a roughly circular ascii-art shape with the 26 uppercase English letters (A-Z) arranged clockwise to form the perimeter:

   XYZABC

 VW      DE

U          F

T          G

S          H

 RQ      JI

   PONMLK

Write a program that takes in a single letter character, A-Z, and outputs that same bowl of alphabet soup "rotated", so to speak, so the input letter appears where the A does in the example above and the rest of the alphabet cycles fully around clockwise.

So the output for input A would be that same original bowl of alphabet soup.

And the output for input B would be this one:

   YZABCD

 WX      EF

V          G

U          H

T          I

 SR      KJ

   QPONML

Likewise the output for H would be:

   EFGHIJ

 CD      KL

B          M

A          N

Z          O

 YX      QP

   WVUTSR

Or for Z:

   WXYZAB

 UV      CD

T          E

S          F

R          G

 QP      IH

   ONMLKJ

This needs to work for all 26 letters, A through Z.

Details:

• You can assume the only input will be a single letter, A through Z.


• If convenient you may use lowercase a-z for input and/or output, you can even mix and match lower and uppercase.


• The alphabet order must cycle clockwise, not counter-clockwise.


• You must use spaces, not something else, to indent and fill the soup bowl.


• There may be leading or trailing newlines or spaces in the output as long as the soup bowl is arranged properly.


• Note that the bowl shape is 12 characters wide by 7 tall to make it appear roughly circular as text. Your bowls need to be the same shape.

This is code golf so the shortest code wins!

05AB1E, 21 bytes

A roughly straightforward approach. Most likely golfable.

Code:

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

Try it online!

JavaScript (Node.js), 121 bytes

c=>`2XYZABC

0VW5DE

U9F

T9G

S9H

0RQ5JI

2PONMLK`.replace(/./g,x=>1/x?''.padEnd(-~x):(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))

Try it online!

MATL, 49 bytes

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

What a mess. But it was fun writing. There's even an arctangent involved.

Try it online!

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

Try it online!

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

Try it online!

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}

Uses a complex number raised to a power to map to an ellipse. A complete turn is 26, so each quadrant is 6.5.

This approach relies on the required output resembling an ellipse sufficiently that a valid mapping can be achieved.

Try it online!

Charcoal, 33 bytes

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

Try it online! Link is to verbose version of code. Explanation:

ＧＨ

Trace a path.

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

Outline the bowl. Each 7 expands to ↙←.

²

Move one character at a time (this API overlaps each line's ends with the next).

✂⁺αα⌕αＳ

Draw using the doubled alphabet, but starting at the position of the input character.