Questa sfida è ispirata a una domanda SO sulla traversata di una matrice elencando tutte le sue strisce diagonali.

Invece di una matrice, considera un blocco di testo:

ABCD
EFGH
IJKL

Attraversando le diagonali SW-NE di questo blocco da sinistra a destra, partendo dall'angolo in alto a sinistra e terminando in basso a destra, si ottiene il seguente output:

A
EB
IFC
JGD
KH
L

Sfida

Scrivi un programma o una funzione che esegua il contrario del processo sopra descritto. Cioè, dato un set di strisce diagonali SW-NE, genera il blocco di testo che lo ha prodotto.

Ingresso e uscita

Sia l'input che l'output possono essere rappresentati come stringhe con newline o matrici / elenchi di stringhe.

Le nuove righe finali sono opzionali.

L'input consisterà in almeno un carattere stampabile e si può presumere che sia corretto (non ci saranno lunghezze di riga incoerenti).

Il blocco di output avrà sempre un numero di colonne maggiore o uguale al numero di righe.

Casi test

Ingresso:

A

Produzione:

A

Ingresso:

.
LI
PO.
PV.
CE
G

Produzione:

.I..
LOVE
PPCG

Ingresso:

M
DA
AIT
LAR
SGI
/OX
/N
/

Produzione:

MATRIX
DIAGON
ALS///

CJam, 23 20 byte

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

Provalo qui .

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

Input e output sono elenchi di stringhe.

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

L'elenco delle righe Lda emettere viene creato mentre leggiamo l'input. Ogni nuovo personaggio viene aggiunto a una riga, partendo dall'ultima riga i=-1e procedendo verso il fronte.

Ogni volta che la nuova linea da aggiungere è troppo lungo per la lista, una nuova riga vuota viene aggiunto: L+=[''][:len(w)-len(L)]. Spero in un modo per abbreviare questa parte.

Python 2, 165 162 169 163 163 byte

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

Legge tutte le righe dall'input, quindi le trasforma in un elenco di elenchi. Passa mentre l'elenco contiene elementi. In ogni iterazione, estrae l'ultimo elemento dal numero di elenchi interni pari al numero di colonne nell'output. L'elenco viene quindi pulito e la riga stampata.

Esempi:

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

Grazie a w0lf per aver salvato 6 byte.

PYG , 139 byte

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)

Pitone, 332 325 byte

Perché 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")]