Question: Say I have text like this (each word on one line, with no spaces)

```
Programming
Puzzles
&
Code
Golf

```

That makes no sense! It totally defies the laws of physics.

Your challenge is to remedy this impossible situation and collapse the text like so:

```
P
Prog
&uzz
Coderam
Golflesming

```

So that there is no empty space underneath any character but the characters retain their vertical order.

The goal is to satisfy the requirements but use the fewest bytes of source code possible.

Answer: 
Haskell, 62 bytes
=================

```
import Data.List
p=reverse;o=transpose
f=unlines.p.o.o.p.lines

```

I'm very mature.
[Turtlèd](https://github.com/Destructible-Watermelon/turtl-d/), 72 bytes, noncompeting
======================================================================================

Fairly sure I could change approach to save bytes, but later.

:p Non-golf esolang beats regular langs :p

The odd thing about Turtlèd is it was originally made after discussion about ascii art langs, but it actually seems to be best at these kinds of challenges

Turtlèd can not take newline input but for multiple inputs, and this takes only one input: terminate each word with a space, including the last one.

```
!l[*,+r_][ l]ur[*,[ -.]+.[ r{ d}u+.]-.[ -.]{ l}[ l]r[ u]_]' d[ d]u[ ' r]

```

### [Try it online!](http://turtled.tryitonline.net/#code=IWxbKiwrcl9dWyBsXXVyWyosWyAtLl0rLlsgcnsgZH11Ky5dLS5bIC0uXXsgbH1bIGxdclsgdV1fXScgZFsgZF11WyAnIHJd&input=UHJvZ3JhbW1pbmcgUHV6emxlcyAmIENvZGUgR29sZiA)

Explanation:
------------

```
!                          Take string input
 l                         Move left, off the asterisk at the start of grid
  [*    ]                  Until cell is *
    ,+r_       write *, string pointer+=1, move right, write * if pointed char is last char
         [ l]ur    move left until finding a space, move up and right
               [*                                        ]     Until cell is *
                 ,                               write *
                  [   ]             until cell is [space]
                    -.               decrement string pointer, write pointed char
                       +.           increment and write string pointer
                         [         ] until cell is [space]
                           r{ d}     move right, move down until finding nonspace
                                u+.  move up, string pointer+=1 and write pointed char
                                    -.      decrement string pointer and write pointed char
                                      [   ]  until cell is [space]
                                        -.  string pointer-=1 and write pointed char
                                           { l}   move left until finding nonspace
                                               [ l]   move left until finding space
                                                   r   move right
                                                    [ u]  move up until finding space
                                                        _  write * if pointed char is last char
                                                          (if it is written, loop ends)

                                                          ' d[ d]u[ ' r] just cleanup

```