text:
Alphabet Diamond
You've seen the amazing alphabet triangle, the revenge of the alphabet triangle and now it's time for the revenge of the revenge of the alphabet triangle!
Introducing...
THE ALPHABET DIAMOND!
Your task is to output this exact text, lowercase/uppercase does not matter, though newlines do:
bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb
cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc
defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed
efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe
fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf
ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg
hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih
ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji
jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj
klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk
lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml
mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm
nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon
opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo
pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp
qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq
rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr
stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts
tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut
uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu
vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv
wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw
xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx
yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy
zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz
abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba
bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb
abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba
zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz
yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy
xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx
wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw
vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv
uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu
tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut
stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts
rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr
qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq
pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp
opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo
nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon
mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm
lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml
klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk
jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj
ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji
hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih
ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg
fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf
efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe
defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed
cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc
bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb

This is code-golf, lowest bytecount wins.
Rules:

Standard loopholes are disallowed.
a must be the center of the alphabet diamond.

Nice challenge. I personally think it would make more sense if the corners were a and the center was z

@ETHproductions I wanted to make it harder for the golfing languages who can push the alphabet ;). Though I doubt it's much harder.

@carusocomputing A left rotate would do it. For example, .< would do it in Pyth: .<S5 1 would result in [2, 3, 4, 5, 1]. It is the same as .<[1 2 3 4 5)1. Not sure for the diamond, though.

@EriktheGolfer I realize, there are some smarter ways to do it too, like collapsing the shift in a do-while. The diamond itself should require shifting, so there are ways to combine the initial shift in the actual diamond iterations as well. It was an intentional part of the challenge to see who optimized their looping.

@carusocomputing I meant about b being the initial letter instead of a. Of course shifting is vital too.

@carusocomputing huh?

05AB1E, 13 12 bytes
A27FÀDûˆ}¯û»

Try it online!
Explanation
A              # push alphabet
 27F           # 27 times do
    À          # rotate alphabet left
     Dû        # create a palendromized copy
       ˆ       # add to global list
        }      # end loop
         ¯     # push global list
          û    # palendromize list
           »   # merge list on newline
               # implicit output

Could probably save a byte using registers and the g to calc the length of the alphabet instead of duping it.

@carusocomputing: Unless I'm doing it wrong (feel free to educate me if that is the case) I ended up at 13 doing that. I did manage to save a byte with the global list though.

A©gF®À©û})û» is what I was thinking. By no means are you ever doing it wrong! I've learned all I know from watching you heh. The global list is the same basic idea.

@carusocomputing: Yeah, with ƒ instead of F that would indeed be 12. Nice!

Now you're tied with me. :3

@Oliver: Indeed! And with 2 different approaches in the same language :)

Vim, 62, 60 keystrokes
:se ri|h<_<cr>jjYZZPqqx$pYpq26@qdjyH:g/^/m0<cr>VP:%norm DPA<C-v><C-r>"<C-v><esc>x<cr>

Drawing on inspiration from Lynn's awesome vim answer to take the idea of stealing the alphabet from the help docs.
You can watch it happen in real time as I struggle to remember the right sequence of keystrokes!

Note that this gif is slightly outdated because it produces the wrong output, and I haven't gotten around to re-recording it yet.

I tried this program and got this.

Pls rerecord ty

MATL, 14 bytes
2Y226Zv27Zv!+)

Try it online!
2Y2     % Push string 'abc...z'
26Zv    % Push symmetric range [1 2 ... 25 26 25 ... 2 1]
27Zv    % Push symmetric range [1 2 ... 25 26 27 26 25 ... 2 1]
!       % Transpose into a column
+       % Addition with broadcast. Gives a matrix of all pairwise additions:
        % [  2  3 ... 26 27 26 ...  3  2
             3  4 ... 27 28 27 ...  4  3
             ...
            27 28 ... 51 52 51 ... 28 27
            28 29 ... 52 53 52 ... 29 28
            27 28 ... 51 52 51 ... 28 27
             ...
             2  3 ... 26 27 26 ...  3  2 ]
)       % Index modularly into the string. Display implicitly

PHP, 129 Bytes
for(;++$i<27;)$o.=($s=($f=substr)($r=join(range(a,z)),$i,26-$i)).$t.strrev($s.$t=$f($r,0,$i))."\n";echo$o.$f($o,0,51).strrev($o);

syntax error, unexpected '(' on line 1 Which php version?

@Tschallacka PHP > 7 before you can write  for($f=substr; and $f($r=join(range(a,z)),$i,26-$i)) instead of ($f=substr)($r=join(range(a,z)),$i,26-$i)) to avoid the error

Haskell, 75 bytes
g=(++)<*>reverse.init
unlines$g$g.take 26.($cycle['a'..'z']).drop<$>[1..27]

How it works:
g=(++)<*>reverse.init    -- helper function that takes a list and appends the
                         -- reverse of the list with the first element dropped, e.g.
                         -- g "abc"  -> "abcba"

             <$>[1..27]  -- map over the list [1..27] the function that
           drop          -- drops that many elements from
    ($cycle['a'..'z'])   -- the infinite cycled alphabet and
   take 26               -- keeps the next 26 chars and
  g                      -- appends the reverse of itself

                         -- now we have the first 27 lines

 g                       -- do another g to append the lower half
unlines                  -- join with newlines

Jelly, 13 bytes
Øaṙ1ṭṙJ$ŒBŒḄY

Try it online!
Explanation
Øaṙ1ṭṙJ$ŒBŒḄY  Main link. No arguments
Øa             Get the lowercase alphabet
  ṙ1           Rotate left by 1
    ṭ          Append to
       $       Monadic chain
      J          Indices of the alphabet [1, 2, ..., 26]
     ṙ           Rotate the alphabet by each
        ŒB     Bounce each rotation
          ŒḄ   Bounce the rotations
            Y  Join with newlines and print implicitly

Øaṙ'JŒBŒḄY for 10 :)

@JonathanAllan Thanks but that's missing the middle part which is why I had to do that ṙ1ṭ bit. Also ØaṙJŒBŒḄY is fine, you don't need the quick since it vectorizes on the right to 0

Totally missed that the diamond was not perfect! Oh well...

C, 76 bytes
Function, to be called as below. Prints capital letters.
f(i){for(i=2756;--i;)putchar(i%52?90-(abs(i%52-26)+abs(i/52-26)+25)%26:10);}

//call like this
main(){f();}

Simple approach, add the x and y distances from the centre of the square, plus an offset of 25 for the a in the middle, take modulo 26 and subract from 90, the ASCII code for Z. Where i%52==0 a newline ASCII 10 is printed.

Your offset of +25 is the same as -1 in modulo 26

@KarlNapf C doesn't implement modulo of negative numbers the way mathematicians do. -1%26 in C is -1, not 25. The result is a [ in the centre instead of the expected A. Thanks anyway, you would have been correct in a language such as Ruby where -1%26 does equal 25.

R, 71 bytes
cat(letters[outer(c(1:27,26:1),c(0:25,24:0),"+")%%26+1],sep="",fill=53)

outer creates a matrix with the indices of the letters, letters[...] then creates a vector with the correct letters in. cat(...,sep="",fill=53) then prints it out with the desired formatting.

Nice one! Somehow I had forgotten about the fill option for cat. Great way of printing formatted matrices.

Jelly, 11 bytes
27RØaṙŒḄŒBY

Explanation:
27R          range of 1...27
   Øa        the alphabet
     ṙ       rotate
      ŒḄŒB   bounce in both dimensions
          Y  join on newline

JavaScript (ES6), 97 96 bytes
Saved 1 byte thanks to @user81655
R=(n,s=25,c=(n%26+10).toString(36))=>s?c+R(n+1,s-1)+c:c
C=(n=1,r=R(n))=>n<27?r+`
${C(n+1)}
`+r:r

Two recursive functions; C is the one that outputs the correct text. Try it here:

R=(n,s=25,c=(n%26+10).toString(36))=>s?c+R(n+1,s-1)+c:c
C=(n=1,r=R(n))=>n<27?r+`
${C(n+1)}
`+r:r

console.log(C())

@user81655 I always forget about string interpolation when newlines are involved :P

Python 2, 96 85 bytes
Printing the uppercase version (saves 1 byte).
R=range
for i in R(53):print''.join(chr(90-(abs(j-25)+abs(i-26)-1)%26)for j in R(51))

