Digamos que eu tenha um texto como este (cada palavra em uma linha, sem espaços)

Programming
Puzzles
&
Code
Golf

Isso não faz sentido! Isso desafia totalmente as leis da física.

Seu desafio é remediar essa situação impossível e recolher o texto da seguinte maneira:

P
Prog
&uzz
Coderam
Golflesming

Para que não haja espaço vazio embaixo de qualquer caractere, os caracteres mantêm sua ordem vertical.

O objetivo é satisfazer os requisitos, mas use o menor número possível de bytes de código-fonte.

Pitão, 10 bytes

jb_.T.T_.z

Experimente online no Pyth Compiler / Executor .

Idéia

Podemos alcançar a saída desejada aplicando quatro transformações simples:

1. Inverta a ordem das linhas:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Transponha linhas e colunas:

   GC&PP
   oour
   ldzo
   fezg
   lr
   ea
   sm
   m
   i
   n
   g
   

   Esta parte superior justifica, recolhendo as colunas originais.

3. Transponha linhas e colunas:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Inverta a ordem das linhas:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

Código

        .z  Read the input as a list of strings, delimited by linefeeds.
       _    Reverse the list.
   .T.T     Transpose the list twice.
  _         Reverse the list.
jb          Join its strings; separate with linefeeds.

Haskell, 62 bytes

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

Sou muito madura

Python 2, 104 bytes

l=[]
for x in input().split('\n'):n=len(x);l=[a[:n]+b[n:]for a,b in zip(l+[x],['']+l)]
print'\n'.join(l)

Um algoritmo iterativo de uma passagem. Analisamos cada linha em ordem, atualizando a lista lde linhas para saída. A nova palavra efetivamente sai do fundo, deslocando todas as letras acima dela em um espaço. Por exemplo, no caso de teste

Programming
Puzzles
&
Code
Golf

depois que terminamos Code, temos

P
Prog
&uzzram
Codelesming

e, em seguida, adicionando Golfresultados em

P
Prog
&uzz
Coderam
Golflesming

que podemos ver como a combinação de duas peças

P     |
Prog  |
&uzz  |
Code  | ram
Golf  | lesming

onde a primeira peça foi deslocada golf. Realizamos esse deslocamento com um zipda lista de saída com o elemento no final (lado esquerdo) e a precedência da lista de saída por uma linha em branco (lado direito), cortando cada parte no comprimento do novo elemento.

Pode parecer mais natural, ao contrário, iterar para trás, deixando que novas cartas caiam do topo, mas minha tentativa disso acabou por mais tempo.

Para comparação, aqui está uma abordagem zip/ filter, com map(None,*x)usado para iziplongest(109 bytes):

f=lambda z:[''.join(filter(None,x))for x in map(None,*z)]
lambda x:'\n'.join(f(f(x.split('\n')[::-1]))[::-1])

CJam, 11 bytes

qN/W%zzW%N*

Experimente online no intérprete CJam .

Como funciona

A idéia é a mesma da minha resposta Pyth .

q           e# Read from STDIN.
 N/         e# Split at linefeeds.
   W%       e# Reverse the resulting array.
     zz     e# Transpose it twice.
       W%   e# Reverse the resulting array.
         N* e# Join its strings; separate with linefeeds.

JavaScript (ES6), 146

(As duas novas linhas dentro das seqüências de modelo são significativas e contadas)

A idéia de @Dennis implementada em JavaScript. A longa função S faz a transposição linha por linha e char por char, deixando o resultado na tmatriz.

a=>(S=z=>{for(t=[];z.join``;t.push(w))for(w='',n=z.length;n--;z[n]=z[n].slice(1))w+=z[n][0]||''},S(a.split`
`),S(t.reverse()),t.reverse().join`
`)

Menos golfe dentro do snippet (experimente no Firefox)

F=a=>(
  S=z=>{
    for(t=[];z.join``;t.push(w))
      for(w='',n=z.length;n--;z[n]=z[n].slice(1))
        w+=z[n][0]||''
  },
  S(a.split`\n`),
  S(t.reverse()),
  t.reverse().join`\n`
)

#I,#O { margin:0; width: 200px; height:100px; border: 1px solid #ccc }

