Враховуючи квадратний рядок, виробляють весь вихід для рядка на кожному етапі розгортання.

Рядок повинен розгортатися за годинниковою стрілкою по черзі по черзі.

Приклади

Вхід :

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

Правила

Це код-гольф, тому найкоротший код у байтах виграє.

• Будь-який розумний формат може використовуватися для вводу / виводу, якщо він є послідовним.
• Пробіли повинні використовуватися для прокладки верхніх ліній виводу.
• Повинно працювати з введенням усіх символів для друку (включаючи пробіл: \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символу кожної залишкової рядка у зворотному масиві.

⊞υι↙←⮌⪫υω

Додайте до цього попередньо видалений останній рядок u, який містить неперевершене значення, і надрукуйте його.

Ｄ⎚

Виведіть результат, а потім очистіть полотно, готове до наступної ітерації.

Зауважте, що ця версія виводить остаточну розгортку в окремий рядок, якщо це небажано, то на 38 байт:

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κповертає поточний масив, попередньо розгортає розгорнуту лінію, потім перевертає символи в кожному рядку, потім друкує все догори дном, створюючи таким чином бажаний результат.

Haskell , 127 120 байт

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)щоб сильно роздрукувати результат.

Редагувати: Збережено 7 байт, помітивши, що коротшеtranspose я знайшов деякий час, коли йти стане в нагоді, оскільки його можна змінити для зворотного зміни кожного перенесеного безпосередньо.

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 ряду (частина циклу час)
• Мені потрібно усунути всі рядки, що складаються виключно з пробілу (напевно, для цього повинен бути або вбудований, або кращий спосіб зробити це), який є фільтром наприкінці
• Є безліч шапок, функцій ідентичності та атопів

Пояснення

Якщо я скасую це, я розділяю основну функцію на три.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Ми будемо працювати з другою тестовою справою.

undeurl_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 в основному поєднує інші функції разом і окремі випадки введення символів.

Коли потужність verb ( ^:) задається порожнім полем ( 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
}