previous solution with help from muddyfish
s="abcdefghijklmnopqrstuvwxyz"*3
for i in range(53):j=min(i,52-i);print s[j+1:j+27]+s[j+25:j:-1]

isn't just typing the alphabet fewer chars?

Batch, 255 bytes
@echo off
set l=abcdefghijklmnopqrstuvwxyz
set r=yxwvutsrqponmlkjihgfedcba
for /l %%i in (1,1,27)do call:u
for /l %%i in (1,1,25)do call:l
:l
set r=%r:~2%%l:~-1%.
set l=%l:~-2%%l:~0,-2%
:u
set r=%l:~-1%%r:~0,-1%
set l=%l:~1%%l:~0,1%
echo %l%%r%

Explanation: The subroutine u rotates the alphabet outwards by one letter from the centre, which is the pattern used in the top half of the desired output. The subroutine l rotates the alphabet inwards by two letters. It then falls through into the u subroutine, achieving an effective single letter inward rotation. Finally the last line is printed by allowing the code to fall through into the l subroutine.

Perl, 77 bytes
Requires -E at no extra cost.
Pretty standard approach... I don't like the calls to reverse I think there's likely a more maths based approach to this, will see how I get on!
@a=((a..z)x3)[$_..$_+26],$a=pop@a,(say@a,$a,reverse@a)for 1..26,reverse 1..25

Usage
perl -E '@a=((a..z)x3)[$_..$_+26],$a=pop@a,(say@a,$a,reverse@a)for 1..26,reverse 1..25'

You can save 1 byte by removing the whitespace after reverse in reverse 1..25. The for needs it though.

@simbabque maybe it's a Perl version thing, but reverse1..25 results in 0..25. I'm running 5.18.2...

You're right. Because the bareword reverse1 is undefined. Makes sense.

Python 3, 119 bytes
I tried to exploit the two symmetry axes of the diamond, but this ended up more verbose than Karl Napf's solution.
A='abcdefghijklmnopqrstuvwxyz'
D=''
for k in range(1,27):
 D+=A[k:]+A[:k]
 D+=D[-2:-27:-1]+'\n'
print(D+D[:51]+D[::-1])

A good solution nonetheless! You can cut down 3 bytes by writing the for loop in 1 line: for k in range(1,27):D+=A[k:]+A[:k];D+=D[-2:-27:-1]+'\n'

shortened again: replace A with 'bcdefghijklmnopqrstuvwxyza' and replace range(1,27) with range(26). My byte count is now 114

Haskell, 67 66 bytes
unlines[[toEnum$mod(-abs j-abs i)26+97|j<-[-25..25]]|i<-[-26..26]]

C, 252 bytes
#define j q[y]
#define k(w,v) (v<'z')?(w=v+1):(w=97)
char q[28][52],d;main(){int y,x=1;y=1;j[0]=98;j[50]=98;for(;y<27;y++){for(;x<26;x++){(x<1)?(k(d,q[y-1][50])):(k(d,j[x-1]));j[50-x]=d;j[x]=d;}x=0;j[51]=0;puts(j);}strcpy(j,q[1]);for(;y;y--)puts(j);}

Formatted, macro-expanded version, which is hopefully more intelligible:
#define j q[y]
#define k(w,v) (v<'z')?(w=v+1):(w=97)
char q[28][52],d;
main(){
int y,x=1;
y=1;
q[1][0]=98;q[1][50]=98;
//98 takes one less byte to type than the equivalent 'b'
for(;y<27;y++){
    for(;x<26;x++){
        (x<1)?
            (k(d,q[y-1][50]))
            :(k(d,q[y][x-1]));
        q[y][50-x]=d;
        q[y][x]=d;
        }
    x=0;
    q[y][51]=0;
    puts(q[y]);
    }
strcpy(q[y],q[1]);
for(;y;y--)puts(q[y]);
}

I know this can't win, but I had fun trying. This is my first ever attempt at code golf.

Welcome to code golf, it's addicting haha ;).

Pyke, 23 22 21 bytes
GV'th+jj_t+j)K]0n'JOX

Try it here!
GV          )         - repeat 26 times, initially push alphabet.
  'th+                -  push tos[1:]+tos[0]
      j               -  j = tos
       j              -  push j
        _t+           -  push pop+reversed(pop)[1:]
           j          -  push j
             K        - pop
              ]0      - list(stack)
                n'JOX - print "\n".join(^),
                      - splat ^[:-1]

VBA, 109 105 78 Bytes
Anonymous VBE immediate window function that takes no input and outputs the alphabet diamond to the VBE immediate window.
For i=-26To 26:For j=-25To 25:?Chr(65+(52-(Abs(j)+Abs(i)))Mod 26);:Next:?:Next

Charcoal, 24 21 bytes
-3 bytes thanks to ASCII-only.
Ｆ²⁷«Ｐ✂×β³⊕ι⁺ι²⁷↓»‖Ｂ↓→

Try it online! Link is to verbose version.
...I need to work on my Charcoal-fu. :P

some easy bytes off

Now I find out that the fourth argument to Slice is optional. >_>

All (yes, all four) arguments are optional

wat, what does niladic Slice even do?

Same as in Python, deep copy

Deep copy of what? With no arguments...

Oh wait nvm yeah the first argument is required :P

oh more bytes off wait even more

C++, 191 179 166 165 139 bytes
-12 bytes thanks to Kevin Cruijssen
-14 bytes thanks to Zacharý
-26 bytes thanks to ceilingcat
#import<cstdio>
#define C j;)putchar(97+j
main(){for(int i=0,j,d=1;i<53;d+=i++/26?-1:1){for(j=d;26+d>C++%26);for(j--;d<=--C%26);puts("");}}

You can save 12 bytes like this: #include<iostream> int main(){for(int i=0,j,d=1;i<53;d+=i++/26?-1:1){for(j=0;j<26;)std::cout<<char((j+++d)%26+97);for(j=24;j>=0;)std::cout<<char((j--+d)%26+97);std::cout<<'\n';};}

Dang it Kevin, ya ninja'd me.

@KevinCruijssen Thanks you for the help. By the way, your code in the comment contained unprintable unicode characters.

@HatsuPointerKun That's something that happens automatically in the comments I'm afraid. It's indeed pretty annoying when you try to copy-paste code from it.. :)

@KevinCruijssen Yup, i get "0 is an unknown identifier" and "std doesn't have cout identifier/type" and so on...

You can abuse macros by adding this: #define C j;)std::cout<<char(97+(d+j, and then changing the last line to this:
int main(){for(int i=0,j,d=1;i<53;d+=i++/26?-1:1){for(j=0;26>C++)%26);for(j=24;0<=C--)%26);std::cout<<'\n';};}

Wait ... what is that stray semicolon doing after the for loop?

Suggest 1-++i/27*2 instead of i++/26?-1:1

VBA (Excel) , 116 Bytes
Sub a()
For i=-26To 26
For j=-25To 25
b=b & Chr(65+(52-(Abs(j)+Abs(i))) Mod 26)
Next
Debug.Print b
b=""
Next
End Sub

Following Sir Joffan's Logic. :D

PowerShell, 64 bytes
1..27+26..1|%{$y=$_
-join(0..25+24..0|%{[char](97+($_+$y)%26)})}

Try it online!

JavaScript (ES6), 128 115 114 bytes
a='abcdefghijklmnopqrstuvwxyz'
for(o=[i=27];i--;)o[26-i]=o[26+i]=(a=(p=a.slice(1))+a[0])+[...p].reverse().join``
o

Groovy - 103 97 bytes
I realise there are cleverer ways of doing this but...
{t=('a'..'z').join();q={it[-2..0]};c=[];27.times{t=t[1..-1]+t[0];c<<t+q(t)};(c+q(c)).join('\n')}
When run the result of the script is the requested answer.
(Thanks to carusocomputing for the tip on saving 7 bytes).
Updated example accordingly on:
See http://ideone.com/MkQeoW

Instead of the for loop you can use 27.times(){} and save 7 bytes ;).

Racket 293 bytes
(let*((ls list->string)(rr reverse)(sr(λ(s)(ls(rr(string->list s))))))(let p((s(ls(for/list((i(range 97 123)))(integer->char i))))
(n 0)(ol'()))(let*((c(string-ref s 0))(ss(substring s 1 26))(s(string-append ss(string c)(sr ss))))(if(< n 53)(p s(+ 1 n)(cons s ol))
(append(rr ol)(cdr ol))))))