<table><tr><td>
Input<br><textarea id=I>Programming
Puzzles
&
Code
Golf
</textarea></td><td>
Output<pre id=O></pre>
</td></tr></table>  
<button onclick='O.innerHTML=F(I.value)'>go</button>

R, 223 bytes

function(x){a=apply(do.call(rbind,lapply(p<-strsplit(strsplit(x,"\n")[[1]],""),function(x)c(x,rep(" ",max(lengths(p))-length(x))))),2,function(x)c(x[x==" "],x[x!=" "]));for(i in 1:nrow(a))cat(a[i,][a[i,]!=" "],"\n",sep="")}

Essa é uma maneira absurdamente longa e ingênua de fazer isso.

Ungolfed:

f <- function(x) {
    # Start by spliting the input into a vector on newlines
    s <- strsplit(x, "\n")[[1]]

    # Create a list consisting of each element of the vector
    # split into a vector of single characters
    p <- strsplit(s, "")

    # Pad each vector in p to the same length with spaces
    p <- lapply(p, function(x) c(x, rep(" ", max(lengths(p)) - length(x))))

    # Now that the list has nice dimensions, turn it into a matrix
    d <- do.call(rbind, p)

    # Move the spaces to the top in each column of d
    a <- apply(d, 2, function(x) c(x[x == " "], x[x != " "]))

    # Print each row, omitting trailing whitespace
    for (i in 1:nrow(a)) {
        cat(a[i, ][a[i, ] != " "], "\n", sep = "")
    }
}

Você pode experimentá-lo online .

Matlab / Octave, 99 bytes

function f(s)
c=char(strsplit(s,[10 '']));[~,i]=sort(c>32);[m,n]=size(c);c(i+repmat((0:n-1)*m,m,1))

Exemplo :

Defina uma sequência de entrada em uma variável, digamos s. 10é o caractere de avanço de linha:

>> s = ['Programming' 10 'Puzzles' 10 '&' 10 'Code' 10 'Golf'];

Função de chamada fcom entrada s:

>> f(s)
ans =
P          
Prog       
&uzz       
Coderam    
Golflesming

Ou experimente on-line (obrigado a @beaker pela ajuda com o intérprete Octave on-line)

JavaScript ES6, 119 bytes

F=s=>(C=o=>--a.length?C(a.reduce((p,c,i)=>c+p.slice((a[i-1]=p.slice(0,c.length)).length)))+`
`+o:o)(a=(s+`
`).split`
`)

Aqui ele é não-destruído e no ES5 com comentários explicando como funciona:

function F(s) {
  var arr = (s+'\n').split('\n'); // Create an array of words and append an empty member
  return (function C(output) {
    return --arr.length ? // Remove the last item from the array
      C(arr.reduce(function(p,c,i) { // If the array still has length reduce it to a string and recurse
        var intersection = (arr[i-1] = p.slice(0, c.length)) // Overwrite the previous word with the part that intersects the current word
        return c + p.slice(intersection.length) // Add the part of the previous word that doesn't intersect to the current value
      })) + '\n' + output : output // Add the last level of recursions output on to the end of this
  })(arr);
}

input.addEventListener('input', updateOutput, false);

function updateOutput() {
  var oldLength = input.value.length;
  var start = this.selectionStart;
  var end = this.selectionEnd;
  input.value = input.value.split(/ +/).join('\n');
  var newLength = input.value.length;
  input.setSelectionRange(start, end + (newLength - oldLength));
  output.value = F(input.value).trim();
}

updateOutput();

textarea {
  width: 50%;
  box-sizing: border-box;
  resize: none;
  float: left;
  height: 10em;
}

label {
  width: 50%;
  float: left;
}

<p>Type in the input box below, spaces are automatically converted to newlines and the output updates as you type</p>
<label for="input">Input</label>
<label for="output">Output</label>
<textarea id="input">
Type inside me :)
</textarea>
<textarea id="output" disabled>
</textarea>

APL (Dyalog Extended) , 13 11 bytes ^SBCS

-2 com minhas extensões para Dyalog APL.

Função tácita anônima, recebendo e retornando uma matriz de caracteres.

~∘' '⍤1⍢⍉⍢⊖

Experimente online!

~ remova
∘ os
' ' espaços
⍤ das
1 linhas (sub-matrizes 1D iluminadas)
⍢ enquanto
⍉ transpostas
⍢ enquanto
⊖ viradas

R, 190 178 175 Bytes

