Diese Herausforderung ist inspiriert von einer SO-Frage zum Durchlaufen einer Matrix durch Aufzählung aller diagonalen Streifen.

Betrachten Sie anstelle einer Matrix einen Textblock:

ABCD
EFGH
IJKL

Wenn Sie die SW-NE-Diagonalen dieses Blocks von links nach rechts von der oberen linken Ecke bis zur unteren rechten Ecke durchlaufen, erhalten Sie die folgende Ausgabe:

A
EB
IFC
JGD
KH
L

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die die Umkehrung des oben beschriebenen Prozesses ausführt. Das heißt, wenn ein Satz von SW-NE-Diagonalstreifen angegeben ist, wird der Textblock ausgegeben, der ihn erzeugt hat.

Ein- und Ausgabe

Sowohl Eingabe als auch Ausgabe können als Zeichenfolgen mit Zeilenumbrüchen oder Arrays / Listen von Zeichenfolgen dargestellt werden.

Nachfolgende Zeilenumbrüche sind optional.

Die Eingabe besteht aus mindestens einem druckbaren Zeichen und kann als korrekt angenommen werden (es gibt keine inkonsistenten Zeilenlängen).

Der Ausgabeblock hat immer eine Anzahl von Spalten, die größer oder gleich der Anzahl von Zeilen ist.

Testfälle

Eingang:

A

Ausgabe:

A

Eingang:

.
LI
PO.
PV.
CE
G

Ausgabe:

.I..
LOVE
PPCG

Eingang:

M
DA
AIT
LAR
SGI
/OX
/N
/

Ausgabe:

MATRIX
DIAGON
ALS///

CJam, 23 20 Bytes

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

Probieren Sie es hier aus .

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

Eingabe und Ausgabe sind Listen von Zeichenfolgen.

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

Die Liste der Lauszugebenden Zeilen wird beim Lesen der Eingabe erstellt. Jedes neue Zeichen wird an eine Zeile angehängt, beginnend mit der letzten Zeile i=-1und nach vorne.

Immer wenn die neue hinzuzufügende Zeile zu lang für die Liste ist, wird eine neue leere Zeile angehängt: L+=[''][:len(w)-len(L)] . Ich hoffe auf einen Weg, diesen Teil zu verkürzen.

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

Liest alle Zeilen von der Eingabe und wandelt sie dann in eine Liste von Listen um. Schleifen, während diese Liste Elemente enthält. In jeder Iteration wird das letzte Element aus der Anzahl der inneren Listen eingefügt, die der Anzahl der Spalten in der Ausgabe entspricht. Die Liste wird dann bereinigt und die Zeile gedruckt.

Beispiele:

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

Danke an w0lf für das Speichern von 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)

Python, 332 325 Bytes

Weil 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")]