[Question]
  [
# Alphabet Rain
## The Task:
The basic premise is to print out the input string and then repeat each character vertically, based on it's (0-indexed) position in the (case-insensitive) alphabet `A-Z`. `A` is at location 0 so is not repeated, `e` is at position 4 so is repeated 4 times, `P` is at position 15 so is repeated 15 times, `!` is not in `A-Z` so is repeated 0 times, etc.
For clarity, anything that falls outside of the range `B-Zb-z`, for example digits or special characters, will not be repeated, and thus will only appear on the first line. 
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest solution in each language is the winner.
## Input:
* Input will be in the standard printable ASCII character set, from 32  up to 126 `~`.
* The input string will be 1 character long or longer.
* There will not be any leading or trailing whitespace.
* You can take take input as a string (`"hello"`) or list of characters ( `["h", "e", "l", "l", "o"]`)
## Examples:
Input of `aaaa` gives:
```
aaaa
```
Input of `abcda` gives:
```
abcda
 bcd
  cd
   d
```
Input of `Programming Puzzles & Code Golf!`, gives:
```
Programming Puzzles & Code Golf!
Progr mming Puzzles   Code Golf
Progr mming Puzzles   Code Golf
Progr mming Puzzles    ode Golf
Progr mming Puzzles    o e Golf
Progr mming Puzzl s    o   Golf
Progr mming Puzzl s    o   Gol
Pro r mmin  Puzzl s    o    ol
Pro r mmin  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzz  s    o    o
Pro r    n  Puzz  s    o    o
Pro r       Puzz  s    o    o
Pr  r       Puzz  s
 r  r        uzz  s
 r  r        uzz  s
             uzz  s
             uzz
             uzz
              zz
              zz
              zz
              zz
              zz
```
Input of `~|[abc<0>cba]|~`, gives:
```
~|[abc<0>cba]|~
    bc   cb
     c   c
```
## Notes:
* standard loopholes apply
* output *can* be a list of strings, but:
* extraneous trailing newlines are not allowed (single `\n` on final line is acceptable)
* output *can* be a list of lists of characters, so long as it looks like it's raining characters
* no leading newline
* to our Nordic users who have a [few extra](https://en.wikipedia.org/wiki/Danish_and_Norwegian_alphabet) letters in their "A-Z" alphabet, feel free to support them, but it's not part of the challenge
  
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (C64), 113 bytes
```
00 C0 20 FD AE 20 9E AD 85 FB 20 A3 B6 A0 00 84 FC B1 22 99 6F C1 C9 41 90 14 
C9 5B B0 04 E9 40 B0 0E C9 C1 90 08 C9 DB B0 04 E9 C0 B0 02 A9 00 99 6F C0 C5 
FC 30 02 85 FC C8 C4 FB D0 D3 A9 00 99 6F C1 A0 C1 A9 6F 20 1E AB A9 0D 20 D2 
FF A6 FC D0 01 60 C6 FC A0 00 B9 6F C1 F0 E6 BE 6F C0 D0 07 A9 20 99 6F C1 D0 
05 CA 8A 99 6F C0 C8 D0 E7
```
[![screenshot](https://i.stack.imgur.com/Zgg4y.png)](https://i.stack.imgur.com/Zgg4y.png)
**[Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22rain.prg%22:%22data:;base64,AMAg/a4gnq2F+yCjtqAAhPyxIplvwclBkBTJW7AE6UCwDsnBkAjJ27AE6cCwAqkAmW/AxfwwAoX8yMT70NOpAJlvwaDBqW8gHqupDSDS/6b80AFgxvygALlvwfDmvm/A0AepIJlvwdAFyoqZb8DI0Oc=%22%7D,%22vice%22:%7B%22-autostart%22:%22rain.prg%22%7D%7D)**
**Usage:** `sys49152,"[string]"`, e.g. `sys49152,"Programming Puzzles & Code Golf!"`.
**Important:** If the program was loaded from disk (like in the online demo), issue a `new` command first! This is necessary because loading a machine program trashes some C64 BASIC pointers.
**Note:** The C64 is by default in a mode without lowercase letters -- in order to be able to enter a mixed-case string, switch to lowercase mode first by pressing `SHIFT`+`CBM`.
---
### Explanation
Here's a commented disassembly listing:
```
         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FB       STA $FB            ; store string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A0 00       LDY #$00           ; initialize counter
.C:c00d  84 FC       STY $FC            ; and number of "extra" lines
.C:c00f   .copyloop:                    
.C:c00f  B1 22       LDA ($22),Y        ; load next character
.C:c011  99 6F C1    STA .outbuf,Y      ; store to buffer
.C:c014  C9 41       CMP #$41           ; compare with 'a'
.C:c016  90 14       BCC .zerocount     ; smaller -> no repetition
.C:c018  C9 5B       CMP #$5B           ; compare with 'z'
.C:c01a  B0 04       BCS .checkupper    ; larger -> check for uppercase
.C:c01c  E9 40       SBC #$40           ; subtract 'a' ('a' - 1 and carry)
.C:c01e  B0 0E       BCS .cl_storecount ; and jump to store in repeat count
.C:c020   .checkupper:                  
.C:c020  C9 C1       CMP #$C1           ; compare with 'A'
.C:c022  90 08       BCC .zerocount     ; smaller -> no repetition
.C:c024  C9 DB       CMP #$DB           ; compare with 'Z'
.C:c026  B0 04       BCS .zerocount     ; larger -> no repetition
.C:c028  E9 C0       SBC #$C0           ; subtract 'A' ('A' - 1 and carry)
.C:c02a  B0 02       BCS .cl_storecount ; and jump to store in repeat count
.C:c02c   .zerocount:                   
.C:c02c  A9 00       LDA #$00           ; store 0 ...
.C:c02e   .cl_storecount:               
.C:c02e  99 6F C0    STA .repcount,Y    ; ... in repeat count
.C:c031  C5 FC       CMP $FC            ; compare with number of extra lines
.C:c033  30 02       BMI .cl_next       ; smaller -> go on with loop
.C:c035  85 FC       STA $FC            ; repeat count to number of extra lines
.C:c037   .cl_next:                     
.C:c037  C8          INY                ; next
.C:c038  C4 FB       CPY $FB            ; compare with string length
.C:c03a  D0 D3       BNE .copyloop      ; not yet reached? -> repeat
.C:c03c  A9 00       LDA #$00           ; terminate string in buffer
.C:c03e  99 6F C1    STA .outbuf,Y      ; with 0 byte
.C:c041   .outloop:                     
.C:c041  A0 C1       LDY #>.outbuf      ; output ...
.C:c043  A9 6F       LDA #<.outbuf      ; ...
.C:c045  20 1E AB    JSR $AB1E          ; ... string
.C:c048  A9 0D       LDA #$0D           ; and output ...
.C:c04a  20 D2 FF    JSR $FFD2          ; ... newline
.C:c04d  A6 FC       LDX $FC            ; load extra line count
.C:c04f  D0 01       BNE .ol_step       ; not zero -> go on
.C:c051  60          RTS                ; WE ARE DONE HERE ;)
.C:c052   .ol_step:                     
.C:c052  C6 FC       DEC $FC            ; decrease extra line count
.C:c054  A0 00       LDY #$00           ; initialize counter
.C:c056   .eraseloop:                   
.C:c056  B9 6F C1    LDA .outbuf,Y      ; load next character from buffer
.C:c059  F0 E6       BEQ .outloop       ; 0 byte? -> end of string, output
.C:c05b  BE 6F C0    LDX .repcount,Y    ; load repeat count for this characer
.C:c05e  D0 07       BNE .el_step       ; not 0 yet? -> jump to decrement
.C:c060  A9 20       LDA #$20           ; load code for space
.C:c062  99 6F C1    STA .outbuf,Y      ; store in current string position
.C:c065  D0 05       BNE .el_next       ; and jump to next loop iteration
.C:c067   .el_step:                     
.C:c067  CA          DEX                ; decrease repeat count ...
.C:c068  8A          TXA                ; ... and ...
.C:c069  99 6F C0    STA .repcount,Y    ; ... store back
.C:c06c   .el_next:                     
.C:c06c  C8          INY                ; increase counter ...
.C:c06d  D0 E7       BNE .eraseloop     ; and jump back to loop
.C:c06f   .repcount:
.C:c06f              .RES $100          ; 256 bytes for repeat count
.C:c16f   .outbuf:
.C:c16f              .RES $100          ; 256 bytes as buffer for output
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~13~~ 12 bytes
```
,εDlAsk×}ζ»,
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f59xWlxzH4uzD02vPbTu0W@f//4Ci/PSixNzczLx0hYDSqqqc1GIFNQXn/JRUBff8nDRFAA "05AB1E – Try It Online")
**Explanation**
```
,             # print input
 ε      }     # apply to each char in input
  D           # duplicate
   l          # convert to lower case
    Ask       # get index of current char in the lower case alphabet
       ×      # repeat the char that many times
         ζ    # transpose with space as filler
          »,  # join on newlines and print
```
[Answer]
# Pyth, ~~12~~ ~~10~~ 9 bytes
```
.tm+*xGr0
```
[Test suite.](http://pyth.herokuapp.com/?code=.tm%2B%2axGr0&input=%22Programming+Puzzles+%26+Code+Golf%21%22&test_suite=1&test_suite_input=%22Programming+Puzzles+%26+Code+Golf%21%22%0A%22abcda%22%0A%22aaaa%22&debug=0)
Explanation:
```
.tm+*xGr0dddQ   Expanded program with autofilled input variable
  m      dddQ    For each character d in the input:
       r0d     get its lowercase variant
     xG        and return its 0-based index in the alphabet 
                   (-1 if not found, for special chars)
                (empty string for A/a and special characters)
    *     d    that many of the corresponding character
   +       d   and one more for good measure (because x is 0-indexed)
.t             Transpose it and fill blanks with spaces
```
12 bytes:
```
j.t*VmxGr0d
```
(with trailing newline)
[Test suite.](http://pyth.herokuapp.com/?code=j.t%2aVmxGr0d%0A&input=%22Programming+Puzzles+%26+Code+Golf%21%22&test_suite=1&test_suite_input=%22Programming+Puzzles+%26+Code+Golf%21%22%0A%22abcda%22%0A%22aaaa%22&debug=0)
Explanation:
```
j.t*VmxGr0d
QQ              Expanded program with autofilled input variable
Q               print the input verbatim
     m    dQ    For each character d in the input:
        r0      get its lowercase variant
      xG        and return its 0-based index in the alphabet 
                    (-1 if not found, for special chars)
   *V       Q   multiply the corresponding characters in (the second autofilled input)
                 by their alphabet indices we just calculated
                 (empty string for A/a and special characters)
 .t             Transpose it and fill blanks with spaces
j               Join the result on newlines
```
[Answer]
# [Python 3](https://docs.python.org/3/), 83 bytes
```
f=lambda s,k=65:[*{*s}-{' '}]and[s]+f([[' ',c][91>ord(c.upper())>k]for c in s],k+1)
```
[Try it online!](https://tio.run/##FctBC4IwGIDhc/2Kr0vb1ASJggSF8tDV@1iwprPl3GSrQ4r9dbPj@8Dbf14Pa/bzLDPNu3vFwUdtdjykNBgDP@1GBGhi3FTUs1BiSpeOBKOnJLeuwiJ@933tMCF5y6R1IEAZ8Cxqw4TMf9B/kFgr/8KodLZxvOuUaaB8D4OuPWyhsFUNV6vlhrLbOH3P/HIvBCIkXa96p8wyovhplcGakPkH "Python 3 – Try It Online") Takes a list of characters. Returns a list of lists of characters.
## [Python 2](https://docs.python.org/2/), 90 bytes
```
f=lambda s,k=65:s.strip()and s+'\n'+f(''.join([' ',c][91>ord(c.upper())>k]for c in s),k+1)
```
[Try it online!](https://tio.run/##DcvBCoIwGADgV/m7tA2HYFBQoFAeuno3g7k5W@q/sekho1599d0/95ofFncx6nwUU6sEBD7kh/0ppGH2xlEmUEFIyA1Joikh6dMapDUBwmVTH7PCekVlujjXecpYMTTaepBgEALjQ5Kx6LzBGf658rb3YpoM9lAt6zp2AbZQWtXB1Y56Uzf39@d7Fpe2lITFHw "Python 2 – Try It Online") Takes a string. Returns a string.
[Answer]
# Mathematica, ~~115~~ 89 bytes
It takes as `input` a **list of characters** `[{"a", "b", "c", "d", "a"}]` and outputs **a list of lists of characters**
```
Thread[PadRight[Table[#,Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]]&/@#]/. 0->" "]&
```
[Try it online!](https://tio.run/##DcuxCsMgFEDRXxGFTCb2BxosXVuQ4iYOzygqJLGYBy20/XbrcO52N8AUNsC8QIvnplMN4I0C/8gxodHg1mAYv8NbqnJkzGU3l/WZwAU0VkwU6Dgzzr663Mor1CscQTJrB9ErJnIaZ0qoHZqqeUcio/n0hVPXLZ3vgP5sa38 "Wolfram Language (Mathematica) – Try It Online")
*-26 bytes from Misha Lavrov*
*-5 bytes from user202729*
but if you want to see the output as it is in the test case, try this (128 bytes) code  
[Try it online!](https://tio.run/##DY7BCsIwEAV/JW6gKFTrB2iJ9OBFIWhvMYfVbpNA20gaUcR/j7m@gZk3YrQ0YnQPTGafrjG4yVxc3w@kAHY1LyqxbG0g7ITE7uKMjarFe8a8PONHSD@76PykDsPT4p2i0tUGENY1L/mv9Sf/ptDgTIJrnWWNxYCPSGHOQ7Vh23UNDFYl3CbQRZK5H5kwCmTwJuA45j9Mvr7fgWZWsMZ3xI5@6BegU/oD "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Dyalog APL](https://www.dyalog.com/), ~~27~~ 22 bytes
*5 bytes saved thanks to @Adám*
```
⍉∘↑⊢⍴¨⍨1⌈27|⎕A⍳819⌶⍨∘1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHvZ2POmY8apv4qGvRo94th1Y86l1h@Kinw8i85lHfVMdHvZstDC0f9WwDCgPVGQI1KagHFOWnFyXm5mbmpSsElFZV5aQWK6gpOOenpCq45@ekKaoDAA)
**How?**
`⍴¨⍨` - shape each char to length of
    `1⌈` - at least one or 
    `⎕A⍳819⌶⍨∘1` - index of the char uppercased in alphabet
        `27|` - modulo 27
`↑` - flatten to a matrix
`⍉` - and transpose
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 12 bytes
```
θ↙↓Ｅ⮌θ×ι⌕α↥ι
```
[Try it online!](https://tio.run/##AVAAr/9jaGFyY29hbP//zrjihpnihpPvvKXirozOuMOXzrnijJXOseKGpc65//9bJ1Byb2dyYW1taW5nIFB1enpsZXMgJiBDb2RlIEdvbGYnXf8tYQ "Charcoal – Try It Online")
-3 thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil).
[Answer]
# Python, ~~105~~ 103 bytes
*2 bytes saved thanks to @TFeld*
```
lambda s:'\n'.join(''.join((' '+l)[i<1or 91>ord(l.upper())>i+64]for l in s)for i in range(26)).rstrip()
```
[Try it online!](https://tio.run/##LcmxCsIwEIDhVzkXc0ehUJWCol0cXLtbh0iTepIm4dIO9uWjBaf/gz9@plfw@2wvXXZ6fPYa0kl1XpXvwB7Vv6hAFY7ufK6CwLFqgvToyjlGI0jUcFEfHva3HLCHRCt5pWg/GNzVRKWkSTgi5SjsJ7SoWgmD6HFkP0A7L4szCbZwDb2BW3B2o4jyFw)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~111~~ ~~106~~ ~~99~~ ~~98~~ ~~97~~ ~~87~~ 93 bytes
```
s=input()
i=65
while s.strip():print s;s=''.join([' ',c][91>ord(c.upper())>i]for c in s);i+=1
```
[Try it online!](https://tio.run/##BcGxDoIwEADQna84F9tGQ4KJJkrK4uDKThgMFDgDveaujZGfr@@FX1zIX3IWiz6kqE2B9nYtvguuDqSUyBi0eQRGH0FqsUqVH0KvOwXqPPTdvWqIRz2UKQTH2pgG@4kYBkAPYmo82Spn1TLN/N429DO0ad9XJ3CEJ40OXrROB/UH "Python 2 – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 162 bytes
```
s=>{string A="abcdefghijklmnopqrstuvwxyz",r=s;for(int i=-1;++i<s.Max(A.IndexOf);)r+='\n'+string.Concat(s.Select(c=>A.IndexOf(char.ToLower(c))>i?c:' '));return r;}
```
[Try it online!](https://tio.run/##RZBPS8NAEMXPyacYczAb0i54Nd1IKShCi4UKPaiHdbNJV5NdO7PpX/rZYySip8fw3vvBG0Vj5VB3LRlbwepIXjd8buw2C1UtiWAZnsOAvPRGwc6ZAhbSWGDksS@8vIHEipIw6EPBb/u@tWoy@CMYNIcSREciPw83TEUk31Why2pjPj7rxrqvLZJvd/vD8RSNUFBWOmTGejBifJOlqZkQX8gDm/JHW@jDU5lkCaYifrVxOkD5zFklPSO@0rVWnimR/6WZ2kjkz27u9hqZSpLc3KnbGOIkyVD7Fi1gdumy/xk9jVyt@RqN1/1HNCtZtERXoWyanw3L9nSqNcE1zFyh4cHV5VXU48LgEl66bw "C# (.NET Core) – Try It Online")
[Answer]
# Bash, ~~78~~, ~~76~~ 71 bytes
```
for c in {B..a};{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z${c,}-z]/ }";}
```
Depending on collation (default LC\_ALL) can save some more bytes
```
for c in {b..z} _;{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z]/ }";}
```
[Try It Online](https://tio.run/##Fcq9DoMgFIbhW/kkhE2NM2OHrs4lpFGKP4lyErALhGs/tdubPO88pY15oQiHPaDMXZcr3rrAGLQBsgx9jwprlfJuIwg5CJ38dcefTCNd@7L3InRl5jHSGqfz3MOK8Zvz4RMUHvTxeNKxND8)
[Answer]
# [Perl 5](https://www.perl.org/), 43 bytes
**41 bytes code + 2 for `-nl`.**
```
$c=A;print,s/$c|[^a-z]/ /gi,$c++while/\S/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l2dbRuqAoM69Ep1hfJbkmOi5RtypWX0E/PVNHJVlbuzwjMydVPyZY////xKTklNRErkQg4Aooyk8vSszNzcxLVwgorarKSS1WUFNwzk9JVXDPz0n7l19QkpmfV/xfNy8HAA "Perl 5 – Try It Online")
[Answer]
# JavaScript (ES6), ~~87~~ ~~78~~ 76 bytes
*-9 bytes thanks to [@RickHitchcock](https://codegolf.stackexchange.com/users/42260/rick-hitchcock).*  
*-2 bytes thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil).*
```
f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)
```
Takes input as a string and returns with one trailing newline.
## Test Cases
```
f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)
;["hello", "Programming Puzzles & Code Golf!", "~|[abc<0>cba]|~", "abcdefg0123456789"]
.forEach(s=>console.log(f(s)));
```
```
.as-console-wrapper{max-height:100%!important}
```
[Answer]
# R, ~~118~~ 114 bytes
```
function(a)while(grepl("[^ ]",a)){F=F+1;cat(a,"\n");for(j in c("[^a-zA-Z]",letters[F],LETTERS[F]))a=gsub(j," ",a)}
```
Thanks to @Giuseppe for those 4 bytes off
[Try it online!](https://tio.run/##JcxBC4IwGMbxe59i7RAbKdTZDCK0SwcpT5nB69xMmVtMJTDzqy@l2/@BH4@xwreiU6wttSJA389SclIY/pIEJw@UYgco/YR@uN56DFoCDr4rTD2hDalQqRCbHbj9wb1NWPK25aZJwtQ5B3EcXK5TUgp@0XQZqRyM5sOvFQRHRhcG6rpUBYq6vpe8QSt01DlHJy3FEtPFpCBjOfxzHJJp7TZ7lkE6jJjaHw)
Short explanation:
```
function(a)
    while(grepl("[^ ]",a)){ #As long as the string is not just spaces.
        F=F+1 #Increment letter counter (F is FALSE, hence 0 by default)
        cat(a,"\n") #Print string
        for(j in c("[^a-zA-Z]",letters[F],LETTERS[F])) #Get rid of non-letters, and the current letter in lower and upper case
             a=gsub(j," ",a)
    }
```
[Answer]
# [R](https://www.r-project.org/), ~~125~~ 123 bytes
*[Outgolfed by plannapus](https://codegolf.stackexchange.com/a/144905/67312)*
```
for(i in 1:max(p<-pmax(1,match(tolower(S<-el(strsplit(scan(,""),''))),letters),na.rm=T)))cat(ifelse(p<i," ",S),'\n',sep='')
```
[Try it online!](https://tio.run/##FYxLCsMwDAWvEryxDEoh25KcIl12o7gKMfiHLGh7etddPRhmnvQYDiH5QmK9yqu5fhaBMIU8LfdEH6jrXP@7YCL1F2iJ5c0C@zpzhKbSagwKzVMGNMahtc45jKzK0hxmuknaHoN5Uggnx8bjNKCdLO5Df2aLjes2um7o8C8y/Qc "R – Try It Online")
Prints to stdout with a single trailing newline and reads from `stdin()`.
Let's break it down:
```
S <- el(strsplit(scan,""))            # split the string to characters
m <- match(tolower(S),letters)        # 1-based index in letters (lowercase a-z)
p <- pmax(1,m,na.rm=T)                # parallel max, replaces NA (non-alphabet) or 0 with 1
for(i in 1:max(p)){                   # iterate
 cat(                                 # print
  ifelse(p<1,' ',S),                  # the corresponding letter in S if p>=1, space otherwise
  '\n',sep='')                        # newline, and no spaces between chars
}
```
## Alternate answer, 106 bytes
```
function(S)for(i in 1:max(p<-pmax(1,match(tolower(S),letters),na.rm=T)))cat(ifelse(p<i,' ',S),'\n',sep='')
```
[Try it online!](https://tio.run/##FYu7DsIwDAB3viKbbSlF6opaJv4ARpZQHDVSXnKMAKn/Hsp0w91Jj@EhTr6YWNfybHTwZhq6f@VFQ8l4JV8EgwnZjKfkPlinof452uR0WVFLLG@WPbSRVVka2eyOkuYbES1OMXiOjfcxWDBg9xDuGWzjOgNQ98gRm0qrMSiCm7bLdnZgd0fUfw "R – Try It Online")
Function; prints to stdout but it's basically my response above ported to accept a list of characters rather than splitting the string, so I feel like it's "cheating." Plus, plannapus' approach with regex is quite neat!
[Answer]
# [Octave](https://www.gnu.org/software/octave/) / MATLAB, ~~74~~ 66 bytes
```
@(s)char(arrayfun(@(c){repmat(c,1,prod(find(upper(c)==65:90)))},s))'
```
[**Try it online!**](https://tio.run/##DclLCsIwEADQq8SNmYEQdKGgECh04bZXGPKphebDpBGsePbo275sN3r5HozWug9Q0T6JgZjpHVqCASx@2JdIG1h1VoWzg7AkB60Uz/815nq5306I@FUVUfYAcuI8M8W4pFlMbd9XX8VRjNl58chrOEjsPw)
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), ~~15~~ ~~14~~ ~~11~~ 10 bytes
First chance to play with Japt's new string padding methods so there might still be room for improvement.
```
y_ùZInZu c
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=eV/5WkluWnUgYw==&input=IlByb2dyYW1taW5nIFB1enpsZXMgJiBDb2RlIEdvbGYhIg==)
---
## Explanation
Implicit input of string `U`.
```
y_
```
Pass each column of `U` through a function, where `Z` is the current element (or letter, in this case).
```
InZu c
```
Convert `Z` to uppercase (`u`), get its charcode (`c`) and subtract (`u`) 64 (`I`).
```
ùZ
```
Pad the start of `Z` with itself until it reaches that length.
---
## Alternative
```
y_ùZ9aZn36
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=eV/5WjlhWm4zNg==&input=IlByb2dyYW1taW5nIFB1enpsZXMgJiBDb2RlIEdvbGYhIg==)
[Answer]
# [Haskell](https://www.haskell.org/), ~~137~~ ~~136~~ ~~127~~ 119 bytes
```
import Data.Char
p c=last$0:[k|k<-[0..25],k+65==ord(toUpper c)]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$map p s]]
```
[Try it online!](https://tio.run/##bYy9CsIwGABn@xSfUqyihiLoUIyLgouCIE4hyEd/bGjShCQFkeKr16qr6x13Jboql7LrhDLaetijR7Ir0QYGUirR@TBOWNVWmwWLCVmu@LyarVeUaptNvL4ak1tIpzwowFHGvkGasAiiVmz7BW/TzcLxVvx6hQ@hGhUqNGDAcd4pFDXNdDDo0ekGpvEXb481hFDAZ0NI9Ir4Xz06W323qJSo73Bunk@ZOxjDTmc5HLQshqPuDQ "Haskell – Try It Online")
Pretty long but I can't think of any way to shorten it further. ~~I feel like there must be some way shorter than the if-then syntax but I don't see it.~~
EDIT: Thanks @streetster for helping me shave off one byte! I didn't use `toUpper` at first because of the cost of importing `Data.Char` but I forgot that it also provides `ord` which is much shorter than `fromEnum`
EDIT 2: Thanks to @Laikoni for shaving off another 6 bytes and identifying a bug which I have now fixed. I used 26 instead of 25 because I forgot that Haskell arrays are inclusive. Then I noticed I could use `last` instead of `head` which would allow me to use `0:` rather than `++[0]`.
EDIT 3: Thanks again Laikoni for those 8 bytes. I had actually forgotten about that space. For some reason Sublime Text flips out without it and I forgot to remove it. I wasn't aware that lists of lines were allowed, I should've read the rules more carefully.
[Answer]
# Excel VBA, 110 Bytes
Anonymous VBE Immediate Window Function that takes input as expected type `Variant\String` from range `[A1]` and uses it to make it rain the alphabet in the VBE immediate window.
```
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
```
### Sample I/O
```
[A1]="qwertyuiop[]ASDFGHJKL:'zxcvbnm,./"
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
qwertyuiop[]ASDFGHJKL:'zxcvbnm,./
qwertyuiop   SDFGHJKL  zxcvbnm   
qwertyuiop   SDFGHJKL  zxcv nm   
qwertyuiop   SDFGHJKL  zx v nm   
qwertyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S  GHJKL  zx v nm   
qw rtyuiop   S   HJKL  zx v nm   
qw rtyuiop   S    JKL  zx v nm   
qw rtyu op   S    JKL  zx v nm   
qw rtyu op   S     KL  zx v nm   
qw rtyu op   S      L  zx v nm   
qw rtyu op   S         zx v nm   
qw rtyu op   S         zx v n    
qw rtyu op   S         zx v      
qw rtyu  p   S         zx v      
qw rtyu      S         zx v      
 w rtyu      S         zx v      
 w  tyu      S         zx v      
 w  tyu                zx v      
 w   yu                zx v      
 w   y                 zx v      
 w   y                 zx        
     y                 zx        
     y                 z         
                       z 
```
[Answer]
# PHP, ~~69 78 77~~ 85+1 bytes
```
for($c=A;!$c[1]&&~trim($s=&$argn);$s=eregi_replace("[^".++$c."-Z]"," ",$s))echo"$s
";
```
requires PHP<7. Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/97c87c85e9a7b186f01e5d1bb08825638b996927).
[Answer]
# Bash + sed, 37
```
sed -rne"/^ *$/q;p;s/\W|"{a..z}/\ /gi
```
[Try it online](https://tio.run/##S0oszvj/vzg1RUG3KC9VST9OQUtFv9C6wLpYPya8Rqk6UU@vqlY/RkE/PfP//4Ci/PSixNzczLx0hYDSqqqc1GIFNQXn/JRUBff8nDRFrsSk5JREAA).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 189 bytes
```
#define F for(q=c,p=s;*p;++p,++q)
char*p,*q,s[99],c[99];main(h){gets(s);F{*q=*p>64&&*p<91?*p-65:*p>96&&*p<123?*p-97:0;h=h>*q?h:*q;}for(puts(s);h--;){F{putchar(*q?--*q,*p:32);}putchar(10);}}
```
[Try it online!](https://tio.run/##NY3BioMwFEX38xUZCmKeCWg7tcTUdlFwtt2XWUgajVD1xYybit/uxA7dXLiHyz2K10oty@auq6bTpCBVP4Q2VwxzJwFlFCGLIks/lCkHQAaWuZsQP0ytKduy6UJDp1r/utBRWUxgc8BT@hUEgEeRnAF5us88EukLJdvdysQhi6XJzQns2WRg5byKcfy/MZxLOhWT76s39CPOvRow222pnN88iX2Zl@U69PVQtm3T1eQ6Pp8P7UhALv1dk@/@UX3@AQ "C (gcc) – Try It Online")
[Answer]
## Ruby, ~~70~~ ~~67~~ 74 bytes
```
f=->s{puts s;(?b..?z).each{|c|s.gsub! /[^#{c}-z]/i,' ';puts s if s=~/\S/}}
```
Thanks to [@TuukkaX](https://codegolf.stackexchange.com/users/41754/tuukkax) for pointing out some parens could be dropped (-3 bytes)
Unfortunately I then had to add 7 bytes because original version failed to handle "z".
Calling it:
```
f.call('The quick brown fox jumps over the lazy dog!')
The quick brown fox jumps over the lazy dog!
The quick brown fox jumps over the l zy dog
The quick  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy  og
Th  qui k  rown fox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  o
T   qui k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t     zy  o
T   qu     rown  ox  u ps ov r t     zy  o
T   qu     row   ox  u ps ov r t     zy  o
T   qu     r w    x  u ps  v r t     zy
T   qu     r w    x  u  s  v r t     zy
T    u     r w    x  u  s  v r t     zy
T    u       w    x  u  s  v   t     zy
T    u       w    x  u     v   t     zy
     u       w    x  u     v         zy
             w    x        v         zy
             w    x                  zy
                  x                  zy
                                     zy
                                     z
```
[Answer]
# Oracle SQL, 186 Bytes
Assumes the string will be in a table `t` in column `v`:
```
WITH a(s,l)AS(SELECT v,64 FROM t UNION ALL SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1 FROM a WHERE l<90)SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)FROM a
```
[SQL Fiddle](http://sqlfiddle.com/#!4/8fdd1d/15)
**Oracle 11g R2 Schema Setup**:
```
CREATE TABLE t ( v ) AS
SELECT '~|[abc<0>cba]|~' FROM DUAL
/
```
**Query 1**:
```
WITH a(s,l)AS(
  SELECT v,64 FROM t
UNION ALL
  SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1
  FROM a
  WHERE l<90
)
SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)
FROM a
```
**[Results](http://sqlfiddle.com/#!4/8fdd1d/15/0)**:
```
|      LISTAGG(RTRIM(S),CHR(10))WITHINGROUP(ORDERBYL) |
|-----------------------------------------------------|
| ~|[abc<0>cba]|~                                     |
|    abc   cba                                        |
|     bc   cb                                         |
|      c   c                                          |
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
ØaḊiÐ€Œl‘⁸ẋ"z⁶Y
```
[Try it online!](https://tio.run/##AUoAtf9qZWxsef//w5hh4biKacOQ4oKsxZJs4oCY4oG44bqLInrigbZZ////IlByb2dyYW1taW5nIFB1enpsZXMgJiBDb2RlIEdvbGYhIg "Jelly – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 98 bytes
```
p c=sum[length[a..c]|a:e<-["B[","b{"],[c]<e]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$p<$>s]]
```
[Try it online!](https://tio.run/##dY2xDoIwFABn@YpnQ2SBxpkAgw6uJI7NG2op0NgWQtvEYOOvI36A8@XuRu6eUuttm0HULhimpR38yDilAiMvZVUwcmEkJ483wZwJrCQmPbiaMc2dT0XJMsiiavYARlEVDqPapTOlhr@UCSadq7RxiJvhytbdlBzm4O9@AQrBamWlgxR6IO0yDQs3RtkB2rCuegcnuE6dhNuk@yP5I/7@lGafDLcv "Haskell – Try It Online")
Example usage: `f "[Abc]"` yields a list of lines: `["[Abc]"," bc "," c "]`. Use `putStr.unlines.f $ "[Abc]"` for pretty-printed output:
```
[Abc]
  bc
   c
```
~~Partly inspired by~~ Now directly based on [user1472751's Haskell answer](https://codegolf.stackexchange.com/a/144911/56433).
---
### Previous approach (~~100~~ 99 bytes)
```
f s=[h|i<-[0..26],h<-[[(c:concat[c<$[a..c]|[a,e]<-["B[","b{"],c<e]++cycle" ")!!i|c<-s]],any(>' ')h]
```
[Try it online!](https://tio.run/##dc69CsIwFIbh3as4DcUoxiAODlIddHAtOIYzxGPaBtNE@jO0Fm899gbcPnj44K10@zLOxVhAe1LVZLOt2km5P6Co5qlWdKTgSXeKslRpKQknpYXBGdlFMcEeH4aCMoObDQ3kDAO2ThI7UbZtEYX2w@rMga8rjLW2Hk7wDAsAePfdvWtAQu@d9aaFFApg@kHsv@ZNKBtd19aXkPfj6GZYwjU8DdyCK5L/VzUnSMm/HOMP "Haskell – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~122~~ 127 bytes
```
param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''
```
[Try it online!](https://tio.run/##DcpBC4IwFMDxr9LhxXuDJmYUpNWtY7duY8hzClvolBUUpX715fX/@w/9uwlP27RtjAMH7ghYABe0TZJsP65/4M5QFiQfvfOkjOWgtAZehHCFGyiFglJ2/DIWFcuvRsm@VkuwOs9v/KF0Q8tR9WGXCXk8SHBCT0Ik9@C6q69JTEL6BjHGiPOouDKn9GIq1uOMfw "PowerShell – Try It Online")
Short thanks to how PowerShell can dynamically cast between `[char]` and `[int]`, but long because of removing extraneous whitespace and the calculation of whether to output a space or the character.
*Bugfix thanks to beatcracker.*
[Answer]
# Java 8, ~~151~~ ~~147~~ ~~144~~ ~~143~~ 139 bytes
```
s->{String x="\n"+s;for(int i=64,t;++i<91;)for(char c:x.toCharArray())s+=(t=c&~32)>64&t<91&t>i|c<11?c:" ";return s.replaceAll("\\s+$","");}
```
**Explanation:**
[Try it here.](https://tio.run/##pVBda8IwFH33V9yFURqqZW4izNgO8WFPE2GP6kNMo4tLk5Kk4lf96zXOvgy2Jy8J3K9zOOdu6JZ2dMHVJvuumaTWwgcV6tgCEMpxs6KMw@RaAnw6I9QaWNgkFhPfr/z3zzrqBIMJKEigtp302GztEjRXKLJkpU3oOUEk/V7bkSgSw9cuwdc2@6IG2GAXOz326cgYug8xtlESuoQF55dnnPZ7gfOAwKXixIbd7hsbIEDEcFcaBTY2vJBe7EjKEM3nNnpEbYQwqWoCv@ImtyiX0sttVG@1yCD3vhtrswVQ3JjeW8fzWJcuLvzISRWqmIWI@kD45wJ/Lv0/ucGXLLsHPzV6bWieXy88LQ8HyS0EMNYZh3ctVw93UJ9PM69u@JSyJV2czg1T1arqCw)
```
s->{                   // Method with String as both parameter and return-type
  String x="\n"+s;     //  Temp-String (equal to leading new-line + input)
  for(int i=64,        //  Index-integer `i` (starting at 64)
          t;           //  Temp-integer
      ++i<91;)         //  Loop (1) from 'A' (65) to 'Z' (90) (inclusive)
    for(char c:x.toCharArray())
                       //   Inner loop (2) over the character of the array
      s+=(t=c&~32)>64  //    If the current character as uppercase is larger than 'A'
         &t<91         //    and smaller or equal to 'Z'
         &t>i          //    and larger than the current index
         |c<11?        //    or the current character is a new-line
          c            //     Append the current character to `s`
         :             //    Else:
          " ";         //     Append a space to `s` instead
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
  return s             //  Return the result,
    .replaceAll("\\s+$",""); 
                       //   after we've removed all trailing spaces and new-lines
}                      // End of method
```
[Answer]
# [q](https://code.kx.com/v2/ref/), ~~42~~ 37 bytes
```
{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}
```
-5 thanks to streetster!
---
old solution+explanation:
```
{(+)max[m]$'(m:1+mod[.Q.a?lower x;26])#'x}
{                                        }  / lambda func
                     .Q.a?lower x           / get lowercase of input (ignores non-alpha values) and find (?) their index in "a...z" (.Q.a). non-alpha values return `26`
                 mod[.Q.a?lower x;26]       / get mod 26 of each index, this returns 0 where index is 26
            (m:1+mod[.Q.a?lower x;26])      / add 1 and assign to m
            (m:1+mod[.Q.a?lower x;26])#'x   / m and x conform, so we can take (#) m copies of each (') x at corresponding indices
    max[m]$'(m:1+mod[.Q.a?lower x;26])#'x   / get max of m, and pad each ($') of right-side list to that length
 (+)                                        / transpose the char matrix
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~12~~ 11 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā,{Z⁴UW1Χ∙┼
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTAxJTJDJTdCWiV1MjA3NFVXMSV1MDNBNyV1MjIxOSV1MjUzQw__,inputs=UHJvZ3JhbW1pbmclMjBQdXp6bGVzJTIwJTI2JTIwQ29kZSUyMEdvbGYlMjElMjBhYmNCQQ__)
Explanation:
```
ā            push an empty array
 ,{          for each character in the input, pushing it
   Z           push the uppercase alphabet
    ⁴          push a duplicate of the character
     U         uppercase it
      W        find its index in that alphabet
       1Χ      get the maximum of that and 1
         ∙     repeat the character that many times
          ┼    append horizontally to that array
```
]