Provavelmente ainda há espaço para jogar nisto. Provavelmente algumas operações desnecessárias lá

l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')

Ungolfed e explicou

a<-scan(,'')    # get STDIN
h<-length(a)    # number of lines
w=max(nchar(a)) # length of longest line
M<-lapply(a,substring,1:w,1:w)   # create a list of split strings with empty chars
M<-do.call(rbind,M)[h:1,]        # turn it into a matrix with line order reversed
M<-apply(M,1,paste0,collapse='') # paste together the columns
M<-lapply(M,substring,1:h,1:h)   # split them back up
M<-do.call(rbind,M)[,h:1]        # reform a matrix
M<-rbind(M,'\n')                 # add some carriage returns
cat(M,sep='')   # output with seperators

Execução de teste. É interessante notar que, devido à maneira como a digitalização funciona, a frase inteira pode ser inserida com espaços e ainda fornecer a saída conforme especificado.

> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming
2: Puzzles
3: &
4:     Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming
> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming Puzzles & Code Golf beta
7: 
Read 6 items
P
Prog
&uzz
Code
Golfram
betalesming
>   

STATA, 323 bytes

Recebe entrada em um arquivo chamado ab. Só funciona com até 24 caracteres agora. Será atualizado mais tarde para fazê-lo funcionar com mais. Além disso, não funciona no compilador online. Requer o compilador não livre.

gl l=24/
forv x=1/$l{
gl a="$a str a`x' `x'"
}
infix $a using a.b
gl b=_N
forv k=1/$l{
gen b`k'=0
qui forv i=$b(-1)1{
forv j=`i'/$b{
replace b`k'=1 if _n==`j'&a`k'==""
replace a`k'=a`k'[_n-1] if _n==`j'&a`k'==""
replace a`k'="" if _n==`j'-1&b`k'[_n+1]==1
replace b`k'=0
}
}
}
forv i=1/$b{
forv k=1/$l{
di a`k'[`i'] _c
}
di
}

Editar: moveu o silenciosamente (para suprimir a saída) para o próprio loop de cada instrução no loop, economizando 8 bytes.

R, 171 bytes

S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")

Com novas linhas e recuo:

S=scan(,"") #Takes input from stdin
while(any((D<-diff(N<-sapply(S,nchar)))<0)){
    n=max(which(D<0))
    S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]))
    S[n]=substr(S[n],1,N[n]+D[n])
}
cat(S,sep="\n")

Uso:

> S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")
1: Programming
2: Puzzles
3: &
4: Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming

Gelatina , 6 bytes (não concorrente)

ỴṚZZṚY

Experimente online!

Como funciona

A idéia é a mesma da minha resposta Pyth .

ỴṚZZṚY  Main link. Argument: s (string)

Ỵ       Split at linefeeds.
 Ṛ      Reverse the order of the lines.
  ZZ    Zip/transpose twice.
    Ṛ   Reverse the order of the lines.
     Y  Join, separating by linefeeds.

Turtlèd , 72 bytes, não competidor

Com certeza eu poderia mudar a abordagem para salvar bytes, mas mais tarde.

: p Esolang não-golfe bate langs regulares: p

O estranho de Turtlèd é que ele foi originalmente feito depois de uma discussão sobre ascii art langs, mas na verdade parece ser melhor nesses tipos de desafios

Turtlèd não pode receber entrada de nova linha, mas para várias entradas, e isso requer apenas uma entrada: termine cada palavra com um espaço, incluindo a última.

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

Experimente online!

Explicação:

!                          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

Perl, 133 bytes

Esse foi um daqueles desafios que mudaram na minha cabeça de ser muito difícil, fácil e muito mais código do que eu previra ... Não estou particularmente feliz com a abordagem, tenho certeza de que há uma maneira muito melhor de reduzir o print pop@F...bit usando talvez -nou apenas regex puro, mas não posso chegar lá agora ... Originalmente, eu estava usando say, mas acho que teria que pontuar mais ( use 5.01) por causa disso $'.

@F=(/.+/g,@F)for<>;$_%=$#F,($x=length$F[$_++])<length$F[$_]&&($F[$_]=~/.{$x}/,$F[$_-1].=$',$F[$_]=$&)for 0..1e2;print pop@F,$/while@F

Uso

Salvar como vertically-collapse-text.pl.

