Biorąc pod uwagę kwadratową strunę, produkuj całą moc wyjściową struny na każdym etapie rozwijania.

Sznurek musi się rozwijać w kierunku zgodnym z ruchem wskazówek zegara o ćwierć obrotu na raz.

Przykłady

Wejście :

A

Wyjście :

A

Uwaga : Akceptuję również dane wejściowe zduplikowane dla tego konkretnego przypadku testowego, tylko jeśli pomoże to zmniejszyć liczbę bajtów.

Wejście :

DC
AB

Wyjście :

DC
AB

  D
ABC

ABCD

Wejście :

GFE
HID
ABC

Wyjście :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Wejście :

JIHG
KPOF
LMNE
ABCD

Wyjście :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Zasady

To jest code-golf, więc wygrywa najkrótszy kod w bajtach.

• Do we / wy można zastosować dowolny rozsądny format, zakładając, że jest spójny.
• Spacje muszą być użyte do wypełnienia górnych linii wyniku.
• Musi być w stanie obsłużyć wprowadzanie wszystkich znaków do wydruku (w tym spacji: \x20- \x7e):

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

• Wiodące / końcowe białe znaki są dozwolone.
• Możesz założyć, że ciąg zawsze będzie kwadratem.
• Wszystkie standardowe luki są zabronione.

Inspiracja: Napisz kwadratowy program, który wyświetli liczbę „rozwinięć” .

SOGL V0.12 , 21 20 19 18 17 bajtów

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

Wypróbuj tutaj! ( →dodano, ponieważ oczekuje to danych wejściowych na stosie)

Wyjaśnienie:

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

-4 bajty dzięki @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)

Wypróbuj online!

Python 2 , 219 217 215 213 212 211 207 bajtów

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)

Wypróbuj online!

Pierwszy wyprowadza jako listę ciągów, drugi wyprowadza jako ASCII-art.

Węgiel drzewny , 42 35 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Edycja: Zapisano 7 bajtów, głównie poprzez zamianę tablic znaków na ciągi znaków. Wyjaśnienie:

ＡＥθＳθ

Odczytaj kwadrat wejściowy jako tablicę ciągów do zmiennej q.

Ｗ⊟θ«

Podczas gdy ostatni ciąg w tablicy nie jest pusty, usuń go.

⪫θ¶

Wydrukuj resztę tablicy.

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

Obróć resztę tablicy, zapętlając każdy znak ostatniego ciągu i łącząc lznak th każdego pozostałego ciągu w odwróconej tablicy.

⊞υι↙←⮌⪫υω

Dołącz poprzednio usunięty ostatni ciąg do u, który zawiera rozwiniętą wartość, i wydrukuj go.

Ｄ⎚

Wyjmij wynik, a następnie wyczyść płótno gotowe do następnej iteracji.

Zauważ, że ta wersja wyświetla końcowe rozwinięcie w osobnym wierszu, jeśli jest to niepożądane, to dla 38 bajtów:

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

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κodwraca bieżącą tablicę, wstawia rozwiniętą linię, następnie odwraca znaki w każdej linii, a następnie drukuje wszystko do góry nogami, uzyskując w ten sposób pożądany wynik.

Haskell , 127 120 bajtów

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

Wypróbuj online!

Wejście znajduje się lista linii, na przykład ["DC","AB"]dla drugiego przypadku testowego, wyjście jest lista wykazów linii: [["DC","AB"],[" D","ABC"],["ABCD"]]. Służy mapM (putStrLn . unlines)do ładnego wydrukowania wyniku.

Edycja: Zapisano 7 bajtów, zauważając, że im krótszytranspose znalazłem, podczas gdy przydaje się, ponieważ można go zmodyfikować, aby odwrócić każdy transponowany bezpośrednio.

05AB1E , 18 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

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

Wypróbuj online!

Jestem pewien, że można w to dużo grać w golfa. Powoduje to wydrukowanie dodatkowych białych znaków, ale tylko ze względu na sposób, w jaki J formatuje tablice zawarte w tablicy wyjściowej, aby uzyskać ten sam kształt.

