给定一个矩形的文本网格，将从左上角到右下角的对角线排列成列，以使所有对角线的最右下角的字符都在一个水平上。使用空格进行缩进。

例如，如果输入的文本网格为

abcd
1234
WXYZ

然后你会排队对角线W，1X，a2Y，b3z，c4，和d在给这个输出列：

  ab
 123c
WXYZ4d

请注意，所有对角线的最右下角的字符WXYZ4d处于同一级别。

细节

• 文本的输入网格的大小至少为1×1，并且所有行的长度都相同。

• 您可以将输入网格作为多行字符串或作为单行字符串的列表。

• 输入网格将仅包含可打印的ASCII字符（包括空格）。

• 输出可能有一个尾随换行符，但不应有其他空行。

• 输出的行可以选择有尾随空格，但不应有不必要的前导空格。

其他例子

空行分隔示例。每个输入后紧跟其输出。

123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@  

 **
@  @


/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

计分

以字节为单位的最短代码获胜。

J，12个字节

|./.&.|:&.|.

定义一个匿名动词。 在线尝试！

说明

|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

在J中，u &. v（u在下阅读：）v表示“ v，然后是u，然后是v的倒数”。反转和转置是自反转，因此该程序的真正含义是“反转，转置，提取反转的反对角线，转置，反转”。

输入示例：

abcd
1234
WXYZ

相反：

WXYZ
1234
abcd

转置：

W1a
X2b
Y3c
Z4d

提取反对角线（并用空格填充）：

W  
X1 
Y2a
Z3b
4c 
d  

转置：

WXYZ4d
 123c 
  ab  

相反：

  ab  
 123c 
WXYZ4d

果冻，11或10个字节

ZŒDṙLUz⁶ṚUY

在线尝试！

与我的其他解决方案完全不同的算法；这是使用内置函数来获取对角线，而不是手动执行操作。

说明：

ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

对角线可能以最差的方向（需要重复的换位，反转和旋转）出现，并且顺序错误（果冻先输出主要对角线，因此我们必须从末端到起点移动一些对角线才能得到对角线）为了）。但是，这仍然比我的其他Jelly解决方案短。

CJam，29个字节

qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

在线尝试！

说明

我们不提取对角线，而是从末端剥离层，左右交替。考虑以下输入：

GFDB
EEDB
CCCB
AAAA

如果我们根据挑战的要求写出对角线，则会得到：

   G
  EEF
 CCCDD
AAAABBB

请注意，这只是（从底部到顶部）最底端的行，与最右边的列相连。如果输入为矩形，则此定义也适用。

{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

JavaScript，116101字节

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l


G.onclick=()=>O.textContent=f(I.value);

<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button><pre id=O></pre>

我只是想使用这种正则表达式模式的/.$|\n?(?!.*\n)..+/gm想法。^{（https://regex101.com/r/mjMz9i/2）}

JavaScript regex风格令人失望，我不得不使用(?!.*\n)它，因为它尚未\Z实现，并且某种程度上我没有使用\0。

• 谢谢@Neil，节省了15个字节。

果冻，15或14个字节

L’⁶x;\Ṛ;"µZUZṚY

在线尝试！

这是一种不使用Jelly内置对角线的算法。这样做可能会使它变短；我接下来可能会尝试。

这是算法的工作原理。让我们从以下输入开始：

["abc",
 "def",
 "ghi"]

我们从开始L’⁶x;\。L’给我们输入的长度减去1（在这种情况下为2）。然后⁶x给我们一串相同长度的空格（" "在这种情况下）；并;\在将其连接在一起时给出累积结果（空格三角形）。然后，我们反转三角形并将其连接到原始对象的左侧（;"连接列表的相应元素，µ强行导致解析中断，因此默认情况下将原始输入用作第二个列表），从而得到以下结果：

["  abc",
 " def",
 "ghi"]

这几乎是我们想要的解决方案，但是我们需要向下移动元素以与最后一个字符串齐平。这是换位（Z），在每行（U）内反转，再次换位（Z）和反转线（Ṛ）的问题：

["  abc",
 " def",
 "ghi"]

转置

["  g",
 " dh",
 "aei",
 "bf",
 "c"]

行内反转

["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

转置

["ghifc",
 " deb",
 "  a"]

反转行

["  a",
 " deb",
 "ghifc"]

最后，Y加入换行符。对我来说尚不清楚是否需要符合规范（它允许以字符串列表形式输入，但关于输出的含义不同），因此确切的字节数取决于是否包含或省略。

Pyth，16个字节

j_.t_M.Tm+*;l=tQ

大Pyth：

join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

由于人们说打高尔夫球的语言很难看懂，所以我设计了Big Pyth，它既易于阅读又可轻松翻译成Pyth。链接的文件将Big Pyth的输入流转换为Pyth。每个由空格分隔的Big Pyth令牌都对应一个Pyth令牌，可以是一个字符，也可以是.后跟一个字符。implicit标记是例外，它们在Pyth代码中是隐式的。

我想看看Big Pyth的解释格式有多好，所以我将不做任何其他解释。问我是否想要一些解释。

JavaScript（ES6），140个字节

a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

将输入和输出作为字符串数组。还接受二维字符数组输入，如果可接受二维字符数组输出，则保存7个字节。说明：结果m的高度是原始数组的高度h和宽度的最小值w，而宽度仅比原始数组的高度和宽度的总和小1。结果主要部分中字符的源行直接来自原始数组的相应行，从底部开始向上计数，而结果的其余部分中，源行每增加一列就向上移动一行。结果的两半的源列等于目标列，对于底部上方的每个源行，该列向左移动了一列。

八度，57字节

@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Python 3，247个字节

def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Python 2，150个字节

def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

将输入作为字符串列表。

Clojure，194个字节

通过将字符分组到G然后生成行来实现硬方法。

#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

取输入作为vec的vec就像[[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]。例：

(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