Desafío

Dada una entrada de cadena, genera la versión demolida de la misma.

El proceso

P
r      Pr       r
o       o       o
g       g       g
r       r       r      rogr         r
a  ->   a  ->   a  ->     a  ->     a  ->           ->           ->           ->           ->  
m       m       m         m         m
m       m       m         m         m         mmar         m
i       i       i         i         i         i            i           mi           m
n       n       n         n        gn        gn           gn           gn           gni         mgni
g       g      Pg        Pg      roPg      roPg         roPgmar      roPgmar      roPgmar      roPgmar

1. Coloque la cuerda verticalmente.
2. Seleccione un entero aleatorio entre 1y (height of the column of characters) - 1y una dirección aleatoria (izquierda o derecha).
3. Gire ese número de caracteres en esa dirección (si esos espacios están desocupados, vaya al paso 4; si no, vuelva al paso 2).
4. Deja que esos personajes caigan debido a la gravedad.
5. Repita hasta que la altura de la columna de caracteres sea como máximo 1mayor que la altura de las columnas a su lado (es decir, se hace imposible demoler aún más ("pasos 2-4") la columna).
6. Si hay otra columna de caracteres que tiene más de un 1carácter más alto que una o más de sus columnas circundantes (es decir, puede demoler), demuela repetidamente esa columna hasta que ya no pueda demoler. Si hay varias columnas capaces de demoler, demuele completamente la columna más alta (si hay varias columnas más altas, demuela completamente la más a la izquierda).
7. Repita hasta que todas las columnas ya no sean demolibles.

Si hay caracteres de espacio en la entrada, demórelos primero, todos a la vez.

C
o

d      
e  ->     oC  ->         ->  ...
       de         
G        G          G
o        o          o
l        l          l
f        f        defoC

Reglas

• Las lagunas estándar están prohibidas.
• Se permiten nuevas líneas finales y principales.
• Su programa puede imprimir o devolver una cadena / equivalente.
• La salida debe ser no determinista (a menos que la entrada no sea demolible).

Este es el código de golf , por lo que las presentaciones con el menor número de bytes en sus idiomas ganan.

Python 2 , 622 595 573 552 542 534 527 520 515 bytes

from random import*
s=input()
r=range
R=choice
Z=len
L=h=Z(s)
a=[[]for _ in'  '*-~h]
S=s[::-1].split()
X=-1,1
for w in S[1:]:
 for i in r(Z(w)):a[h-~i*R(X)]+=w[i]
a[h]+=S[0]
while L:
 H=[map(Z,a[c-1:c+2])+[c]for c in r(1,h-~h)];D=L=[(min(n,m)-C,i)for n,C,m,i in H if~-C>min(n,m)]
 while D:
	_,c=min(L);n,C,m=map(Z,a[c-1:c+2]);D=X[n+2>C:1+(C-1>m)]
	if D:
	 d=R(D);l=R(r(1,C-[0,m,n][d]));w,a[c]=a[c][-l:],a[c][:-l]
	 for i in r(l):a[c-~i*d]+=w[i]
for l in zip(*[l+[' ']*max(H)[1]for l in a if l])[::-1]:print`l`[2::5]

Pruébalo en línea!