perl vertically-collapse-text.pl <<< 'Programming
Puzzles
&
Code
Golf'
P
Prog
&uzz
Coderam
Golflesming

SmileBASIC, 90 bytes

X=RND(50)Y=RND(20)G=CHKCHR(X,Y+1)<33LOCATE X,Y+G?CHR$(CHKCHR(X,Y));
LOCATE X,Y?" "*G
EXEC.

Aplica gravidade a todo o texto no console. Não tenho certeza se isso é válido ou se tenho que usar uma matriz de string.

Ruby, 99 82 bytes

Chegando la...

f=->a,i=-1{a.map{|l|i+=1;(0...l.size).map{|c|a.map{|x|x[c]}.join[~i]}*''}.reverse}

Uma tentativa de explicação:

f=->a,i=-1{a.map{|l|i+=1; # For each line `l` with index `i` in string array `a`
(0...l.size).map{|c|        # For each column `c` in `l`
a.map{|x|x[c]}.join           # Make a string of non-nil characters `c` across `a`...
[~i]                          # ...and grap the `i`th character *from the end*, if any
}*''}.reverse}              # Join the characters grabbed from each column and reverse the result

Execute-o assim:

a = %w[
  Programming
  Puzzles
  &
  Code
  Golf
]
puts f[a]

K, 30

