Bespoke, 437 bytes

this A-B-C pyramid program is easy,but it is quite involved
space it with counter;start off to put it behind by specific integer
as loop reaches end,do a at-once way of giving first triangle text
extend it as much as rows require;start off as far in series as we were
put in spaces,then triangle text;reduce it,counting backward to just nothing
end of a row is a designated return of carriage+newline
it will put it at origin,starting it

I wasn't sure exactly what approach to use for this at first.

Tcl, 92 bytes

time {puts [format %[expr 25+[incr i]]s [lreverse [lappend L [format %c [expr $i+64]]]]]} 26

Try it online!

Vyxal 3, 15 bytes

kAPƛ⇄␣j26nL-␣×p

returns a list of strings. add }” at the end to pretty-print or use the -§ flag for something in between

Vyxal It Online!

kAPƛ⇄␣j26nL-␣×p­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏⁠‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁤⁣‏‏​⁡⁠⁡‌⁢⁣​‎‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏‏​⁡⁠⁡‌⁢⁤​‎‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏‏​⁡⁠⁡‌­
kA               # ‎⁡uppercase alphabet
  P              # ‎⁢prefixes
   ƛ             # ‎⁣map over each
    ⇄            # ‎⁤reverse
     ␣j          # ‎⁢⁡intersperse spaces
               p # ‎⁢⁢prepend...
            ␣×   # ‎⁢⁣spaces times...
       26nL-     # ‎⁢⁤26 - length of slice
💎

Created with the help of Luminespire.

<script type="vyxal3">
kAPƛ⇄␣j26nL-␣×p}”
</script>
<script>
    args=[]
</script>
<script src="https://themoonisacheese.github.io/snippeterpreter/snippet.js" type="module"/>

AWK, 66 bytes

END{for(x=28;i++<26;)printf"%"x"s\n",s=(sprintf("%c",37+x++))" "s}

Attempt This Online!

OpTeX, 63 bytes

