Este desafío está inspirado en una pregunta SO sobre atravesar una matriz enumerando todas sus tiras diagonales.

En lugar de una matriz, considere un bloque de texto:

ABCD
EFGH
IJKL

Al atravesar las diagonales SW-NE de este bloque de izquierda a derecha, comenzando desde la esquina superior izquierda y terminando en la esquina inferior derecha, se obtiene el siguiente resultado:

A
EB
IFC
JGD
KH
L

Desafío

Escriba un programa o una función que ejecute el reverso del proceso descrito anteriormente. Es decir, dado un conjunto de tiras diagonales SW-NE, genera el bloque de texto que lo produjo.

Entrada y salida

Tanto la entrada como la salida se pueden representar como cadenas con nuevas líneas o matrices / listas de cadenas.

Las nuevas líneas finales son opcionales.

La entrada consistirá en al menos un carácter imprimible y se puede suponer que es correcta (no habrá longitudes de fila inconsistentes).

El bloque de salida siempre tendrá una cantidad de columnas mayor o igual que la cantidad de filas.

Casos de prueba

Entrada:

A

Salida:

A

Entrada:

.
LI
PO.
PV.
CE
G

Salida:

.I..
LOVE
PPCG

Entrada:

M
DA
AIT
LAR
SGI
/OX
/N
/

Salida:

MATRIX
DIAGON
ALS///

CJam, 23 20 bytes

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

Pruébalo aquí .

Pitón 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

La entrada y la salida son listas de cadenas.

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

La lista de líneas Lpara generar se construye a medida que leemos la entrada. Cada nuevo personaje se agrega a una línea, comenzando desde la última línea i=-1y avanzando hacia el frente.

Cada vez que la nueva línea a añadir es demasiado larga para la lista, una nueva línea vacía se añade: L+=[''][:len(w)-len(L)]. Espero una forma de acortar 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

Lee todas las líneas de entrada, luego las convierte en una lista de listas. Bucles mientras esa lista tiene elementos. En cada iteración, muestra el último elemento del número de listas internas igual al número de columnas en la salida. Luego se limpia la lista y se imprime la línea.

Ejemplos:

$ 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///

Gracias a w0lf por guardar 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ón, 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")]