[Question]
  [
*Due to technical limitations of Stack Exchange, the title is rendered incorrectly. The **correct** title for this challenge is*
Make a
```
Word Icicle!
Word Icicle 
Word  cicle 
 ord  cicle 
 ord   icle 
 ord   i le 
 or    i le 
 or    i l  
 or      l  
 or         
  r         
```
---
Today's challenge is to make icicles out of the input word. Given a string of entirely [printable ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters), and at least 2 non-space characters, perform the following steps:
1. Print the current state of the string.
2. Replace the lexically smallest character (other than spaces) with a space. If there is a tie, replace the leftmost character.
3. Repeat on consecutive lines until the string contains only 1 non-space character.
This creates the effect that the input string looks like it's melting...
```
I'm Melting!!!
I'm Melting !!
I'm Melting  !
I'm Melting   
I m Melting     
  m Melting   
  m  elting   
  m   lting   
  m   ltin    
  m   lt n    
  m    t n    
       t n    
       t      
```
### Rules
* After a couple iterations, your output will almost surely have trailing spaces on each line. If you choose to truncate these, that is allowed.
* You may have **one** trailing empty line, but not more.
* Remember that the input may contain several spaces, but these are all effectively skipped. For example, the input `a a` should give
```
a      a
       a
```
* You may take input as a list of strings if you want. For output, you may return or print a list of strings, a single string with newlines, or char matrix/2D array. Generally, I prefer permissive IO formats, so other formats are most likely allowed as long as they are consistent and clearly correspond to the right output. If in doubt, feel free to ask. As usual, full programs or functions are allowed.
* Remember, this is a contest to make the shortest answer in any language! If you choose to answer in Java, try to make the shortest Java answer (in bytes) that you can.
### Test cases
```
Hello World! -->
Hello World!
Hello World 
 ello World 
 ello  orld 
 ello  orl  
  llo  orl  
   lo  orl  
    o  orl  
    o  or   
       or   
        r   
AbCdEfGhIjKlMnOpQrStUvWxYz -->
AbCdEfGhIjKlMnOpQrStUvWxYz
 bCdEfGhIjKlMnOpQrStUvWxYz
 b dEfGhIjKlMnOpQrStUvWxYz
 b d fGhIjKlMnOpQrStUvWxYz
 b d f hIjKlMnOpQrStUvWxYz
 b d f h jKlMnOpQrStUvWxYz
 b d f h j lMnOpQrStUvWxYz
 b d f h j l nOpQrStUvWxYz
 b d f h j l n pQrStUvWxYz
 b d f h j l n p rStUvWxYz
 b d f h j l n p r tUvWxYz
 b d f h j l n p r t vWxYz
 b d f h j l n p r t v xYz
 b d f h j l n p r t v x z
   d f h j l n p r t v x z
     f h j l n p r t v x z
       h j l n p r t v x z
         j l n p r t v x z
           l n p r t v x z
             n p r t v x z
               p r t v x z
                 r t v x z
                   t v x z
                     v x z
                       x z
                         z
PPCG is da BEST --> 
PPCG is da BEST
PPCG is da  EST
PP G is da  EST
PP G is da   ST
PP   is da   ST
 P   is da   ST
     is da   ST
     is da    T
     is da     
     is d      
     is        
      s        
({({})({}[()])}{}) -->
({({})({}[()])}{})
 {({})({}[()])}{})
 { {})({}[()])}{})
 { {}) {}[()])}{})
 { {}) {}[ )])}{})
 { {}  {}[ )])}{})
 { {}  {}[  ])}{})
 { {}  {}[  ] }{})
 { {}  {}[  ] }{} 
 { {}  {}   ] }{} 
 { {}  {}     }{} 
   {}  {}     }{} 
    }  {}     }{} 
    }   }     }{} 
    }   }     } } 
        }     } } 
              } } 
                } 
```
  
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 28 bytes
```
/\S/+¶<~(O`.
0L$`\S
0`$\$&¶ 
```
[Try it online!](https://tio.run/##K0otycxLNPz/Xz8mWF/70DabOg3/BD0uAx@VhJhgLoMElRgVtUPbFP7/D88vSlHwTM5MzklVBAA "Retina – Try It Online")Explanation:
```
/\S/+
```
Repeat while the input value isn't blank.
```
¶<
```
Print the current value.
```
~(
```
Execute the rest of the script on the value. Then, execute the result of that script as a script on the value.
```
O`.
```
Sort the characters into order.
```
0L$`\S
0`$\$&¶ 
```
Select the first nonblank character and output a Retina program that replaces the first literal (`$\`) occurrence of that character (`$&`) with a space (trailing space in original code).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~71~~ 70 bytes
-1 byte thanks to ovs
```
x=input()
while x.strip():print x;r=x.replace;x=r(min(r(*' ~')),' ',1)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8I2M6@gtERDk6s8IzMnVaFCr7ikKLNAQ9OqoCgzr0ShwrrItkKvKLUgJzE51brCtkgjNzNPo0hDS12hTl1TU0ddQV3HUPP/fyXHJOcU1zT3DM8s7xzfPP@CwKLgktCy8IrIKiUA "Python 2 – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~18~~ 11 bytes
```
∪∘↓∘⍉⍋∘⍋⍴⌸⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZv6jtgmG/9OA5KOOVY86Zjxqmwwiezsf9XaDGd2Perc86tnxqGvR//@P2iamqYfnF6UoeCZnJuekKqpzgYU81dVzFXxTc0oy89IVFWGiHqk5OfkKQOU5KTAhxyTnFNc09wzPLO8c3zz/gsCi4JLQsvCKyCqogoAAZ3eFzGKFlEQFJ9fgEKioRrVGda0mEEdraMZq1gLZ6gA "APL (Dyalog Unicode) – Try It Online")
uses `⎕io←1`; returns an array of strings (vector of character vectors)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
ðм{v=yð.;
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8IYLe6rLbCsPb9Cz/v/fUz1XwTc1pyQzL11RUREA "05AB1E – Try It Online")
### Explanation
```
ð      # Push space
м      # Implicit input. Remove spaces
{      # Sort. Gives string of sorted, non-space chars
v      # For each char in that string
  =    #   Print latest string, without popping. The first time it prints the input
  y    #   Push current char
  ð    #   Push space
  .;   #   Replace first occurrence of current char by space
       # Implicitly end for-each loop
```
[Answer]
# Pyth, ~~17~~ ~~14~~ 13 bytes
```
V-SQdQ=XQxQNd
```
[Try it here](http://pyth.herokuapp.com/?code=V-SQdQ%3DXQxQNd&input=%22Word+Icicle%21%22&debug=0)
```
V-SQdQ=XQxQNd
V-SQd              For each non-space character in the sorted input (Q)...
     Q             ... print the current value of Q...
      = Q          ... and set Q to itself...
         xQN       ... with the first instance of the character...
       X    d      ... replaced by a space.
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~60~~ ~~58~~ ~~55~~ 47 bytes
```
->a{[-a]+a.scan(/\S/).sort.map{|x|a[x]=' ';-a}}
```
[Try it online!](https://tio.run/##HYrNCoJAFIX3PcXVjUppDxAGFWISUWERMc3i5k8Zk8o4hTXOs5u6OPCd7xz@vn3b1G3tOUpiIx2jU0WYm9NrOLWcquDCeWEpm7pBUlPXAGNmo1It0c8FjyGIsoglmj4BPTBesE2YyPK7pg1mnTBWQPdj8dAXt1Xspf4jeG7YNt@VBx6K0@dcX379ut@vfMgqiBGWXnjslSlNqawuxLSopTrWqZNg9JCNaEblW1SQEkFV@wc "Ruby – Try It Online")
[Answer]
# [sed](https://www.gnu.org/software/sed/) `-rn`, 142 ~~143~~ bytes
```
:a
p
s/$/	ABCDEFGHIJKLMNOPQRSTUVWXYZ/
s	\w+$	!"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_`\L&{|}~	
:b
/(.).*	\1/!s/	./	/
tb
s/(.)(.*)	\1.*/ \2/
ta
```
[Try it online!](https://tio.run/##Dc1bU4JAAAXg591fAUW0YOym3emqREhqYmhkrhYIFQ0DDEuXyeinR/twZs585@GwKNRe0ve61n2YQ0YkAtod49K8srr2da8/uBk6o1t3PLnz7qcPBDJAPxsSENfWpQ0qbyJFbWxpmGw3Wzu7e/sHh0f68cnp2fmFPKN0vnh8on159VP9AqgHkCCsYBXQJhEZAZgAAsuAX3JGWFX4gFUi0BZnv669rAgFexkvk0iE3ShJMoFTEoqwHRih@Wy92m@9ZJAO81HhlpMP72v6DR3HsISYCaEvdEx3DNEKrSqFZ4aUuVLx/pflZZylrNaK9B8 "sed – Try It Online")
(note: there are tabs in the program)
Since sed has no concept of lexicographical order, I had to hardcode the set of printable ASCII characters in and it takes up more than half the bytecount.
Using sed 4.2.2 will reduce bytecount by 2, since that allows for unnamed labels, [Try it online!](https://tio.run/##Dc1bT4MwAAXg5/ZXFJ3YMte6ecfrhshwm2OyiXOdFwZGDAFCiRoRf7rYh5OcfOfhiDCoax1mULAGA92ecWleWX37ejAc3Yydya07nd159/MHBgXgn80GUNbWGxtc3cREa261KNtud3Z29/YPDo/045PTs/MLdcH58vHpmQ/V8qf6BVD3IcOUUA3wNlMEA5QBBgtfXkrGVCNyoBpDvCO5rr00D5C9ilZxqMB@GMcpkhQHCuz6RmC@Wm/2@yAeJeNskrvF7MP7mn9DxzEsFAkUvKCe6U4hLnFZEZkFJktSyf6XZkWUJqJu5ck/ "sed 4.2.2 – Try It Online")
---
`-r` enables extended regular expressions (golfier)
`-n` disables implicit printing of the pattern space at the end of the program
The pattern space starts with the input
`:a` label `a`, this is the main program loop
`p` print the pattern space (fancy name for the buffer)
now we append the set of printable ASCII characters (excluding the space)
`s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/` append a tab, acting as the 1-byte delimiter, followed by the uppercase alphabet
`s<tab>` substitute (sed can take any character as the delimiter, in this case the tab is used to save a byte from escaping the `/`)
* `\w+$` the uppercase alphabet we just appended
* `<tab>` with
* `!"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>` the rest of the characters, note that `\L&` is the lowercase version of the uppercase alphabet
`:b` label `b`, remove characters from the beginning set that are not present in input
`/(.).* \1/!` if the first character from the ASCII set is not in the input
* `s/ ./ /` remove it
`tb` repeat `b` until the substitution fails
`s/(.)(.*) \1.*/ \2/` replace the first character in the ASCII set present in the input with a space, and remove the ASCII set
`ta` recurse
[Answer]
# [R](https://www.r-project.org/), ~~140~~ 100 bytes
-40 bytes Thanks to Giuseppe !
```
function(x)for(i in any((z=utf8ToInt(x))<33):max(y<-rank(z,,"f"))){z[y==i]=32
cat(intToUtf8(z),"
")}
```
[Try it online!](https://tio.run/##DctBC4IwGIDhu79i7tL3gV7yEqGHiAgJiUiJiA7LWq30W4wZuui3L6/vw2u8ZGnsZUe1VZqgR6kNKKaICRoAXNZZOSt1TnY0TJME563oYUhjI@gFLoq45Ij4dachy9Q5S6ZBLSwosqWuxhccRjzg@PMSeD5pWXFrrKJ7GIYcg7EtLsvrSq4f@XPTFLR978zeVp9Df3Qc/R8 "R – Try It Online")
A solution using `outer` and Giuseppe's magic to work properly is longer at 104 bytes. Inspired by [this answer](https://codegolf.stackexchange.com/questions/142037/matrix-with-1-to-ln-in-all-n-columns/142047#142047). 
```
function(x,z=utf8ToInt(x)-32)apply(t(outer(rank(z,,"f"),(2-(min(z)>0)):nchar(x),">=")*z+32),1,intToUtf8)
```
[Try it online!](https://tio.run/##DczRCoIwFIDh@55Cd9M5NaHsJiKFiAgJiUiJLs1crvRMxgzby9tuf/h@PQpvG4yip9JIRTBwG/VGrDOVkIEBg1WIRdc1PzCgelNp0AV9wHLOBEMOYQCtJLAYLxA3VNaFdoqzOGI4s3On@ZJLMpnK3RVHASyZtl5aNUbSy/d9hhPXdo/98yCOdfI@NSmdu4u@mvx7G@6W4fgH "R – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 71 bytes
```
f=lambda a:[*a.strip()]and[a]+f(a.replace(min(a.replace(*" ~"))," ",1))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRIdEqWitRr7ikKLNAQzM2MS8lOjFWO00jUa8otSAnMTlVIzczD4mnpaRQp6SpqaOkoKRjqKn5v6AoM69EQykmT0kvKx@oMk1DyTHJOcU1zT3DM8s7xzfPvyCwKLgktCy8IrIKqFHzPwA "Python 3 – Try It Online")
-4 bytes thanks to ovs
[Answer]
# [Python 2](https://docs.python.org/2/), ~~70~~ ~~69~~ ~~66~~ 64 bytes
```
def f(s):print s;S=set(s)-{' '};S and f(s.replace(min(S),' ',1))
```
[Try it online!](https://tio.run/##LcqxCgIxEATQ3q/YVNmFU9DSww@4wiqFhVocyUYDuVzIpZGQb48RLAaGNxM/@b2GU2uGLVjc6ByTCxm2UV02zh32RYKso4I5mN/jkDj6WTMuLqCioa/DkahZlLc1GZi0056FpF2X6SEXuLLPLryE@CMWLJV67khPqr1Lal8 "Python 2 – Try It Online")
Thx for 2 bytes from [ovs](https://codegolf.stackexchange.com/users/64121/ovs) via using `S and f()` instead of `if S:f()`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
ẋ"ỤỤ$z⁶Q
```
[Try it online!](https://tio.run/##y0rNyan8///hrm6lh7uXAJFK1aPGbYH/H@7ecrj9UdMa78j//z2AavIVwvOLclIUuRyTnFNc09wzPLO8c3zz/AsCi4JLQsvCKyKruAICnN0VMosVUhIVnFyDQ7g0qjWqazWBOFpDM1azFsgGAA "Jelly – Try It Online")
### Idea
The basic idea is to build the columns of the desired output directly, instead of manipulating the string and returning all intermediate results.
We start by numerating the characters of the input string in the order they will be removed. For the moment, we'll pretend spaces will be removed as well.
```
tee ay oh
845139276
```
Now, we build the columns by repeating each character by its index in this enumeration.
```
tee ay oh
tee ay oh
tee ay oh
tee  y oh
t e  y oh
t    y oh
t    y o 
t    y   
     y   
```
All that's left is to remove duplicates, to account for the spaces.
### Code
```
ẋ"ỤỤ$z⁶Q  Main link. Argument: s (string)
    $     Combine the two links to the left into a chain.
  Ụ       Grade up; sort the indices of s by their corresponding values.
          Let's call the result J.
          Grade up again, sorting the indices of J by the corr. values in J.
          This enumerates the positions of s as described before.
ẋ"        Repeat each character of s that many times.
     z⁶   Zip the resulting 2D array, filling missing characters with spaces.
       Q  Unique; deduplicate the array of rows.
```
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, ~~37~~ 34 bytes
*Dropped three bytes with help from @TonHospel*
```
say&&s/\Q$a/ / while($a)=sort/\S/g
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJNrVg/JlAlUV9BX6E8IzMnVUMlUdO2OL@oRD8mWD/9/3@Nao3qWk0gjtbQjNWsNQBy/uUXlGTm5xX/1/U11TMwNPivmwcA "Perl 5 – Try It Online")
[Answer]
# JavaScript, ~~67~~ ~~66~~ 65 bytes
Because I haven't golfed drunk in a while!
```
s=>[...t=s].sort().map(x=>x>` `?t+=`
${s=s.replace(x,` `)}`:0)&&t
```
[Try it online](https://tio.run/##HY5Ra8IwHMTf9ylSEJeghj0P0qEiWobM4URGV/hnSepSYlKSIGWln72Lezi4@909XMNvPAiv27iwTqqxZmNgeUkpjSxUNDgfMaFX3uKO5V0OCF7ijMHDpA8sUK9aw4XC3TwVZIDnJzKdxlE4G5xR1LgLLuHsvESF0MKoDOZQPF7RXpmo7SXL7mCnjHEorYy8x@X3Wm7q7U/RvJq9fWvf/TGebufu8zeVh8N6i3RAkqPV5viRCO5xP5CkEpOKDMlD9f@3JrRx2sKXBTL@AQ)
Thanks to DanielIndie for pointing out 4 redundant bytes that beer included!
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~26~~ 24 bytes
```
{?(,x),x{x[y]:" ";x}\<x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqtpeQ6dCU6eiuiK6MtZKSUHJuqI2xqai9n@aUnh@UYqCZ3Jmck6qohJXmpKneq6Cb2pOSWZeuqIiWMQjNScnXwGoLicFzHdMck5xTXPP8MzyzvHN8y8ILAouCS0Lr4isAskGBDi7K2QWK6QkKji5BoeAhDSqNaprNYE4WkMzVrMWyFb6DwA "K (ngn/k) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 129 bytes
```
var s=ReadLine();while(s.Any(c=>c!=32)){WriteLine(s);var i=s.IndexOf(s.Min(c=>c==32?(char)999:c));s=s.Remove(i,1).Insert(i," ");}
```
[Try it online!](https://tio.run/##HcuxCsIwEIDhV2m6mAMtqFMMqTgWLEIX55Ce9qCNkAtVEZ89xm7/8P2ON44ppdmGgk2Htj@TRwn6OdCIkquTf0tnaifMfgfwuQaKuBAG/Z/IcNX4Hl@XW9Yt@UWbrI/SDTaAUurgADRn2OH0mFHSegt5Ygwxd1mUoL8pNaupaHGM5O9CiB8 "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
## [Perl 5](https://www.perl.org/) with `-nlF/\s|/`, 39 bytes
```
@F=sort@F;say,s~\Q$F[$F++]~ ~ while/\S/
```
This might be pushing the boundaries of Perl's flags not being counted, if so I'll revert to the previous answer.
[Try it online!](https://tio.run/##DchNC4IwAIDhu79iggfFbHbwJIIlziQkxUJCPZguNIYTJ32Z/vSWhxce3g73xOASsnST28hitB9sZLLivWJzFkkolZCq5jOYwbNuCIZZDDlPaF8Bv2xKgkVRFPaYEAqWSSpR2F6dyr15tX8/kKA9dlEfD@dH8rp8hDB0PNAwUBVg58YnQR7lcVKWUlnJlWnxj3ZDQ1vGtZYgmLEv5FpgrPWN/gc "Perl 5 – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), 27 bytes
```
>>ò2Ùúú^lDhrfDj|@"r kdòdj<H
```
[Try it online!](https://tio.run/##K/v/387u8CajwzMP7zq8Ky7HJaMozSWrxkGpSCE75fCmlCwbD8IqAA "V – Try It Online")
Hexdump:
```
00000000: 3e3e f232 d9fa fa5e 6c44 6872 6644 6a7c  >>.2...^lDhrfDj|
00000010: 4022 7220 6b64 f264 6a3c 48              @"r kd.dj<H
```
[Answer]
# [Haskell](https://www.haskell.org/), 67 bytes
*12 bytes saved thanks to Laikoni*
```
f s|(a,_:b)<-span(/=minimum(id=<<words s))s=putStrLn s>>f(a++' ':b)
```
[Try it online!](https://tio.run/##Dcy7CoAgFADQX7m4pFS0hzY3tDU0xg2TJB/hLVr6d/MDzjmQzt25nA3Qx7FZ@03Ili4MvFPeBusfz61WUr4xaQISgtT13POdpgA0DIZjXVdQFZc92qAMG0sYG1hicprlHw "Haskell – Try It Online")
*This one terminates in an error*
# [Haskell](https://www.haskell.org/), ~~83~~ 79 bytes
```
g(a,_:b)=a++' ':b
mapM_ putStrLn.(iterate$g.(span=<<(/=).minimum.concat.words))
```
[Try it online!](https://tio.run/##DcyxCsMgEADQvV8hoRAl4bqH3N6hnTp0DJdEotQ7RQ39fNv3Ac9R@dgQWjs0jcu0GqRh6FU/rReHTOm5qHTWV80PAe2rzVTt9QBdEgnOs76hAfbi@WTYomxU4RvzXoxpTF7Qdfd/H0f1jjnsXfsB "Haskell – Try It Online")
*This one terminates in an error*
# [Haskell](https://www.haskell.org/), 86 bytes
```
u=concat.words
g(a,_:b)=a++' ':b
(take.length.u)<*>(iterate$g.(span=<<(/=).minimum.u))
```
[Try it online!](https://tio.run/##Dc2xDoMgEADQ3a8whkSohu4GnLt36NicSoAIh4Ej/Xzq/pLnoJwmhNaq3hPuQPKX8lE6y2H@LpvQME1jPy5b5zQnOI0MBi05WYV6rNyTyUCGWcnLBaiV4k8tZPToY403Ei2CR31VelNmFYNHU5gbXnea5v6TcjiG9gc "Haskell – Try It Online")
# [Haskell](https://www.haskell.org/), ~~100~~ ~~91~~ 88 bytes
```
u=concat.words
f x|(a,_:b)<-span(/=minimum(u x))x=a++' ':b
(take.length.u)<*>(iterate f)
```
[Try it online!](https://tio.run/##Dc0xDoMgFADQ3VMQYyJUa3cjzt07dGy@ioUIHwOflKF3p30XeBrioawtJcnV4wo0fHzYYrWz/OXQv8ZFTNd4AvKbdAaNS44nloXIErquZe24VFpygkMNVuGb9JDEdJm5IRWAFNtFcWBQnokeFJqE1qCKja7v/9b37OmD3eryAw "Haskell – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~80~~ 65 bytes
```
x=>[...x].sort().map(c=>x=x.replace(c,' ',c>' '&&console.log(x)))
```
[Try it online!](https://tio.run/##DcQxDsMgDADAr4QMwZZS/wD2Dn1B1QG5VpSKYASo8u9pb7hP@qbO7azjVvQtE6aF@CQie1HXNgDpShU4RAtGTWpOLMC7X/zO8f@2sZauWSjrAYaIE2G9@2t5SB5nOZxzK84f "JavaScript (Node.js) – Try It Online")
Didn't know `replace` take string as string, not regexp
[Answer]
# [K4](http://kx.com/download/), ~~28~~ ~~20~~ 18 bytes
**Solution:**
```
?x{x[y]:" ";x}\<x:
```
**Example:**
```
q)k)?x{x[y]:" ";x}\<x:"PPCG is da BEST"
"PPCG is da BEST"
"PPCG is da  EST"
"PP G is da  EST"
"PP G is da   ST"
"PP   is da   ST"
" P   is da   ST"
"     is da   ST"
"     is da    T"
"     is da     "
"     is d      "
"     is        "
"      s        "
"               "
```
**Explanation:**
It's the same thing as [ngn](https://codegolf.stackexchange.com/a/162183/69200) is doing. Find indices that would result in an ascending list, overwrite them one-by-one with `" "`, then take the distinct to remove any duplicate lines:
```
?x{x[y]:" ";x}\<x: / the solution
                x: / save input as x
               <   / return indices that would result in ascending sort
 x{        ; }\    / two-line lambda with scan
        " "        / whitespace
       :           / assignment
   x[y]            / x at index y
            x      / return x
?                  / distinct
```
[Answer]
# gcc 32-bit, ~~66~~ 65 bytes
```
char*p,i;f(a){for(i=32;i++;)for(p=a;*p;)*p==i?puts(a),*p=32:++p;}
main(){char s[]="3.1415926";f(s);}
```
Thanks for Jonathan Frech for -1 byte
[Answer]
# MATLAB, 74 bytes
This uses the 2-output form of the max() function to retrieve the smallest character and its index, having transformed the string to zero values in the spaces and 256-the character value for the printable characters.
```
s=input('s');x=1;while(x);disp(s);[x,y]=max((256-s).*(s~=' '));s(y)=' ';end
```
[Answer]
# [Common Lisp](http://www.clisp.org/), ~~240~~ ~~228~~ 224 bytes
```
(setf s(read))(defun f(x)(setf y(char-code(elt s x)))(if(= y 32)1e9 y))(loop for _ across s do(print s)do(setf s(replace s" ":start1(position(code-char(reduce #'min (loop for i from 0 below(length s)collect i):key #'f))s))))
```
[Try it online!](https://tio.run/##RY5NTgMxDIWv4pkuai8qtbCiEgdgwRlQSJzWIhNHcSo6px9cIcHOev7eTyxibdvQeGQw7BwSESbOtwoZ7/T7WDFeQz9ETYxcBhjcyTHJ@AorPD/RiV9gdaWoNsja4QNC7GrmaFJsXaq7yM@/olZCZLAZ5rON0McJm5oM0YqPnsOj0bF0c2q3X6TCf7pA7rrAET656DcWrpdx9fyopXAcIHT@4tVtmch8KW3b/LZf4N3HS71M0zT/AA "Common Lisp – Try It Online")
This is my first time posting.  
I'm in the process of learning lisp so I'm sure someone can think of something shorter than this.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 39 bytes[SBCS](https://github.com/abrudz/sbcs)
```
{⎕←⍵⋄×≢⍵∩g←' '~⍨⎕UCS⍳256:∇' '@(⊃g⍋⍵)⊢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR31TgdSj3q2PulsOT3/UuQjE7FiZDhRUV1Cve9S7Aqgi1Dn4Ue9mI1Mzq0cd7UBhB41HXc3pj3q7gYo1H3WB9NQCzVP3SM3JyVcIzy/KSVFU50pTd0xyTnFNc8/wzPLO8c3zLwgsCi4JLQuviKwCyQYEOLsrZBYrpCQqOLkGh4CENKo1qms1gThaQzNWsxbIVgcA "APL (Dyalog Unicode) – Try It Online")
Dfn.
### How?
```
{⎕←⍵⋄×≢⍵∩g←' '~⍨⎕UCS⍳256:∇' '@(⊃g⍋⍵)⊢⍵} ⍝ Main function, argument ⍵
 ⎕←⍵⋄                                    ⍝ Print ⍵
         g←' '~⍨⎕UCS⍳256                 ⍝ Assign to g every Unicode character except space
     ×≢⍵∩                :               ⍝ If ⍵∩g is not empty
                          ∇              ⍝ Recursively call the function with argument:
                           ' '@       ⍵  ⍝ Space at
                               (⊃g⍋⍵)    ⍝ The first (⊃) element in ⍵ graded up (⍋) with g
                                         ⍝ The dyadic grade up function will index ⍵ according
                                         ⍝ to its left argument, in this case g.
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~103~~ 99 bytes
```
param($a)2..$a.length|%{($x=$a);[regex]$p=""+([char[]]$a-ne' '|sort)[0];$a=($p.replace($x," ", 1))}
```
[Try it online!](https://tio.run/##Dc1BCsIwEEDRq8RhpAnWoG5L9t7ARchiqEOziE2YFlqwnj1m@@HxS95Ylsgp1VpI6KORzMNaJJt4ntZ4nL8ad9fq4IUn3gMWB3DRfowkPgSk68yd6o4ly2r8LQxITmOxwiXRyE33oKBXd2N@tVZ4tllWryzpfYI/ "PowerShell – Try It Online")
Takes input as a string into `$a`. We then loop from `2` to `$a.length` (i.e., the appropriate number of vertical times necessary to remove all but one character). Each iteration, we output the current string and conveniently saved into `$x` at the same time. We then construct a new `[regex]` object, `$p`attern consisting of the remaining characters in `$a` that are `-n`ot`e`qual to space, `sort`ed, then the `0`th one thereof.
We then set `$a` equal to a new string of the regex object with the `.Replace` method to replace in the string `$x`, the `$p`attern, with a space `" "`, but only the `1`st match. Yeah, this syntax is weird.
The strings are left on the pipeline and implicit `Write-Output` gives us a newline between them for free, plus one trailing newline.
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 140 bytes
```
s->{for(int m=1,i;m>0;s=s.substring(0,i=s.indexOf(m=s.chars().filter(c->c>32).min().orElse(0)))+" "+s.substring(i+1))System.out.println(s);}
```
[Try it online!](https://tio.run/##bY4/T8MwEMX3foojk00aq4UxNAtiYEAMHRgQg@s45Yr/RL5LAVX97MFNB5DodPd@793p7fReV7v2Y0Tfx8Swy1oNjE5d17N/rBuCYYzhokmcrPYnyzhNBE8aAxxmAP2wcWiAWHMe@4gt@OyJNScM29c30GlLcooC3MdAg7fp7uw28BlT@2jQOAurkarm0MUkMDD41XKOtW8WNa1I0bCh6UIs5pg1htZ@PXfC592860RCqg4d2yRM1Zjm9kYqn0tIFdODIysWUsqygKL8@wvLpZTrb2LrVRxY9ZmyC4JkfRzrqfBvP6WNsT2L4iUjOLOrQp5ix9lx/AE "Java (JDK 10) – Try It Online")
Technically there's a blank line, but it's not *empty*.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 9 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü¡%/"=πbΓ
```
[Run and debug it](https://staxlang.xyz/#p=81ad252f223de362e2&i=Word+Icicle%21%0AI%27m+Melting%21%21%21%0AHello+World%21%0AAbCdEfGhIjKlMnOpQrStUvWxYz%0APPCG+is+da+BEST%0A%28%7B%28%7B%7D%29%28%7B%7D[%28%29]%29%7D%7B%7D%29&m=2)
This is the same algorithm as [Luis' 05AB1E solution](https://codegolf.stackexchange.com/a/162206/527)
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~17~~ 16 bytes
```
tSXz"tOy@=f1)(]x
```
[Try it online!](https://tio.run/##y00syfn/vyQ4okqpxL/SwTbNUFMjtuL/f/Xw/KIUBc/kzOScVEV1AA) Or [verify all test cases](https://tio.run/##y00syfmf8L8kOKJKqcS/0sE2zVBTI7bif4RLyH/18PyiFAXP5MzknFRFdS51T3X1XAXf1JySzLx0RUWQiEdqTk6@AlBZTgqI65jknOKa5p7hmeWd45vnXxBYFFwSWhZeEVkFlAwIcHZXyCxWSElUcHINDgGKaFRrVNdqAnG0hmasZi2QrQ4A).
### Explanation
```
t       % Implicit input. Duplicate
S       % Sort
Xz      % Remove spaces
"       % For each char in that string
  t     %   Duplicate last result. This is the most recent string obtained
        %   from replacing chars by spaces in the input
  O     %   Push 0
  y     %   Duplicate from below
  @     %   Push current char
  =     %   Equals? (element-wise) Gives 1 for occurrences of current char
        %   in the most recent string, 0 otherwise
  f     %   Indices of nonzeros
  1)    %   Get the first entry
  (     %   Write 0 at that position. Char 0 will be displayed as space
]       % End
x       % Delete last result, which consists only of space / char zero
```
[Answer]
# Excel VBA, 167 bytes
An anonymous VBE immediate window function that takes input from range `[A1]` and outputs to the VBE immediate window.
```
s="Code(Mid(A$1,Row(),1))":[B1].Resize([Len(A1)])="=If("&s &"=32,1E3,"&s &")":For i=1To[Len(A1)-CountIf(B:B,1E3)]:?[A1]:[A1]=[Substitute(A1,Char(Min(B:B))," ",1)]:Next
```
# Ungolfed and Commented
```
''  run as `call icicle("Test")` or `icicle"I am the WALRUS`
Sub icicle(Optional str As String)
    If Not IsMissing(str) Then [A1] = str   ''  pipe input
    [B:B].Clear                             ''  reset between runs
    [B1].Resize([Len(A1)]) = "=If(Code(Mid(A$1,Row(),1))=32,1E3,Code(Mid(A$1,Row(),1)))"  ''  get char number for every char in input
    For i = 1 To [Len(A1)-CountIf(B:B,1E3)] ''  iterate across from 1 to length of input - number of spaces
        Debug.Print [A1]                    ''  output a single line
        [A1]=[Substitute(A1,Char(Min(B:B))," ",1)]  ''  replace minimum char with space
    Next
End Sub
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~32~~ 18 bytes
*Saved 14 bytes thanks to Shaggy!*
```
rS ¬£=hSUbZn gYÃiN
```
[Try it online!](https://tio.run/##y0osKPn/vyhY4dCaQ4ttM4JDk6LyFNIjDzdn@v3/r@SY5Jzimuae4ZnlneOb518QWBRcEloWXhFZpcTFpRsEAA "Japt – Try It Online")
]