Cho một chuỗi vuông, tạo ra tất cả đầu ra cho chuỗi ở mọi giai đoạn mở ra.

Chuỗi phải mở ra theo chiều kim đồng hồ một phần tư lần lượt tại một thời điểm.

Ví dụ

Đầu vào :

A

Đầu ra :

A

Lưu ý : Tôi cũng sẽ chấp nhận đầu vào trùng lặp cho trường hợp thử nghiệm cụ thể này chỉ khi điều này giúp giảm số byte của bạn.

Đầu vào :

DC
AB

Đầu ra :

DC
AB

  D
ABC

ABCD

Đầu vào :

GFE
HID
ABC

Đầu ra :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Đầu vào :

JIHG
KPOF
LMNE
ABCD

Đầu ra :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Quy tắc

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

• Bất kỳ định dạng hợp lý nào cũng có thể được sử dụng cho I / O giả sử nó phù hợp.
• Không gian phải được sử dụng để đệm các dòng trên cùng của đầu ra.
• Phải có khả năng xử lý đầu vào của tất cả các ký tự có thể in (bao gồm khoảng trắng: \x20- \x7e):

 ! "# $% & '() * +, -. / 0123456789:;?

• Khoảng trắng hàng đầu / dấu được cho phép.
• Bạn có thể giả sử chuỗi sẽ luôn là một hình vuông.
• Tất cả các sơ hở tiêu chuẩn đều bị cấm.

Cảm hứng: Viết một chương trình hình vuông cho ra số lần mà nó đã không được kiểm soát .

SOGL V0.12 , 21 20 19 18 17 byte

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

Hãy thử nó ở đây! ( →được thêm vào vì điều này mong đợi đầu vào trên ngăn xếp)

Giải trình:

ø;[;ο⁴№č▓┼№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 byte

-4 byte nhờ @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)

Hãy thử trực tuyến!

Python 2 , 219 217 215 213 212 211 207 byte

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)

Hãy thử trực tuyến!

Cái đầu tiên xuất ra dưới dạng một danh sách các Chuỗi, cái thứ hai xuất ra dưới dạng ASCII-art.

Than , 42 35 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Đã lưu 7 byte chủ yếu bằng cách chuyển từ mảng ký tự sang chuỗi. Giải trình:

ＡＥθＳθ

Đọc ô vuông đầu vào dưới dạng một chuỗi các chuỗi vào biến q.

Ｗ⊟θ«

Trong khi chuỗi cuối cùng trong mảng không trống, hãy xóa nó.

⪫θ¶

In phần còn lại của mảng.

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

Xoay phần còn lại của mảng bằng cách lặp qua từng ký tự của chuỗi cuối cùng và nối lký tự thứ của mỗi chuỗi còn lại trong mảng đảo ngược.

⊞υι↙←⮌⪫υω

Nối chuỗi đã xóa trước đó vào chuỗi ugiữ giá trị chưa được xử lý và in chuỗi đó.

Ｄ⎚

Xuất kết quả và sau đó xóa khung vẽ sẵn sàng cho lần lặp tiếp theo.

Lưu ý rằng phiên bản này xuất ra lần mở cuối cùng trên một dòng riêng biệt, nếu điều này là không mong muốn thì với 38 byte:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κđảo ngược mảng hiện tại, chuẩn bị dòng chưa được xử lý, sau đó đảo ngược các ký tự trong mỗi dòng, sau đó in mọi thứ lộn ngược, do đó tạo ra kết quả mong muốn.

Haskell , 127 120 byte

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

Hãy thử trực tuyến!

Đầu vào là danh sách các dòng, ví dụ ["DC","AB"]cho trường hợp thử nghiệm thứ hai, đầu ra là danh sách các danh sách các dòng : [["DC","AB"],[" D","ABC"],["ABCD"]]. Sử dụng mapM (putStrLn . unlines)để in đẹp kết quả.

Chỉnh sửa: Đã lưu 7 byte bằng cách nhận thấy rằng tôi đã tìm thấy một số ngắn hơntranspose trong khi đi có ích vì nó có thể được sửa đổi để đảo ngược từng chuyển đổi trực tiếp.

05AB1E , 18 byte

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

Hãy thử trực tuyến!

Giải trình

