Учитывая квадратную строку, производите весь вывод для строки на каждом этапе развертывания.

Струна должна развернуться по часовой стрелке на четверть оборота за раз.

Примеры

Вход :

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 [\] ^ _` АБВГДЕЖЗИКЛМНОПРСТУФХЧШЭЮЯ {|} ~

• Пробелы в начале / конце разрешены.
• Вы можете предположить, что строка всегда будет квадратной.
• Все стандартные лазейки запрещены.

Вдохновение: Напишите квадратную программу, которая выводит количество раз, когда она была «развернута» .

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, в которой хранится развернутое значение, и напечатайте его.

Ｄ⎚

Выведите результат, а затем очистите холст, готовый к следующей итерации.

Обратите внимание, что эта версия выводит окончательное развертывание в отдельной строке, если это нежелательно, тогда для 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 строки ввода (в то время как часть цикла)
• Я должен исключить все строки, состоящие исключительно из пробелов (конечно, для этого должен быть или встроенный или лучший способ сделать это), который является фильтром в конце
• Есть много заглавных букв, функций идентичности и atops.

объяснение

Разгадывая это, я разделю основную функцию на три части.

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](give "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
}