Ungolfed:
(define (f)
  (define (sr s)           ; sub-fn reverse string;
    (list->string
     (reverse
      (string->list s))))
  (let loop ((s
              (list->string
               (for/list
                   ((i
                     (range 97 123)))
                 (integer->char i))))
             (n 0)
             (ol '()))
    (define c (string-ref s 0))
    (define ss (substring s 1 26))
    (set! s (string-append
             ss
             (string c)
             (sr ss)))
    (if (< n 53)
        (loop s (add1 n) (cons s ol))
        (append (reverse ol) (rest ol)))))

Testing:
(f)

Output:
'("bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb"
  "cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc"
  "defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed"
  "efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe"
  "fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf"
  "ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg"
  "hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih"
  "ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji"
  "jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj"
  "klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk"
  "lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml"
  "mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm"
  "nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon"
  "opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo"
  "pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp"
  "qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq"
  "rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr"
  "stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts"
  "tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut"
  "uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu"
  "vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv"
  "wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw"
  "xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx"
  "yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy"
  "zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz"
  "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"
  "bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb"
  "cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc"
  "defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed"
  "efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe"
  "fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf"
  "ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg"
  "hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih"
  "ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji"
  "jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj"
  "klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk"
  "lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml"
  "mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm"
  "nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon"
  "opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo"
  "pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp"
  "qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq"
  "rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr"
  "stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts"
  "tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut"
  "uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu"
  "vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv"
  "wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw"
  "xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx"
  "yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy"
  "zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz"
  "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"
  "bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb"
  "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"
  "zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz"
  "yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy"
  "xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx"
  "wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw"
  "vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv"
  "uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu"
  "tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut"
  "stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts"
  "rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr"
  "qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq"
  "pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp"
  "opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo"
  "nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon"
  "mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm"
  "lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml"
  "klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk"
  "jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj"
  "ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji"
  "hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih"
  "ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg"
  "fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf"
  "efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe"
  "defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed"
  "cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc"
  "bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb"
  "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"
  "zabcdefghijklmnopqrstuvwxyxwvutsrqponmlkjihgfedcbaz"
  "yzabcdefghijklmnopqrstuvwxwvutsrqponmlkjihgfedcbazy"
  "xyzabcdefghijklmnopqrstuvwvutsrqponmlkjihgfedcbazyx"
  "wxyzabcdefghijklmnopqrstuvutsrqponmlkjihgfedcbazyxw"
  "vwxyzabcdefghijklmnopqrstutsrqponmlkjihgfedcbazyxwv"
  "uvwxyzabcdefghijklmnopqrstsrqponmlkjihgfedcbazyxwvu"
  "tuvwxyzabcdefghijklmnopqrsrqponmlkjihgfedcbazyxwvut"
  "stuvwxyzabcdefghijklmnopqrqponmlkjihgfedcbazyxwvuts"
  "rstuvwxyzabcdefghijklmnopqponmlkjihgfedcbazyxwvutsr"
  "qrstuvwxyzabcdefghijklmnoponmlkjihgfedcbazyxwvutsrq"
  "pqrstuvwxyzabcdefghijklmnonmlkjihgfedcbazyxwvutsrqp"
  "opqrstuvwxyzabcdefghijklmnmlkjihgfedcbazyxwvutsrqpo"
  "nopqrstuvwxyzabcdefghijklmlkjihgfedcbazyxwvutsrqpon"
  "mnopqrstuvwxyzabcdefghijklkjihgfedcbazyxwvutsrqponm"
  "lmnopqrstuvwxyzabcdefghijkjihgfedcbazyxwvutsrqponml"
  "klmnopqrstuvwxyzabcdefghijihgfedcbazyxwvutsrqponmlk"
  "jklmnopqrstuvwxyzabcdefghihgfedcbazyxwvutsrqponmlkj"
  "ijklmnopqrstuvwxyzabcdefghgfedcbazyxwvutsrqponmlkji"
  "hijklmnopqrstuvwxyzabcdefgfedcbazyxwvutsrqponmlkjih"
  "ghijklmnopqrstuvwxyzabcdefedcbazyxwvutsrqponmlkjihg"
  "fghijklmnopqrstuvwxyzabcdedcbazyxwvutsrqponmlkjihgf"
  "efghijklmnopqrstuvwxyzabcdcbazyxwvutsrqponmlkjihgfe"
  "defghijklmnopqrstuvwxyzabcbazyxwvutsrqponmlkjihgfed"
  "cdefghijklmnopqrstuvwxyzabazyxwvutsrqponmlkjihgfedc"
  "bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb")

Pyth, 21 19 bytes
j+PKm+PJ.<Gd_JS27_K

Try it online!
Explanation:
j+PKm+PJ.<Gd_JS27_K   expects no input

j                     joins on new line
 +   +                joins two strings
  P   P               prints everything but the last element
   K                  initialize K and implicitly print
    m                 for...in loop, uses d as iterator variable
       J              initialize J and implicitly print
        .<            cyclically rotate
          G           initialized to the lowercase alphabet
           d          iterating variables of m
            _    _    reverse
             J        call J
              S27     indexed range of 27
                  K   call K

SOGL V0.12, 10 bytes
zl{«:}«¹╬,

Try it Here!
Explanation:
z           push the lowercase alphabet
 l{  }      repeat length times
   «          put the 1st letter at the end
    :         duplicate
      «     put the 1st letter at the end (as the last thing called is duplicate)
       ¹    wrap the stack in an array
        ╬,  quad-palindromize with 1 X and Y overlap

Java 10, 154 153 151 148 147 142 141 bytes
v->{var r="";for(int i=0,j,d=1;i<53;d+=1-++i/27*2){for(j=d;j<26+d;)r+=(char)(j++%26+97);for(j--;j>d;)r+=(char)(--j%26+97);r+="\n";}return r;}

Port of @HatsuPointerKun C++ answer, so make sure to upvote him/her as well.
-8 bytes thanks to @ceilingcat.
-1 byte thanks to @Grimmy.
Try it here.

-1

Kotlin, 106 bytes
{(0..52).map{i->(0..50).map{j->print((90-((Math.abs(j-25)+Math.abs(i-26)-1)+26)%26).toChar())}
println()}}

Beautified
{
    (0..52).map {i->
        (0..50).map {j->
            print((90 - ((Math.abs(j - 25) + Math.abs(i - 26) - 1)+26) % 26).toChar())
        }
        println()
    }
}

Test
var v:()->Unit =
{(0..52).map{i->(0..50).map{j->print((90-((Math.abs(j-25)+Math.abs(i-26)-1)+26)%26).toChar())}
println()}}

fun main(args: Array<String>) {
    v()
}

TryItOnline
Port of @Karl Napf's answer

uBASIC, 86 bytes
0ForI=-26To26:ForJ=-25To25:?Left$(Chr$(65+(52-(Abs(J)+Abs(I)))Mod26),1);:NextJ:?:NextI

Try it online!

MY-BASIC, 89 bytes
Anonymous function that takes no input and outputs to the console.
For i=-26 To 26
For j=-25 To 25
Print Chr(65+(52-(Abs(j)+Abs(i)))Mod 26)
Next
Print;
Next

Try it online!

Visual Basic .NET (Mono), 160 bytes
Declared Subroutine that takes no input and outputs to the console.
Module M
Sub Main
Dim S,I,J
For I=-26To 26
S=""
For J=-25To 25
S+=Chr(65+(52-(Math.Abs(j)+Math.Abs(i)))Mod 26)
Next
Console.WriteLine(S)
Next
End Sub
End Module

Try it online!

Are you attempting to tell me that this challenge is "Basic" or something?

BA DUM TSSSSSSSSSSS

@MagicOctopusUrn Lol!, Nope - I just realized that there were a couple of flavors of BASIC on TIO and thought I would give them a try - and as it turns out there are some pretty huge bugs in uBASIC (it cannot take any input on TIO at the moment) so alphabet challenges are the best I can do for all of the BASIC flavors

Yabasic, 74 bytes
Now I'm telling you that this challenge BASIC. /sarcasm
For i=-26To 26
For j=-25To 25
?Chr$(65+Mod(Abs(j)+Abs(i),26));
Next
?
Next

Try it online!

"YA BASIC!" - Had me laughing, thanks for that one lol.

PowerShell v6+, 59 bytes
1..27+26..1|%{-join(('a'..'z'*3)[$_..($_+25)+($_+24)..$_])}

Try it online!
Ranges on ranges on ranges.

maybe an gu could try?

@mazzy I have no idea how I'd work gu into this one. If you have it, you should post it as your own.

You're right. gu useless. Try it online!

05AB1E, 9 bytes
Aā._Ć€ûû»

Try it online!

FALSE, 137 bytes
1c:53 0$d:[65@$0=~\1-\][@@\c;+d;1=[1_c:]?$26=[%0 1d:]?$1_=[%25]?$@+1b:51[$0=~][$26=[1_b:]?\$,b;+[$a:$64=[90a:]?91=[65a:]?a;]!\1-]#%%10,]#

Try it online!

Vyxal jr, 11 bytes
27ƛkaǓøm;øm

Try it Online!
Explanation:
27ƛ     ;    # For each number x in range [1..27]:
   ka        #   Lowercase alphabet
     Ǔ       #   Rotate it left x times
      øm     #   Mirror without duplicating middle
         øm  # Mirror without duplicating middle
             # 'j' flag - Join top of stack with newlines and print

J, 48 bytes
(}:@|.,])(],.}.@|."1)(1+i._26)|."0 1 a.{~97+i.26

Try it online!

Common Lisp, 221 bytes
(let((k 26)a(s"~26{~a~}~25{~a~}~%"))(#4=dotimes(i k)(push(code-char(- 90 i))a))(let*((u(append a a a))(b(reverse u)))(#4#(i 27)(#3=format t s #1=(nthcdr(1+ i)u)#2=(nthcdr(- k i)b)))(rotatef u b)(#4#(i k)(#3#t s #2##1#))))

Try it online!
More readable version:
(let (a)                             ; variable to hold the alphabet
  (dotimes (i 26)                    ; creation of the alphabet as list
    (push (code-char (- 90 i)) a))
  (let* ((u (append a a a))          ; make three copies of a
         (b (reverse u)))                ; reverse u
    (dotimes (i 27)                  ; first half: form a line with two parts
       (format t "~26{~a~}~25{~a~}~%" (nthcdr (1+ i) u) (nthcdr (- 26 i) b)))
    (rotatef u b)                    ; exchange the role of u and b
    (dotimes (i 26)                  ; second half: exchange the two parts
       (format t "~26{~a~}~25{~a~}~%" (nthcdr (- 26 i) b) (nthcdr (1+ i) u)))))

Japt -R, 15 12 bytes
;26ÆCé´T êÃê

Test it
;26ÆCé´T êÃê
 26Æ             :Map the range [0,26)
;   C            :  Lowercase alphabet
     é           :  Rotate right by
      ´T         :    T (initially 0) prefix decremented
         ê       :  Palindromise
          Ã      :End map
           ê     :Palindromise
                 :Implicit output joined with newlines

Dyalog APL, 31 bytes
{⍵⍪1 0↓⊖⍵}{⍵,0 1↓⌽⍵}↑(⌽∘⎕A)¨⍳27

Try it online!

q/kdb+, 51 bytes
Solution:
-1 .Q.a t{rotate[y;x]x,1_(|)x}/:(1+t),1,(-)t:(!)26;

Explanation:
Build the range of 1..26,1,0,-1..-25, feed this into a lambda that rotates the range 0..25 and indexes in at the range 0..25,24..0... Then use this to index into the lowercase alphabet.
-1 .Q.a t{rotate[y;x]x,1_reverse x}/:(1+t),1,neg t:til 26; / ungolfed
-1                                                       ; / print to stdout and swallow return value
                                                 t:til 26  / store range of 0..25 in variable t
                                             neg           / negate (0..-25)
                                           1,              / prepend 1
                                     (1+t),                / prepend 1+t (1..26)
        t{                        }/:                      / lambda function with parameters t, and each-right
                         reverse x                         / x = t = 0..25, reversed is 25..0
                       1_                                  / 1 drop, so 24..0
                     x,                                    / prepend x, so 0..25,24..0
          rotate[y;x]                                      / rotate x by y (rotate[1;"abc"] -> "bca")
   .Q.a                                                    / index into alphabet at these indices

Notes:
Feels like it should be able to be golfed further, building the ranges seems clunky.

Recursiva, 44 25 21 19 bytes
{p+)'a'"Pp+J''_Q)}}

Try it online!
Explanation:
{p+)'a'"Pp+J''_Q)}}
{                     - For each
 p+)'a'               - 'abc..xyzazyx..abc'
       "              - Iteration command begin
        P             - Print
         p            - palindromize 'cde..xyzabazyx..cde'
          +           - concatenate 'cde..xyzab'
           J''        - join with nothing 'cde..xyza'
              _       - reverse ['cde...xyz', 'a']
               Q)}    - split ) at } ['a','cdef..xyz']
                  }   - current element (say 'b' for 2nd iteration)

