Digamos que tengo un texto como este (cada palabra en una línea, sin espacios)

Programming
Puzzles
&
Code
Golf

¡Eso no tiene sentido! Desafía totalmente las leyes de la física.

Su desafío es remediar esta situación imposible y colapsar el texto así:

P
Prog
&uzz
Coderam
Golflesming

Para que no haya espacio vacío debajo de ningún carácter, pero los caracteres conservan su orden vertical.

El objetivo es satisfacer los requisitos pero utilizar la menor cantidad de bytes de código fuente posible.

Pyth, 10 bytes

jb_.T.T_.z

Pruébelo en línea en Pyth Compiler / Executor .

Idea

Podemos lograr el resultado deseado aplicando cuatro transformaciones simples:

1. Invierta el orden de las líneas:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. Transponer filas y columnas:

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

   Esta parte superior justifica, contrayendo las columnas originales.

3. Transponer filas y columnas:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. Invierta el orden de las líneas:

   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

Soy muy maduro

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)

Un algoritmo iterativo de un paso. Pasamos por cada línea en orden, actualizando la lista lde líneas a la salida. La nueva palabra efectivamente empuja desde la parte inferior, desplazando todas las letras por encima de un espacio. Por ejemplo, en el caso de prueba

Programming
Puzzles
&
Code
Golf

después de haber terminado Code, tenemos

P
Prog
&uzzram
Codelesming

y luego agregando Golfresultados en

P
Prog
&uzz
Coderam
Golflesming

que podemos ver como la combinación de dos piezas

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

donde se desplazó la primera pieza golf. Realizamos este desplazamiento con una zipde la lista de salida con el elemento al final (lado izquierdo) y la precedencia de la lista de salida con una línea en blanco (lado derecho), cortando cada parte a la longitud del nuevo elemento.

Puede parecer más natural iterar hacia atrás, dejando caer nuevas letras desde la parte superior, pero mi intento fue más largo.

A modo de comparación, aquí hay un enfoque zip/ filter, con map(None,*x)utilizado 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*

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

La idea en la misma que en mi respuesta 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

(Las 2 nuevas líneas dentro de las cadenas de plantilla son significativas y cuentan)

La idea de @Dennis implementada en JavaScript. La larga función S realiza la transposición línea por línea y char por char, dejando el resultado en la 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 golf dentro del fragmento (prueba en 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="")}

Esta es una manera absurdamente larga e ingenua de hacerlo.

Sin golf:

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 = "")
    }
}

Puedes probarlo en línea .

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))

Ejemplo :

Definir una cadena de entrada en una variable, por ejemplo s. 10es el carácter de avance de línea:

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

Función de llamada fcon entrada s:

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

O pruébelo en línea (gracias a @beaker por su ayuda con el intérprete en línea de Octave)

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`
`)

Aquí no tiene golf y en ES5 con comentarios que explican cómo 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 ^SBCS de 11 bytes

-2 con mis extensiones a Dyalog APL.

Función tácita anónima, tomar y devolver una matriz de caracteres.

~∘' '⍤1⍢⍉⍢⊖

Pruébalo en línea!

~ eliminar
∘ los
' ' espacios
⍤ de las
1 filas (literalmente, sub-matrices 1D)
⍢ mientras se
⍉ transponen
⍢ mientras se
⊖ voltea

R, 190 178 175 Bytes

Probablemente todavía hay espacio para jugar al golf en esto. Probablemente un par de operaciones innecesarias allí

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='')

Desengañado y explicado

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

Prueba de funcionamiento. Es interesante observar que, debido a la forma en que funciona el escaneo, toda la oración se puede ingresar con espacios y aún así dar la salida como se especifica.

> 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

Toma entrada en un archivo llamado ab Solo funciona para hasta 24 caracteres ahora. Se actualizará más tarde para que funcione con más. Además, no funciona en el compilador en línea. Requiere el compilador no libre.

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: movió silenciosamente (para suprimir la salida) al propio bucle desde cada instrucción en el bucle, ahorrando 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")

Con nuevas líneas y sangría:

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 (no competitiva)

ỴṚZZṚY

Pruébalo en línea!

Cómo funciona

La idea en la misma que en mi respuesta 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, sin competencia

Bastante seguro de que podría cambiar el enfoque para guardar bytes, pero más tarde.

: p Esolang que no es de golf supera las langs regulares: p

Lo extraño de Turtlèd es que se hizo originalmente después de una discusión sobre el arte ascii langs, pero en realidad parece ser el mejor en este tipo de desafíos

Turtlèd no puede tomar entradas de nueva línea, sino para entradas múltiples, y esto solo requiere una entrada: terminar cada palabra con un espacio, incluida la última.

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