[            Ž       # 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 byte

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

Hãy thử trực tuyến!

Tôi chắc chắn rằng điều này có thể được chơi golf rất nhiều. Điều này in thêm khoảng trắng, nhưng chỉ vì cách J định dạng các mảng có trong mảng xuất ra để có cùng hình dạng.

Tôi nghĩ rằng một khi tôi đi vào và nhận xét chính xác những gì tôi đang làm, tôi có thể hiểu rõ hơn về cách chơi golf này (đã làm điều đó bây giờ, tôi thực sự không biết ...). Đối với mục đích chơi gôn, đáng chú ý rằng

• Tôi phải nhập trường hợp đặc biệt 1 hàng (phần trong của vòng lặp)
• Tôi phải loại bỏ tất cả các dòng chỉ bao gồm khoảng trắng (chắc chắn phải có một nội dung cho việc này hoặc cách tốt hơn để làm điều đó), đó là bộ lọc gần cuối
• Có rất nhiều mũ, chức năng nhận dạng và atops

Giải trình

Để giải thích điều này, tôi sẽ chia đôi chức năng chính.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Chúng tôi sẽ làm việc với trường hợp thử nghiệm thứ hai.

chưa hoàn thành

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

Điều này cung cấp cho một chuỗi mở ra một lần, nhưng ngược lại. Tất cả điều này đang được thực hiện theo chiều ngược lại và theo một thứ tự cụ thể sao cho cách J tự động đệm các chuỗi với khoảng trắng để khớp với hình dạng của mảng mà chúng nằm trong sẽ cho khoảng cách đúng.

|:@}: là chuyển vị của đường cong của đầu vào

   |:@}: test_case
GH
FI
ED

|.@{: là đảo ngược của đuôi của đầu vào

   |.@{: test_case
CBA

Tôi nghĩ rằng bạn có thể thấy những gì chúng tôi muốn làm: chúng tôi muốn nối phần đuôi của phần đuôi vào phần cuối của chuyển vị của phần đuôi (đó là một câu cửa miệng, nhưng về cơ bản gắn CBAvào phần cuối của ED). Điều này sẽ cho chúng ta một bước tháo gỡ, đảo ngược.

(}:@],{:@],[) làm điều đó

Nó nối CBAvào ED, sau đó nối nó với phần còn lại của mảng. Do đó, đầu ra của chúng tôi là

   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

Về cơ bản, thử nghiệm này để xem liệu có bất kỳ hàng nào là hoàn toàn không gian và loại bỏ nó nếu có. Nó không làm gì cho lần lặp đầu tiên của trường hợp thử nghiệm.

Điều này là cần thiết (ít nhất là cho đến khi tôi tìm thấy một giải pháp thay thế) vì nếu không cuối cùng chúng ta sẽ mở ra khoảng trắng trong chuỗi đầu ra của chúng ta.

trương

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

Unurl về cơ bản đặt các chức năng khác lại với nhau và trường hợp đặc biệt là các ký tự đơn.

Khi sức mạnh của động từ ( ^:) được đưa ra vào ô trống ( a:), nó sẽ áp dụng một hàm trên một đầu vào cho đến khi nó hội tụ và thu thập các kết quả trong một mảng.

(1 < #) kiểm tra xem các hàng luôn lớn hơn 1 (đối với đầu vào 1 hàng trong trường hợp đặc biệt).

|."1đảo ngược từng hàng, do đó nó đảo ngược kết quả của whitespace_filter @: unfurl.

Python 2 , 143 132 byte

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]

Hãy thử trực tuyến!

Trong mỗi lần lặp lại, blà phần đầu của nhóm Điên của chuỗi (n hàng đầu tiên − 1 hàng), được xoay 90 độ: nếu alà [" NML", " OPK", "ABCDEFGHIJ"]thìb là ["ON", "PM", "KL"].

Để giăng một chuỗi một lần, chúng ta thêm dòng cuối cùng của bđể a[-1](cho "ABCDEFGHIJKL") và sau đó Tính toán lạia[:-1] bằng cách thêm không gian để phần còn lại của chuỗi trong b.

Chúng tôi chấm dứt bằng cách cố gắng bật từ b khi nó trống rỗng.

Python 2 , 132 byte

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))

Hãy thử trực tuyến!

Cùng một ý tưởng, được viết khác nhau. Chúng tôi chấm dứt bằng cách cố gắng a.pop(-2)khi achỉ có một yếu tố.

Perl 5 , 155 byte

$"=$,;@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}

Hãy thử trực tuyến!

Đã lưu một vài byte mà không thực sự sửa đổi logic. Dòng chảy bên dưới vẫn cơ bản đúng.

# Perl 5 , 163 byte

$"=$,;@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}

Hãy thử trực tuyến!

Làm sao?

$"=$,; #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
}