[Question]
  [
Inspired by [a bug](https://tio.run/##S9ZNT07@/z9TJ8s6TSM5I7FIq1izujwjMydVA8RKyy/SyLI1M7XOsrE0tM7S1tbUKra1zbIvKMrMK0nTUNMqBgpZQXlKCkqa1gWlJcUaSkBGbe3/3MTMPA2gIRpKUZER4WGhIcFBgQH@fr4@3l6eHu5uri7OTo4glf8B) in a solution to [this challenge](https://codegolf.stackexchange.com/q/141372/61563), your challenge is to produce this exact text:
```
                         ZYXWVUTSRQPONMLKJIHGFEDCBA
                        YXWVUTSRQPONMLKJIHGFEDCBA
                       XWVUTSRQPONMLKJIHGFEDCBA
                      WVUTSRQPONMLKJIHGFEDCBA
                     VUTSRQPONMLKJIHGFEDCBA
                    UTSRQPONMLKJIHGFEDCBA
                   TSRQPONMLKJIHGFEDCBA
                  SRQPONMLKJIHGFEDCBA
                 RQPONMLKJIHGFEDCBA
                QPONMLKJIHGFEDCBA
               PONMLKJIHGFEDCBA
              ONMLKJIHGFEDCBA
             NMLKJIHGFEDCBA
            MLKJIHGFEDCBA
           LKJIHGFEDCBA
          KJIHGFEDCBA
         JIHGFEDCBA
        IHGFEDCBA
       HGFEDCBA
      GFEDCBA
     FEDCBA
    EDCBA
   DCBA
  CBA
 BA
A
```
* The first line will have 25 spaces, then the alphabet backwards starting from the 26th letter (`ZYXWVUTSRQPONMLKJIHGFEDCBA`), then a newline.
* The second line will have 24 spaces, then the alphabet backwards starting from the 25th letter (`YXWVUTSRQPONMLKJIHGFEDCBA`), then a newline.
* ...
* The last (26th) line will have no spaces, then the alphabet backwards starting from the 1st letter (`A`), then a newline.
Additional rules:
* Your program may use any allowed output methods.
* One trailing newline and/or one leading newline is allowed.
* There must be one newline between lines containing the letters, no more.
* The letters must be all uppercase.
As with [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest submission wins. Good luck!
Leaderboard:
```
var QUESTION_ID=141725,OVERRIDE_USER=61563;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# [R](https://www.r-project.org/), ~~67~~ 55 bytes
```
for(i in 26:1)cat(rep(" ",i-1),LETTERS[i:1],"
",sep="")
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPwcjMylAzObFEoyi1QENJQUknU9dQU8fHNSTENSg4OtPKMFZHiUtJpzi1wFZJSfP/fwA "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
### Code:
```
₂žp.s1Λ
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f//UVPT0X0FesWG52b//w8A "05AB1E – Try It Online")
### Explanation
```
 žp.s      # Get the suffixes of ZYX...CBA
      Λ    # Using the canvas mode, print the
₂          # first 26 elements of the array
     1     # into the upper-right direction
```
[Answer]
# [Python 2](https://docs.python.org/2/), 57 bytes
```
i=26
while i:i-=1;print' '*i+bytearray(range(65+i,64,-1))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWyIyrPCMzJ1Uh0ypT19bQuqAoM69EXUFdK1M7qbIkNbGoKLFSoygxLz1Vw8xUO1PHzERH11BT8/9/AA "Python 2 – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~13~~, 11 bytes
```
¬ZAòY>HGpxl
```
[Try it online!](https://tio.run/##K/v//9CaKMfDmyLtPNwLKnL@/wcA "V – Try It Online")
Hexdump:
```
00000000: ac5a 41f2 593e 4847 7078 6c              .ZA.Y>HGpxl
```
Written from my phone :P.
```
¬ZA         " Insert the alphabet backwards
   ò        " Recursively:
    Y       "   Yank this current line
     >H     "   Add one space to every line
       G    "   Move to the last line in the buffer
        p   "   Paste the line we yanked
         x  "   Delete one character
          l "   Move one character to the right, which will throw an error on 
            "   the last time through, breaking the loop
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 42 bytes
```
25..0|%{' '*$_+-join[char[]]((65+$_)..65)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38hUT8@gRrVaXUFdSyVeWzcrPzMvOjkjsSg6NlZDw8xUWyVeU0/PzFSz9v9/AA "PowerShell – Try It Online")
### Explanation:
```
25..0|%{                                 } # Loop from 25 to 0
                             (65+$_)..65   # Construct a range of the specific ASCII codes
                    [char[]](           )  # Cast that as a character array
               -join                       # that has been joined together into a string
        ' '*$_+                            # Prepended with the correct amount of spaces
```
[Answer]
# Bash + GNU sed, 60
```
printf %s {Z..A}|sed 'h
s/./ /g
G
s/ \n//
:x
p
s/ \S//
tx
d'
```
[Try it online](https://tio.run/##S0oszvj/v6AoM68kTUG1WKE6Sk/PsbamODVFQT2Dq1hfT19BP53LHchSiMnT1@eyquAqAHOCgZySCq4U9f//AQ).
[Answer]
# [///](https://esolangs.org/wiki////), ~~105~~ 97 bytes
```
/:/\\\\*//#/: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//\\*/\/\/_____#
\/ //_/     //*#
```
[Try it online!](https://tio.run/##Fcu7DoIwAEbh3ado0o3l38@mIuAFQVBQ0qRhIGFg6/un0u/MJ2xzWJcQo5DbZZIVEz@@jAx8eNPT8aKl4UnNgzs3rlSUFFzIOXPiKKXZ7fnEHpyM5GUSKbMx/gE "/// – Try It Online")
### Explanation
/// only knows one command, `/<pattern>/<substitution>/<text>` replaces all occurrences of `<pattern>` in `<text>` with `<substitution>`. Additionally `\` can be used to escape characters. 
Shortened code for simplicity: 
```
/:/\\\\*//#/:E:D:C:B:A//\\*/\/\/__#
\/ //_/  //*#
```
The first command `/:/\\\\*/` replaces `:` with `\\*` in the subsequent code. This gives:
```
/#/\\*E\\*D\\*C\\*B\\*A//\\*/\/\/__#
\/ //_/  //*#
```
Then `/#/\\*E\\*D\\*C\\*B\\*A/` replaces `#` with `\*E\*D\*C\*B\*A`:
```
/\\*/\/\/__\*E\*D\*C\*B\*A
\/ //_/  //*\*E\*D\*C\*B\*A
```
Then `/\\*/\/\/__\*E\*D\*C\*B\*A<newline>\/ /` replaces `\*` with `//__*E*D*C*B*A<newline>/`:
```
/_/  //*//__*E*D*C*B*A
/ E//__*E*D*C*B*A
/ D//__*E*D*C*B*A
/ C//__*E*D*C*B*A
/ B//__*E*D*C*B*A
/ A
```
Notice: I had to use `\*` for replacement. Since `*` is also part of the substitution, it would generate an infinite loop if I only replace `*`. 
Then command `/_/ /` replaces `_` with spaces, and `/*//` deletes all `*`:
```
EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/ A
```
The next command `/#//` replaces `#` by nothing. Since there is no `#` in the code, it does nothing. This is just here to remove the two leadings `//` from the beginning of the code. This leaves 
```
EDCBA
/ E//    EDCBA
/ D//    EDCBA
/ C//    EDCBA
/ B//    EDCBA
/ 
```
Then the command `/ E//` removes `<space>E`, so this will leave the code
```
    EDCBA
   DCBA
/ D//   DCBA
/ C//   DCBA
/ B//   DCBA
/ 
```
Similar `/ D//` removes `<space>D`: 
```
    EDCBA
   DCBA
  CBA
/ C//  CBA
/ B//  CBA
/ 
```
`/ C//`:
```
    EDCBA
   DCBA
  CBA
 BA
/ B// BA
/ 
```
`/ B//`:
```
    EDCBA
   DCBA
  CBA
 BA
A
/ 
```
And the last command is incomplete, so it does nothing:
```
    EDCBA
   DCBA
  CBA
 BA
A
```
[Answer]
## Haskell, ~~53~~ 52 bytes
```
f(a:b)=(b>>" ")++a:b++'\n':f b
f x=x
f['Z','Y'..'A']
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00j0SpJ01Yjyc5OSUFJU1sbyNXWVo/JU7dKU0jiSlOosK3gSrdNi1aPUtdRj1TX01N3VI/9n5uYmadgq1BQWhJcUqSQ/h8A "Haskell – Try It Online")
How it works
```
f['Z','Y'..'A']        -- call f with the full backwards alphabet
f(a:b)=                -- let `a` be the first char and `b` the rest. Return
   (b>>" ") ++         -- replace each char in b with a space, followed by
   a:b ++              -- the input string, followed by
   '\n' :              -- a newline, followed by
   f b                 -- a recursive call of `f` with `b`
f x=x                  -- stop on an empty input string
```
[Answer]
# JavaScript (ES6), ~~83~~ ~~77~~ 76 bytes
```
f=(n=0,p='')=>n<26?f(++n,p+' ')+p+`ZYXWVUTSRQPONMLKJIHGFEDCBA
`.slice(~n):''
o.innerText = f()
```
```
<pre id=o>
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~66~~ 64
```
i=26
while i:i-=1;print' '*i+'ZYXWVUTSRQPONMLKJIHGFEDCBA'[25-i:]
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWyIyrPCMzJ1Uh0ypT19bQuqAoM69EXUFdK1NbPSoyIjwsNCQ4KDDA38/Xx9vL08PdzdXF2clRPdrIVDfTKvb/fwA "Python 2 – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), 105 bytes
```
++++++++[>+>+++++++++++>++++>+++<<<<-]>++>++>>++[[->+>+<<]>-[-<<.>>]>[-<<<<.->>>+>]<-[-<+<<+>>>]<<<<.>>>]
```
[Try it online!](https://tio.run/##RYrRCYBQDAMHKnWCkEVKP1QQRPBDcP6aPhQPUhJ6yzXv53avR5W9BI32w@9AeHIMKhHeJpD0cGAik11UnTKY6IcM@RoYDrPqAQ "brainfuck – Try It Online")
Minified and formatted:
```
++++++++[>+>+++
++++++++>++++>+
++<<<<-]>++>++>
>++[[->+>+<<]>-
[-<<.>>]>[-<<<<
.->>>+>]<-[-<+<
<+>>>]<<<<.>>>]
```
Readable version:
```
[
  pre-initialize the tape with the values 10 90 32 >26<
  C_NEWLINE: 10
  V_ALPHA: 90
  C_SPACE: 32
  V_COUNTER: 26
AS:
  10 = 8 *  1 + 2
  90 = 8 * 11 + 2
  32 = 8 *  4 + 0
  26 = 8 *  3 + 2
]
8 ++++++++ [
  *  1 >+
  * 11 >+++++++++++
  *  4 >++++
  *  3 >+++
<<<<-]
PLUS 2 >++
PLUS 2 >++
PLUS 0 >
PLUS 2 >++
UNTIL V_COUNTER == 0 [
  COPY V_COUNTER to RIGHT and RIGHT_RIGHT
  [->+>+<<]
  TAPE: 10 V_ALPHA 32 >0< V_COUNTER_R V_COUNTER_RR
  V_COUNTER_R SUB 1 TIMES: >-[-
     PRINT C_SPACE <<.
  >>]
  TAPE: 10 V_ALPHA 32 0 >0< V_COUNTER_RR
  V_COUNTER_RR TIMES: >[-
    PRINT V_ALPHA <<<<.
    DECREMENT V_ALPHA -
    INCREMENT V_COUNTER_R >>>+
  >]
  TAPE: 10 V_ALPHA 32 0 V_COUNTER_R(26) >0<
  V_COUNTER_R SUB 1 TIMES: <-[-
    INCREMENT V_COUNTER <+
    INCREMENT V_ALPHA <<+
  >>>]
  PRINT C_NEWLINE <<<<.
>>>]
```
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/), 601 bytes
```
one night i camped a bit
throughout all the forest now
the sweet sights
i saw giant things
i saw little small things
here i am
seated around all my trees i saw
i sleep
i sle-e-p
sleep in a cabin
i am sleep-y
i sleep a bit
i awaken in bed
i stand
i walk
i am ready
i saw a vision of a dragon
i am fooled
i know i am
should i f-ight
i f-light
i did f-light
i did a flight
go away,i do imply
i*m afraid
i run
i leave
i flee
i am timid
i*m just a person,not toughie-tough-guy
no,never
i*m waste
i am stupid
a quitter i was
i am stupid
i*m turning around
i do not appreciate camping
i cry
i am crying
no
no
```
Poetic is an esolang I created in 2018 for a class project, and it is a brainfuck derivative in which the lengths of words correspond to brainfuck commands (and the +, -, >, and < commands each have 1-digit arguments).
The fact that only word-length dictates the commands means that I technically could have created a program entirely composed of non-words (i.e. the letter X as many times as needed, with spaces in between words), but I wanted to make an interesting free-verse poem out of it while not adding any unnecessary bytes.
If you want to try it online (which is half the point of the class project in the first place), check out [my online interpreter](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/)!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
ØAµ⁶ṁḊ;ṚµƤṚY
```
[Try it online!](https://tio.run/##y0rNyan8///wDMdDWx81bnu4s/Hhji7rhztnHdp6bAmQivz/HwA "Jelly – Try It Online")
```
ØAµ⁶ṁḊ;ṚµƤṚY  Main Link
ØA            "ABC...XYZ"
         Ƥ    For each prefix,
  µ⁶ṁḊ;Ṛµ     Monadic Link
   ⁶          ' '
    ṁ         (with automatic repetition) molded to the shape of
     Ḋ        All but the first letter of the input (repeat - 1)
      ;       With the input          appended to it
       Ṛ                     reversed
           Y  Join on newlines
          Ṛ   Flip upside down
```
-3 bytes thanks to miles
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~53~~ ~~49~~ ~~46~~ 45 bytes
*1 byte removed thanks to [@Sanchises](https://codegolf.stackexchange.com/users/32352/sanchises)*
```
for k=25:-1:0,disp([blanks(k) 65+k:-1:65])end
```
[Try it online!](https://tio.run/##y08uSSxL/f8/Lb9IIdvWyNRK19DKQCcls7hAIzopJzEvu1gjW1PBzFQ7GyRjZhqrmZqX8v8/AA)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
žpDvÐg<ú,¦
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6L4Cl7LDE9JtDu/SObTs/38A "05AB1E – Try It Online")
**Explanations:**
```
žpDvÐg<ú,¦
žp           Push the uppercased alphabet, reversed
  D          Duplicate
   v         For each letter (we just want to loop 26 times, so we use the 
                already pushed alphabet for that purpose)
    Ð        Triplicate
     g<      Length of the string - 1
       ú     Add that number of spaces at the beginning of the string
        ,    Print with newline
         ¦   Remove the 1st element of the remaining copy of the string
```
[Answer]
# [Perl 6](https://perl6.org), 37 bytes
*Saved 9 bytes thanks to @Massa.*
```
say " "x$_,chrs $_+65...65 for 25...0
```
[Try it online!](https://tio.run/##K0gtyjH7/784sVJBSUGpQiVeJzmjqFhBJV7bzFRPT8/MVCEtv0jBCMQ2@P8fAA "Perl 6 – Try It Online")
**Explanation:** `25...0` is a range from 25 to 0 (as expected). We iterate over that range, saying (= printing with newline) that many spaces and the string of characters that have ASCII codes (`chrs`) from 65 + that number (`$_+65...65`).
[Answer]
# Vim, 43 keystrokes
```
:h<_<CR>jjYZZPVgUxjpqqy$-i <Esc>lpl"aDYPD"ap+q25@q
```
You can see it in action in this GIF made using [Lynn's](https://codegolf.stackexchange.com/users/3852/lynn) [python script](https://gist.github.com/lynn/5f4f532ae1b87068049a23f7d88581c5)
[![enter image description here](https://i.stack.imgur.com/qaLoG.gif)](https://i.stack.imgur.com/qaLoG.gif)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~19~~ 11 bytes
*-8 bytes thanks to ASCII-only.*
```
Ｆ²⁶«Ｐ⮌…α⊕ι↗
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBw8hMU6GaSwEIfEtzSjILijLzSjSCUstSi4pTNXzzc1I0EnUUtLUzNTU1Iaryy1I1rEILgjLTM0o0uWr///@vW/ZftzgHAA "Charcoal – Try It Online") Link is to verbose version.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 54 52 bytes
```
25.downto 0{|n|puts' '*n+[*?A..?Z][0..n].reverse*''}
```
[Try it online!](https://tio.run/##KypNqvz/38hULyW/PK8kX8GguiavpqC0pFhdQV0rTztay95RT88@KjbaQE8vL1avKLUstag4VUtdvfb/fwA "Ruby – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 43 ~~46~~ bytes
```
$/\;u:\s/':(!$u;:'@^!@Wu;oSU;o+<u(;;oN;(!|
```
[Try it online!](https://tio.run/##Sy5Nyqz4/19FP8a61CqmWF9dykpDUaXU2krdIU7RIbzUOj841Dpf26ZUw9o6389aQ7Hm/38A "Cubix – Try It Online")
Cubified
```
      $ / \
      ; u :
      \ s /
'  : ( ! $ u ; : ' @ ^
! @ W u ; o S U ; o + <
u ( ; ; o N ; ( ! | . .
      . . .
      . . .
      . . .
```
[Watch it run](https://ethproductions.github.io/cubix/?code=ICAgICAgJCAvIFwKICAgICAgOyB1IDoKICAgICAgXCBzIC8KJyAaIDogKCAhICQgdSA7IDogJyBAIF4KISBAIFcgdSA7IG8gUyBVIDsgbyArIDwKdSAoIDsgOyBvIE4gOyAoICEgfCAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4K&input=Cg==&speed=20)
Have managed to shave a few more of this, but it was a bit more difficult than I thought. There is a substitute character after the first quote to give me 26.
* `'<sub>` push 26 onto the stack as the base number
* `:(!` duplicate base as a counter, decrement, test for truthy
* `u` on true skip the `$` command and u-turn to the right
	+ `So;u` push 32, output as character, pop 32 and u-turn right onto the decrement
* `$` on false jump the next `u` command
* `;:'@^` pop, duplicate the base number, push 64 onto stack and redirect into a torturous route
* `$\s/:\/u;$` this is the order of the steps on the top face. It boils down to swap the counter with the 64. Ends with a skip over the redirect that put it here.
* `<+o;U` redirect to add, output character, pop, u-turn left
* `(!` decrement, test for truthy. If true starts on a path which hits the u-turn and goes back to the redirect.
* `|(;No` on false, reflect, redundant test, redundant decrement, pop, push 10 and output character
* `;;(u!@W` pop down to the base number, decrement, u-turn right onto truthy test, halt if false otherwise change lane onto the duplicate at the beginning. Rinse and repeat.
[Answer]
# Python, 83 bytes
```
[print(' '*i+''.join([chr(64+i)for i in range(i+1,0,-1)]))for i in range(25,-1,-1)]
```
My first answer on codegolf :)
[Answer]
# [sed 4.2.2](https://www.gnu.org/software/sed/) + [Bash](https://www.gnu.org/software/bash/), 50 bytes
```
s/^/printf %25s;printf %s {Z..A}/e
:
p
s/ \S//
t
d
```
[Try it online!](https://tio.run/##K05N@f@/WD9Ov6AoM68kTUHVyLTYGsYuVqiO0tNzrNVP5bLiKuAq1leICdbX5yrhAuoBAA "sed 4.2.2 – Try It Online")
---
# [Bash](https://www.gnu.org/software/bash/) + [sed 4.2.2](https://www.gnu.org/software/sed/), 51 bytes
```
printf %s {Z..A}|sed 'h
s/./ /g
G
:
s/ [^ ]//p
t
d'
```
Building on [@DigitalTrauma's answer](https://codegolf.stackexchange.com/a/141748/12012).
[Try it online!](https://tio.run/##S0oszvgf4BjiYaukn19Qol@cmqKflJlnpQISU/pfUJSZV5KmoFqsUB2lp@dYWwOUV1DP4CrW19NX0E/ncueyArIVouMUYvX1C7hKuFLU//8HAA "Bash – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) + `-p`, 37 bytes
```
}{$\=$"x$-++.($a=$_.$a).$/.$\for A..Z
```
## Explanation
Since `-p` is being used with no input, the leading `}{` is to break out of the implicit `while(<STDIN>){` that's added. This builds the string, in reverse, into `$\` which is implicitly output after any content that is `print`ed. `for` each char in `A..Z`, `$\` is set to `$-` (which starts as `0` and is post-incremented for the next loop) `$"`s (which is the record separator and is initialised to space) to indent the string, concatenated with `$a` (which is prepended with `$_`, the current letter from the `for` loop), followed by `$/` (the line terminator, defaults to `"\n"`) and the existing contents of `$\`.
[Try it online!](https://tio.run/##K0gtyjH9/7@2WiXGVkWpQkVXW1tPQyXRViVeTyVRU09FX08lJi2/SMFRTy/q//9/@QUlmfl5xf91CwA "Perl 5 – Try It Online")
---
# [Perl 5](https://www.perl.org/) + `-M5.10.0`, 37 bytes
```
$#@-=say$"x$#@,reverse@@for\(@@=A..Z)
```
## Explanation
This approach outputs the string in order directly. `for` each char in the reference (`\(...)`) to `@@` (which is set to `A..Z`), this runs the loop once for each letter, `@@`'s final index is decremented by the result of outputting (`say`, includes a final newline) `$"` (space) 'the final index of `@@` times', followed by the `reverse` of `@@`. Using the return from `say` as the decrement means that the output happens before the final index is removed avoiding the need to add another entry to the list. So in the first iteration this outputs 25 spaces and `Z` to `A`, then 24 spaces and `Y` to `A` ... then 1 space and `BA` and 0 spaces and `A`.
I feel like it should be possible to remove some syntax here. I played around with a way to define a list that shrinks but doesn't stop the loop halfway through and the `\(...)` seems to do just that, whereas `[...]` is seen as one list entry instead. Also trying to find a non-word character that works with the `$#_` notation was trickier than I'd hoped, `@;` - my usual go-to results in evaluation of `$#` (which is removed).
[Try it online!](https://tio.run/##K0gtyjH9/19F2UHXtjixUkWpAsjUKUotSy0qTnVwSMsvitFwcLB11NOL0vz//19@QUlmfl7xf11fUz1DAz0DAA "Perl 5 – Try It Online")
[Answer]
# JavaScript, ~~75~~ 74 bytes
*1 byte saved thanks to [Rick Hitchcock](https://codegolf.stackexchange.com/users/42260/rick-hitchcock)*
```
f=(a=65,b='',c)=>a>90?'':f(a+1,b+' ',c=String.fromCharCode(a)+[c])+`
`+b+c
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYj0dbMVCfJVl1dJ1nT1i7RztLAXl3dKk0jUdtQJ0lbXQEobhtcUpSZl66XVpSf65yRWOQM1KuRqKkdnRyrqZ3AlaCdpJ38Pzk/rzg/J1UvJz9dI01DU/M/AA)
[Answer]
# [Perl 5](https://www.perl.org/), 49 bytes
```
$_=$"x26 .join'',reverse A..Z,Z;say while s/ \S//
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lZFqcLITEEvKz8zT11dpyi1LLWoOFXBUU8vSifKujixUqE8IzMnVaFYXyEmWF////9/@QUlmfl5xf91fU31DAwNAA "Perl 5 – Try It Online")
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 8 bytes
```
G_.<XFo}h-
```
[Try it here!](http://pyke.catbus.co.uk/?code=47+5F+BC+B0+6F+7D+68+2D&input=&warnings=1&hex=1)
```
           -  o = 0
G_         -    reversed(alphabet)
  .<       -   suffixes(^)
    XF     -  for i in ^:
      o    -      o++
       }   -     ^ * 2
        h  -    ^ + 1
         - -   i.lpad(" ", ^)
           - for i in reversed(^):
           -  print i
```
I can see the right language doing this in 6 bytes if they had a builtin for `prepend n spaces to string` as well as what Pyke does
[Answer]
# PHP (63 58 55 bytes)
This is possibly my favorite strange corner of PHP, a corner which it inherits from Perl:
```
for($c=A;$c!=AA;$q="$s$z 
$q",$s.=" ")$z=$c++.$z;echo$q;
```
This outputs the trailing newline, as explicitly permitted. This can be run in `php -r` to save the opening `<?php` needed to put this in a file.
Explanation: when a variable containing the string `'A'` is incremented in PHP, it becomes `'B'` and then `'C'` and so on up until `'Z'` becomes `'AA'`. There is no digit before `'A'` to start with in this madcap algebra, and the decrement operator does not undo it, so we save the incrementally reversed alphabet to `$z` (which defaults to `NULL` which when it gets concatenated with a string behaves like the empty string -- the same happens with `$s` and `$q`). Whitespace is accumulated in `$s` and the whole string is accumulated backwards in variable `$q` which means we have to echo it at the end.
Thanks to [Titus](https://codegolf.stackexchange.com/users/55735/titus) for golfing off my curly braces and telling me that I don't need to take a penalty for inline-evaluation flags like `-r`.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), ~~10~~ 8 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
Z±{Xf}⁰¼
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=WiVCMSU3QlhmJTdEJXUyMDcwJUJD,v=0.12)
[Answer]
# Common Lisp, ~~84~~ 82 bytes
```
(dotimes(i 26)(format t"~v@{ ~}~a
"(- 25 i)(subseq"ZYXWVUTSRQPONMLKJIHGFEDCBA"i)))
```
[Try it online!](https://tio.run/##S87JLC74/18jJb8kMze1WCNTwchMUyMtvyg3sUShRKmuzKFaoa62LpFLSUNXwchUIVNTo7g0qTi1UCkqMiI8LDQkOCgwwN/P18fby9PD3c3VxdnJUSlTU1Pz/38A)
Two bytes less thanks to @Ascii-only!
[Answer]
# Python 3, 71 69 bytes
```
for i in range(26):print(' '*(25-i)+'ZYXWVUTSRQPONMLKJIHGFEDCBA'[i:])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFTITNPoSgxLz1Vw8hM06qgKDOvRENdQV1Lw8hUN1NTWz0qMiI8LDQkOCgwwN/P18fby9PD3c3VxdnJUT060ypW8////wA)
]