\def~{}\fornum65..90\do{\edef~{\char#1~}\centerline{~}\par}\bye

OpTeX is a modernized version of plain TeX. As always with TeX, the output is better for code golf with a mono-spaced font. We need \tt (typewriter font) for that, but this adds 3 more bytes.

\tt\def~{}\fornum65..90\do{\edef~{\char#1~}\centerline{~}\par}\bye

Python 3, 52 bytes

i=26;s='';while i:i-=1;s=chr(90-i)+s;print(i*' ',*s)

couldn't find anything smaller than this

☾, 18 characters (45 bytes)

26⭥ᴙᐵ⋅𝘀+ABCᴙ􍪴﹕⨝𝘀→☾

Pip, 21 bytes

L26PsX25-i.:RAZ@<UiJs

Attempt This Online!

Explanation

The guts are very similar to my Pip -l answer, but the iterative flagless approach turned out to be one byte shorter (at least until I implement that "center and pad with spaces" operator I've been planning).

L26PsX25-i.:RAZ@<UiJs
                      ; s is " ", i is 0, AZ is uppercase alphabet (implicit)
L26                   ; Loop 26 times:
    sX25-i            ;  String of (25-i) spaces
          .:          ;  Concatenate with:
                 Ui   ;   Increment i
             AZ@<     ;   Take that many characters from the front of AZ
            R         ;   Reverse
                   Js ;   Join on spaces
   P                  ;  Print that string

SNOBOL4 (CSNOBOL4), 103 93 77 bytes

N	&UCASE B LEN(1) . B @X :F(END)
	A =B ' ' A
	OUTPUT =LPAD(A,26 + X) :(N)
END

Try it online!

Pip -l, 22 bytes

sX26-_.(RAZ@<_Js)M\,26

Attempt This Online!

Explanation

sX26-_.(RAZ@<_Js)M\,26
                  \,26  ; Range of numbers from 1 through 26
                 M      ; Map this function to each:
  26-_                  ;  26 minus function argument
sX                      ;  That many spaces
      .(        )       ;  Concatenate to the following:
         AZ             ;  Uppercase alphabet
           @<_          ;  Slice left of function argument
        R               ;  Reverse
              Js        ;  Join on spaces

Ruby, 57 54 bytes

?A.upto(?Z){puts' '*(90-_1.ord)+[*?A.._1].reverse*' '}

Attempt This Online!

Retina 0.8.2, 57 52 42 bytes

T`L`_L
}`^
Z
.
$.`$* $&$'¶
\B\w
 $&
O`
G`.

Try it online! Explanation:

T`L`_L

Move all of the letters so far one step backwards in the alphabet, but delete any A.

^
Z

Prefix a Z to the current string.

}`

Repeat the above until the transformation becomes idempotent. This happens when the string is the entire alphabet; the A is deleted, the Z-B get transliterated into Y-A, and another Z is prefixed.

.
$.`$* $&$'¶

Turn the alphabet into a triangle.

\B\w
 $&

Space out the letters.

O`

Get the lines in the correct order.

G`.

Remove an extraneous trailing newline. (Retina 0.8.2 always adds a trailing newline, so there would have been two; had I used Retina 1 I could have claimed that newline as my allowed newline.)

Vyxal j, 10 bytes

kA¦RvṄøĊøR

Try it Online!

Very nice

Explained (old)

₄ƛkAẎṘṄ
₄ƛ        # over the range [1, 26]: (call each item n)
  kAẎ     #     push "ABCDE....XYZ"[0:n]
     ṘṄ   #     reverse and join on spaces
          # the -C flag auto-centers the top of the stack 

Japt -R, 13 bytes

;Båi ˬ¸ùBÊ+E

Test it

;Båi ˬ¸ùBÊ+E
;B                :Uppercase alphabet
  å               :Cumulatively reduce by
   i              :  Prepending
     Ë            :Map each element at 0-based index E
      ¬           :  Split
       ¸          :  Join with spaces
        ù         :  Left pad with spaces to length
         BÊ+E     :    Length of B plus E

Python 3.8 (pre-release), 103 bytes

p=-1
x="abcdefghijklmnopqrstuvwxyz"
s=""
for a in[0]*26:print(" "*abs(26-p)+" ".join(s:=x[(p:=p+1)]+s))

Try it online!

JavaScript (Node.js),  65  63 bytes

Saved 2 bytes thanks to @l4m2

f=(n=26,s=`A
`)=>n--?''.padEnd(n)+s+f(n,Buffer([91-n,32])+s):''

Try it online!

JavaScript (Node.js), 79 bytes

More maths, more bytes.

f=(x=y=0)=>y<26?Buffer([x<y+26?y+x++&x>25-y?156-x+y>>1:32:(x=!++y,13)])+f(x):''

Try it online!

Scratch, 256 240 bytes

-16 thanks to @Lyxal because I can't read! XD

Try it online!

At first, I thought it would be shorter to add each string manually, but I was very wrong! It doesn't look very good outside of monospace fonts though...

delete all of[P v
set[A v]to[ABCDEFGHIJKLMNOPQRSTUVWXYZ
set[C v]to(25
set[L v]to( 
repeat(26
set[S v]to(
repeat(C
set[S v]to(join(S)( 
change[C v]by(-1
set[L v]to(join(join(letter(round((length of(L))/(2)))of(A))( ))(L
add(join(S)(L))to[P v

Zsh, 46 43 bytes

-3 bytes from @pxeger using eval instead of a for loop

eval a={A..Z}'\ $a;echo ${(l:26+i++:)a%?};'

Try it online!

The eval expands to:

a=A\ $a;echo ${(l:26+i++:)a%?}; a=B\ $a;echo ${(l:26+i++:)a%?}; ...

Which is the same as the for loop from the second 46-byte solution below:

Originals:

for c ({A..Z})a=($c $a)&&echo ${(l:25-i++:)}$a

Try it online!

Abuses arrays implicitly joining on spaces. l:expr: pads on the left with spaces until at expr characters wide. Putting parameter expansion flags with no parameter like this causes them to operate on an empty string.

Alternate 46 byte solution, using a string with ${a%postfixremoval} instead. Note that here we increment the padding width to accommodate the growing total string length.

for c ({A..Z})a=$c\ $a&&echo ${(l:26+i++:)a%?}

Try it online!

Brainfuck, 189 bytes

++[[+<]>+>++]<->>+[+[<]>>+<+]>>>-[-[-<]>>+<]>-<++++++++++<<<<<<<<[-[->+>+<<]>[-<+>]>[->>>>>>>.<<<<<<<]>>[->+>+<<]<+[->>>+<<<<+<+>>]<[->>>>-.>>>.<<<<<<<]<[->>+<<]>>>>>[-]<[-<+>]>>>.<<<<<<<<]

Try It Online!

(Using 8-bit wrapping)

I cannot put into words how much I hate this language.

Excel, 79 bytes

=LET(k,ROW(1:26),REPT(" ",26-k)&RIGHT(CONCAT(" "&CHAR(91-TRANSPOSE(k))),2*k-1))

Explanation

k,ROW                                                         ' k = 1..26
REPT(" ",26-k)&RIGHT(CONCAT(" "&CHAR(91-TRANSPOSE(k))),2*k-1) ' Final Calculation
REPT(" ",26-k)                                                ' 26-k spaces
                     CONCAT(" "&CHAR(91-TRANSPOSE(k)))        ' " Z Y ...
               RIGHT(                                 ,2*k-1) ' Right 2k-1 characters

vim, 42 41 bytes

:set nf=alpha
aZ<ESC>qqYp<C-x>q24@qVggJqqYPxq24@q

<ESC> is 0x1b, <C-x> is 0x18, <NL> is 0x0a.

Annotated

:set nf=alpha   # make <C-x> work with letters
aZ<ESC>         # put Z in buffer
qqYp<C-x>q      # Record macro q: Append a line with the previous letter
24@q            # ...and execute until we have all the letters
VggJ            # combine all lines into "Z Y X ... C B A"
qqYPxq         # Record macro q: Copy line to previous line, delete first char
24@q            # ...and execute until we have all the rows

Try it online!

R, 52 bytes

write(intToUtf8(outer(26:1,1:26,"<=")*90:65,T),1,26)

Try it online!

A different and (for now) golfier approach than this or that R answers.

To generate "exact text" as is required in kolmogorov-complexity challenges, there are usually two options in R: cat and write. cat is more flexible, as write is actually a wrapper around cat, but the advantage of write is that if you can construct your data in a rectangular (matrix) form, some of the verbosity of cat goes away, for instance, you get a newline without explicitly including it as you do in cat, which will then include an extra separator argument, which is usually undesirable. Since each line of the text here appears to be of variable width, write is not the first thing that comes to mind, and both of the other R answers are quite creative in getting around the shortcomings of cat. In particular, the fill argument is not one I'm familiar with, but will have to keep trying out.

The trick here is that write, like cat, separates elements by spaces. Since every line has the same number of spaces, if we can construct the right matrix of empty strings "" and capital letters, we can just use write to automatically put the spaces where they go.

My first attempt started by constructing the matrix directly:

R, 63 bytes

m=matrix(LETTERS,26,26);m[lower.tri(m)]="";write(m[26:1,],1,26)

Try it online!

This builds up a matrix of capital letters, then sets the lower triangle to empty strings, and finally flips vertically since write proceeds down the columns.

This is equally as long as Bart-Jan van Rossum's answer; I was going to post it since the approach was different, but when I went to read a comment on another completely unrelated challenge, I thought to try intToUtf8 instead.

Two things make this possible. Typically, intToUtf8 takes a vector of integers and converts them to a single string made up of their utf8 codepoints. There is also an optional argument, usually FALSE that when set to TRUE will instead return a vector of characters of the utf8 codepoints. The other trick is that intToUtf8(0) returns the empty string. So instead of constructing a matrix of "" and LETTERS, I constructed a matrix of codepoints, which ended up (finally) being shorter than the other R answers:

R, 61 bytes

write(intToUtf8((outer(1:26,1:26,"<=")*65:90)[26:1,],T),1,26)

Try it online!

Luckily, despite intToUtf8 returning a vector, write takes a ncolumns argument to specify how many columns wide it ought to be, which provides enough structure for write to print it correctly.

Finally, there are a couple of inefficient golfs which bring it to its current 52 byte form.

Stax, 11 bytes

ùivK‼9⌂m¬╚─

Run and debug it

Deadfish~, 10394 bytes

{i}{i}{i}ii{c}{c}ccccc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{c}cccc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{c}ccc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{c}cc{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{c}c{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{c}{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}ccccccccc{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}cccccccc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}ccccccc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}cccccc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}ccccc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}cccc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}ccc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}cc{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}c{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}ii{c}{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iiccccccccc{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iicccccccc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iiccccccc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iicccccc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iiccccc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iicccc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iiccc{{i}ddddd}iiiiic{{d}iiiii}dddddc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iicc{{i}ddddd}iiiiiic{{d}iiiii}ddddddc{{i}ddddd}iiiiic{{d}iiiii}dddddc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{i}{i}iic{{i}dddd}dddc{{d}iiii}iiic{{i}ddddd}iiiiiic{{d}iiiii}ddddddc{{i}ddddd}iiiiic{{d}iiiii}dddddc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic{{d}iiiii}dddddc{{i}dd}c{{d}iiii}iic{{i}dddd}dddc{{d}iiii}iiic{{i}ddddd}iiiiiic{{d}iiiii}ddddddc{{i}ddddd}iiiiic{{d}iiiii}dddddc{{i}ddddd}iiiic{{d}iiiii}ddddc{{i}ddddd}iiic{{d}iiiii}dddc{{i}ddddd}iic{{d}iiiii}ddc{{i}ddddd}ic{{d}iiiii}dc{{i}ddddd}c{{d}iiiii}c{{i}ddddd}dc{{d}iiiii}ic{{i}ddddd}ddc{{d}iiiii}iic{{i}ddddd}dddc{{d}iiiii}iiic{{i}dddddd}iiiiiic{{d}iiiiii}ddddddc{{i}dddddd}iiiiic{{d}iiiiii}dddddc{{i}dddddd}iiiic{{d}iiiiii}ddddc{{i}dddddd}iiic{{d}iiiiii}dddc{{i}dddddd}iic{{d}iiiiii}ddc{{i}dddddd}ic{{d}iiiiii}dc{{i}dddddd}c{{d}iiiiii}c{{i}dddddd}dc{{d}iiiiii}ic{{i}dddddd}ddc{{d}iiiiii}iic{{i}dddddd}dddc{{d}iiiiii}iiic{i}{i}{i}iiiiiic{d}{d}{d}ddddddc{i}{i}{i}iiiiic{d}{d}{d}dddddc{i}{i}{i}iiiic{d}{d}{d}ddddc{i}{i}{i}iiic

Compared to others, terrible!

C, 83 82 bytes

(−1 golfing thanks to ceilingcat)

main(c){for(char s[99]="",*t=s+98;*--t=c+64,printf("%*s\n",c+++25,t)<52;*--t=32);}

Builds the final string from end to beginning, printing all the unfinished versions.

Java (JDK), 82 bytes

v->{var x="";for(char c=64;++c<91;)System.out.printf("%"+(c-38)+"s%n",x=c+" "+x);}

Try it online!

Credits

• -2 bytes thanks to Kevin Cruijssen.

Retina, 35 bytes

25* 

.
Y`.`RL
L^$w`^(..)*
$#1* $'

Try it online! Explanation:

25* 

Insert 25 spaces.

.

Insert .s in all available positions. This results in 26 .s, because both the start and end can have a . inserted.

Y`.`RL

Cyclically transliterate the .s using a reversed uppercase alphabet.

L^$w`^(..)*

List all (necessarily overlapping) prefixes of even numbers of characters, in reverse order (i.e. longest prefix to shortest).

$#1* $'

For each prefix, output the number of pairs as a run of spaces (effectively deleting the letters) plus its suffix.

Batch, 144 bytes

Abuses token delimiters ([ and ;)

@!! 2>nul||cmd/q/v/c%0&&exit/b
set;=for /l %%A in (65 1 90)do set[=
%;% ![!
%;%![:~,-1!&cmd/cexit %%A&set]=!=exitcodeascii! !]!&echo(![!!]:~,-1!

Sources

• Golfing Delayed Expansion Variables in Batch
• CMD.EXE parsing - Token Delimiters
• Write HEX values to file in Windows batch

APL (Dyalog Extended), 22 bytes

(⌽0,⍳25)⌽⌽↑{∊⍺' '⍵}\⎕A

Try it online!

Output of above function.

Explanation:

• ⎕A is the uppercase alphabet character vector.
• {∊⍺' '⍵} is a 1 character shorter version of {⍺,' ',⍵} which puts a space between arguments ⍺ and ⍵.
• Reducing / this function over ⎕A would result in the uppercase alphabet with spaces between, 'A B C ...'. Scanning \ instead produces a nested vector of all the intermediate results, ('A') ('A B') ('A B C')....
• Mix ↑ turns the nested vector into a matrix, padding rows to equal length with spaces, which is then horizontally mirrored with ⌽ (the one on the right).
• To get the final answer we need to rotate the rows (dyadic ⌽) by 25, 24, 23, ... 0 characters.
• The left argument to the rotation is the sequence 25, 24, 23, ... 0, which is obtained concisely by ⌽0,⍳25.

Julia 1.0, 51 bytes

[' '^i*join(('Z'-i:-1:'B').*' ')*'A' for i=25:-1:0]

Try it online!

J, 31 bytes

(|.@;:inv,~' '#~26-#)\u:65+i.26

Try it online!

k4, 24 bytes

(-26-!26)$|:',\.Q.A,'" "

explanation:

               .Q.A,'" " /append space to each capital letter ("A ";"B "; "C "; ... )
             ,\          /join scan, join each element successively and return intermediate results ("A ";"A B ";"A B C "; ... )
          |:'            /reverse each
(-26-!26)$               /left-pad each with -26 -27 -28 ... 

run like:

q)k)(-26-!26)$|:',\.Q.A,'" "
"                         A"
"                        B A"
"                       C B A"
"                      D C B A"
..

Jelly, 12 bytes

ØAa⁶ḊÐƤżKƤUY

A full program which prints the result

Try it online!

How?

ØAa⁶ḊÐƤżKƤUY - Main Link: no arguments
ØA           - (set left to) uppercase alphabet  say:['A','B','C']
   ⁶         - space character                       ' '
  a          - AND (vectorises)                      [' ',' ',' ',]
     ÐƤ      - for postfixes:
    Ḋ        -   dequeue                             [[' ',' '],[' '],[]]
         Ƥ   - for prefixes (of left=alphabet):
        K    -   join with spaces                    [['A'],['A',' ','B'],['A',' ','B',' ','C']]
       ż     - zip together                          [[[' ',' '],['A']],[[' '],['A',' ','B']],[[],['A',' ','B',' ','C']]]
          U  - upend                                 [[[' ',' '],['A']],[[' '],['B',' ','A']],[[],['C',' ','B',' ','A']]]
           Y - join with newlines                    [[' ',' '],['A'],'\n',[' '],['B',' ','A'],'\n',[],['C',' ','B',' ','A']]
             - implicit, smashing print >>>  A
             -                          >>> B A
             -                          >>>C B A 

Python 3, 133 130 125 123 122 bytes

Not the shortest, but I wanted to try to make the output one single string

print('\n'.join((25-len(v)//2)*' '+v for v in(''.join(" "+chr(i)for i in range(90,64,-1))[i:52]for i in range(51,-1,-2))))

Try it online!

Perl 5, 30 bytes

$b[26+--$i]=$_,say"@b"for A..Z

Try it online!

R, 78 72 63 bytes

for(i in 1:26){cat(strrep(" ",26-i));cat(LETTERS[i:1],fill=52)}

Try it online!

Nothing fancy. First print spaces, then print letters.

Improvement inspired by https://codegolf.stackexchange.com/a/195078/89953, but cannot comment there because of reputation.

R, 65 bytes

for(i in 1:26){cat(strrep(" ",26-i));cat(LETTERS[i:1]);cat("\n")}

Try it online!

Forth (gforth), 62 bytes

: f 25 for i spaces 25 i - for i 65 + emit ."  "next cr next ;

Try it online!

Code explanation

: f            \ start a new word definition
  25 for       \ loop from 25 to 0
    i spaces   \ print loop-index spaces
    25 i - for \ loop from (25 - loop-index) to 0
      i 65 +   \ add inner loop-index to 65 (ascii 'A')
      emit     \ output ascii char for value
      ."  "    \ output a single space
    next       \ end inner loop
    cr         \ output a newline
  next         \ end outer loop
;              \ end word definition

Keg 32 31 30 26 25 24 25 bytes (SBCS)

A(\≤|:Z$- ⅍*,:Aɧ∑, ,)⑨
,)

Try it online!

Hey, Keg's coming 9th (at the time of writing)! Contains unprintable characters. Uses the 26 byte approach but uses a space converted to a string to pad lines.

Answer History

25 bytes

A(|:Aɧ ⅍!3--*,∑, ,)1+
,

Try it online!

26 bytes (SBCS)

A(|:Aɧ(!;;-| ,)∑, ,)1+
,

-4 bytes by using stack mechanics rather than the register

Explained

A(␚|:Aɧ(␚!;;-| ,)∑, ,)1+¶,
A                           #Push "A" onto the stack
(␚|                         #26 times:
    :Aɧ                     #   Push a generated range from A to the top of stack
    (␚!;;-| ,)              #   Space-align the row
    ∑, ,)                   #   Print each character space seperated
    1+                      #   Increment the top letter by one
    ¶,                      #   Print a newline 

Substitute ␚ for the actual unprintable control key and ¶ for a literal newline

30 bytes (SBCS)

A&(|A&:&ɧ(!;-| ,)(, ,)&1+&
,

Explained

A&(␚|A&:&ɧ(␚!;-| ,)(, ,)&1+&¶,
A&                              #Put A in the register
  (␚|                           #26 times:
      A&:&ɧ                     #   Push a generated range from A to the top of stack
           (␚!;-| ,)            #   Space-align the row
                    (, ,)       #   Print each character space seperated
                         &1+&   #   Increment the top letter by one
                             ¶, #   Print a newline     

Substitute ␚ for the actual unprintable control key and ¶ for a literal newline

31 bytes (SBCS)

A&(\≤|A&:&ɧ(\≤!-| ,)(, ,)&1+&
,

Explained

A&(\≤|A&:&ɧ(\≤!-| ,)(, ,)&1+&¶,)
A&                              #Store A in the register
  (\≤|                          #26 times:
      A&:&ɧ                     #   Push a generated range from A to the top
           (\≤!-| ,)            #   Align it using spaces               
                    (, ,)       #   Print the row
                         &1+&   #   Increment the letter
                             ¶,)#   Print a newline (replace ¶ w/ \n)

sed 4.2.2 (with GNU exec extension), 58 bytes

s/^/bash -c 'echo {Z..A}'/e
:
s/^( *)\S([^\n]+)/\1\2\n&/
t

Try it online!

Pure sed 4.2.2, 71 bytes

s/^/ZYXWVUTSRQPONMLKJIHGFEDCBA/
s/\B/ /g
:
s/^( *)\S([^\n]+)/\1\2\n&/
t

Try it online!

Bash + common GNU tools, 42

echo {Z..A}|sed -n ':l;p;s/[B-Z]//;tl'|tac

Explanation

• echo {Z..A} is a bash brace expansion that outputs Z Y X W V U T S R Q P O N M L K J I H G F E D C B A
• The sed expression is a loop that:
  • :l Define a label l
  • print the current pattern space
  • s/[B-Z]// match the first instance of B-Z and replace it with ""
  • tl if a match occurred above, jump back to label l
  • (implicit) otherwise quit. -n suppresses implicit output of the pattern space at the end of line processing.
• The output of the sed is the required triangle, but upside down. The tac reverses it line-by-line to give the required output.

Try it online!

C# (Visual C# Interactive Compiler), 81 bytes

var x="A";for(char y='\x41';++y<92;x=y+" "+x){WriteLine(new string(' ',91-y)+x);}

Try it online!

05AB1E, 8 bytes

ASuηí».c

Try it online!

A           # push the alphabet, "abcdefghijklmnopqrstuvwxyz"
 S          # split to a list of chars
  u         # uppercase
   η        # prefixes
    í       # reverse each
     »      # join by newlines, joining sublists by spaces
      .c    # center

PowerShell, 37 bytes

25..0|%{' '*$_+[char[]]((90-$_)..65)}

Try it online!

Javascript ES6, 105 bytes

[..."ZYXWVUTSRQPONMLKJIHGFEDCBA"].forEach((l,i,a)=>console.log(" ".repeat(25-i)+a.slice(25-i).join(" ")))

Elixir, 70 bytes

r=90..65;for i<-0..25,do: IO.puts for j<-r,do: 65+i-j>-1&&[j,' ']||' '

Try it here

Wren, 125 119 bytes

Not very interesting until I read other answers.

for(i in 0..25){
System.write(" "*(25-i))
for(j in 0..i)System.write(" "+String.fromCodePoint(65+i-j))
System.print()
}

Try it online!

Perl 6, 33 bytes

{(' 'Xx(25...0))Z~[\R,] 'A'..'Z'}

Try it online!

Anonymous code block that returns a list of lines.

Explanation:

{                               }  # Anonymous code block
  ' 'Xx                            # String multiply spaces
       (25...0)                       # by the range 25 to 0
 (             )Z~                 # Zip these indents with
                  [\  ]               # The triangular reduced
                    R,                # Reversed list concatenation
                        'A'..'Z'      # Of the alphabet

J, 34 bytes

((32#~26-#)<@u:@,32,@,.65+|.)\i.26

Try it online!

Python 3, 76 75 bytes:

-1 byte thanks to @pppery

for i in range(27):print((27-i)*' '+' '.join(chr(64+i-x)for x in range(i)))

Try it online.

Another 75 bytes:

for i in range(27):print(' '.join(chr(64+i-x)for x in range(i)).center(51))

Try it online.

Jelly, 13 bytes

ØALḶ⁶ẋṚżUK$ƤY

Try it online!

A full program that prints the desired output to STDOUT.

Explanation

ØA            | Uppercase letters
  L           | Length (26)
   Ḷ          | Lowered range (0..25)
    ⁶ẋ        | Space that many times (vectorises)
      Ṛ       | Reverse list
       ż      | Zip with:
          $Ƥ  | - Following applied to each prefix of the uppercase letters:
        U     |   - Reverse
         K    |   - Join with spaces
            Y | Join with newlines

Without the final Y, a list of lists of Jelly strings woulf be returned, with the spaces and letters in separate sublists. As such, I’ve gone with joining the outer list with newlines and relying on Jelly’s default printing method to produce the correct output.

Red, 76 bytes

a:""repeat n 26[insert a rejoin[sp#"@"+ n]print next pad/left copy a n + 26]

Try it online!

Python 3, 78 bytes

for i in range(26):print(' '*(25-i)+' '.join(chr(65+i-j) for j in range(i+1)))

A straightforward solution.

K (ngn/k), 27 bytes

1_|^\(," "/+,a),a:`c$90-!26

Try it online!

!26 is 0 1..25

90-!26 is 90 89..65

`c$ convert to chars: "ZY..A"

a: assign to a

(,..), prepend as a single element

• +,a flip enlist, i.e. make each char a length-1 string: (,"Z";,"Y";..;,"A")

• " "/ join with spaces (in some dialects of k this may be " "/:)

^\ without-scan, i.e. start with "Z Y..A", then remove "Z", then remove "Y", etc, and collect intermediate results

| reverse

1_ drop the first, as it's an all-spaces string

Canvas, 13 bytes

Ｚ［± ＊ＺＬ³－ ××］

Try it here!

Explanation:

Z[± *ZL³- ××]
Z[          ] map over the prefixes of the uppercase alphabet
  ±             reverse the current prefix
    *           interleave it with spaces
     ZL³-       substract the loop index from 26
          ×     that many spaces
           ×    prepend the spaces to the prefix

7 bytes with padding with spaces. yep, 2x bytecount to "remove" them..

K (oK), 34 33 bytes

-1 byte thanks to ngn

(-26-!26)$`c${,/32,'|65+!x}'1+!26

Try it online!

Charcoal, 7 9 bytes

ＵＴ↙Ｅα…α⊕κ

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

  α     Uppercase alphabet
 Ｅ      Map over characters
    α   Uppercase alphabet
   …    Truncated to length
      κ Current index
     ⊕  Incremented
↙       Output with a 135° rotation

Effectively, this starts with the A in the bottom right corner, then works its way to the top left printing longer and longer prefixes of the uppercase alphabet each time, each prefix being printed towards the bottom left. The ＵＴ simply suppresses Charcoal's default rectangular output, apparently needed for this question for some reason.

Japt -R, 14 bytes

;Båi ®¬¸Ãû
mx1

Saved a byte thanks to @Shaggy.

Gained 4 bytes due to fixing a bug.

Test it

Icon, 84 bytes

procedure main()
s:="";i:=1to 26&s[1:1]:=" "||char(64+i)&write(right(s,25+i))&\z
end

Try it online!

C (gcc),  82 79 77 75  74 bytes

Saved 2 bytes thanks to @ceilingcat
Saved 1 byte thanks to @gastropner

Derived from my 2^nd JS answer.

f(x,y,s){for(x=0,y=25;~y;putchar(s>51?x=!y--,13:s&x>y?90-s/2:32))s=++x+y;}

Try it online!

How?

We start with \$x=0\$ and \$y=25\$. We increment \$x\$ at the beginning of the line. We set \$x\$ to \$0\$ and decrement \$y\$ at the end of the line, which is reached when \$x+y=52\$. We stop when \$y=-1\$.

This gives:

   0        1         2         3
   123456789012345678901234567890...
25 .........................A
24 ........................B.A
23 .......................C.B.A
22 ......................D.C.B.A
21 .....................E.D.C.B.A
 ⋮

We append a letter when \$x+y\$ is odd and \$x\$ is greater than \$y\$, or a space otherwise.

The ASCII code of the letter at \$(x,y)\$ is given by:

$$90-\left\lfloor\frac{x+y}{2}\right\rfloor, (x+y)\equiv 1 \pmod 2$$

Poetic, 686 bytes

the a-b-c corner
i was a child of ten or eleven
i said i am smart,i am likely to get an answer
i got a chance to read papers,novels or some old poetry
i read in class
as i read,i paused a bit
the words,i do admit,were a huge issue
please tutor,i said,i desire a nap
i truly do not
i fibbed
i am hiding a r-real g-great l-lie,a secret
i am idiot,i cant t-truly r-r-read
i think im reading,really im no smart reader
i need a lesson,i say,i really do
not a whole lot of people are helping teach me
i want a tutor,i say,i really want someone smart
i call a skilled tutor on my phone
as i call a person,i see a letter key,then i press down
it worked!i see a letter shape
amazing start for me

Try it online!

Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.

PHP, 59 bytes

for($a=A;$i++<26;)echo str_pad('',26-$i),$s=$a++." $s","
";

Try it online!

Haskell, 53 bytes

[tail$do c<-reverse a;' ':[c|c<=d]|d<-a]
a=['A'..'Z']

Try it online!

This uses that each line has exactly 25 spaces. So, instead of separately handling the prefix spaces and the spaces between letters, we take 26 spaces, and decide whether to put a letter after each. This unfortunately gives one extra leading space, which we remove.

54 bytes

foldl(\m c->map(' ':)m++[c:' ':last m])["A"]['B'..'Z']

Try it online!

55 bytes

"A"%['B'..'[']
s%(h:t)=((' '<$t)++s):(h:' ':s)%t
s%_=[]

Try it online!

Japt, 29 bytes

;1o27@Bt0X)w)ò1)qS)ùS25+X})qR

Try it online!

Python3, 91 bytes

for _ in range(26):print(f'{" ".join([*map(chr,range(65,91))][0:_+1][::-1]):^52}'.rstrip())

Try it online!

-1 byte thanks to @cairdcoinheringaahing

Haskell, 63 bytes

[(' '<$[c..'Y'])++foldl(\s->(:' ':s))"A"['B'..c]|c<-['A'..'Z']]

Try it online!

Python 2, 53 bytes

i=26
s='A'
while i:i-=1;print' '*i+s;s='%c '%(91-i)+s

Try it online!

We take care not to introduce any trailing spaces, which means avoiding center and also avoiding adding a space with A for the first row.

V (vim), 16, 15, 12 bytes

¬ZAòé hòòxâÄ

Try it online!

Hexdump:

00000000: ac5a 41f2 e920 68f2 f278 e2c4            .ZA.. h..x..

Thanks to Kritixi Lithos for helping me golf a few off.

Explanation:

¬ZA                 " Insert every character between 'Z' and 'A'
                    " The cursor is on the 'A'
   ò         ò      " Recursively...
    é<space>        "   Insert a space
            h       "   Move back one character
                    "   If we're on the first column, this will break the loop
              ò     " Recursively...
               x    "   Delete the current character
                â   "   Stop looping if there's only one non-whitespace character on this line
                 Ä  "   Duplicate this line upward

Pyth, 20 bytes

VlGp*dt-lGNjdr_<GhN1

Pretty happy with this, since it's my first Pyth answer. Probably can be golfed a lot

Explanation

VlG   for N in range(26)

p*dt-lGN    26-N spaces outputted


    <GhN   First N alphabet characters
   _       Reversed
  r        Capitalised
j       1  Joined with spaces (space after each character)

Try it online!

Wolfram Language (Mathematica), 76 bytes

Array[StringRiffle[Reverse@ToUpperCase@Alphabet[][[;;#]]]&,26]~Column~Center

Jelly, 16 bytes

L26_⁶x;KU$
ØAÇƤY

Try it online!

This seems too long for Jelly, despite being terrible at ascii-art challenges