Ce défi est inspiré d' une question SO sur la traversée d'une matrice en énumérant toutes ses bandes diagonales.

Au lieu d'une matrice, considérez un bloc de texte:

ABCD
EFGH
IJKL

La traversée des diagonales SW-NE de ce bloc de gauche à droite, en partant du coin supérieur gauche et se terminant en bas à droite, donne le résultat suivant:

A
EB
IFC
JGD
KH
L

Défi

Écrivez un programme ou une fonction qui exécute l'inverse du processus décrit ci-dessus. C'est-à-dire, étant donné un ensemble de bandes diagonales SW-NE, sortir le bloc de texte qui l'a produit.

Entrée et sortie

L'entrée et la sortie peuvent être représentées sous forme de chaînes avec des retours à la ligne ou des tableaux / listes de chaînes.

Les sauts de ligne sont facultatifs.

L'entrée comprendra au moins un caractère imprimable et peut être considérée comme correcte (il n'y aura pas de longueurs de ligne incohérentes).

Le bloc de sortie aura toujours un nombre de colonnes supérieur ou égal au nombre de lignes.

Cas de test

Contribution:

A

Production:

A

Contribution:

.
LI
PO.
PV.
CE
G

Production:

.I..
LOVE
PPCG

Contribution:

M
DA
AIT
LAR
SGI
/OX
/N
/

Production:

MATRIX
DIAGON
ALS///

CJam, 23 20 octets

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

Essayez-le ici .

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

L'entrée et la sortie sont des listes de chaînes.

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

La liste des lignes Là produire est établie au fur et à mesure que nous lisons l'entrée. Chaque nouveau personnage est ajouté à une ligne, en commençant par la dernière ligne i=-1et en progressant vers l'avant.

Chaque fois que la nouvelle ligne à ajouter est trop long pour la liste, est ajouté une nouvelle ligne vide: L+=[''][:len(w)-len(L)]. J'espère un moyen de raccourcir cette partie.

Python 2, 165 162 169 169 163 octets

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

Lit toutes les lignes de l'entrée, puis les transforme en une liste de listes. Boucles alors que cette liste contient des éléments. À chaque itération, il extrait le dernier élément du nombre de listes internes égal au nombre de colonnes dans la sortie. La liste est ensuite nettoyée et la ligne imprimée.

Exemples:

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

Merci à w0lf pour avoir économisé 6 octets.

PYG , 139 octets

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 octets

Parce que 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")]