Retina, 166 bytes

bcdefghijklmnopqrstuvwxyzazyxwvutsrqponmlkjihgfedcb____________________________________________________
+(`([a-z]+)_(_+)
$1¶$1$2¶$1
(.)(.{24})(.)(.{24})._
$2$3$1$3$4

Try it online!

APL (Dyalog Classic), 21 bytes
(⍉⊢⍪1↓⊖)⍣2⍉1↓27 27⍴⎕a
Try it online!
With the alphabet (⎕a) fill in row-major order a 27x27 matrix (27 27⍴), then drop the first row (1↓) and transpose (⍉).
Do this twice (⍣2): concatenate to the bottom (⍪) of this matrix (⊢) a vertically reversed copy (⊖) without its first row (1↓) and transpose (⍉) the result.

Stax, 13 bytes
éÑ8╟╘"╧ö↑D☼▓}

Run and debug it

Elixir, 111 bytes
import Enum
c=?a..?z
a=map 1..26,&(drop(c,&1)++slice c,0,&1)
map a++[hd a]++reverse(a),&IO.puts&1++tl reverse&1

Try it online!
Feel like there are some key savings I'm missing here...


text:
Alphabet Pattern Matching
We've had a lot of alphabet challenges.  For this challenge, you are passed the output of an alphabet challenge, and you need to output the pattern scaled to size N.
For example, if N=5 and you were passed the L-phabet:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

You would need to output:
ABCDE
BBCDE
CCCDE
DDDDE
EEEEE

For the purposes of explanation, I'll be using only ABCD, instead of the full alphabet.  You need to be able to match the L-phabet (above), as well as the following patterns:
The single line:
ABCD    or     A
               B
               C
               D

The single line repeated N times
ABCD    or    AAAA
ABCD          BBBB
ABCD          CCCC
ABCD          DDDD

The Tabula Recta:
ABCD
BCDA
CDAB
DABC

This alphabet triangle:
A      or   AAAAAAA
AB           BBBBB
ABC           CCC
ABCD           D
ABC
AB
A

We also have half triangles in lots of varieties:
A           AAAA      A        ABCD
BB          BBB       AB       ABC
CCC         CC        ABC      AB
DDDD        D         ABCD     A

Finally, the square:
AAAAAAA
ABBBBBA
ABCCCBA
ABCDCBA
ABCCCBA
ABBBBBA
AAAAAAA

All of the above patterns are of size 4.  However, you will be passed a pattern of size 26, as well as an N between 1 and 26, and you need to scale the pattern.  You do not need to handle any other patterns.

The output for 1 will always be the single character A
The output for 26 will always be the same, full-sized pattern passed in.
Trailing spaces are allowed at the end of each line, as well as a trailing newline at the end
You can find all patterns of size 26 here

This is a code-golf, so do it in as few bytes as possible!

You could provide the full-sized patterns somewhere.

@KarlNapf done: http://pastebin.com/Kt8NX5MF

R, 483 412 bytes
    x=function(n){d=1:n;a=LETTERS[d];z=rep;f=function(...)cat(...,"\n",sep="");g=c(d,n:2-1);for(i in d)f(a[z(i,i)],if(i!=n)a[(i+1):n]);f(a);for(i in d)f(a[i]);for(i in d)f(a);for(i in d)f(z(a[i],n));for(i in d)f(a[i:n],if(i>1)a[1:i-1]);for(i in g)f(a[1:i]);for(i in d)f(z(" ",i-1),z(a[i],2*(n-i)+1));for(i in d)f(z(a[i],i));for(i in d)f(z(a[i],n-i+1));for(i in g)f(if(i>1)a[2:i-1],z(a[i],2*(n-i)+1),if(i>1)a[i:2-1])}

This is my first time posting, I was told I didn't have a recent years experience of R, so just practise a little bit here.
Expanded
    x=function(n){
    # array of 1 to n
    d=1:n
    # first n capital letters
    a=LETTERS[d]
    # use z to represent the repeat function
    z=rep
    # use f to represent concatenate, with new line and close the gap
    f=function(...)cat(...,"\n",sep="");
    # use g to represent 1 to n then n to 1
    g=c(d,n:2-1)

    # L-phabet
    # start and repeat the first letter to i, combine the i+1 to the end
    for(i in d) f(a[z(i,i)],if(i!=n)a[(i+1):n])

    # single line - horizontal
    f(a)

    # single line - vertical
    for(i in d)f(a[i])

    # single line - repeated by row
    for(i in d)f(a)

    # single line - repeated by column
    for(i in d)f(z(a[i],n))

    # Tabula Recta
    # start from i, combine the 1 to i-1
    for(i in d) f(a[i:n],if(i>1)a[2:i-1])

    # alphabet triangle
    for(i in g)f(a[1:i])

    # alphabet triangle - upside down
    for(i in d)f(z(" ",i-1),z(a[i],2*(n-i)+1))

    # half triangles
    for(i in d)f(z(a[i],i))
    for(i in d)f(z(a[i],n-i+1))

    # the square
    # combine the first part from i to i-1 letters, repeat the i in the middle, combine the last part from i-1 to 1 letters
    for(i in g) f(if(i>1)a[2:i-1],z(a[i],2*(n-i)+1),if(i>1)a[i:2-1])
    }

PHP, 502 Bytes
<?$c=count($x=explode("\n",$_GET[p]));for($t=$u=$o="",$f="substr",$n=0;$n<$g=$_GET["n"];$n++){if(2651==$l=strlen($s))$o.=$f($x[$n],0,$g).$f($x[$n],1-$g)."\n";elseif($l==1026)echo($t=$f($x[$n],0,$g)).$f(strrev($t),1)."\n";elseif($f($s,-1)=="Y")echo$f($x[$n],0,$g-$n).$f($x[$n],-$n,$n)."\n";elseif($l==376&&$f($s,-2,1)=="\n")echo$f($x[$n],0,$g-$n)."\n";elseif($l==726){$t.=$x[$n]."\n";$n+1==$g?:$u=$x[$n]."\n".$u;}else echo$f($x[$n]??"",0,$g)."\n";}if($o)echo$o.substr(strrev($o),2*$g+1);if($t)echo$t.$u;

Works with the string length of a pattern. A pattern has these conditions.
Letter at begin an end. CR are removed.
Expanded
foreach($p as$s){ # all patterns in an array
    $c=count($x=explode("\n",$s));
    for($t=$u=$o="",$f="substr",$n=0;$n<$g=$_GET["n"];$n++){
    if(2651==$l=strlen($s))$o.=$f($x[$n],0,$g).$f($x[$n],1-$g)."\n";
# square pattern
    elseif($l==1026)echo($t=$f($x[$n],0,$g)).$f(strrev($t),1)."\n";
#alphabet triangle up down
    elseif($f($s,-1)=="Y")echo$f($x[$n],0,$g-$n).$f($x[$n],-$n,$n)."\n";
# Tabula recta
    elseif($l==376&&$f($s,-2,1)=="\n")echo$f($x[$n],0,$g-$n)."\n";
# two half triangle
    elseif($l==726){$t.=$x[$n]."\n";$n+1==$g?:$u=$x[$n]."\n".$u;}
#alphabet triangle left right
    else echo$f($x[$n]??"",0,$g)."\n";
# all other
    }
    if($o)echo$o.substr(strrev($o),2*$g+1);
    if($t)echo$t.$u;
}

unnecessary quotes: "substr", $_GET["n"], "Y" (-6). 2) $x[$n]."\n" -> "$x[$n]\n", analogue for $u (-2). 3) I´m pretty sure you can use some sort of > for your <number>==$l comparisons (-4). 4) ($n=0;$n<...;$n++) -> ($n=-1;++$n<...;) (-1). 5) if($o) is unnecessary: if $o is empty, so is strrev($o) and any of its substrings, so nothing will be printed (-6). 6) && -> & (-1). 7) Do you really need empty string instead of null for substr? $x[$n]??"" --> $x[$n] (-4)?

JavaScript (ES6), 382 380 370 bytes
f=(a,N)=>{X=Y=0
if(a[1]){Y=a[1].trim()[0]=='B'
X=z=a[0][1]==a[1][0]?1:!Y
l="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[s='slice'](0,N)
if(z){if(a[0][1]=='A'){for(a=[],i=0,L=l;i<N;i++)a[N-i]=a[N+i]=L[s](0,-1)+l[N-i-1].repeat(i*2)+[...L].reverse().join``
L=L[s](0,-1)
return a}if(a[1][1]=='C')for(i=0;a[i++]=l,i<N;)l=l[s](1)+l[0]}}else X=1
a=X?a.map(l=>l[s](0,N)):a
return Y?a[s](0,N):a}

Pass an array of strings to the function f(), like this:
f(
`AAAAAAA
ABBBBBA
ABCCCBA
ABCDCBA
ABCCCBA
ABBBBBA
AAAAAAA`.split('\n'), 3)

Less golfed version with comments:
f=(a,N)=>{
    // Whether to truncate array horizontally to width N.
    X=0

    // Whether to truncate array vertically to height N.
    Y=0

    // If a second row exists...
    if(I=a[1]){
        // If the first non-whitespace character in the second row == 'B', truncate vertically.
        if(I.trim()[0]=='B')Y=1

        // Truncate horizontally if 2nd character in row 1 == 1st character in row 2; otherwise, if not truncating vertically.
        X=z=a[0][1]==I[0]?1:!Y

        // If 2nd character in row 1 == 1st character in row 2
        if(z){
            // Make an alphabet.
            l="ABCDEFGHIJKLMNOPQRSTUVWXYZ".slice(0,N)

            // If 2nd character in row 1 == 'A', forget everything we just did. Make a new array, generate a Square pattern, then return it.
            if(a[0][1]=='A'){
                for(a=[],i=0,L=l;i<N;i++)
                    a[N-i]=a[N+i]=L.slice(0,-1)+l[N-i-1].repeat(i*2)+[...L].reverse().join``,
                    L=L.slice(0,-1)
                return a
            }

            // If 2nd character in row 2 == 'C', fill array with a Tabula Recta.
            if(I[1]=='C')
                for(i=0;a[i++]=l,i<N;)
                    l=l.slice(1)+l[0]
        }
    }else{
        // If a second row doesn't exist, it's a horizontal line; truncate horizontally.
        X=1
    }

    // Truncate array horizontally if necessary.
    a=X?a.map(l=>l.slice(0,N)):a

    // Truncate array vertically if necessary.
    return Y?a.slice(0,N):a
}

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Draw an alphabet party hat
Your task is to print this exact text:
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

Case does not matter.
Remember, this is code-golf, so the code with the smallest number of bytes wins.

Why the downvotes?

I suspect some people are just tired of all the alphabet-pattern ascii-art KC challenges.

Can we do it in uppercase?

@Downgoat Yes..

Also, can we output an array of lines rather than join them by newlines?

@Downgoat You need to join it by newlines.

Seriously though, another alphabet challenge?

Also, can I print trailing newlines?

@EriktheGolfer Yes

I enjoy these alphabet challenges. This one could easily re-branded as a Christmas tree.

Halp its my birthday and I do not freakin' want to learn ABCs again

Can I print a leading newline?

Cheddar, 50 45 42 37 bytes
25|>0=>i->print" "*(i/2|0)+(65+i)@"90

Straightforward, but utilizes cheddar's consise ranging syntax (both numerical and alphabetical)
Try it online!
Explanation
25 |> 0 =>    // Map range [0, 26) (i.e. [25, 0] reversed) over....
   i ->
     print    // Prints in it's own line...
     " " * (i/2 |0) +     // Number of spaces is floor(n/2).
                          // `|0` for flooring is hack from JS
     (65 + i) @" 90       // Char code range is this

65 is char code for A and 90 for Z

Z is 90, not A.

05AB1E, 15 13 bytes
A.svy12N;ï-ú,

Try it online! (slightly different from above as ú isn't on TIO yet)
Explanation

Push alphabet
Compute the suffixes of the alphabet
Prepend 12-index/2 spaces
Print

Python 2, 70 bytes
Ported from Emigna's answer, -2 bytes for replacing -i-1 with ~i
for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]

I'm fairly sure using map can yield a shorter alphabet, except maybe lowercase having higher values

Actually I'm not sure anymore. I think it wouldn't work for this anyway :( soz

R, 67 66 59 bytes
EDIT: Saved a couple of bytes thanks to @rturnbull
for(i in 25:0)cat(rep(" ",i/2),letters[i:25+1],"\n",sep="")

Exploiting the fact that any number passed to the rep function is automatically rounded down to the closest integer (e.g. rep("*",1.99) => "*") which means that the actual sequence passed is floor(13-1:26/2):
12 12 11 11 10 10  9  9  8  8  7  7  6  6  5  5  4  4  3  3  2  2  1  1  0  0

This comes out shorter than my matrix attempt. Replace 14...-1 with 13?

@JDL Ah yes of course. A remnant of attempting another approach

If you loop through 25:0 instead of 1:26, you can change 13-i/2 to i/2, and simplify (27-i):26 to i:25+1, saving 6 bytes.

05AB1E, 5 bytes
A.s.c

Try it online!
A.s.c
A     Push 'abcdefghijklmnopqrstuvwxyz'
 .s   Push suffixes starting from the shortest one
   .c Centralize focused on the left

JavaScript (ES6), 85 75 69 68 bytes
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+`
`

-1 byte thanks to @l4m2.

Isn't this a snippet rather than a function or program?

for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#' 1B shorter

@l4m2 Brilliant!

Nice idea using base 36! +1

Python 2, 52 bytes
n=26;s=''
while n:n-=1;s=chr(97+n)+s;print n/2*' '+s

Accumulates the string s to print and updates the number of leading spaces n/2. A while loop terminating at 0 is a rare numerical loop than beats an exec loop (53 bytes):
n=26;s=''
exec"n-=1;s=chr(97+n)+s;print n/2*' '+s;"*n

Also a 53-byte alternative:
s=''
exec"s=chr(122-len(s))+s;print s.center(26);"*26

Pyth, 15 bytes
j_m+*/d2\ >GdUG

A program that prints the result to STDOUT.
Try it online
How it works
j_m+*/d2\ >GdUG  Program
             UG  Yield [1, 2, 3, 4, ..., 26]
  m              Map over the range with variable d:
          >Gd      Yield alphabet with first d-1 letters discarded
   +               Prepend
     /d2             d//2
    *   \            spaces
 _               Reverse
j                Join on newlines
                 Implicitly print

Try ; instead of \

Jelly, 15 13 bytes
-2 bytes thanks to @miles (formed a niladic chain I suspected existed but did not form)
ØaJ’H⁶ẋżṫJ$ṚY

TryItOnline!
How?
ØaJ’H⁶ẋżṫJ$ṚY - Main link
Øa            - alphabet yield -> ['a', 'b', 'c', ..., 'y', 'z']
  J           -    range(length)      -> [1, 2, 3, ..., 25, 26]
   ’          -    decrement          -> [0, 1, 2, ..., 24, 25]
    H         -    halve              -> [0,.5  1, ..., 12, 12.5]
     ⁶        -    literal [' ']
      ẋ       -    repeat list        -> [[], [], [' '], ..., 12x' ', 12x' ']
          $   - last two links as a monad
         J    -     range(length)     -> [1, 2, 3, ..., 25, 26]
        ṫ     -     tail (vectorises) -> [['a'-'z'], ['b'-'z'], ..., ['y','z'], ['z']]
       ż      - zip
              -> [[[],['a'-'z']], [[],['b'-'z']], ..., [12x' ',['y','z']], [12x' ',['z]]]
           Ṛ  - reverse whole array
            Y - join with line feeds (implicit print)

I found a way to form a niladic chain starting with the alphabet ØaJ’H⁶ẋżṫJ$ṚY that saves 2 bytes

Do you think the explanation is correct?

Yeah just think of it as a monadic chain with a single argument being the alphabet

Brain-Flak, 244 bytes
((((((()()()()())){}{}){}){}()){})((((()()()){}){}()){}){(({}[()]<>)<({}<(<>({})<>)>){({}[()]<(({})[()])>)}({}({})<>[({})]<>(((()()()){}){}){}())((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{}){({}[()]<((((()()()()){}){}){})>)}((()()()()()){})><>)}<>

Try it online!

This should be readable enough as is. If you need it, I have a full explanation:
push 122 (z): ((((((()()()()())){}{}){}){}()){})
push 26:      ((((()()()){}){}()){})
loop 26 times (i = 25..0): {
 (
  i--, push to b stack:({}[()]<>)
  <
   put 122 from a stack under i: ({}<(<>({})<>)>)
   i times push letter-1: {({}[()]<(({})[()])>)}
   replace top 0 with 26-i: ({}({})<>[({})]<>(((()()()){}){}){}())
   devide by two: ((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{})
   add spaces: {({}[()]<((((()()()()){}){}){})>)}
   push 10 (\n): ((()()()()()){})
  >
  flip stack back: <>
 push i--: )
}
flip to results stack: <>

This should be readable enough as is. You are talking about Brain-Flak, right?

C, 72 68 bytes
m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}

Stax, 7 bytes
ô2òΘé8└

Run and debug it

Vyxal C, 4 bytes
kz¦R

Try it Online!
Explanation:
kz    # Lowercase backwards alphabet
  ¦   # Prefixes
   R  # Reverse each
      # 'C' flag - Center top of stack, join on newlines, and print

PHP, 71 Bytes
for(;++$i<27;)echo str_pad(substr(join(range(a,z)),-$i),26," ",2)."\n";

(26-$i)/2 → 13-$i/2

Will it throw an error if you removed the last colon? Also, would be nice if you provided a link to an online website with example, ex. http://sandbox.onlinephpfunctions.com/

Turtlèd, 70 68 bytes
note the trailing space
#abcdefghijklmnopqrstuvwxyz#' -{ -{ +.r_}' l[ l-]d,(*@!' r)(!@*)_}'

Try it online!
How it works:
#abcdefghijklmnopqrstuvwxyz#              Set string var to this value
                            ' -           write space on first grid cell, string pointer-=1
                               {                                    } While cell is space
                                 -                 decrement string pointer
                                  {     }    While cell is space
                                    +.       increment string pointer, write pointed char
                                      r      move right
                                       _     write non-space if pointed char is last char

                                         '[space]   write space on cell
                                           l        move left
                                            [ l-]   move left, pointer-- until cell's space
                                                 d, move down, write character var \
                                                                           (initially *)

                                                   (*     ) if cell is *
                                                     @!     set char var=!
                                                       ' r  write space over *, move right

                                                           (!    ) if cell is !
                                                             @*    set char var=*
                                                               '[space] write space over !

                                                                 _ (explanation below)
                                               write (*|!) if pointed char is last char

                                                                   '[space]    Write space

Human-readable explanation(?):
It uses the string var to contain the alphabet. Each iteration, it reduces the index by one, until it wraps around, and halts, after getting to the last line. For the alternating indents, it uses the char var. Each iteration it checks the char var and flips it. if it was * it shifts right, so the first character aligns, otherwise not, so the last character aligns.

Java 7 ,128 127  bytes
Saved 1 byte.Thanks to kevin.
String c(int n,String s,char v,String d){String c="";for(int j=0;j++<(n-1)/2;c+=" ");return n>0?c(--n,s=v+s,--v,d+c+s+"\n"):d;}

ungolfed
  class A {

public static void main(String[] args) {
System.out.print(c(26, "", (char)122, ""));
}
static String c(int n, String s, char v, String d){

    String c = "";

    for (int j = 0; j++ < (n - 1)/2; c += " ");

    return n > 0 ? c(--n, s = v + s, --v, d + c + s + "\n" ) : d;
}
}

Without an passing 122 in a function
132 bytes
String c(String s,int n,String d){String c="";int v=96,j=0;for(;j++<(n-1)/2;c+=" ");return n>0?c(s=(char)(v+n--)+s,n,d+c+s+"\n"):d;}

ungolfed
  class A{

public static void main(String[] args) {
System.out.print(c("",26,""));

}
static String c(String s, int n, String d) {
    String c = "";
    int v = 96,j=0;
    for (; j++ < (n - 1)/2; c += " ");
    return n > 0 ? c(s = ( char) (v + n--) + s, n, (d + c + s + "\n")) : d;
     }
  }

You can remove the = at d+=c+s+"\n". Also, you might want to format your ungolfed code a bit with indentations. I noticed that with some of your other answers as well. :)

oops! i did this mistake again,Shame to me.    ......ok @KevinCruijssen i am on it.

Can't you replace the s=v+s in the recursion with s+=v?

No..because the letters pattern are in backward.

Perl, 44 bytes
This is a port of @xnor's answer.
$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--

Needs -E (or -M5.010) to run :
perl -E '$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--';

Ruby, 64 bytes
(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}

A few comments:
You don't need to put the brackets after join
Calling each instead of map is unnecessary, since we don't care about what we're returning
You can call last on a range

Instead of (0..26).map, try 27.times; instead of ('a'..'z').to_a, [*?a..?z]; and instead of .join, *"".

Common Lisp, SBCL, 83 82 bytes
(dotimes(i 27)(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))

Explanation
(dotimes(i 27) ; loop from i=0 to i=26
(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))
;print out part of alphabet starting from character number 26-i (counting from zero)
;using justification (~26:@<~a~>) to center with weight 26 characters

-1 using sugestion by ASCII-only to use <enter> instead of ~%

82

Tcl, 92 bytes
set a {}
time {set a [format %c [expr 123-[incr i]]]$a;puts [format %[expr 13+$i/2]s $a]} 26

Try it online!

tcl, 94
set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr 74-$i/2]s $a]} 26

demo

In the middle of the process, I accidentaly got the italic version of the hat:
tcl, 94
set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]} 26

demo

tcl, 101
set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr ($i-48)/2]s $a]}

demo
In the middle of the process, I accidentaly got the italic version of the hat:
tcl, 99
set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]}

demo

92?

@ASCII-only thanks!

Japt, 16 bytes
;C¬£SpY/2 +CsYÃw ·

Try it online!
Explanation:
;C¬£SpY/2 +CsYÃw ·
;C                  // Alphabet shortcut
  ¬                 // Split into an array of chars
   £          Ã     // Map each item X and index Y by:
    SpY/2           //  " " repeated floor(Y/2) times
          +CsY      //  + alphabet.slice(Y)
               w    // Reverse the array of lines
                 ·  // Join with newlines

REXX, 52 bytes
do i=1 to 26
  say centre(right(xrange(a,z),i),26)
  end

Output:
            Z
            YZ
           XYZ
           WXYZ
          VWXYZ
          UVWXYZ
         TUVWXYZ
         STUVWXYZ
        RSTUVWXYZ
        QRSTUVWXYZ
       PQRSTUVWXYZ
       OPQRSTUVWXYZ
      NOPQRSTUVWXYZ
      MNOPQRSTUVWXYZ
     LMNOPQRSTUVWXYZ
     KLMNOPQRSTUVWXYZ
    JKLMNOPQRSTUVWXYZ
    IJKLMNOPQRSTUVWXYZ
   HIJKLMNOPQRSTUVWXYZ
   GHIJKLMNOPQRSTUVWXYZ
  FGHIJKLMNOPQRSTUVWXYZ
  EFGHIJKLMNOPQRSTUVWXYZ
 DEFGHIJKLMNOPQRSTUVWXYZ
 CDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Vim, 25 Keystrokes
:h<_␍jjYZZPqqPxYPr Yq12@q

Where ␍ is the Enter key, also sometimes notated as <cr>.
Explanation
:h<_␍jjYZZ                 " get a-z
          P                " initialize by pasting
           qq              " start record macro @q
             Px            " paste and remove the 1st char
               YPr␣        " yank and paste and replace 1st char with space
                   Y       " yank the whole line again
                    q      " end recording
                     12@q  " call macro 12 @q times

I am new to ViM though -- I started in November.  Wondering if there is a way to merge the initializing P with the one in the macro.
What is the "correct" way to test a golfed ViM sequence?  I tested with \vi -u /dev/null. However in a VM even :h<_␍ doesn't work.  Also not very sure why my ViM will move to the first non space character haha.
P.S. Before I moved to use OS X, I golfed in Hexagony with great tools... Now on OS X I don't do wine and thus not running the great tools for explanations and debugging.  So started my journey with ViM!

C# (.NET Core), 112 bytes
()=>string.Join("\n",new int[26].Select((_,i)=>"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".Substring(25-i)))

Try it online!
()=>string.Join("\n", // OP doesnt want to output a sequence of string...
    new int[26].Select((_,i)=> // yield range from 0 to 25
        "".PadLeft(12-i/2)+ // add spaces to center
            "abcdefghijklmnopqrstuvwxyz".Substring(25-i)))  // remove letters

Perl 5, 40 38 bytes
-2 bytes thanks to @Dom Hastings
say$"x(13+--$x/2),@a[$x..-1]for@a=a..z

Try it online!

Came up with a slightly different variation for -2: Try it online!

T-SQL, 107 bytes
DECLARE @t VARCHAR(99)=SPACE(13),@ INT=27a:SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))PRINT @t
SET @-=1IF @>1GOTO a

Modifies the string for each line by cramming in the correct letter at the correct position using the SQL fuction STUFF(). Formatted:
DECLARE @t VARCHAR(99)=SPACE(13), @ INT=27
a:
    SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))
    PRINT @t
    SET @-=1
IF @>1 GOTO a

@/2 uses integer division (no remainder) to determine the position to insert the letter. @%2 is the MODULO function, and flips between 0 (insert the letter) and 1 (overwrite a space).
If you prefer capitial letters, use CHAR(@+63) instead (doesn't change our byte count).

PowerShell, 62 51 46 bytes
-11 bytes thanks to mazzy reminding me of a function
-5 bytes thanks to mazzy
25..0|%{' '*($_-shr1)+-join('a'..'z')[$_..25]}

Try it online!
Uses the -replace -shift-right 1 trick to bypass banker's rounding. Additionally, uses a character range to generate the alphabet.

-shr1 instead -replace :)

@mazzy D'oh. I even scrolled passed that tip while looking something else up. Thanks

What do you think about using the the Powershell 5+ features by default?

@mazzy I think at this point, it's probably fine and we should instead specify an earlier version if you need a specific feature.

Haskell (Lambdabot), 73 bytes
unlines[([1..div(26-length x)2]>>" ")++x|x<-reverse.init$tails['a'..'z']]

same length:
do x<-reverse.init$tails['a'..'z'];([1..div(26-length x)2]>>" ")++x++"\n"

I use init.tails or tail.inits with a possible reverse in front in pretty much every challenge; I wish they would add it to Prelude already.

Pyke, 18 12 bytes
26Fed*Gi>+)X

Try it here!
26F       )  -  for i in range(26):
   ed*       -    (i//2)*" "
         +   -   concatenate ↑ and ↓
      Gi>    -    alphabet[i:]
           X - splat(^) (print list reversed with newlines)

Or 10 bytes noncompetitive
26DXF2GR>c

Try it here!

Is it splat or split?

@EriktheGolfer it is splat. It pops a list and pushes the contents of that list in reverse to the stack

Okay, putting the spellcheck edit in.

Python 2, 66 64 bytes
i=91;exec'i-=1;print`map(chr,range(i,91))`[2::5].center(26);'*26

QBIC, 57 bytes
[25,0,-1|Y=Z[1,a/2|Y=Y+@ |]X=Z[a,25|X=X+$CHR$(65+|c)]?Y+X

This one works surprisingly well with QBIC' FOR loops.
Explanation (of previous version - same principle applies):
[26,1,-1|          Loops from 26 to 1, decrementing 'a'
                   'a' is used to determine the number of spaces per line and the last letter we want to print
Y=Z                Z is always an empty string in this program,
                   Y will hold the spaces we need to center this line
[1,a/2|Y=Y+@ |]    Add a space to Y equal to half the value of 'a', giving us a center alignment
X=Z                X holds the characters we need on this line, reset it
[a,26|             FOR c = a to 26 --> loop over the last part of the alphabet
X=X+$CHR$(64+|c)]  Convert c+64 to ASCII and append
?Y+X               Print the spaces and the letters

<outer FOR loop is closed by QBIC>

Output:
            Z
            YZ
           XYZ
           WXYZ
          VWXYZ
          UVWXYZ
         TUVWXYZ
         STUVWXYZ
        RSTUVWXYZ
        QRSTUVWXYZ
       PQRSTUVWXYZ
       OPQRSTUVWXYZ
      NOPQRSTUVWXYZ
      MNOPQRSTUVWXYZ
     LMNOPQRSTUVWXYZ
     KLMNOPQRSTUVWXYZ
    JKLMNOPQRSTUVWXYZ
    IJKLMNOPQRSTUVWXYZ
   HIJKLMNOPQRSTUVWXYZ
   GHIJKLMNOPQRSTUVWXYZ
  FGHIJKLMNOPQRSTUVWXYZ
  EFGHIJKLMNOPQRSTUVWXYZ
 DEFGHIJKLMNOPQRSTUVWXYZ
 CDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Doesn't match the OP.

@carusocomputing it does now.

Groovy, 53 bytes
('z'..'a').each{println((it..'z').join().center(26))}

Output:
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

Racket 137 bytes
(for((n(range 122 96 -1)))(for((i(floor(/(- n 97)2))))(display #\space))
(for((i(range n 123)))(display(integer->char i)))(displayln ""))

Ungolfed:
(define (f)
  (for ((n (range 122 96 -1)))
       (for ((i (floor(/(- n 97)2))))
         (display #\space))
       (for ((i (range n 123)))
         (display (integer->char i)))
    (displayln "")))

Testing:
(f)

Output:
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

C#, 175 Bytes:
Golfed:
string H(){string o="",a="abcdefghijklmnopqrstuvwxyz";int p=12,i=0;for(i=0;i<=26;i++){o+=a.Substring(26-i,i).PadLeft(p+i)+"\n";if(i==0||i==1)continue;p-=i%2==0?1:0;}return o;}

Ungolfed:
public string H()
{
  string o = "", a = "abcdefghijklmnopqrstuvwxyz";
  int p = 12, i=0;
  for (i = 0; i <= 26; i++)
  {
    o += a.Substring(26 - i, i).PadLeft(p+i)+ "\n";
    if (i == 0 || i == 1) continue;
    p -= i % 2 == 0 ? 1 : 0;
  }
  return o;
}

Test:
Console.Write(new DrawAnAlphabetHat().H());

Output:
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

Javascript, 133 Bytes
for(i=26,s="";i>0;i--){for(k=26-i+Math.floor((i+1)/2),l=34+Math.floor((i+1)/2);k>0;k--,l--)k>27-i?s+=" ":s+=l.toString(36);s+="<br>"}

Try it here

SOGL V0.12, 8 bytes
z{Xf}¹№╚

Try it Here!
Explanation:
z         push the lowercase alphabet
 {  }     for each, pushing current character
  X         remove the character from the stack as it's not needed
   f        push the remaining string, including the current character, what the loop has to traverse
     ¹    wrap all that in an array
      №   reverse vertically
       ╚  center horizontally - this centers it exactly as required :D

VBA, 68 66 Bytes
Anonymous VBE immediate function that takes no input and outputs to the VBE immediate window
For i=1To 26:?:?Spc(13-i/2);:For j=27-i To 26:?Chr(j+96);:Next j,i

C# (Visual C# Compiler), 125 bytes
()=>{var s="";for(var c='z';c>'`';c--){for(var i='a';i<'{';i++)s+=i<c?' ':i;s+="\n";}Console.WriteLine(s.Replace("  "," "));}

Try it online!
Highlights: seen how char is a numeric datatype, let's use it for the loop. The value ranges from 'a' to 'z', which is awesome! We can just add a char to a string, so that's another back-curling - but now convenient - feature.
The outer counter counts from z to a, the inner counter from a to z. The inner loop checks if the inner counter is more than the outer, if so print a space, else print the counter character. After every outer iteration we print a newline, after the function completes we print it to the console after replacing a double space with a single one (very, very wasteful line, but included in character count).
I couldn't think of any more abuse in a language specification than this.
EDIT: added lambda function specification and call in accordance to alois' remark.

Hello fellow C# golfer. We are not allowed to post a snippet, but we can use a function and lamda are allowed. source.

Got it, alois. Sorry for being too short through. Are we allowed to not print but output the text, and leave the printing and line breaking to an outside-the-function loop-and-print? If so, i'll have a go at shaving off those characters again! Thanks dude,

most of the time we can, but here OP want to output a string with "\n"...

F# (.NET Core), 101 bytes
[0..25]|>Seq.map(fun i->"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".[25-i..])|>String.concat "\n"

Try it online!
A naive port of my C# answer

Ruby, 54 bytes
puts (0..25).map{|c|[*(90-c).chr..'Z'].join.center 26}

Try it online!

Charcoal, 16 bytes
Ｆ²⁷«Ｐ⮌…⮌βι¿﹪ι²↓↙

Try it online!
Link is to the verbose version of the code. I'm sure there must be a shorter way to do this in Charcoal.

12 bytes, I think

@ASCII-only 11 bytes: ⮌Ｅβ⁺× ⊘κ✂βκ

J, 39 bytes
echo(' '<@#"0~2#i._13),&><@|.\u:90-i.26

Try it online!
I see capital letters in some submissions so I assume it's OK to use them. If not, then add a byte to convert to lowercase.
Explanation
See my (almost identical) answer to this (duplicate) question.
The only difference is in generating the alphabet, where I generate ZYX...CBA and then reverse each prefix of that string to give the desired parts. I feel like there is a way to avoid that but I'm tired right now and this is the best way of fixing it that I could think of.

Yabasic, 82 bytes
A jolly solution that takes no input and outputs to the console.
For i=1To 26
For j=1To 13-i/2
?" ";
Next
For j=27-i To 26
?Chr$(j+96);
Next
?
Next

Try it online!

uBASIC, 75 bytes
Anonymous function that takes no input and outputs to the console.
Slightly different approach than other BASIC answers as uBASIC's integer division functions differently - (25/2 equals 12 rather than 13)
0ForI=2To27:?Tab(13-I/2);:ForJ=28-ITo26:?Left$(Chr$(J+96),1);:NextJ:?:NextI

Try it online!

APL (Dyalog Classic), 20 bytes
(⌈13-.5×⍳26)⌽⌽↑,\⌽⎕a
Try it online!
uses ⎕io←1

PHP, 68 58 57 bytes
edit #1: a different approach with left padding and string concatenation + uppercase
edit #2: shorter padding expression
while($i++<26)printf("
%".($i+26>>1).s,$s=chr(91-$i).$s);

Add two bytes if a leading newline is disallowed:
while($i++<26)printf("%".($i+26>>1)."s
",$s=chr(91-$i).$s);

Run with -nr or try them online.

Gol><>, 22 bytes
asFa`z9sL-F:M|L2,R` |H

Try it online!
How it works
asFa`z9sL-F:M|L2,R` |H

asF                 |   Repeat 26 times...
   a                      Push 10 (\n)
    `z                    Push z
      9sL-F  |            Repeat (25 - loop counter(L)) times...
           :M               Clone the top and decrement
              L2,R        Repeat (L / 2) times...
                  `         Push 32 (space)
                     H  Output the entire content (top to bottom) and halt

Basically, this constructs the entire output backwards.
There are two division operators in Gol><>, namely , (floating division) and S, (integer division). Luckily R (repeat X times) floors its argument, so I could save a byte.

Java 10: 136 bytes
GOLFED
for(int i=25;i>=0;i--){for(int j=0;j<i/2;j++){System.out.print("
");}System.out.println("abcdefghijklmnopqrstuvwxyz".substring(i,26));}}

UNGOLFED
class a {
    public static void main(String[] args) {
        for (int i = 25; i >= 0; i--) {
            for (int j = 0; j < i/2; j++) {
                System.out.print(" ");
            }
            System.out.println("abcdefghijklmnopqrstuvwxyz".substring(i,26));
        }
    }
}

RESULTS
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

Welcome to PPCG! One thing: your code doesn't seem to run, on TIO at least. Also, it's a good idea to add a TIO link to your answer.

Your current GOLFED submission seems to be a snippet, which is not allowed here. What you can do to make this a valid submission is to convert this into a function, which can be done in 139 bytes.

Not an expert with Java, but can't you use the repeat function for 109 bytes?

Canvas, 6 bytes
ｚ±［±］ｒ

Try it here!

Japt -R, 7 bytes
;CÔåi û

Test it

Elixir, 99 bytes
import Enum
reduce 25..0,'            ',&(IO.puts(&2++slice(?a..?z,&1,26))&&rem(&1,2)>0&& &2||tl&2)

Try it online!
Trying to find another way to generate the space string but can't make anything shorter...

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/