[Question]
  [
Given a string as input, print a new string with each letter pushed to the right by its respective alphabet index.
We all know that A is a slow and Z is a fast letter. This means that Z gets shifted to the right by 25 spaces, A doesn't get shifted at all and B gets shifted by 1 space.
Your program only has to handle uppercase letters from A-Z, and no other characters, no whitespaces, no punctuation.
Note that if 2 or more letters fall onto the same space after shifting, the latest character will be used. (Example: `BA` -> `A`) 
## Examples
```
"AZ" -> "A                         Z"
"ABC" -> "A B C"
"ACE" -> "A  C  E"
"CBA" -> "  A"
"HELLOWORLD" -> "     E H    DLL   OLO   R  W"
```
## Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in any language bytes wins.
* Standard loopholes are forbidden.
* Input must be received as a string.
* You may print the result to `stdout` or return a string.
* A *single* trailing whitespace and/or newline is allowed.
* You may also use lowercase letters as input or output, but only use either case.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 81 bytes
```
t=[]
i=65
for c in input():t+=[' ']*26;t[ord(c)-i]=c;i-=1
print`t`[2::5].rstrip()
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8Q2OpYr09bMlCstv0ghWSEzD4gKSks0NK1KtG2j1RXUY7WMzKxLovOLUjSSNXUzY22TrTN1bQ25Cooy80oSShKijaysTGP1iopLijILNDT//1f3cPXx8Q/3D/JxUQcA "Python 2 – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
''jtfy65-+(
```
[Try it online!](https://tio.run/##y00syfn/X109qySt0sxUV1vj/38PVx8f/3D/IB8XAA) Or [verify all test cases](https://tio.run/##y00syfmf8F9dPaskrdLMVFdb479LyH/HKC5HJ2cuR2dXLmcnRy4PVx8f/3D/IB8XAA).
### Explanation
MATL indexing is 1-based. [This golfing trick](https://codegolf.stackexchange.com/a/133943/36398) is used here. [This other one](https://codegolf.stackexchange.com/a/86227/36398) cannot be used because we need an empty string, not an empty numeric array.
Consider input `'ACE'` as an example. Stack contents are shown bottom to top.
```
''     % Push empty string
       %   Stack: ''
j      % Input string
       %   Stack: '', 'ACE'
t      % Duplicate
       %   Stack: '', 'ACE', 'ACE'
f      % Indices of nonzero entries. Gives [1 2 ... n] where n is input length
       %   Stack: '', 'ACE', [1 2 3]
y      % Duplicate from below
       %   Stack: '', 'ACE', [1 2 3], 'ACE'
65     % Push 65
       %   Stack: '', 'ACE', [1 2 3], 'ACE', 65
-      % Subtract, element-wise. Characters are converted to codepoints
       %   Stack: '', 'ACE', [1 2 3], [0 2 4]
+      % Add, element-wise
       %   Stack: '', 'ACE', [1 4 7]
(      % Fill string '' with values 'ACE' at positions [1 4 7]. The original
       % empty string is extended. Non-existing values are filled with char 0,
       % which is displayed as space. Implicitly display
       %   Stack: 'A  C  E'
```
[Answer]
# [R](https://www.r-project.org/), ~~140~~ ~~133~~ ~~129~~ 74 bytes
Saved a ton of bytes porting an ASCII value approach like everyone else. Sad I didn't think of it before :(
```
function(s){F[X-65+1:sum(X|1)]=X=utf8ToInt(s)
F[is.na(F)]=32
intToUtf8(F)}
```
[Try it online!](https://tio.run/##K/qfk5lUlFhUqZGbWpKRn1KsyZWmYKP7P600L7kkMz9Po1iz2i06QtfMVNvQqrg0VyOixlAz1jbCtrQkzSIk3zOvBKiCyy06s1gvL1HDDShlbMSVmVcSkh8KVAAUqP2fpqHuGKUONFdD3dnJUV3zPwA)
### original answer, 129 bytes:
```
function(s){o=rep(' ',(n=nchar(s))+25)
for(i in 1:n){k=substr(s,i,i)
o[x<-i+match(k,LETTERS)-1]=k
F=max(F,x)}
cat(o[1:F],sep='')}
```
[Try it online!](https://tio.run/##HYqxCoMwFAB3v8It72EcLHQRM9iiU6fWqdYhWsVgTSSJYBG/PQ3djrvT7iNazfUX5t6O6m0wGMIsdsMqOyuUBIO7YrpfgISEgmSyG7n2FqPT2b9KgwiFDJNU4j4xs7bG@kwFFRioestiEc3cdiNM9FZUVXF/YJw0bApKNvMNSrrhEXTcgqqTtGyo6RdGCB5uAJI/Cf4beUlP3lwvOUH3Aw "R – Try It Online")
generates a too-long list `o` of spaces, then iterates through `s`, replacing the values in `o` with the correct value and updating `F`, the position of the rightmost character. Then prints out the first `F` elements of `o` with no separators between them.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~20~~ 16 bytes
-4 bytes thanks to Emigna
```
ð₄×svyAuykN+ǝ}ðÜ
```
[Try it online!](https://tio.run/##ASQA2/8wNWFiMWX//8Ow4oKEw5dzdnlBdXlrTivHnX3DsMOc//9BQ0U "05AB1E – Try It Online")
[Answer]
# JavaScript (ES6), 81 bytes
```
s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``
```
Somewhat builds off of [Rick Hitchcock's incomplete answer](https://codegolf.stackexchange.com/a/145265/69583) but ended up rather different.
Places the characters into their respective index of an empty array, then uses array spread (`[...a]`) to turn the missing elements into `undefined`, allowing `map` to replace empty elements with a space.
## Test Cases
```
let f=
s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``
;["AZ", "ABC", "ACE", "CBA", "HELLOWORLD"]
.forEach(t=>console.log(`"${t}"`, "=>", `"${f(t)}"`))
```
[Answer]
## Perl 5, 42 bytes
**41 bytes code + 1 for `-p`. The `\x1b`s in the code are literal escape characters.**
Relies on ANSI escape sequences to position the cursor and therefore doesn't work on TIO.
```
s/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge
```
### Usage
```
perl -pe 's/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge' <<< 'HELLOWORLD'
     E H    DLL   OLO   R  W
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~207~~ ~~191~~ ~~189~~ ~~183~~ ~~178~~ ~~174~~ ~~173~~ 170 bytes
```
s->{char i=0,l,c[]=new char[s.chars().map(j->j+s.lastIndexOf(j)).max().getAsInt()-64];for(;i<s.length();c[i+l-66]=l)l=s.charAt(i++);return"".valueOf(c).replace('',' ');}
```
[Try it online!](https://tio.run/##fY/NasMwEIR7zlMIXyxhW/RQclEcSP9owCXQHHowPqiyksiVZSGt04SQZ3edxqWF0uiyYmZ2lq/iW540VpqqfO9UbRsHqOo12oLSdOYc32fKAxv98f6RV60RoBpDb9Xj8L2UumuMb2vpLmV@eka2fdNKIKG59@iZK4MOHjj00ndosgSnzDpG5zlFWgJIt7RSlihFnU@mB7HhDqn0OtaxyIvUyA90knJPT8NjQmtucZVMq8jT/hTMTSl3ixWuyMna9YG1hJmfG8AkGd8UbNU4zNSkT0uzhg0mTOQq0sl4XKSa6PTcPAOsoogwJ6F1JgjolutW9r2CUCet5kLi8CqMQxQSduzYQDsQbhtVorpnxme0vECcoMMIDW@59yBr2rRAbe@DNvgXO@XW6j0Onh6ybPG6eMnuA0LY1/Lx2H0C "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 41 + (`-F`) = 43 bytes
```
map$r[$i++-65+ord]=$_,@F;print$_||$"for@r
```
[Try it online!](https://tio.run/##K0gtyjH9/z83sUClKFolU1tb18xUO78oJdZWJV7Hwc26oCgzr0QlvqZGRSktv8ih6P9/D1cfH/9w/yAfl3/5BSWZ@XnF/3V9TfUMDA3@67oBAA "Perl 5 – Try It Online")
Just for @lynn
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 127 bytes
```
,[[-<+<+>>]----[----<<->>]<<-[[>]>++++>[-<[-]<+>>]<[-<++++++++>]<[<]>-]>[>]<[-]+[<]>-[[>]<+[<]>-]>.[-]>[>]<[[->>+<<]<]>,]>>[.>]
```
[Try it online!](https://tio.run/##NYyxCgJBEEM/aG7uC0IqBYuFAxuLkEIFQQQLwe9fZ5fzFYFMkrl9rs/343t/9b5IiUCQzkJDgCxbKtGMglVSetYwBjvDwUxTM3BMO3aIPVn1j1VvA3DdF5Na6d5Px9a2y3Zuhx8 "brainfuck – Try It Online")
### Explanation
```
,[                    Take input and start main loop
  [-<+<+>>]             Make two copies of input byte
  ----[----<<->>]<<-    Subtract 64 from one of them to get position in alphabet
                        There are two zero cells between the input and the
                        remaining output cells; we wish to move these zeroes
                        to indicate where the letter is to be moved
  [                     A number of times equal to the position in the alphabet:
    [>]                   Go to current position in output string
    >++++>                Create 4 (as part of creating a space if needed)
    [-<[-]<+>>]           Move output byte back two cells; zero the previous 4 if output existed
    <[-<++++++++>]        Otherwise move a space (32) into that position
    <[<]>-                Move back to counter and decrement
  ]
  >[>]<[-]              Delete last moved byte to make room for input byte
  +[<]>-                Initialize slot at 1 so it is always nonzero in this loop
  [[>]<+[<]>-]          Move input byte into slot
  >.[-]                 Output next output byte and clear
  >[>]<                 Move to space vacated in preparation to remove gap
                        (Moves to end instead if input was A; this causes no problems)
  [[->>+<<]<]           Move values two cells right until zero reached
  >,                    Get into position and take another byte of input
]
>>[.>]                Output characters beyond end of input
```
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 78 bytes
```
x=>{t=[' ']*26*(q=len(x))for i:0..q{t[i+ord(k=x[i])-65]=k}"".join(t).rstrip()}
```
[Try it online!](https://tio.run/##BcGxCsIwEADQXylZelcxiGAH4ZwUHAIFF4eQTQNnJUnPGwKl3x7fK5I1pxapVbqsSr7v@jAcxwEW@r4TVMSYpePzwdplVc@7LC@YqXoOuB9PgebNGPvJnEDRyk@FC@DWinBSiGDuN@em5/RwV4PY2h8 "Proton – Try It Online")
69 bytes by porting Lynn's solution: `x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 bytes
```
ØAiÐ€+JṬ€a"⁸Zḟ€0Ṫ€o⁶
```
[Try it online!](https://tio.run/##y0rNyan8///wDMfMwxMeNa3R9nq4cw2QTlR61Lgj6uGO@UC2wcOdq4BU/qPGbf////dw9fHxD/cP8nEBAA "Jelly – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~90~~ 88 bytes
```
d=drop 1
[a]#s|s<"A"=a:d s|0<1=s
b#s=(s++" ")!!0:d b#d s
f(c:t)=['A'..c]#(' ':f t)
f s=s
```
[Try it online!](https://tio.run/##FckxCoMwFADQPaf4JkMSLKKrmCFaoYNF6FKoSInaUKla8Tt69zRd3vLeBj@vaXJuUMP2XSEhjWkZHphRTZVJB8AjzhKFpGOoBIYhBSqDIPbTMb/Eij7dpWq45lHUt0xw4KmFXRILqNDNZlxAwWzW6xPEuo3LDhFYCQ3VD3qiOi/@FqW3yLX3UlZVfa9v1Zm27gc "Haskell – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 23 bytes
```
;iB ç
Ng £=hX10nY+XnG
U
```
[Test it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=O2lCIOcKTmcgoz1oWDEwblkrWG5HClU=&input=IkhFTExPV09STEQi)
First attempt, may be improvable...
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 76 bytes
```
SparseArray[Reverse@MapIndexed[#&@@#2+LetterNumber@#-1->#&,#]]<>""/. 0->" "&
```
Takes a list of characters as input. This generates some error messages that are safe to ignore.
I included `Print` and `Character` command in the footer of the TIO link for ease of use. (`Character` command simply converts a string to a list of characters)
[Try it online!](https://tio.run/##Dcu7CsIwFADQPV9REgiK1teqhogKCtFKOziEDNf2lnZIKbdR9OtjxzMcD6FBD6EtIdb7SSx6oAEPRPCzOX5whL5Bf@0q/GJlhdRabGYGQ0C6v/0LSYt0nSoh58K5neJ8uUhWqeIJl3G6fVDbBV3rYwME5XgGyxi/nI3JnlluTpwxF/8 "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# J, ~~37~~ 31 bytes
~~`[`]`(' '#~(1+>./)@])}(i.@#+65-~a.&i.)`~~
```
[`]`(' '#~(1+>./)@])}#\-66-3&u:
```
-6 bytes thanks to FrownyFrog
### explanation
The entire thing is a hook:
```
[`]`(' '#~(1+>./)@])}  #\-66-3&u:
```
The right side calculates the new indexes for all the letters.
The left side uses the gerund form of Amend `}` first to create a string of the necessary number of spaces: `(' '#~(1+>./)@])` . And then to place each letter of the original string into its appropriate index within the all-space string.
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/6MTYhM01BXUles0DLXt9PQ1HWI1a5VjdM3MdI3VSq3@a3Ip6Smop9laqSvoKNRaKaQVc3GlJmfkK6QpqDs6u6rDOR6uPj7@4f5BPi7q/wE "J – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 88 bytes
```
foldr(\c->(((['B'..c]>>" ")++[c])#).(' ':))[]
(x:r)#(y:t)|y>' '=y:r#t|1<3=x:r#t
r#t=r++t
```
[Try it online!](https://tio.run/##Hc1BC4IwHAXwu5/izzy4YQrRbTRBTehgCHUI0h1kakVqYy5Q8LO3tMPj93iX9yiHV922ZpB1XQErTPNuK4UL4QUY49yJHN8XPAgQIOK6ueDEJj52wKGE5NzCI1XExhPVZJ6CZWYTVbaet/sdG9dmLWHKdbXpymcPDLpSngDLj75olfbgw/@ZQI7CG9oACqP4T5ysxFG4ckzSNLtm5/SAuPmKpi3vg/GElD8 "Haskell – Try It Online")
[Answer]
## Haskell, 88 bytes
```
f s|q<-zipWith((+).fromEnum)s[0..]=[last$' ':[c|(c,i)<-zip s q,i==p]|p<-[65..maximum q]]
```
[Try it online!](https://tio.run/##XcrBCoIwGADge0/xI4JKOrrUIdxBTeggCF2Exg5DE39yczqFCN99QcddP75BmPdrHK3twexzmnxRN7gOYXiMSL9MslSbjAw7EcIpG4VZ/QCCK2v3sI0x@n8wMMdIqea7ThN2ORMixQflJmHm3EqBCih00wFAL6hW8KEHL3t6DuSFK0XpSJFnjtzLqqqb@lHdPPsD "Haskell – Try It Online")
`q` is the list of the final indices of the letters of the input string (with an offset of `65`). Loop through all indices (starting at `65`) and find all letters for it, prepending a space. Take the last. 
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~117~~ ~~110~~ 84 bytes
Saved 7 bytes thanks to **Ayb4tu**.
Changed return type from `string` to `char[]` to save 26 bytes.
```
n=>{int i=0,l=n.Length;var t=new char[l+26];for(;i<l;)t[i+n[i]-65]=n[i++];return t;}
```
[Try it online!](https://tio.run/##PU/BaoNAED0nXzF4UjRSCs1ls4HUpu3BktAccpA9LNtVB8wIO5uUIn67VQw5zcybN@/NM7wyrbODaTQzHF1bOX2Bbrlgrz0auLX4A18aKWTvkKpCgXYVRxNlcfpjby/p@5XMZl4nYGrtCrWFEuRActsheUD5lDSS0txS5Wtx0w68JPs7k5v4ea1E2bpQ4KYRkS8wpgLVav2i5NjEsRLO@qsj8KIfxGj8@MVotgwSJrEH2EHwugsSCHbZfiqf@zw/nA/f@ds0HY/ZRwD9JDN6Wm1quGcDBqRZMoJ7tqwlbhubnh16myPZsAw5isbrftkP/w "C# (.NET Core) – Try It Online")
[Answer]
# **C# .NET, ~~89 Bytes~~ 87 Bytes**
-2 bytes thanks to [Lan H.](https://codegolf.stackexchange.com/users/72738/ian-h)
```
f=>{var s=new char[f.Length+26];for(int i=0;i<f.Length;i++)s[f[i]+i-65]=f[i];return s;}
```
[Try it Online!](https://tio.run/##VVDBasMwDL33K0ROCWnDGKwX14Uu67ZDRsN26CHkYDwnEbQ2WG7HCPn2LF7WdH0H2XqSnp8laSGNVT0MkAdBBLk1tRXHmWfa3@hBTjiUcDb4CW8CdUjOoq6LEoStKZr6rhMeH9/k1DF5Pmm5GgfmIBthi3IN1UAC7yu@bs/CAnGtvsZilWRK166J75clq4wNUTtAfsdwdSkxjOOIiqrAMsbF8qHk/sqsciergVjX/7fBbkxNzqUgRcDBPzyRLQSPm2AOwSbd@uN1m2W7/e49e/JZnqcvAXS3goNFJWQDfzsBAtSjeHTZQGo0mYNK9hadylCr0H8/pCi6SnWzrv8B)
[Answer]
# Kotlin, ~~207 bytes~~ ~~189 bytes~~ ~~187 bytes~~ 177 bytes
```
fun main(){val i=(readLine()+" ".repeat(26)).toCharArray();for(x in(i.size-1) downTo 0){if(i[x]!=' '){i[x+i[x].toInt()-65]=i[x];i[x]=' '}};print(i.joinToString("").trim())}
```
If the leading blank should remain I would just call `trimEnd()` instead of `trim()`.
**Unminified:**
```
fun main() {
    val m = (readLine() + " ".repeat(26)).toCharArray()
    for (x in (m.size - 1) downTo 0) {
        if(m[x] != ' ') {
            m[x + m[x].toInt() - 65] = m[x]
            m[x] = ' '
        }
    }
    print(m.joinToString("").trim())
}
```
---
Maybe Kotlin is not the best language for code golfing but I liked the challenge and I wanted to make myself more familiar with Kotlin's standard library.
[Answer]
# q/kdb+, 37 bytes
**Solution:**
```
@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:
```
**Examples:**
```
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"AZ"
"A                         Z"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ABC"
"A B C"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ACE"
"A  C  E"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"CBA"
"  A"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"HELLOWORLD"
"     E H    DLL   OLO   R  W"
```
**Explanation:**
I think this is the same idea as the J solution, calculate the correct indices for the input array and then assign them to an empty string of correct length:
```
@[max[1+m]#" ";m:til[count x]+.Q.A?x;:;]x: / ungolfed solution
                                        x: / save input as x
@[            ;                     ; ;]   / apply[variable;indices;function;parameters]
                                     :     / assignment
                              .Q.A?x       / location of x in uppercase alphabet
                             +             / added to
                     count x               / length of input
                 til[       ]              / range, 0..n
               m:                          / save as m
  max[   ]                                 / maximum of list
      1+m                                  / m + 1
          #" "                             / take " ", creates empty character list
```
[Answer]
# [Jq 1.5](https://stedolan.github.io/jq/), 91 bytes
```
reduce(explode|[.,keys]|transpose[]|.[1]+=.[0]-65)as[$c,$p]([];.[$p]=$c)|map(.//32)|implode
```
Expanded
```
  reduce(  explode         # convert string to array of ordinals
         | [.,keys]        # [ [v0,v1,...], [0,1,2,...] ]
         | transpose[]     # [ [v0,0], [v1,1], [v2,2]...]
         | .[1]+=.[0]-65   # adjust position of each value
  ) as[$c,$p] (
    []
  ; .[$p]=$c               # store each value at its position
  )
| map(.//32)               # map null values to spaces
| implode                  # convert back to string
```
[Try it online!](https://tio.run/##HYxNC8IgAIb/y9jB0XR9UJfYYVuDDoNBlyD1IJsHy6lNRwX@9ky6vDwPPLz3Z0iqG1FV3cRpWqKauiLq3HZdf@0v3YmoxFsjhQNJxAxTH2Y@LgMH/G2kHrnHKH/wj6XezUxZoy2PEcIbuioRXlN42GfM4nTIU0MBpkeEI5TpkPmJGYCKYrfNvJj@ZyF8tXFCKxsgVIuUUCizuCgze0G9uCg/ "jq – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
Ｐ ＦＳ«Ｍ⌕αι→ιＭ⌕αι←
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@3NKcks6AoM69EQ0lBSdOaKy2/SEHDM6@gtCS4BCicrqGpqVDNxembX5aq4ZaZl6KRqKOQqamjYBWUmZ5RAtTAGQDWnQliYqrySU0DKar9/9/D1cfHP9w/yMflv25ZDgA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｐ                   Output a space to force the indent
   Ｓ                Input string
  Ｆ «               Loop over each letter
       α            Uppercase letters predefined variable
      ⌕ ι           Find index of current letter
     Ｍ   →          Move that many characters right
          ι         Implicitly print the current letter
           Ｍ⌕αι←    Move the same number of characters left
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 26 bytes
Anonymous prefix lambda which takes the input string as argument and returns the output string. Assumes `⎕IO` (**I**ndex **O**rigin) `0`, which is default on many systems.
```
{⍵@i⊢''↑⍨1+⌈/i←(⎕A⍳⍵)+⍳≢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/4MLUlNTgKzqR71bHTIfdS1SV3/UNvFR7wpD7Uc9HfqZQCkNoGrHR72bgSo0tUF05yIgs/Y/RK@CumOUOheM6eSMYDu7wtnOTo5wtoerj49/uH@Qj4s6AA "APL (Dyalog Unicode) – Try It Online")
`{`…`}` anonymous lambda; `⍵` represents the argument
 `≢⍵` tally of the argument
 `⍳` than many **ɩ**ntegers (0…LengthOfArgument-1)
 `(`…`)+` plus:
  `⎕A⍳⍵` the indices of the argument in the uppercase **A**lphabet
 `i←` strore in `i` (for **i**ndices)
 `⌈/` maximum (reduction)
 `1+` add one
 `''↑⍨` take that many characters from the empty string, padding with spaces as needed
 `⊢` yield that (serves to separate `i` from `''`)
 `⍵@i` amend that with the argument letters **at** the `i` indices
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 10 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā,{ZFWē+1ž
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTAxJTJDJTdCWkZXJXUwMTEzKzEldTAxN0U_,inputs=SEVMTE9XT1JMRA__)
Explanation:
```
ā           push an empty array
 ,{         for each char in the input
   ZFW        get its index in the uppercase alphabet
      ē+      add to that the 0-indexed counter
        1ž    at [pop; 1] insert in the array the current character
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~44~~ 38 bytes
Striked out 44 is still 44 :(
Bloody Pyth beginner.
Saved 6 bytes thanks to @Mr. Xcoder.
```
K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK
```
[Try it online!](https://tio.run/##K6gsyfj/31srRTunysgsLKdKwds2wlvX2aHKT9fM1A9IWeuFF6Z6pAREef//7@Hq4@Mf7h/k4wIA "Pyth – Try It Online")
---
**How?**
```
K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK          Full program
K*d+lz26                                        Assign a string consisting of 
                                                  (26 + input.length) whitespaces to K
        Vlz                                     For-loop from 0 to input.length
                -C@zN-65N                       Calculate the index for the current letter
                         @zN                    The current letter
            K=XK                                Insert the current letter into K at
                                                  position i
                            ;                   End statement
                             .WqeHdPZK          While the last character of H is not a 
                                                  whitespace, pop the last character off K
```
[Answer]
# Batch, ~~418~~ 331 bytes
Works with uppercase letters only and will take some seconds for longer strings.
Learned new tricks here, the character to ASCII value conversion using `%=exitcodeAscii%`. Also, `if defined` and "array" access using `call`. Also, golfing by almost 100 bytes was good batch code golf training.
Note the trailing space in `set z=set`.
```
@echo off
setlocal EnableDelayedExpansion
set z=set 
%z%a=%1
:a
%z%v=64
:b
%z%/Av+=1
cmd/Cexit %v%
if %=exitcodeAscii% neq %a:~0,1% goto b
%z%/Ao=v+c
%z%a%o%=%a:~0,1%
if %o%. geq %m%. %z%m=%o%
%z%/Ac+=1
%z%a=%a:~1%
if %a%. neq . goto a
for /l %%n in (65,1,%m%)do (
if defined a%%n (call %z%r=%%r%%%%a%%n%%
)else %z%r=!r! )
echo %r%
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 68 bytes
```
->s{r,w="",-66;s.bytes{|b|r[(b+w+=1).times{|a|r[a]||=" "}]=b.chr};r}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664ukin3FZJSUfXzMy6WC@psiS1uLomqaYoWiNJu1zb1lBTryQzFySWCBRLjK2psVVSUKqNtU3SS84oqrUuqv1fUFpSrJAWre7h6uPjH@4f5OOiHvsfAA "Ruby – Try It Online")
[Answer]
# x86-16 machine code, PC DOS, 27 bytes
```
00000000: b403 cd10 d1ee ad98 91ac b402 8ad0 80ea  ................
00000010: 4102 d343 cd10 cd29 e2ef c3              A..C...)...
```
**Listing:**
```
B4 03       MOV  AH, 3          ; get current cursor position row into DH 
CD 10       INT  10H            ; call BIOS 
D1 EE       SHR  SI, 1          ; SI to DOS PSP 
AD          LODSW               ; AL = command line string length 
98          CBW                 ; AH = 0 
91          XCHG AX, CX         ; CX = length 
        OUTPUT: 
AC          LODSB               ; load DS:SI into AL 
B4 02       MOV  AH, 2          ; BIOS set cursor position function 
8A D0       MOV  DL, AL         ; ASCII char to DL 
80 EA 41    SUB  DL, 'A'        ; convert ASCII char to numeric val (A=0, Z=25) 
02 D3       ADD  DL, BL         ; add current position offset 
43          INC  BX             ; increment position offset 
CD 10       INT  10H            ; move cursor to column in DL
CD 29       INT  29H            ; write char in AL to console
E2 EF       LOOP OUTPUT         ; loop until end of input 
C3          RET                 ; exit to DOS 
```
Standalone PC DOS executable. Input from command line and prints the new "faster" version to console.
**Output:**
[![enter image description here](https://i.stack.imgur.com/HlPAN.png)](https://i.stack.imgur.com/HlPAN.png)
[Answer]
# PHP, ~~127~~ 123 bytes
```
function b($i){for($q=0;$q<strlen($i);$q++){$n[ord($i[$q])-65]=$i[$q];}while($x++<26){$m.=$n[$x-1]?$n[$x-1]:" ";}return$m;}
```
[Try it online](https://repl.it/Maak/2)
Had to fix a bug that wouldn't output 'A'...
]