Desafio

Dada uma entrada de sequência, produza a versão demolida dela.

O processo

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 a corda verticalmente.
2. Selecione um número inteiro aleatório entre 1e (height of the column of characters) - 1e uma direção aleatória (esquerda ou direita).
3. Gire esse número de caracteres nessa direção (se esses espaços estiverem desocupados, vá para a etapa 4; caso contrário, volte para a etapa 2).
4. Deixe esses caracteres caírem devido à gravidade.
5. Repita até que a altura da coluna de caracteres seja no máximo 1maior que a altura das colunas próximas a ela (ou seja, torna-se impossível demolir ainda mais ("etapas 2-4") a coluna).
6. Se houver outra coluna de caracteres com mais do 1que um caractere mais alto que uma ou mais colunas adjacentes (por exemplo, capacidade de demolição), demolir essa coluna repetidamente até que não seja mais capaz de demolir. Se houver várias colunas capazes de demolir, demolir completamente a coluna mais alta (se houver várias colunas mais altas, demolir completamente a coluna mais à esquerda).
7. Repita até que todas as colunas não possam mais ser demolidas.

Se houver caracteres de espaço na entrada, destrua-os primeiro, de uma só vez.

C
o

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

Regras

• As brechas padrão são proibidas.
• Novas linhas à direita e à direita são permitidas.
• Seu programa pode imprimir ou retornar uma string / equivalente.
• A saída deve ser não determinística (a menos que a entrada não possa ser demolida).

Isso é código-golfe , então os envios com a menor contagem de bytes em seus idiomas vencem!

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]

Experimente online!