{+{(-#x)$x@&~^x}'+x@\:!|/#:'x}

.

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

Explicação

x@\:!|/#:'x estende cada string para criar uma matriz de caracteres quadrada.

k){x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"Programming"
"Puzzles    "
"&          "
"Code       "
"Golf       "

+ transpõe

k){+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"PP&CG"
"ru oo"
"oz dl"
"gz ef"
"rl   "
"ae   "
"ms   "
"m    "
"i    "
"n    "
"g    "

{(-#x)$x@&~^x} removerá os espaços de uma string e, em seguida, preencherá a string pelo comprimento original

k){(-#x)$x@&~^x}"a  b  c   de  f"
"         abcdef"

Aplique essa função a cada uma das seqüências de caracteres transpostas e depois gire a saída para obter o resultado

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

pb - 310 bytes

^w[B!0]{w[B=32]{vb[1]^b[0]}>}b[1]vb[1]>b[2]<[X]w[B!2]{t[T+B]b[0]>}b[0]v[T]w[X!-1]{b[1]<}b[1]vb[1]w[B!0]{w[B!0]{^w[B!0]{>}<<<<^[Y+1]w[B!0]{<}>t[B]b[0]w[B!1]{v}v<[X]w[B!0]{>}b[T]}b[0]vb[1]^w[X!0]{<vb[1]^t[B]b[0]^w[B!0]{^}b[T]w[B!0]{v}}vw[B!0]{^^w[B!0]{>}<b[0]vvw[B=0]{<}b[0]<[X]}^^>w[B=0]{vb[1]}v<<}>>^b[0]^<b[0]

Que desastre. Eu mal me lembro de nada sobre como isso funciona.

Devido à maneira como a entrada do pb funciona (uma única linha ao mesmo tempo), é necessário usar espaços em vez de novas linhas na entrada. Se o intérprete não fosse lixo e você pudesse incluir novas linhas na entrada, a única alteração seria a [B=32]do início [B=10].

Estou trabalhando em uma atualização para o pbi (o intérprete) que limpará os recursos visuais se você quiser assistir o programa sendo executado. Ele ainda precisa de muito trabalho, mas, enquanto isso, você pode assistir a este programa no YouTube .

J, 17 bytes

-.&' '"1&.(|:@|.)

Solução bastante agradável.

Explicação:

-.&' '"1&.(|:@|.)  input: list of strings y
              |.   reverse lines
           |:@     then transpose
-.&' '"1           remove blanks from columns
        &.         and undo the inside
           |:@|.   (that is, transpose and reverse again.)

Caso de teste explicado

   s
Programming
Puzzles
&
Code
Golf
   |.s
Golf
Code
&
Puzzles
Programming
   |:|.s
GC&PP
oo ur
ld zo
fe zg
   lr
   ea
   sm
    m
    i
    n
    g
   -.&' '"1|:|.s
GC&PP
oour
ldzo
fezg
lr
ea
sm
m
i
n
g
   |.-.&' '"1|:|.s
g
n
i
m
sm
ea
lr
fezg
ldzo
oour
GC&PP
   |.|:-.&' '"1|:|.s
P
Prog
&uzz
Coderam
Golflesming
   (-.&' '"1)&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming
   -.&' '"1&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming

Casos de teste

   f =: -.&' '"1&.(|:@|.)
   f
-.&' '"1&.(|:@|.)
   f >'Programming';'Puzzles';'&';'Code';'Golf'
P
Prog
&uzz
Coderam
Golflesming
   g =: [: > [: <;._1 '|'&,
   g 'Programming|Puzzles|&|Code|Golf'
Programming
Puzzles
&
Code
Golf
   f g 'Programming|Puzzles|&|Code|Golf'
P
Prog
&uzz
Coderam
Golflesming
   F =: f @ g
   F &. > 'Programming|Puzzles|&|Code|Golf' ; '1|23|456|7890' ; '1234|567|89|0'
+-----------+----+----+
|P          |1   |1   |
|Prog       |23  |52  |
|&uzz       |456 |863 |
|Coderam    |7890|0974|
|Golflesming|    |    |
+-----------+----+----+

Na verdade , 13 bytes

Isso usa o algoritmo descrito na resposta de Dennis 'Jelly . Entrada e saída são duas listas de strings. Infelizmente, a função de transposição interna não funciona muito bem se as listas ou cadeias internas não tiverem o mesmo comprimento, o que meio que anularia o ponto de colapsar verticalmente em primeiro lugar. Sugestões de golfe são bem-vindas. Experimente online!

R2`;i(lZ♂Σ`nR

Ungolfing

          Implicit input s.
R         Reverse s.
2`...`n   Run the following function twice.
  ;i        Duplicate and flatten onto the stack.
  (l        Get the number of strings in the list.
  Z         Zip len strings together, which results in a list of lists of characters.
  ♂Σ        Sum each list of characters, which essentially joins them together.
           This function essentially transposes
R         Reverse the result.
          Implicit return.

Raquete 312 bytes

(let((lr list-ref)(ls list-set)(sl string-length)(ss substring)(l(string-split s)))(let p((ch #f))
(for((i(-(length l)1)))(define s(lr l i))(define r(lr l(+ 1 i)))(define n(sl s))(define m(sl r))
(when(> n m)(set! l(ls l i(ss s 0 m)))(set! l(ls l(+ 1 i)(string-append r(ss s m n))))(set! ch #t)))(if ch(p #f)l)))

Ungolfed:

(define (f s)
  (let ((lr list-ref)
        (ls list-set)
        (sl string-length)
        (ss substring)
        (l (string-split s)))
    (let loop ((changed #f))
      (for ((i (sub1 (length l))))
        (define s (lr l i))
        (define r (lr l (add1 i)))
        (define n (sl s))
        (define m (sl r))
        (when (> n m)
          (set! l (ls l i (ss s 0 m)))
          (set! l (ls l (add1 i)(string-append r (ss s m n))))
          (set! changed #t)))
      (if changed (loop #f)
          l))))

Testando:

(f "Programming Puzzles & Code Golf")

Resultado:

'("P" "Prog" "&uzz" "Coderam" "Golflesming")

JavaScript (ES6), 103 bytes

v=>(v=v.split`
`).map(_=>v=v.map((x,i)=>v[++i]?x.slice(0,n=v[i].length,v[i]+=x.slice(n)):x))&&v.join`
`

Dividido no CR, o mapa externo garante que passemos o tempo suficiente para permitir que a "gravidade" solte as letras o quanto for necessário.

O mapa interno primeiro verifica se existe uma próxima linha, se houver, e é mais curta, solte o estouro para a próxima linha. ou seja, se a 1ª linha tiver "ABCD" e a 2ª linha tiver "FG", solte o "CD" da 1ª para a 2ª para que a 1ª linha se torne "AB" e a 2ª se torne "FGCD".

Como fazemos isso quantas vezes houver linhas, as letras caem o mais longe que deveriam, deixando-nos com o resultado desejado.

Japonês , 8 bytes

y kS ù y

Experimente online!

Como funciona

Uy kS ù y

Uy  Transpose at newline
kS  Replace spaces with nothing
ù   Left-pad to fit the longest line
y   Transpose at newline

Há também o zque gira a string 2D em um múltiplo de 90 graus, mas de alguma forma trunca a string quando height > length.

05AB1E , 10 9 bytes

¶¡RζðмζR»

Experimente online.

ou com partida alternativa:

.BRøðмζR»

Experimente online.

Abordagem semelhante à resposta de @ Dennis ♦ 'Pyth .
-1 byte graças a @Emigna substituindo ðõ:por ðм.

Explicação:

¶¡       # Split on new-lines
  R      # Reverse the list
   ζ     # Zip/Transpose with unequal-length items (with space filler by default)
ðм       # Remove all spaces
  ζ      # Zip/Transpose unequal-length items (with space filler) again
   R     # Reverse the list again
    »    # Join the list by newlines, and output implicitly

Explicação alternativa:

.B      # Box (implicitly splits on new-lines and appends spaces)
   ø    # Zip/Transpose with equal-length items
        # Rest is the same

R, s81 52 bytes

function(x)apply(x,2,function(.).[order(!is.na(.))])

#old,longer version did the same but less efficiently
#function(x)apply(x,2,function(x){n<-na.omit(x);c(rep("",length(x)-length(n)),n)}))

Tomei alguma liberdade na interpretação da questão e presumi que o texto é representado em uma matriz com um caractere por célula, assim:

x <- as.matrix(read.fwf(textConnection("Programming
Puzzles
&
Code
Golf"), widths=rep(1, 11)))

Então x se torna:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" "r" "o" "g" "r" "a" "m" "m" "i" "n" "g"
[2,] "P" "u" "z" "z" "l" "e" "s" NA  NA  NA  NA 
[3,] "&" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" NA  NA  NA  NA  NA  NA  NA 
[5,] "G" "o" "l" "f" NA  NA  NA  NA  NA  NA  NA 

Agora eu uso ordere [para classificar as colunas para que os NAs cheguem primeiro e depois todos os outros valores:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[2,] "P" "r" "o" "g" NA  NA  NA  NA  NA  NA  NA 
[3,] "&" "u" "z" "z" NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" "r" "a" "m" NA  NA  NA  NA 
[5,] "G" "o" "l" "f" "l" "e" "s" "m" "i" "n" "g"

Torna-se mais longo se for necessário que a saída seja palavras:

s <- (function(x)apply(x,2,function(.).[order(!is.na(.))]))(x)
s[is.na(s)]<-""
apply(s, 1, paste, collapse="")
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

R, 196 189 170 bytes

function(x){l=nchar;o=function(y)which(diff(l(y))<0)[1];d=function(x,i)"[<-"(x,i:(j<-i+1),c(a<-substr(x[i],1,l(x[j])),sub(a,x[j],x[i])));while(!is.na(o(x)))x=d(x,o(x));x}

Uma versão legível por humanos:

f<-function(x){
  l=nchar;

  # find the first line in x that is longer than the next line
  # if no such line exists o(x) will be NA
  o = function(y) which(diff(l(y))<0)[1]

  # d(x,i) --> clips the line i in x, adding the remainder to x[i+1]
  d = function(x,i) "[<-"(x,i:(j<-i+1),
        c(a<-substr(x[i],1,l(x[j])), sub(a,x[j],x[i])))
         # a --> clipped x[i],      sub(a,x[j],x[i]) --> expanded x[j]

  while(!is.na(o(x)))x=d(x,o(x));x
}                            

Como funciona:

1. Pegue a primeira linha "ruim", ou seja, a linha mais longa que a próxima, pegue a parte "extra" e adicione-a à próxima linha
2. Verifique se existem linhas "ruins" restantes, se sim, vá para o número 1

(Ou, em outras palavras, partes "supérfluas" caem até que tudo o que pode cair caia.)

Entrada: um vetor de caracteres.

x<-readLines(textConnection("Programming\nPuzzles\n&\nCode\nGolf"))
f(x)
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

Julia 0.6 , 141 bytes

l=length
g(z,i)=(n=z[i];m=z[i+1];(N,M)=l.([n,m]);z[i:i+1]=[n[1:min(N,M)],m*n[M+1:N]])
f(s,w=split(s),d=1:l(w)-1)=(g.([w],[d d]);join(w,"\n"))

Experimente online!

A transmissão com g.([w], [d d])me permite livrar-me de qualquer declaração do mapa e me salva em torno de 7 bytes.