Myślę, że kiedy już wejdę i skomentuję dokładnie to, co robię, mogę uzyskać lepszy pomysł na grę w golfa (po zrobieniu tego teraz tak naprawdę nie wiem ...). Warto zauważyć, że na potrzeby gry w golfa

• Mam przypadek specjalny 1 wiersz wejściowy (część while pętli)
• Muszę wyeliminować wszystkie wiersze składające się wyłącznie z białych znaków (na pewno musi być wbudowany do tego lub lepszy sposób), czyli filtr pod koniec
• Istnieje wiele ograniczeń, funkcji tożsamości i atopów

Wyjaśnienie

Odhaczając to, podzielę główną funkcję na trzy.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Będziemy pracować z drugim przypadkiem testowym.

unfurl_reversed

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

Daje to jeden ciąg rozwinięty raz, ale w odwrotnej kolejności. Wszystko to odbywa się w odwrotnej kolejności i w określonej kolejności, dzięki czemu sposób, w jaki J automatycznie wypełnia ciągi spacjami w celu dopasowania do kształtu tablicy, w której się znajdują, zapewni odpowiednie odstępy.

|:@}: jest transpozycją ograniczenia wejścia

   |:@}: test_case
GH
FI
ED

|.@{: jest odwrotnością ogona wejścia

   |.@{: test_case
CBA

Myślę, że możesz zobaczyć, co chcemy zrobić: chcemy dołączyć odwrotną stronę ogona do ostatniej części transpozycji ograniczenia (to kęs, ale w zasadzie przywiązanie CBAdo końca ED). To da nam jeden krok rozwinięcia, odwrócony.

(}:@],{:@],[) robi tylko to.

Dołącza CBAdo ED, a następnie łączy się to z resztą tablicy. Dlatego nasza produkcja jest

   unfurl_reversed test_case
GH   
FI   
EDCBA

biały filtr

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

Zasadniczo ten test sprawdza, czy którykolwiek wiersz jest całkowicie spacjami, i usuwa go, jeśli tak jest. Nie robi nic dla pierwszej iteracji przypadku testowego.

Jest to konieczne (przynajmniej dopóki nie znajdę alternatywy), ponieważ w przeciwnym razie ostatecznie rozwiniemy białe znaki w naszym ciągu wyjściowym.

rozpostrzeć

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

Unfurl zasadniczo łączy pozostałe funkcje i specjalne przypadki wprowadzania pojedynczych znaków.

Gdy potęga czasownika ( ^:) jest podana w pustym polu ( a:), stosuje ona funkcję na wejściu, dopóki nie zbiega się i nie gromadzi wyników w tablicy.

(1 < #) sprawdza, czy wiersze są zawsze większe niż 1 (w przypadkach specjalnych 1 wiersz).

|."1odwraca każdy wiersz, więc odwraca wyniki whitespace_filter @: unfurl.

Python 2 , 143 132 bajty

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]

Wypróbuj online!

W każdej iteracji bznajduje się „głowa” sznurka (pierwsze n − 1 rzędy), obrócona o 90 stopni: jeśli ajest, [" NML", " OPK", "ABCDEFGHIJ"]to bjest ["ON", "PM", "KL"].

Aby raz rozwinąć ciąg, dołączamy ostatni wiersz bdo a[-1](dając "ABCDEFGHIJKL"), a następnie przeliczamy a[:-1], dodając spacje do pozostałych ciągów w b.

Kończymy, próbując wyskoczyć, bgdy jest pusty.

Python 2 , 132 bajty

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

Wypróbuj online!

Ten sam pomysł, napisany inaczej. Kończymy, a.pop(-2)gdy amamy tylko jeden element.

Perl 5 , 155 bajtów

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

Wypróbuj online!

Zapisano kilka bajtów bez zmiany logiki. Przepływ poniżej jest nadal w zasadzie poprawny.

# Perl 5 , 163 bajtów

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

Wypróbuj online!

W jaki sposó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
}