Diberikan string persegi, hasilkan semua output untuk string pada setiap tahap pembukaan.

Tali harus membentangkan arah searah jarum jam seperempat putaran sekaligus.

Contohnya

Masukan :

A

Keluaran :

A

Catatan : Saya juga akan menerima input yang digandakan untuk kasus uji khusus ini hanya jika ini membantu mengurangi jumlah byte Anda.

Masukan :

DC
AB

Keluaran :

DC
AB

  D
ABC

ABCD

Masukan :

GFE
HID
ABC

Keluaran :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Masukan :

JIHG
KPOF
LMNE
ABCD

Keluaran :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Aturan

Ini adalah kode-golf sehingga kode terpendek dalam byte menang.

• Setiap format yang masuk akal dapat digunakan untuk I / O dengan asumsi itu konsisten.
• Spasi harus digunakan untuk mengisi garis atas output.
• Harus dapat menangani input semua karakter yang dapat dicetak (termasuk spasi: \x20- \x7e):

 ! "# $% & '() * +, -. / 0123456789:;? @ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\] ^ _` abcdefghijklmnopqrstuvwxyz {|} ~

• Ruang putih terkemuka / trailing diizinkan.
• Anda dapat mengasumsikan string akan selalu berbentuk kotak.
• Semua celah standar dilarang.

Inspirasi: Tuliskan sebuah program kuadrat yang menampilkan berapa kali ia telah "dibuka" .

SOGL V0.12 , 21 20 19 18 17 byte

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

Coba Di Sini! ( →ditambahkan karena ini mengharapkan input pada stack)

Penjelasan:

ø;[;ο⁴№č▓┼№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 terima kasih kepada @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)

Cobalah online!

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)

Cobalah online!

Yang pertama menampilkan sebagai daftar Strings, yang kedua menghasilkan sebagai ASCII-art.

Arang , 42 35 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Sunting: Disimpan 7 byte kebanyakan dengan beralih dari array karakter ke string. Penjelasan:

ＡＥθＳθ

Baca kotak input sebagai array string ke dalam variabel q.

Ｗ⊟θ«

Meskipun string terakhir dalam array tidak kosong, hapus.

⪫θ¶

Cetak sisa array.

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

Putar sisa array dengan mengulangi setiap karakter dari string terakhir dan bergabung dengan lkarakter th dari setiap string yang tersisa dalam array yang terbalik.

⊞υι↙←⮌⪫υω

Tambahkan string terakhir yang sebelumnya dihapus ke u, yang memiliki nilai terbuka, dan cetak.

Ｄ⎚

Keluarkan hasilnya dan bersihkan kanvas yang siap untuk iterasi berikutnya.

Perhatikan bahwa versi ini menampilkan unfurl akhir pada baris terpisah, jika ini tidak diinginkan maka untuk 38 byte:

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κmembalikkan susunan saat ini, menambahkan awal baris tidak terbentang, kemudian membalikkan karakter di setiap baris, lalu mencetak semuanya terbalik, sehingga menghasilkan hasil yang diinginkan.

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

Cobalah online!

Input adalah daftar baris, misalnya ["DC","AB"]untuk kasus tes kedua, output daftar daftar baris: [["DC","AB"],[" D","ABC"],["ABCD"]]. Gunakan mapM (putStrLn . unlines)untuk mencetak hasilnya dengan cantik.

Sunting: Disimpan 7 byte dengan memperhatikan bahwa semakin pendektranspose saya menemukan beberapa saat berguna karena dapat dimodifikasi untuk membalikkan masing-masing secara langsung.

05AB1E , 18 byte

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

Cobalah online!

Penjelasan

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

Cobalah online!

Saya yakin ini bisa banyak bermain golf. Ini mencetak spasi tambahan, tetapi hanya karena cara J memformat array yang terdapat dalam array yang di-output untuk memiliki bentuk yang sama.

Saya pikir begitu saya masuk dan berkomentar persis apa yang saya lakukan, saya mungkin mendapatkan ide yang lebih baik tentang cara bermain golf ini (setelah melakukannya sekarang, saya tidak benar-benar tahu ...). Untuk tujuan bermain golf, perlu dicatat

• Saya harus memberi input khusus pada case 1 baris (bagian while dari loop)
• Saya harus menghilangkan semua baris yang hanya terdiri dari spasi putih (tentunya harus ada builtin untuk ini atau cara yang lebih baik untuk melakukannya), yang merupakan filter di dekat akhir
• Ada banyak batasan, fungsi identitas, dan puncak

Penjelasan

Dalam ungolfing ini, saya akan membagi fungsi utama menjadi tiga.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Kami akan bekerja dengan test case kedua.

unfurl_reversed

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

Ini memberikan satu untaian terbuka sekali, tetapi secara terbalik. Semua ini dilakukan secara terbalik dan dalam urutan tertentu sehingga cara J secara otomatis memasang string dengan spasi agar sesuai dengan bentuk array yang ada di dalamnya akan memberikan jarak yang tepat.

|:@}: adalah transpos dari pembatasan input

   |:@}: test_case
GH
FI
ED

|.@{: adalah kebalikan dari ekor input

   |.@{: test_case
CBA

Saya pikir Anda dapat melihat apa yang ingin kami lakukan: kami ingin menambahkan kebalikan dari ekor ke bagian terakhir dari transpos dari kurung (itu seteguk, tetapi pada dasarnya melekat CBApada akhir ED). Ini akan memberi kita satu langkah membuka, membalikkan.

(}:@],{:@],[) tidak hanya itu.

Ini ditambahkan CBAke ED, lalu bergabung dengan array lainnya. Karena itu, output kami adalah

   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

Pada dasarnya, tes ini untuk melihat apakah ada baris yang benar-benar spasi, dan menghapusnya jika benar. Itu tidak melakukan apa pun untuk iterasi pertama dari kasus uji.

Ini perlu (setidaknya sampai saya menemukan alternatif) karena kalau tidak kita akan akhirnya membuka spasi ke string output kami.

membabar

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

Unfurl pada dasarnya menggabungkan fungsi-fungsi lain dan kasus khusus input karakter tunggal.

Ketika kekuatan kata kerja ( ^:) diberikan kotak kosong ( a:), itu berlaku fungsi pada input sampai konvergen dan mengumpulkan hasil dalam array.

(1 < #) memeriksa apakah baris selalu lebih besar dari 1 (untuk input kasus khusus 1 baris).

|."1membalikkan setiap baris, sehingga membalikkan hasil 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]

Cobalah online!

Dalam setiap iterasi, badalah “kepala” dari string (pertama n-1 baris), diputar 90 derajat: jika aadalah [" NML", " OPK", "ABCDEFGHIJ"]kemudian badalah ["ON", "PM", "KL"].

Untuk membentangkan string sekali, kami menambahkan baris terakhir bke a[-1](memberi "ABCDEFGHIJKL") dan kemudian menghitung ulang a[:-1]dengan menambahkan spasi ke sisa string di b.

Kami mengakhiri dengan mencoba keluar dari bketika itu kosong.

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

Cobalah online!

Gagasan yang sama, ditulis berbeda. Kami mengakhiri dengan mencoba a.pop(-2)ketika ahanya memiliki satu elemen.

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}

Cobalah online!

Menyimpan beberapa byte tanpa benar-benar mengubah logika. Aliran di bawah ini pada dasarnya masih benar.

# 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}

Cobalah online!

Bagaimana?

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