给定一个方形字符串，请在展开的每个阶段生成该字符串的所有输出。

字符串必须每次顺时针旋转四分之一圈。

例子

输入：

A

输出：

A

注意：仅在这有助于减少字节数的情况下，我也将接受此特定测试用例重复的输入。

输入：

DC
AB

输出：

DC
AB

  D
ABC

ABCD

输入：

GFE
HID
ABC

输出：

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

输入：

JIHG
KPOF
LMNE
ABCD

输出：

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

规则

这是代码高尔夫球，因此以字节为单位的最短代码获胜。

• 假设它是一致的，则可以将任何合理的格式用于I / O。
• 必须使用空格填充输出的顶行。
• 必须能够处理所有可打印字符（包括空格：输入\x20- \x7e）：

 ！“＃$％＆'（）* +，-。/ 0123456789：;？@ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _`abcdefghijklmnopqrstuvwxyz {|}〜

• 允许前导/尾随空格。
• 您可以假设该字符串将始终是一个正方形。
• 禁止所有标准漏洞。

启示：编写一个平方程序，输出它被“展开”的次数。

SOGL V0.12，21 20 19 18 17 字节

ø;[;ο⁴№č▓┼№TJι;jI

在这里尝试！（→添加是因为这需要在堆栈上输入）

说明：

ø;[;ο⁴№č▓┼№TJι;jI
ø;               push an empty string below the input           stack with the input GFE,HID,ABC
  [              while [ToS (the array) isn't empty] do       ["", [["G","F","E"],["H","I","D"],["A","B","C"]]]  
                                                                stack at the second time looping
   ;               duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], "ABC"]
    ο              wrap it in an array                        [[[H,G], [I,F], [D,E]], ["ABC"]]
     ⁴             duplicate 2nd from top                     [[[H,G], [I,F], [D,E]], ["ABC"], [[H,G], [I,F], [D,E]]]
      №            reverse vertically                         [[[H,G], [I,F], [D,E]], ["ABC"], [[D,E], [I,F], [H,G]]]
       č▓          join the inner arrays (┼ fails otherwise)  [[[H,G], [I,F], [D,E]], ["ABC"], ["DE", "IF", "HG"]]
         ┼         add the 2 parts together                   [[[H,G], [I,F], [D,E]], ["ABCDE", "   IF", "   HG"]]
          №        reverse vertically again                   [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
           T       print that without popping                 [[[H,G], [I,F], [D,E]], ["   HG", "   IF", "ABCDE"]]
            J      take the last line off                     [[[H,G], [I,F], [D,E]], ["   HG", "   IF"], "ABCDE"]
             ι     remove the rest of the array               [[[H,G], [I,F], [D,E]], "ABCDE"]
              ;j   remove the last line of the original array ["ABCDE", [[H,G], [I,F]]]
                I  rotate it clockwise                        ["ABCDE", [[I,H], [F,G]]]

Python 2中，209 207 205 203 202 201个200 196字节

-4个字节，感谢@Quelklef！

s=input();l=len;k=''.join;exec"print s;s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

在线尝试！

Python 2中，219个217 215 213 212 211 207字节

s=input();l=len;k=''.join;exec"print'\\n'.join(s);s=[x for x in[' '*l(s[0])+k(x[:-1]for x in s[-2::-1])[t::l(s[0])-1]for t in range(l(s[0]))][:-1]+[s[-1]+k(x[-1]for x in s)[-2::-1]]if x.strip()];"*(2*l(s)-1)

在线尝试！

第一个输出为字符串列表，第二个输出为ASCII-art。

木炭，42 35字节

ＡＥθＳθＷ⊟θ«⪫θ¶ＡＥι⮌⪫Ｅθ§μλωθ⊞υι↙←⮌⪫υωＤ⎚

在线尝试！链接是详细版本的代码。编辑：主要通过从字符数组切换到字符串来节省7个字节。说明：

ＡＥθＳθ

将输入平方作为字符串数组读取到变量中q。

Ｗ⊟θ«

当数组中的最后一个字符串不为空时，将其删除。

⪫θ¶

打印其余的数组。

ＡＥι⮌⪫Ｅθ§μλωθ

循环遍历最后一个字符串的每个字符，并l在反向数组中加入其余每个字符串的th个字符，从而旋转数组的其余部分。

⊞υι↙←⮌⪫υω

将先前删除的最后一个字符串追加到u，其中包含展开的值，然后打印出来。

Ｄ⎚

输出结果，然后清除画布以准备下一次迭代。

请注意，此版本在最后一行输出最终的unfurl，如果这是不希望的，则使用38个字节：

ＡＥθＳθＷ⊟θ«⊞υι←Ｅ⁺⟦⪫υω⟧⮌θ⮌κＡＥι⮌⪫Ｅθ§μλωθＤ⎚

在线尝试！链接是详细版本的代码。说明：←Ｅ⁺⟦⪫υω⟧⮌θ⮌κ反转当前数组，在未展开的行前加注，然后反转每行中的字符，然后上下颠倒打印所有内容，从而产生所需的结果。

Haskell，127120字节

e=[]:e
i#[x]=[]
i#s|t<-foldl(flip$zipWith(:))e$init s,j<-i++last s=(map((j>>" ")++)(init t)++[j++last t]):j#t
f s=s:""#s

在线尝试！

输入是行列表，例如["DC","AB"]，对于第二个测试用例，输出是行列表：[["DC","AB"],[" D","ABC"],["ABCD"]]。使用mapM (putStrLn . unlines)以美化打印结果。

编辑：通过注意到我在走走时发现的较短transpose路径发现方便，节省了7个字节，因为可以对其进行修改以直接反转每个转置的位置。

05AB1E，18个字节

[Dí.Bí»,¤UR¦ζŽ`Xì)

在线尝试！

说明

[            Ž       # while stack is not empty, do:
 D                   # duplicate current list
  í                  # reverse each element
   .B                # pad with spaces to equal length
     í               # reverse each element again
      »,             # join with newlines and print
        ¤U           # store the last element in X
          R¦         # reverse the list and remove the first element
            ζ        # zip with spaces as filler
              `      # split elements separately to stack
               Xì    # prepend X to the last element
                 )   # join the stack to a list

J，62个字节

|."1@([:(#~[:-.[:*/"1' '=])|.@{:(}:@],{:@],[)|:@}:)^:(1<#)^:a:

在线尝试！

我相信这可以打很多。这会打印出额外的空格，但这仅是因为J格式化输出数组中包含的数组以使其具有相同形状的方式。

我想，一旦我进入并准确地注释掉我在做什么，我可能会更好地了解如何打高尔夫球（现在已经做完了，我真的不知道...）。为了打高尔夫球，值得注意的是

• 我必须特殊情况1行输入（循环的while部分）
• 我必须消除所有仅由空格组成的行（当然，必须为此内置一个或更好的方法），这是末尾的过滤器
• 有很多大写字母，标识功能和顶部

说明

在取消这一点时，我将把主要功能分成三个部分。

unfurl_reversed   =. |.@{: (}:@] , {:@] , [) |:@}:
whitespace_filter =. #~ [: -. [: */"1 ' ' = ]
unfurl            =. |."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

