[Question]
  [
Inspired by a [meme](https://i.stack.imgur.com/yLbE3.jpg) I saw earlier today.
# Challenge description
Consider an infinite alphabet grid:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...
```
Take a word (`CODEGOLF` in this example) and make it a subsequence of the grid, replacing unused letters by a space and removing letters at the end of the infinite grid altogether:
```
  C           O           
   DE G       O           
           L              
     F
```
# Examples
`STACKEXCHANGE`
```
                  ST      
A C       K               
    E                  X  
  C    H                  
A            N            
      G                   
    E
```
`ZYXWVUTSRQPONMLKJIHGFEDCBA`
```
                         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
```
`F`
```
     F
```
`ANTIDISESTABLISHMENTARIANISM`
```
A            N     T      
        I                 
   D    I         S       
    E             ST      
AB         L              
        I         S       
       H    M             
    E        N     T      
A                R        
        I                 
A            N            
        I         S       
            M
```
# Notes
* Trailing whitespaces are allowed.
* You don't need to pad the last any line with spaces. For example, if the input is `ABC`, you may output just `ABC` without 23 trailing spaces.
* You may assume input will match `[A-Z]+` regex.
* Alternatively, you may use lower-case alphabet, in which case output will match `[a-z]+`.
* You must use a newline (`\n`, `\r\n` or equivalent) to separate lines, that is a list of strings is not a proper output format.
* This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, so make your code as short as possible!
  
[Answer]
# [Husk](https://github.com/barbuz/Husk), 15 bytes
```
TṪS`?' €…"AZ"ġ>
```
[Try it online!](https://tio.run/##yygtzv7/P@ThzlXBCfbqCo@a1jxqWKbkGKV0ZKHd////Hf1CPF08g12DQxydfDyDPXxd/UIcgzwd/TyDfQE "Husk – Try It Online")
## Explanation
```
TṪS`?' €…"AZ"ġ>  Implicit input, e.g. "HELLO"
             ġ>  Split into strictly increasing substrings: x = ["H","EL","LO"]
        …"AZ"    The uppercase alphabet (technically, the string "AZ" rangified).
 Ṫ               Outer product of the alphabet and x
  S`?' €         using this function:
                   Arguments: character, say c = 'L', and string, say s = "EL".
       €           1-based index of c in s, or 0 if not found: 2
  S`?'             If this is truthy, then c, else a space: 'L'
                 This gives, for each letter c of the alphabet,
                 a string of the same length as x,
                 containing c for those substrings that contain c,
                 and a space for others.
T                Transpose, implicitly print separated by newlines.
```
[Answer]
# Java 10, ~~161~~ ~~159~~ 152 bytes
```
s->{var x="";int p=0;for(var c:s)x+=p<(p=c)?c:";"+c;for(var y:x.split(";"))System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ".replaceAll("[^"+y+"]"," "));}
```
-2 bytes thanks to *@Nevay*.  
-7 byte printing directly instead of returning a String, and converting to Java 10.
**Explanation:**"
[Try it here.](https://tio.run/##rZBdb4IwGIXv9yve9KqESXYtY0sFRBSKCn7HJV3VDYdAAI3E@NtZ/ciu3B1Ne/Geps85p1t2YI3t6qfiEctzcFkYn54AwrhYZxvG10AvI8AhCVfAMf9m2WIJuaQK9SyO2HnBipADhRg0qPLG2@nAMjhqCKkCA6n2om6SDF9E3sylo6ylrzjVuPTOm0hFMv@7LptHJU@jsMBClyS/zIv1Tkn2hZJmAhXFGJGWbphtq2N3e45Lvf5g6Aej8WQ6myMlW6eRiEyiCKPFB5JLGS3RMwKBUs@Vekub7j8jkfYe@lprJ0pjvxAWX6Ibk26NY4VjpHuGaXlOGylFoovuJMtYiaVrfYBHARv/LXR/dOX6AdF75lTvEGqZdcPns@lkPAr84aDvUdfpde2O1TYNvUXqdgrqBhIa2Ibtm@J/Wo7td1yTBmRoE2r7bt1eLeI4nkcfYc9P5@oX)
```
s->{                      // Method with String parameter and no return-type
  var x="";               //  Temp-String
  int p=0;                //  Previous character (as integer), starting at 0
  for(var c:s)            //  Loop (1) over the characters of the input
    x+=p<(p=c)?           //   If the current character is later in the alphabet
                          //   (replace previous `p` with current `c` afterwards)
        c                 //    Append the current character to Temp-String `x`
       :                  //   Else:
        ";"+c;            //    Append a delimiter ";" + this character to Temp-String `x`
  for(var y:x.split(";")) //  Loop (2) over the String-parts
    System.out.println(   //   Print, with trailing new-line:
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          //    Take the alphabet,
        .replaceAll("[^"+y+"]"," "));}
                          //    and replace all letters not in the String-part with a space
```
The first part of the method splits the input-word into parts with a delimiter.  
For example: `CODEGOLF` → `CO;DEGO;L;F` or `BALLOON` → `B;AL;LO;O;N`.
The second part loops over these parts, and uses the regex `[^...]` to replace everything that isn't matched with a space.  
For example `.replaceAll("[^CO]"," ")` leaves the `C`, and `O`, and replaces everything else with a space.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 69 bytes
```
i;f(char*s){for(i=64;*s;putchar(*s^i?32:*s++))i+=i^90?1:puts("")-26;}
```
[Try it online!](https://tio.run/##hY5Ba8IwAEbv/orQU9IScG4IM0hJ29hmtqmaurkhgnTrlsOiJNWL@Nu7yO72@r734Kvxd113nSINrH/2xrfo0hwMVNPxE/EtOZ7aG4a@3anwcTTxbRAgpIKp2j0Pw4eJ2y30PIRHY3LtlG7B715peD6oTwQuAwAa6MVlwtIyn3mIOHA0znJ0qzHGW32D/5qsaDxnmzijImU97sf75u11XcnVclGKIp@/8CydsSSOaE/Yd4KKiidcMncmyrnMCiYquuJUcFncS81XezIaDMng2v0B "C (gcc) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~24~~ 23 bytes
```
''jt8+t1)wdh26X\Ys(26e!
```
Uses lowercase letters.
Try it at [MATL Online!](https://matl.io/?code=%27%27jt8%2Bt1%29wdh26X%5CYs%2826e%21&inputs=stackexchange&version=20.4.1)
### Explanation
```
''     % Push empty string
jt     % Push input string. Duplicate
8+     % Add 8 to each char (ASCII code). This transforms 'a' 105,
       % 'b' into 106, which modulo 26 correspond to 1, 2 etc
t1)    % Duplicate. Get first entry
wd     % Swap. COnsecutive differences.
h      % Concatenate horizontally
26X\   % 1-based modulo 26. This gives a result from 1 to 26
Ys     % Cumulative sum
(      % Write values (converted into chars) at specified positions
       % of the initially empty string
26e    % Reshape into a 26-row char matrix, padding with char 0
!      % Transpose. Implicitly display. Char 0 is shown as space
```
[Answer]
# [Perl 5](https://www.perl.org/), 44 bytes
**40 bytes code + 4 for `-lF`.**
```
print map/$F[0]/?shift@F:$",A..Z while@F
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvRCE3sUBfxS3aIFbfvjgjM63Ewc1KRUnHUU8vSqE8IzMn1cHt/39nfxdXd38ft3/5BSWZ@XnF/3Vz3AA "Perl 5 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 92 bytes
```
f=lambda x,y=65:x and(y<=ord(x[0])and" "*(ord(x[0])-y)+x[0]+f(x[1:],-~ord(x[0]))or"\n"+f(x))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P802JzE3KSVRoUKn0tbM1KpCITEvRaPSxja/KEWjItogVhPIV1JQ0tKAC@hWamqDGNppQL6hVayObh1cTjO/SCkmTwkkpan5v6AoM69EI01DydnfxdXd38dNSVOTCyzIBZdy9AvxdPEMdg0OcXTy8Qz28HX1C3EM8nT08wz2BSr/DwA)
[Answer]
# JavaScript (ES6), 79
*Edit* As a leading newline is accepted, I can save 2 bytes
```
s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")
```
For 1 byte more, I can accept lowercase or uppercase input:
```
s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\n`")
```
*Less golfed*
```
s=>{
  var i,o,c,v
  for(o = '', v = 1, i = 0; c = s.charCodeAt(i); v %= 27)
    o += v++ ? c-63-v ? ' ' : s[i++] : '\n'
  return o
}  
```
**Test**
```
f=s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")
function update() {
  var i=I.value
  i=i.replace(/[^A-Z]/gi,'').toUpperCase()
  O.textContent=f(i)
}
update()
```
```
<input id=I value='BALLOON' oninput='update()' >
<pre id=O></pre>
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~18~~ 16 bytes
*-2 bytes thanks to @Shaggy*
```
;ò¨ £B®kX ?S:Z
·
```
Uppercase input only.
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=O/KoIKNCrmtYID9TOloKtw==&input=IkFOVElESVNFU1RBQkxJU0hNRU5UQVJJQU5JU00i)
## Explanation
```
;
```
Switch to alternate variables, where `B` is the uppercase alphabet.
```
ò¨
```
Split the input string between characters where the first is greater than or equal to (`¨`) the second.
```
£
```
Map each partition by the function, where `X` is the current partition.
```
B®
```
Map each character in the uppercase alphabet to the following, with `Z` being the current letter.
```
kX
```
Remove all letters in the current partition from the current letter. If the current letter is contained in the current partition, this results in an empty string.
```
?S:Z
```
If that is truthy (not an empty string), return a space (`S`), otherwise return the current letter.
```
·
```
Join the result of the previous line with newlines and print the result.
[Answer]
# C (gcc), ~~91~~ 63 bytes
-28 thanks to ASCII-only
```
_;f(char*s){for(_=64;*s;)putchar(++_>90?_=64,10:*s^_?32:*s++);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/eOk0jOSOxSKtYszotv0gj3tbMxFqr2FqzoLQEJK6hrR1vZ2lgDxLXMTSw0iqOi7c3NgLS2tqa1rX/cxMz8zSAWjWUgkMcnb1dI5w9HP3cXZVAcgA)
---
Previous:
```
i,j;f(char*s){while(s[i]){for(j=65;j<91;j++)s[i]==j?putchar(s[i++]):printf(" ");puts("");}}
```
Yes, there's a shorter solution, but I noticed after I wrote this one... [Try it online!](https://tio.run/##S9ZNT07@/z9TJ8s6TSM5I7FIq1izujwjMydVozg6M1azOi2/SCPL1szUOsvG0tA6S1tbEyRua5tlX1BaAtIAUqetHatpVVCUmVeSpqGkoKRpDZQr1lACMmpr/@cmZuZpAA3SUIqKjAgPCw0JDgoM8Pfz9fH28vRwd3N1cXZyBKn8DwA)
[Answer]
# Pyth, 18 bytes
```
#pbVGp?JqhzNNd=>zJ
```
[Try it here.](http://pyth.herokuapp.com/?code=%23pbVGp%3FJqhzNNd%3D%3EzJ&input=antidisestablishmentarianism&debug=0)
Leading newline in output, lowercase alphabet.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 bytes
```
<2\¬0;œṗfȯ⁶$¥€@€ØAY
```
[Try it online!](https://tio.run/##y0rNyan8/9/GKObQGgPro5Mf7pyedmL9o8ZtKoeWPmpa4wDEh2c4Rv7//9/RL8TTxTPYNTjE0cnHM9jD19UvxDHI09HPM9gXAA "Jelly – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 18 bytes
```
ćIgµ¶?AvDyÊið?ë¼?ć
```
[Try it online!](https://tio.run/##ASwA0/8wNWFiMWX//8SHSWfCtcK2P0F2RHnDimnDsD/Dq8K8P8SH//9jb2RlZ29sZg "05AB1E – Try It Online")
Got trouble with 05AB1E `ć` (extract 1) leaving an empty string/list on the stack after the last element is extracted. This solution would be 1-2 bytes shorter if it weren't for that. 
```
ćIgµ¶?AvDyÊið?ë¼?ć  Implicit input 
ć                   Extract the 1st char from the string
 Igµ                While counter != length of the string
    ¶?              Print a newline
      Av            For each letter of the lowercased alphabet
        DyÊ         Is the examined character different from the current letter?
           ið?      If true, then print a space
              ë¼?ć  Else increment the counter, print the letter and push
                    the next character of the string on the stack
```
[Answer]
# Mathematica, 101 bytes
```
StringRiffle[
  Alphabet[]/.#->" "&/@
   (Except[#|##,_String]&@@@
     Split[Characters@#,#==1&@*Order]),"
",""]&
```
[`Split`](http://reference.wolfram.com/language/ref/Split.html) the input into strictly increasing letter sequences, comparing adjacent letters with [`Order`](http://reference.wolfram.com/language/ref/Order.html). If `Order[x,y] == 1`, then `x` precedes `y` in the alphabet and thus can appear on the same line.
For each sequence of letters, create a pattern to match strings [`Except`](http://reference.wolfram.com/language/ref/Except.html) for those letters; `#|##` is a shorthand for [`Alternatives`](http://reference.wolfram.com/language/ref/Alternatives.html). Replace letters of the [`Alphabet`](http://reference.wolfram.com/language/ref/Alphabet.html) that match the pattern with spaces.
---
Illustration of the intermediate steps:
```
"codegolf";
Split[Characters@#,#==1&@*Order]  &@%
Except[#|##,_String]&@@@         #&@%
Alphabet[]/.#->" "&/@               %
```
```
{{"c", "o"}, {"d", "e", "g", "o"}, {"l"}, {"f"}}
{Except["c" | "c" | "o", _String], 
 Except["d" | "d" | "e" | "g" | "o", _String], 
 Except["l" | "l", _String],
 Except["f" | "f", _String]}
{{" "," ","c"," "," "," "," "," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," ","d","e"," ","g"," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," "," "," "," "," "," "," ","l"," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," ","f"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}
```
[Answer]
# [Zsh](https://www.zsh.org/), 65 bytes
***-4 bytes** thanks to @pxeger, **-2 bytes** thanks to @roblogic*
```
repeat $#1;echo&&for y ({A-Z})printf ${(Ml:1:)1[1]%$y}&&1=${1#$y}
```
~~[Try it online!](https://tio.run/##qyrO@J@moanxPy2/SEFDw1rZ0FpTs7rYlgvEr1TQqHbU04uq1SzWtlWpVqnW8NU0jDaMVVWprLXSjVGoVVMzBIobKgP5XDY2NirFtf81udIUIl19fPzD/wMA "Zsh – Try It Online")
[Try it online!](https://tio.run/##ldDNSgMxFAXgfZ7iQsZpsphCcJfWRcHZtYi6EP8WaSZpAjUpya0yDn32cYIirkSzOrkQznfznt1oGWejjQkYW1Cx4NxoF@u6THpgw2o@fzjxQ/IBLVQD2@ylkFw8iuezqj/VtbioBkGnOHJi4b5dr6/uSDmUUrhpV5ebFiglcrmcXc8IuVWvBgRse8hvHrXzYQc2xRfImErWMWiFJij0MQBG@GyWhPyZWJDfQNk8wU/ll@C8CPbGYnNQXVeKjdJumiCaVGrVlMMOHUQ7cX3IaFRXLvm4zejxiOWRR5i2cCCbf/h@@cIP "Zsh – Try It Online")~~
[Try it online!](https://tio.run/##ldBPS8MwGAbwez7FC6lde@ggeOvmYWBvG6IexD87pGmyBGpSkndKLfvsNUGR4UEwp@cNhOf35iPoOUh0A0LruZBC9EQVZTF7OUiOkFG2kkK7PFfOwwjFtKmeTuXgjUUF2VTs@prVJXtm@4tsPOU5u8omRmOcS6Lgsdlubx5IOpRSuGs217sGKCX1er24XRByz98kMGhHCO8GhTb2AMq7VwjoUxbOCo7ScjTOAjr4aq4JSZ6iWEVfWf4SLpfnxIT8AdbVC5wrvwWXSdBLhdXAuy4VSy50vEGUPtXymO0BNTgVucYGlLxLQzi2AQ0eMT0yCHELDXX1D98fX/gJ "Zsh – Try It Online")
Append to `$s` a `(M)` matched letter, `(l:1:)` left-padded to one character, then remove the letter if it matches the start of `$1`.
[Answer]
# Golfscript, ~~22~~ 21 bytes
[Try it online!](http://golfscript.apphb.com/?c=OyJDT0RFR09MRiIKey5uPnt9eycKJ1x9aWY6bn0lOm47)
*-1 byte thanks to careful final redefining of the `n` built-in.*
```
{.n>{}{'
'\}if:n}%:n;
```
Explanation (with a slightly different version):
```
{.n>{}{"\n"\}if:n}%:n; # Full program
{                }%    # Go through every character in the string
 .n>         if        # If ASCII code is greater than previous...
                       # (n means newline by default, so 1st char guaranteed to fit)
    {}                 # Do nothing
      {"\n"\}          # Else, put newline before character
               :n      # Redefine n as the last used character
                   :n; # The stack contents are printed at end of execution
                       # Literally followed by the variable n, usually newline
                       # So because n is by now an ASCII code...
                       # ...redefine n as the new string, and empty the stack
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 80 bytes
```
^
;¶
{`;.*
¶;ABCDEFGHIJKLMNOPQRSTUVWXYZ
¶¶
¶
)+`;(.*)(.)(.*¶)\2
$.1$* $2;$3
;.*
```
[Try it online!](https://tio.run/##K0otycxL/P8/jsv60Dau6gRrPS2uQ9usHZ2cXVzd3D08vbx9fP38AwKDgkNCw8IjIqOAskCFQKSpnWCtoaelqaEHRFqHtmnGGHGp6BmqaCmoGFmrGHOBTPr/39EvxNPFM9g1OMTRyccz2MPX1S/EMcjT0c8z2BcA "Retina – Try It Online")
There is always exactly one leading newline. The code somewhat clunkily prepends the word with the alphabet along with a marker (semicolon). It then moves the marker up to the first letter of the word, while changing all other letters it passes into spaces. It also removes the first letter of the word. It repeats this until the first letter of the word isn't after the marker anymore. Then it clears that marker and the rest of the alphabet, and replaces it with a new line and the alphabet with a marker again. It keeps repeating this until the input word is empty, then it cleans up the last alphabet and marker, leaving the desired output.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~87~~ 85 bytes
```
def f(s,l=65):c,*t=s;o=ord(c)-l;return o<0and'\n'+f(s)or' '*o+c+(t and f(t,o-~l)or'')
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PyU1TSFNo1gnx9bMVNMqWUerxLbYOt82vyhFI1lTN8e6KLWktChPId/GIDEvRT0mT10bqFozv0hdQV0rXztZW6NEASgBNKJEJ1@3Lgcko675v6AoM69EI01D3dHJWV1T0xrC1@SCizs7OWIVd3L08fH390OS@w8A "Python 3 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~130~~ 126 bytes
```
$
¶A
{-2=`
$'
}T`RL`_o`.$
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
}`¶.*$
```
[Try it online!](https://tio.run/##K0otycxL/P9fhevQNkeual0j2wQuFXWu2pCEIJ@E@PwEPRUu7QQNextbDT1NLU0NIKmndWgbUEDX0A4oomGvYaipYa@oqamnHWOsp6WiyaWgYsSFTwOIAVGqCbQTqLg24dA2IJfr/39HvxBPF89g1@AQRycfz2APX1e/EMcgT0c/z2BfAA "Retina – Try It Online") Edit: Saved 4 bytes by using @MartinEnder's alphabet generator. Explanation:
```
$
¶A
{-2=`
$'
}T`RL`_o`.$
```
Append the alphabet.
```
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
```
Align as many letters as possible with their position in the alphabet.
```
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
```
Start a new line before the first letter that could not be aligned.
```
}`¶.*$
```
Delete the alphabet, but then do everything over again until there are no misaligned letters.
[Answer]
# [J](http://jsoftware.com/), 39 bytes
```
(_65+3 u:[)}&(26{.'')/.~0+/\@,2>:/\3&u:
```
[Try it online!](https://tio.run/##Zc5BC4IwAMXxu5/iHcJNJk6UPIyKvkdGzBo40W24eYr66otFt84P3v83xeiOAvTW7VmLTVyKV06b7lkRUvDqXTPen8vmJHjf5puI6j5aHByC3ZxTK8gg59laQ7K/RZqgH9orH@Qwaz8uygS5amm0X0iWoumb1ijRIAWQCgW@FjAkDX6cHUHi4Bo/)
[Answer]
# [q/kdb+](http://kx.com/download/), ~~48~~ 45 bytes
**Solution:**
```
-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:;
```
[Try it online!](https://tio.run/##y9bNz/4f6Gil5Ojk7OLq5u7h6eXt4@vnHxAYFBwSGhYeERml9D/BwKraIdrITFlJQck60NG@wtrKuiK21kHfSkOtTsNO3UqzQjO@wkrJydHHx9/fT8n6/38A "K (oK) – Try It Online")
**Note:** Link is to a [K (oK)](https://github.com/JohnEarnest/ok) port of this solution as there is no TIO for q/kdb+.
**Examples:**
```
q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"STACKEXCHANGE";
                  ST
A C       K
    E                  X
  C    H
A            N
      G
    E
q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"BALLOON";
 B
A          L
           L  O
              O
             N
```
**Explanation:**
Q is interpreted right-to-left. The solution is split into two parts. First split the string where the next character is less than or equal to the current:
`"STACKEXCHANGE"` -> `"ST","ACK","EX","CH","AN","G","E"`
Then take a string of 26 blanks, and apply the input to it at the indices where the input appears in the alphabet, and print to stdout.
`"__________________________"` -> `__________________ST______`
Breakdown:
```
-1{@[26#" ";.Q.A?x;:;x]}each(0,where (<=':)x) cut x:; / ungolfed solution
-1                                                  ; / print to stdout, swallow return value
                                                  x:  / store input as variable x
                                              cut     / cut slices x at these indices
                            (               )         / do this together
                                     (<=':)x          / is current char less-or-equal (<=) than each previous (':)?
                               where                  / indices where this is true
                             0,                       / prepended with 0
                        each                          / take each item and apply function to it
  {                    }                              / lambda function with x as implicit input
   @[      ;      ; ; ]                               / apply[variable;indices;function;arguments]
     26#" "                                           / 26 take " " is "      "...
            .Q.A?x                                    / lookup x in the uppercase alphabet, returns indice(s)
                   :                                  / assignment
                     x                                / the input to apply to these indices
```
**Notes:**
* -3 bytes by replacing prev with the K4 version
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
Ｆθ«Ｊ⌕αι⁺ⅉ‹⌕αιⅈι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBo1BToZqL06s0tyAkX8MtMy9FI1FHIVNTRyEgp7RYI1IDyPJJLS5GkYrQ0AQCay7OgKLMvBKNTCCz9v9/R78QTxfPYNfgEEcnH89gD19XvxDHIE9HP89g3/@6ZTkA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 θ              Input string
Ｆ «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   Ｊ            Jump to aboslute position
              ι Print current character
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 20 bytes
```
⊃¨⎕a∘.∩⍨⊢⊂⍨1,2≥/⎕a⍳⊢
```
[Try it online!](https://tio.run/##rZXLTsJAFIb3PMXZDSR4Xbob2oEOl3Jpue4aLoZIggE3xrhBYwBTowsT1yQm6Na4cemjzIvgBLBSKJyi/otmOvP1zMzp/Ges09ZO7dxqtY93qi2r221WJ@LusdkWN/f7k4Z8iuHV51h2WaL/tCv6L8Iei@FIDHuycRA@FIPnvemo/Sa7J5Mz@cmFsN/FYNSRzYawP45Iw2q2SLAm7Ff5Kgc7IXF7Tdon5DIQqMN0kh4BUOBH6YU2CdTDDgQqgxgKfSsJLi1DUfAQCRAlrbJYOhklcjsPddcil2WYK6Gps5MEbJyfrYYrLUHTSJrXIhemW5C@abtO4rZb0ywnhkmVBCspGtVjzEdi5qp4/xiXyoBDJcChIuBQAXAoDzhkAg4ZgEM5wKEs4FAGcAj3C3aAZkoB/NV5fuwxVRxwiAMOaYBDPuyxrmT48pCrjAEOKYBDEcAhCushUimXioW8aeSymbSeSibiXItFmapEqGNyGSaMJSAYJlESWi4LHrXJ/PVvVN2Q4Sf5XuU5ssUh5T7MrKGeYFgK6DZlgf/TbeBvd56OJ1Q3ucoNJm@FSJIbWorpJs1xqnMjNT83Xw "APL (Dyalog Classic) – Try It Online")
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~29~~ 28 bytes
```
{{x@x?`c$65+!26}'(&~>':x)_x}
```
[Try it online!](https://tio.run/##pZRPa8JAEMXvforXIFUpvRTqIYG2m2RNVk2iJmpUpJaCpVgsiIeI6FdP/W/UZGLbdwr82N2ZyXszuh9/jMNwKM/nwUvwPHjPFh/vbh6Ki1z@dvmUk4PCa7AIp/I825stJ/IQQKAMvkdKfjB8@/xSAmWmTAr9RWbakzRH54ZTLUkZIC8BGo5yIt9rjhWHzmFQfK8qThThJcRIKvTX5bge0yrc10xmG3xf07lcL3onO9RcQdKb/PIS/8g3582Ymnb3R2Qn9HSYydXvH3vudvx2q@m5jXrNsa1qpSxMo8R1TWVJA9ipezH0E3VAch8kb4PkLZC8CZJ7ILkLkjdA8jpIXgPJSVMTBtjKAv4WihQDb1QGyQVIboLktIETQptm8MPSAMk1kFwFyVliQHYBY7YndOHy1XJRq8I1LW57rCGYLVxrG7GYjHu/HLF@yt2UEZ3tMPU6iwg6IiZlQU70x66MmPjXjkytPy5Cq18Y/gA "K (ngn/k) – Try It Online")
`{` `}` function with argument `x`
`>':x` for each char, is it greater than the previous char?
`~` negate
`&` where (at which indices) do we have true
`(` `)_x` cut `x` at those indices, return a list of strings
`{` `}'` for each of those strings
```
`c$65+!26
```
the English alphabet
`x?` find the index of the first occurrence of each letter in `x`, use `0N` (a special "null" value) if not found
`x@` index `x` with that; indexing with `0N` returns `" "`, so we get a length-26 string in which the letters from `x` are at their alphabetical positions and everything else is spaces
[Answer]
# [R](https://www.r-project.org/), ~~129~~ 117 bytes
```
function(s){z={}
y=diff(x<-utf8ToInt(s)-64)
z[diffinv(y+26*(y<0))+x[1]]=LETTERS[x]
z[is.na(z)]=" "
write(z,1,26,,"")}
```
[Try it online!](https://tio.run/##XY5Ba8IwAIXv/RUlXpKZDpVRPDSHOOMWiC2YnNb1UGoDAUmlja6t@Nu7CJ68Pd734HvtpMMkmvTFVs40FnboNpLbPRjI0WgN@yS6OL1WDbfOsyj@QMGYP5CxVzjMV/EbHJIFQvM@XxYFEUwpdpB5X/iZ6d5tCUdUEBCC4K81roYjXuJVjDEA6D5pCD6zLfvKxA6goCodBL/WJ9/TVPEtl0wquhFcfu9ZquiB05TL/et2Q4XIsvSlPped97X1FT5PIVw1p1N57mri7SicheAnomD6Bw "R – Try It Online")
Explanation (ungolfed):
```
function(s){
 z <- c()                  # initialize an empty vector
 x <- utf8ToInt(s)-64      # map to char code, map to range 1:26
 y <- diff(x)              # successive differences of x
 idx <- cumsum(c(          # indices into z: cumulative sum of:
    x[1],                  # first element of x
    ifelse(y<=0,y+26,y)))  # vectorized if: maps non-positive values to themselves + 26, positives to themselves
 z[idx] <- LETTERS[x]      # put letters at indices
 z[is.na(z)] <- " "        # replace NA with space
 write(z,"",26,,"")        # write z as a matrix to STDOUT ("") with 26 columns and empty separator.
```
[Answer]
# [R](https://www.r-project.org/), 95 bytes
Just run through the upper case alphabet repeatedly while advancing a counter by 1 if you encounter the letter in the counter position of the word and printing out the letter, a space otherwise.
```
function(s)while(F>""){for(l in LETTERS)cat("if"((F=substr(s,T,T))==l,{T=T+1;l}," "));cat("
")}
```
[Try it online!](https://tio.run/##LcrLCoJAFIDhvU8hZzWHbNHaDCYddcpLOafrrqQhQRS80EJ8dotq@fN/zaSX80n3Vd4VdcVafD2L8sH8FQAOum5YaRaVGQkikSnMbx2DQgNjvtP297ZrWGuRRYiOU1oDOTRb2OVogQmI9lcbgOOkGbipJ4I08gGNT10v59PxQCrb79IkjrYbGQa@8Nw1//0/4wlJTyqhiK8jqcJYJMQzyROpYsDpDQ "R – Try It Online")
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 37 bytes
```
64:a;{.a>{}{'
'\64:a;}if.a-(' '*\:a}%
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/38zEKtG6Wi/Rrrq2Wp1LPQbMr81M00vU1VBXUNeKsUqsVf3/39HJ2cXVzd3D08vbx9fPPyAwKDgkNCw8IjIqKjIiPCw0JDgoMMDfz9fH28vTw93N1cXZyREA "GolfScript – Try It Online")
I did a Golfscript one under a different name, but it had incorrect output.
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-n`, 62 bytes
Scans the input string for sequences of increasing letters, and for each sequence, replace letters not in the sequence with spaces.
```
g=*?A..?Z
$_.scan(/#{g*??}?/){puts g.join.tr"^#$&"," "if$&[0]}
```
[Try it online!](https://tio.run/##NcvbCoIwAIDh@z1FLImSWr1AjKlLl3Mrt85UVJDYhYaHixBfvRVB//X3F/X1ZUwytTFBCO@BdUbl7ZL1x90msTFu8XjQPOuq7CTokacZqgp46lo9OIQdmN6t3mFybM0PwNE/aFzpUV/yGVCauCHdugERPgX73XazXmkVLxdSRDycs8CfUc91CCBCM48p@h0czlQQUaFJzIhgKgIO4VxK8c6fVZpnpRllHw "Ruby – Try It Online")
[Answer]
# Powershell, ~~70~~ 63 bytes
*-7 bytes thanks @Veskah*
```
$args|%{if($_-le$p){$x;rv x}
$x=("$x"|% *ht($_-65))+($p=$_)}
$x
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/V8lsSi9uEa1OjNNQyVeNydVpUCzWqXCuqhMoaKWS6XCVkNJpUKpRlVBK6MEpMDMVFNTW0OlwFYlXhMk/x9I5CrYKig5@7u4uvv7uClxqamkKTjk/v8PAA "PowerShell – Try It Online")
Explanation:
For each character in the splatted argument:
* Output string `$x` and clear `$x` value (`rv` is alias for [Remove-Variable](https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Utility/Remove-Variable)), if a code of the current character less or equivalent (`-le`) to a code of the previous character.
* Append spaces and the current character to `$x`, store it to `$x`. Also it freshes a previous character value.
Output last `$x`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~21~~ ~~19~~ 17 bytes
```
Çü@0šÅ¡vð₂×yAykǝ,
```
[Try it online!](https://tio.run/##AUIAvf9vc2FiaWX//8OHw7xAMMWhw4XCoXbDsOKCgsOXeUF5a8edLP//Y29kZWdvbGZhbmRwcm9ncmFtbWluZ3B1enpsZXM "05AB1E – Try It Online")
```
Ç       push a list of ascii values of the input        [84, 69, 83, 84]
ü@      determine which letter is >= the next letter    [1, 0, 0]
0š      prepend a 0 (false) to that list                [0, 1, 0, 0]
Å¡      split input on true values                      [["T"], ["E", "S", "T"]]
v       for each list entry
  ð₂×     push 26 spaces
  y       push list entry (letters)
  Ayk     push the positions of that letters in the alphabet
  ǝ       replace characters c in string a with letters b
  ,       print the resulting string
        implicitly close for-loop
```
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 91 bytes
```
A"$>}\$<>~,<.'~<\.';<.>$${}\../<..>=<...-/.$/=*=32;.>~<>"){-\}.>_{A}\\../010<$..>;=~<$@{{Z'
```
More readably:
```
      A " $ > } \
     $ < > ~ , < .
    ' ~ < \ . ' ; <
   . > $ $ { } \ . .
  / < . . > = < . . .
 - / . $ / = * = 3 2 ;
  . > ~ < > " ) { - \
   } . > _ { A } \ \
    . . / 0 1 0 < $
     . . > ; = ~ <
      $ @ { { Z '
```
And with color paths:
[![enter image description here](https://i.stack.imgur.com/56IXI.png)](https://i.stack.imgur.com/56IXI.png)
[Try it online!](https://tio.run/##Fco9C8IwEAbg/1IOgmLfVB1zORr8WoTuciAOpU66Wo7kr8d2eabnPf5e0/cz15oakqzEUnYMV1jhAkOILCvgGZC4gNaDfNzG4yFACkuzsVYz5Gkp6zq7fce07BALU2/2cLWehvPlNtyvfw "Hexagony – Try It Online")
]