Esse desafio é inspirado em uma pergunta do SO sobre o deslocamento de uma matriz, enumerando todas as suas faixas diagonais.

Em vez de uma matriz, considere um bloco de texto:

ABCD
EFGH
IJKL

Atravessar as diagonais SW-NE deste bloco da esquerda para a direita, iniciando no canto superior esquerdo e terminando no canto inferior direito, resulta na seguinte saída:

A
EB
IFC
JGD
KH
L

Desafio

Escreva um programa ou uma função que execute o inverso do processo descrito acima. Ou seja, dado um conjunto de faixas diagonais SW-NE, imprima o bloco de texto que o produziu.

Entrada e saída

Tanto a entrada quanto a saída podem ser representadas como cadeias de caracteres com novas linhas ou matrizes / listas de cadeias.

Novas linhas à direita são opcionais.

A entrada consistirá em pelo menos um caractere imprimível e pode ser assumida como correta (não haverá comprimentos de linha inconsistentes).

O bloco de saída sempre terá um número de colunas maior ou igual ao número de linhas.

Casos de teste

Entrada:

A

Resultado:

A

Entrada:

.
LI
PO.
PV.
CE
G

Resultado:

.I..
LOVE
PPCG

Entrada:

M
DA
AIT
LAR
SGI
/OX
/N
/

Resultado:

MATRIX
DIAGON
ALS///

CJam, 23 20 bytes

{_z,,Nf*W%\.+zW%sN%}

Experimente aqui .

Python 2, 84

L=[]
for w in input():
 i=0;L+=[''][:len(w)-len(L)]
 for c in w:i-=1;L[i]+=c
print L

Entrada e saída são listas de strings.

input: ['A','EB','IFC','JGD','KH','L']
output: ['ABCD', 'EFGH', 'IJKL']

A lista de linhas La serem impressas é criada à medida que lemos a entrada. Cada novo personagem é anexado a uma linha, começando na última linha i=-1e progredindo em direção à frente.

Sempre que a nova linha para adicionar é muito longo para a lista, uma nova linha em branco é acrescentado: L+=[''][:len(w)-len(L)]. Estou esperando uma maneira de encurtar esta parte.

Python 2, 165 162 169 163 bytes

import sys
j=map(list,[e.strip() for e in sys.stdin.readlines()])
r=max(1,len(j)-2)
while j:
 s=''
 for b in range(r):s+=j[b].pop()
 j=[e for e in j if e]
 print s

Lê todas as linhas da entrada e as transforma em uma lista de listas. Loops enquanto essa lista possui elementos. Em cada iteração, ele exibe o último elemento do número de listas internas igual ao número de colunas na saída. A lista é então limpa e a linha impressa.

Exemplos:

$ python rectangle.py << EOF
> A
> EB
> IFC
> JGD
> KH
> L
> EOF
ABCD
EFGH
IJKL
$ python rectangle.py << EOF
> .
> LI
> PO.
> PV.
> CE
> G
> EOF
.I..
LOVE
PPCG
$ python rectangle.py << EOF
> M
> DA
> AIT
> LAR
> SGI
> /OX
> /N
> /
> EOF
MATRIX
DIAGON
ALS///

Obrigado a w0lf por salvar 6 bytes.

PYG , 139 bytes

j=M(L,[e.strip() for e in sys.stdin.readlines()])
r=Mx(1,len(j)-2)
while j:
 s=''
 for b in R(r):s+=j[b].pop()
 j=[e for e in j if e]
 P(s)

Pitão, 332 325 bytes

Porque Python.

n=[]
v=[]
x=y=-1
l=0
s=""
while 1:
 k=raw_input()
 if len(k)<1:break
 n.append(k)
while 1:
 if l>len(n):break
 y+=1
 try:
    x+=1;k=n[y][x]
    if[x,y]not in v:s+=k;v.append([x,y])
    else:raise
 except:
    try:
     x-=1;k=n[y][x]
     if[x,y]not in v:s+=k;v.append([x,y])
    except:s+="\n";x=-1;y=l;l+=1
print s[:s.rstrip("\n").rfind("\n")]