test_case         =. 3 3 $ 'GFEHIDABC'

我们将使用第二个测试用例。

unfurl_reversed

|.@{: (}:@] , {:@] , [) |:@}:

这使一个字符串解开一次，但是相反。所有这些操作都是以相反的顺序并以特定顺序进行的，因此J自动填充字符串以使其与空格匹配的数组的方式将为它们提供正确的间距。

|:@}: 是缩减输入的转置

   |:@}: test_case
GH
FI
ED

|.@{: 是输入尾部的反面

   |.@{: test_case
CBA

我想您可以看到我们想做的事情：我们想将尾巴的反面附加到缩减的转置的最后一部分（这是一个满口的，但基本上连接CBA到的末尾ED）。这将使我们一步一步展开，扭转。

(}:@],{:@],[) 就是那样。

它附加CBA到ED，然后将其与数组的其余部分连接。因此，我们的输出是

   unfurl_reversed test_case
GH   
FI   
EDCBA

whitespace_filter

#~ [: -. [: */"1 ' ' = ]
                 ' ' = ]  Equate each element to space
            */"1          Product of each row (all true?)
      -.                  Negate
#~                        Filter rows that are true

基本上，此测试检查是否有任何行完全是空格，如果有的话，将其删除。在测试用例的第一次迭代中，它什么都不做。

这是必要的（至少在找到替代方法之前），因为否则，我们最终将空白扩展到输出字符串中。

解开

|."1@(whitespace_filter @: unfurl_reversed) ^: (1 < #) ^: a:

Unfurl基本上将其他功能和特殊情况下的单个字符输入放在一起。

当将动词（^:）的幂赋给空框（a:）时，它将对输入应用一个函数，直到其收敛并将结果收集到数组中。

(1 < #) 检查行是否始终大于1（在特殊情况下为1行输入）。

|."1反转每一行，因此反转的结果whitespace_filter @: unfurl。

Python 2中，143个 132字节

a=input()
while 1:print'\n'.join(a);b=map(''.join,zip(*map(str.strip,a[-2::-1])));a[-1]+=b.pop();a[:-1]=[len(a[0])*' '+x for x in b]

在线尝试！

在每次迭代中，b是字符串（第一n-1行）的“头”，旋转90度：如果a是[" NML", " OPK", "ABCDEFGHIJ"]则b是["ON", "PM", "KL"]。

要对字符串进行一次无卷曲处理，我们将的最后一行附加b到a[-1]（给出"ABCDEFGHIJKL"），然后a[:-1]通过在中的其余字符串上添加空格来重新计算b。

我们尝试从b空的时候弹出来终止。

Python 2，132字节

a=input()
while 1:s=str.strip;print'\n'.join(a);a[:-1]=[len(a[0])*' '+''.join(x)for x in zip(*map(s,a[-2::-1]))];a[-1]+=s(a.pop(-2))

在线尝试！

同样的想法，写的不同。我们通过尝试到a.pop(-2)何时a只有一个元素来终止。

Perl 5，155个字节

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@$_"for@a[0..@a-2];say$s.="@{pop@a}";say@b=();for$i(0..$#a){$q=0;$b[$q++][$#a-$i]=$_ for@{$a[$i]}}@a=@b}

在线尝试！

在不真正修改逻辑的情况下节省了几个字节。下面的流程基本上还是正确的。

＃Perl 5中，163个字节

$"=$,;@a=map[/./g],<>;while(@a){say' 'x(length$s)."@{$a[$_]}"for 0..@a-2;say$s.="@{pop@a}";say@b=();for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}@a=@b}

在线尝试！

怎么样？

$"=$,; #set the array output separator to null
@a=map[/./g],<>;   # take the input as a 2-D array @a
while(@a){         # repeat while there are still things to unfurl
  say' 'x(length$s)."@{$a[$_]}"for 0..@a-2; # output all but last
                                            # line of the remaining
                                            # square
  say$s.="@{pop@a}";  # remove bottom row, add it to the unfurled string $s
                      # and output it
  say@b=();           # clear temporary array; output empty array, causing
                      # a newline to output

                      # rotate remaining shape 90 degrees:
  for$i(0..$#a){$b[$_][$#a-$i]=$a[$i][$_]for 0..$#{$a[$i]}}
  @a=@b               # replace input with rotated array
}