Pruébalo en línea!

Explicación:

!                          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

Este fue uno de esos desafíos que cambió en mi cabeza de ser demasiado difícil, a ser fácil, a ser mucho más código de lo que esperaba ... No estoy particularmente contento con el enfoque, estoy seguro de que hay un una forma mucho mejor de reducir el print pop@F...bit tal vez usando -no simplemente regex puro, pero no puedo llegar allí en este momento ... Originalmente estaba usando say, pero creo que tendría que anotar eso más alto ( use 5.01) debido a $'.

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

Uso

Guardar 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 gravedad a todo el texto en la consola. No estoy seguro de si esto es válido o si tengo que usar una matriz de cadenas.

Ruby, 99 82 bytes

Llegar allí...

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

Un intento de explicación:

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

Ejecútelo así:

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"

Explicación

x@\:!|/#:'x extiende cada cadena para crear una matriz cuadrada de caracteres.

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

+ lo transpone

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} eliminará los espacios de una cadena y luego rellenará la cadena por su longitud original

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

Aplique esa función a cada una de las cadenas transpuestas, luego voltee la salida para obtener el 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]

Qué desastre. Apenas recuerdo nada de cómo funciona.

Debido a la forma en que funciona la entrada de pb (una sola línea de una vez), debe usar espacios en lugar de nuevas líneas en la entrada. Si el intérprete no era basura y podría incluir nuevas líneas en la entrada, el único cambio sería [B=32]al principio [B=10].

Estoy trabajando en una actualización de pbi (el intérprete) que limpiará las imágenes si desea ver el programa en ejecución. Todavía necesita mucho trabajo, pero mientras tanto, puedes ver este programa en YouTube .

J, 17 bytes

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

Solución bastante agradable.

Explicación:

-.&' '"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 prueba 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 prueba

   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|    |    |
+-----------+----+----+

Realmente , 13 bytes

Esto utiliza el algoritmo descrito en la respuesta de Dennis 'Jelly . La entrada y la salida son listas de cadenas. Desafortunadamente, la función de transposición incorporada no funciona muy bien si las listas internas o las cadenas no tienen la misma longitud, lo que podría derrotar el punto de colapso vertical en primer lugar. Sugerencias de golf bienvenidas. Pruébalo en línea!

R2`;i(lZ♂Σ`nR

No golfista

          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.

Raqueta 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)))

Sin golf:

(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))))

Pruebas:

(f "Programming Puzzles & Code Golf")

Salida:

'("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 en CR, el mapa externo asegura que hagamos bucles suficientes veces para permitir que la "gravedad" deje caer las letras tanto como sea necesario.

El mapa interno primero verifica si hay una línea siguiente, si es así, y es más corta, suelte el desbordamiento a la línea siguiente. es decir, si la primera línea tiene "ABCD" y la segunda línea tiene "FG", suelte el "CD" de la primera línea a la segunda para que la primera línea se convierta en "AB" y la segunda se convierta en "FGCD".

A medida que hacemos esto tantas veces como haya líneas, las letras caen tanto como deberían, dejándonos con el resultado deseado.

Japt , 8 bytes

y kS ù y

Pruébalo en línea!

Cómo funciona

Uy kS ù y

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

También hay zque gira la cadena 2D en un múltiplo de 90 grados, pero de alguna manera trunca la cadena cuando height > length.

05AB1E , 10 9 bytes

¶¡RζðмζR»

Pruébalo en línea.

o con inicio alternativo:

.BRøðмζR»

Pruébalo en línea.

Enfoque similar a @ Dennis ♦ 'Respuesta de Pyth .
-1 byte gracias a @Emigna reemplazando ðõ:porðм .

Explicación:

¶¡       # 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

Explicación 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)}))

Me tomé un poco de libertad para interpretar la pregunta y supuse que el texto está representado en una matriz con un carácter por celda, por lo tanto:

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

Entonces x se convierte en:

     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 

Ahora uso ordery [para ordenar las columnas de modo que las NA sean primero y luego todos los demás 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"

Se hace más largo si se requiere que la salida sea palabras:

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}

Una versión legible para 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
}                            

Cómo funciona:

1. Tome la primera línea "incorrecta", es decir, la línea que es más larga que la siguiente línea, tome la parte "extra" y agréguela a la siguiente línea
2. Compruebe si quedan líneas "malas", en caso afirmativo, vaya al n. ° 1

(O, en otras palabras, las partes "superfluas" se caen hasta que todo lo que puede caer se ha caído).

Entrada: un vector 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"))

Pruébalo en línea!

La transmisión con g.([w], [d d])me permite deshacerme de cualquier declaración de mapa y me ahorra alrededor de 7 bytes.