[Question]
  [
Without taking any input, output this exact text:
```
                         A
                        B A
                       C B A
                      D C B A
                     E D C B A
                    F E D C B A
                   G F E D C B A
                  H G F E D C B A
                 I H G F E D C B A
                J I H G F E D C B A
               K J I H G F E D C B A
              L K J I H G F E D C B A
             M L K J I H G F E D C B A
            N M L K J I H G F E D C B A
           O N M L K J I H G F E D C B A
          P O N M L K J I H G F E D C B A
         Q P O N M L K J I H G F E D C B A
        R Q P O N M L K J I H G F E D C B A
       S R Q P O N M L K J I H G F E D C B A
      T S R Q P O N M L K J I H G F E D C B A
     U T S R Q P O N M L K J I H G F E D C B A
    V U T S R Q P O N M L K J I H G F E D C B A
   W V U T S R Q P O N M L K J I H G F E D C B A
  X W V U T S R Q P O N M L K J I H G F E D C B A
 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
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
```
## Rules
* Output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* You can print it to STDOUT or return it as a function result.
* Either a full program or a function are acceptable.
* A single trailing newline is acceptable, but no other formatting changes are allowed.
* Capital letters are required.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
# [Haskell](https://www.haskell.org/), 53 bytes
```
[tail$do c<-reverse a;' ':[c|c<=d]|d<-a]
a=['A'..'Z']
```
[Try it online!](https://tio.run/##DcYxEsIgEADA3ldckZmryAMUCt9gJ1LcHKcynsgASZW3S7LVvql9RHVU9xi@U9Ip/oCtqbJKbQJ0QcCz542ti2GL1lA4kfN4xXnGO4bxpZTBQVn6rVeYYMmasrRjdfz5qfRqw3ApOw "Haskell – 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!](https://tio.run/##FcZRCoMwDADQqwQZRBE9gKCwXWF/1n6ETp0sqaWt1ze69/W@lH4zs8Z@0mXnD5eTgGsGoVAiYFdJXRvX/cuUMoitTPEsrMEXti2OaFVo89BDOPI7R3jA4Xnzc7oX9XQL05q0cSFc "Haskell – Try It Online")
---
**55 bytes**
```
"A"%['B'..'[']
s%(h:t)=((' '<$t)++s):(h:' ':s)%t
s%_=[]
```
[Try it online!](https://tio.run/##DcpBCoMwEEDRfU8xiGESpB4gmEV7hS5TkSBWxRhCZrx@xyz/42@BjiVGKe4rzatRHt/Y9@hxfJDSm2XjtEbAoWXTdWRstZqWjOJ6TM6PcoY9gYN88YcLtHCluKeFoMh//sWwkjznnG8 "Haskell – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~82 79 77 75~~ 74 bytes
*Saved 2 bytes thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)*  
*Saved 1 byte thanks to [@gastropner](https://codegolf.stackexchange.com/users/75886/gastropner)*
Derived from my 2nd 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!](https://tio.run/##BcFBCoMwEADAu69IL2WXJFQjHjRE3yIpqR6s4tqyi9ivpzPRvmLMOQEbMYRnWnfgUBoJrvE/8dvniNO4A/VNNXC4ibWmqju6cy9DW1p6uK52iBS0Zi3@yt91fqplnN@A6iyUSoC@uPIf "C (gcc) – 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$$
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~7~~ 9 bytes
```
ＵＴ↙Ｅα…α⊕κ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMPKJb88zyc1rURHwTexQCNRR8G5Mjkn1TkjH8zxzEsuSs1NzStJTdHI1gQC6////@uW5QAA "Charcoal – 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.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), ~~16, 15~~, 12 bytes
```
¬ZAòé hòòxâÄ
```
[Try it online!](https://tio.run/##K/v//9CaKMfDmw6vVMgAkpsqDi863PL/PwA "V (vim) – 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
```
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html), 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!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?XVLRrp0wDHvnK7J3@KjQ5tCK0qAmDLGfv3PL1TZNQmrVOI4d40mIl3UJFLRVaVOmm42YQsolkn7Ib51yJQtJtVAm4xxx8EF2cPNpXEvepTzkSps4ccVn92Db1Acb1yC93oQjnXxKs7nqTylG2sj0EFIMPFW8PegbOMwNhc0mSHqf5ozmyySCdM0@OfTf2qKhEJU4HtlnTIYrStcmlM0umc4ibJh/ubb59dAbxPJAVj4x0tsFD2Cp2m198rpKfP2lHHPdgGwLVBTalg2nU1lKlpnJJDT53gWg6mAPXJ18eVnR1zs7nadcd8rH8APWuTMCgpeq71JHaayvyrBaxEzrUP7MYxNlSJ3qWO@dtAgV3BHYKQq7xHCWpJxdtwuHRIeMdGvv@LuJf/hGrUehVf6kG1BCg@25FGgZjaSVjofOBOCbzTeqx/rqFBmy3aXRLs@MoCpwZ4MTCL/rlL0nt0v88R/cEn6PiQ/@1bWb94V8MPSQr6@V428)
Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
[Answer]
# [Bash](https://www.gnu.org/software/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
	+ `p`rint 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!](https://tio.run/##S0oszvj/PzU5I1@hOkpPz7G2pjg1RUE3T0HdKse6wLpYP9pJNypWX9@6JEe9piQx@f9/AA "Bash – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 34 bytes
```
((32#~26-#)<@u:@,32,@,.65+|.)\i.26
```
[Try it online!](https://tio.run/##LY5BS8NAFITv@ysGC9rQdCkp5hCsRAUPUjyI4MXLZvu2uxLeSvZFFMS/Hrehpwcz37yZj8lhpy80Nmg2WGs8vOwfp@VyWy3@qnq9KG7asWnLbVW2pa6vV7@6eA@6qqdCPd9rvHqC6eIXYSAZB04wcCNbCZGzlMZeGszkHfqQBNGhi9@UQMZ62MhiAgc@5tzJn9E3AhMdzmBgPKEja8ZEkNzXB86yN7n0EJyjgVjQEx/FJzU/2JNcJXzmSfKTT8j@KXjeoxRZHy9v4dT0Dw "J – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 37 bytes
```
25..0|%{' '*$_+[char[]]((90-$_)..65)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38hUT8@gRrVaXUFdSyVeOzo5I7EoOjZWQ8PSQFclXlNPz8xUs/b/fwA "PowerShell – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 78 72 63 bytes
```
for(i in 1:26){cat(strrep(" ",26-i));cat(LETTERS[i:1],fill=52)}
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPwdDKyEyzOjmxRKO4pKgotUBDSUFJx8hMN1NT0xok6uMaEuIaFBydaWUYq5OWmZNja2qkWfv/PwA "R – 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.
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
i=26
s='A'
while i:i-=1;print' '*i+s;s='%c '%(91-i)+s
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWyIyr2FbdUZ2rPCMzJ1Uh0ypT19bQuqAoM69EXUFdK1O72Boor5qsoK6qYWmom6mpXfz/PwA "Python 2 – 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.
[Answer]
# [Python 3](https://docs.python.org/3/), 76 75 bytes:
-1 byte thanks to [@pppery](https://codegolf.stackexchange.com/users/46076/pppery)
```
for i in range(27):print((27-i)*' '+' '.join(chr(64+i-x)for x in range(i)))
```
[Try it online](https://tio.run/##K6gsycjPM/7/Py2/SCFTITNPoSgxLz1Vw8hc06qgKDOvRAPI1M3U1FJXUNcGYr2s/Mw8jeSMIg0zE@1M3QpNkL4KhL5MTU3N//8B).
Another **75 bytes**:
```
for i in range(27):print(' '.join(chr(64+i-x)for x in range(i)).center(51))
```
[Try it online](https://tio.run/##Rco7CoAwDADQq2RrgljwD95GSrVxSEvoUE8fcfLNrzw1ZZnMzqzAwAJ6yBVx3GgvylLRgfN3ZsGQFNe5477Rl9ufmciHKDUqLgOR2Qs).
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~57~~ 54 bytes
```
?A.upto(?Z){puts' '*(90-_1.ord)+[*?A.._1].reverse*' '}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsGCpaUlaboWN83sHfVKC0ryNeyjNKsLSkuK1RXUtTQsDXTjDfXyi1I0taO1gCr04g1j9YpSy1KLilO1gCpqIbqhhsAMAwA)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 76 bytes
```
Array[StringRiffle[Reverse@ToUpperCase@Alphabet[][[;;#]]]&,26]~Column~Center
```
[![enter image description here](https://i.stack.imgur.com/bQyyS.png)](https://i.stack.imgur.com/bQyyS.png)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;Båi ®¬¸Ãû
mx1
```
Saved a byte thanks to @Shaggy.
Gained 4 bytes due to fixing a bug.
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=O0LlaSCurLjD%2bwpteDE)
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~34~~ 33 bytes
-1 byte thanks to ngn
```
(-26-!26)$`c${,/32,'|65+!x}'1+!26
```
[Try it online!](https://tio.run/##y9bNz/7/X0PXyExX0chMUyUhWaVaR9/YSEe9xsxUW7GiVt1QGyjx/z8A "K (oK) – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 13 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｚ［± ＊ＺＬ³－ ××］
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNBJXVGRjNCJUIxJTIwJXVGRjBBJXVGRjNBJXVGRjJDJUIzJXVGRjBEJTIwJUQ3JUQ3JXVGRjNE,v=8)
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](https://dzaima.github.io/Canvas/?u=JXVGRjNBJXVGRjNCJUIxJTIwJXVGRjBBJXVGRjNEJXVGRjBG,v=8) with padding with spaces. yep, 2x bytecount to "remove" them..
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), 27 bytes
```
1_|^\(," "/+,a),a:`c$90-!26
```
[Try it online!](https://tio.run/##y9bNS8/7/98wviYuRkNHSUFJX1snUVMn0SohWcXSQFfRyOz/fwA "K (ngn/k) – 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
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
ØALḶ⁶ẋṚżUK$ƤY
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//w5hBTOG4tuKBtuG6i@G5msW8VUskxqRZ//8 "Jelly – 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. 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
ASuηí».c
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fMbj03PbDaw/t1kv@/x8A "05AB1E – 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
```
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 62 bytes
```
: f 25 for i spaces 25 i - for i 65 + emit ."  "next cr next ;
```
[Try it online!](https://tio.run/##S8svKsnQTU8DUf//WymkKRiZKgB5CpkKxQWJyanFIH6mgi5UzMxUQVshNTezREFPSUFBKS@1okQhuUgBTFv/T/sPAA "Forth (gforth) – 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
```
[Answer]
# 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"
..
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 35 bytes
```
25* 
.
Y`.`RL
L^$w`^(..)*
$#1* $'
```
[Try it online!](https://tio.run/##K0otycxLNPz/n8vIVEuBi0uPKzJBLyHIh8snTqU8IU5DT09Ti0tF2VBLQUX9/38A "Retina – 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.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 82 bytes
```
v->{var x="";for(char c=64;++c<91;)System.out.printf("%"+(c-38)+"s%n",x=c+" "+x);}
```
[Try it online!](https://tio.run/##HU1Na8MgGL73V7wIBcVFKBtjw6aXnXcq7DJ6cG9jZ2Y06GtIKfntme3p4fnuzWSa/vy3ojc5w6dxAW4bgLH8eIeQyVCFKbozDNXjR0ouXL5PYNIli0cUoK8jqpDzypaA5GJQHzHkMnRp/1WrB7DtOjWH22QSzC1j2sbE8bcybF9ftJS4f99pcbxm6gYVC6mx3pDlbMskx@b5TUiWt4E9zS1KBkzOQi@rfrxbZRC7kXgo3ou7tmyW9R8 "Java (JDK) – Try It Online")
## Credits
* -2 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen).
[Answer]
# 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!](https://tio.run/##K/v/36o4tUQhL802MacgI5ErMUq6sDCyQKLQyMShMCw93QvIC6gA8/7/BwA "V (vim) – Try It Online")
[Answer]
# 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
```
[Answer]
# [Scratch](https://scratch.mit.edu/), ~~256~~ 240 bytes
-16 thanks to @Lyxal because I can't read! XD
[Try it online!](https://scratch.mit.edu/projects/514086333)
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
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~57~~ ~~52~~ 42 bytes
```
T`L`_L
}`^
Z
.
$.`$* $&$'¶
\B\w
 $&
O`
G`.
```
[Try it online!](https://tio.run/##K0otycxL/P8/JMEnId6HqzYhjiuKS49LRS9BRUtBRU1F/dA2rhinmHIuIIfLP4HLPUHv/38A "Retina 0.8.2 – 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.)
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/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!](https://tio.run/##K87LT8rPMfn/349TLdTZMdhVwUnBx9VPw1BTQQ/IdIhQsHLTcPVz0eTidFSwdVJQB0JHLk7/0JCA0BAFW58ARxcNRx0jMwVthQhNBSsNP00uoOr//wE "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/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!](https://tio.run/##K6gsyfj/PyzHvUArpUQ3x90vK6Uo3sY9w8/w/38A "Pyth – Try It Online")
[Answer]
# [Python3](https://docs.python.org/3/), 91 bytes
```
for _ in range(26):print(f'{" ".join([*map(chr,range(65,91))][0:_+1][::-1]):^52}'.rstrip())
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFeITNPoSgxLz1Vw8hM06qgKDOvRCNNvVpJQUkvKz8zTyNaKzexQCM5o0gHosrMVMfSUFMzNtrAKl7bMDbaykrXMFbTKs7UqFZdr6i4pCizQENT8/9/AA)
*-1 byte thanks to @cairdcoinheringaahing*
]