Produzieren Sie bei einer quadratischen Zeichenfolge die gesamte Ausgabe für die Zeichenfolge in jeder Phase des Aufwickelns.

Die Schnur muss sich jeweils um eine Viertelumdrehung im Uhrzeigersinn entfalten.

Beispiele

Eingabe :

A

Ausgabe :

A

Hinweis : Die für diesen speziellen Testfall duplizierte Eingabe wird nur akzeptiert, wenn dies dazu beiträgt, die Anzahl der Bytes zu verringern.

Eingabe :

DC
AB

Ausgabe :

DC
AB

  D
ABC

ABCD

Eingabe :

GFE
HID
ABC

Ausgabe :

GFE
HID
ABC

   HG
   IF
ABCDE

     IH
ABCDEFG

       I
ABCDEFGH

ABCDEFGHI

Eingabe :

JIHG
KPOF
LMNE
ABCD

Ausgabe :

JIHG
KPOF
LMNE
ABCD

    LKJ
    MPI
    NOH
ABCDEFG

       NML
       OPK
ABCDEFGHIJ

          ON
          PM
ABCDEFGHIJKL

            PO
ABCDEFGHIJKLMN

              P
ABCDEFGHIJKLMNO

ABCDEFGHIJKLMNOP

Regeln

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

• Jedes vernünftige Format kann für die E / A verwendet werden, sofern es konsistent ist.
• Leerzeichen müssen verwendet werden, um die oberen Zeilen der Ausgabe aufzufüllen.
• Muss in der Lage sein, alle druckbaren Zeichen (einschließlich Leerzeichen: \x20- \x7e) einzugeben :

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

• Führende / nachfolgende Leerzeichen sind zulässig.
• Sie können davon ausgehen, dass die Zeichenfolge immer ein Quadrat ist.
• Alle Standardlücken sind verboten.

Inspiration: Schreiben Sie ein quadratisches Programm, das ausgibt, wie oft es „abgewickelt“ wurde .

SOGL V0.12 , 21 20 19 18 17 Bytes

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

Probieren Sie es hier aus! ( →hinzugefügt, da dies Eingaben auf dem Stapel erwartet)

Erläuterung:

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

-4 Bytes dank @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)

Probieren Sie es online!

Python 2 , 219 217 215 213 212 211 207 Bytes

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)

Probieren Sie es online!

Der erste gibt als Liste von Strings aus, der zweite als ASCII-Art.

Holzkohle , 42-35 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Speichert 7 Bytes, hauptsächlich durch Umschalten von Zeichenfeldern auf Zeichenfolgen. Erläuterung:

ＡＥθＳθ

Lesen Sie das Eingabequadrat als Array von Zeichenfolgen in die Variable q.

Ｗ⊟θ«

Entfernen Sie die letzte Zeichenfolge in dem Array, obwohl sie nicht leer ist.

⪫θ¶

Drucken Sie den Rest des Arrays.

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

Drehen Sie den Rest des Arrays, indem Sie jedes Zeichen der letzten Zeichenfolge durchlaufen und das lvierte Zeichen jeder verbleibenden Zeichenfolge in dem umgekehrten Array verbinden.

⊞υι↙←⮌⪫υω

Hängen Sie die zuvor entfernte letzte Zeichenfolge an u, die den entfalteten Wert enthält, und drucken Sie sie aus.

Ｄ⎚

Geben Sie das Ergebnis aus und löschen Sie die Zeichenfläche, um sie für die nächste Iteration vorzubereiten.

Beachten Sie, dass diese Version die endgültige Entfaltung in einer separaten Zeile ausgibt, wenn dies unerwünscht ist, dann für 38 Bytes:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung: ←Ｅ⁺⟦⪫υω⟧⮌θ⮌κKehrt das aktuelle Array um, stellt die entfaltete Zeile voran, kehrt die Zeichen in jeder Zeile um und druckt dann alles auf den Kopf, um das gewünschte Ergebnis zu erzielen.

Haskell , 127 120 Bytes

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

Probieren Sie es online!

Eingabe ist eine Liste von Zeilen, zum Beispiel ["DC","AB"]für den zweiten Testfall Ausgabe eine Liste von Listen der Zeilen: [["DC","AB"],[" D","ABC"],["ABCD"]]. Verwenden Sie mapM (putStrLn . unlines)diese Option, um das Ergebnis hübsch auszudrucken.

Bearbeiten: Sie haben 7 Bytes gespart, indem Sie festgestellt haben , dass der kürzeretranspose Wert, den ich während eines Go-Vorgangs gefunden habe, nützlich ist, da er geändert werden kann, um jeden transponierten Wert direkt umzukehren.

05AB1E , 18 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Ich bin mir sicher, dass man hier viel Golf spielen kann. Dadurch werden zusätzliche Leerzeichen gedruckt, jedoch nur aufgrund der Art und Weise, in der J die im ausgegebenen Array enthaltenen Arrays so formatiert, dass sie dieselbe Form haben.

Ich denke, wenn ich einmal reingehe und genau kommentiere, was ich tue, bekomme ich vielleicht eine bessere Vorstellung davon, wie man Golf spielt (nachdem ich das jetzt getan habe, weiß ich es nicht wirklich ...). Für die Zwecke des Golfspiels ist es erwähnenswert, dass

• Ich muss in Sonderfällen 1 Zeile eingeben (der while-Teil der Schleife)
• Ich muss alle Zeilen entfernen, die nur aus Leerzeichen bestehen (es muss entweder ein integrierter oder ein besserer Weg sein, dies zu tun). Dies ist der Filter gegen Ende
• Es gibt viele Caps, Identity-Funktionen und Atops

Erläuterung

Wenn ich dies nicht spiele, teile ich die Hauptfunktion in drei Teile.

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

test_case         =. 3 3 $ 'GFEHIDABC'

Wir werden mit dem zweiten Testfall arbeiten.

unfurl_reversed

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

Dies gibt einem die einmal abgewickelte Saite, jedoch in umgekehrter Reihenfolge. All dies geschieht in umgekehrter Reihenfolge, so dass die Art und Weise, in der J Zeichenfolgen automatisch mit Leerzeichen auffüllt, die der Form des Arrays entsprechen, in dem sie sich befinden, den richtigen Abstand ergibt.

|:@}: ist die Transponierte des Eingangs

   |:@}: test_case
GH
FI
ED

|.@{: ist die Umkehrung des Endes der Eingabe

   |.@{: test_case
CBA

Ich denke, Sie können sehen, was wir tun wollen: Wir wollen die Rückseite des Schwanzes an den letzten Teil der Transponierung des Abschnitts anhängen (das ist ein Schluck, aber im Grunde genommen an CBAdas Ende von anhängen ED). Dies gibt uns einen Schritt zum Entfalten, umgekehrt.

(}:@],{:@],[) macht genau das.

Es hängt CBAzu ED, schließt sich dann die mit dem Rest des Arrays. Unsere Ausgabe ist daher

   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

Grundsätzlich wird hiermit geprüft, ob eine Zeile vollständig Leerzeichen enthält, und es wird entfernt, wenn dies der Fall ist. Bei der ersten Iteration des Testfalls wird nichts unternommen.

Dies ist notwendig (zumindest bis ich eine Alternative gefunden habe), da wir sonst irgendwann Leerzeichen in unserer Ausgabezeichenfolge auflösen.

entfalten

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

Unfurl fügt im Grunde genommen die anderen Funktionen zusammen und in Sonderfällen einzelne Zeicheneingaben.

Wenn der Potenz von verb ( ^:) das leere Kästchen ( a:) zugewiesen wird, wendet sie eine Funktion auf eine Eingabe an, bis sie konvergiert und die Ergebnisse in einem Array sammelt.

(1 < #) prüft, ob die Zeilen immer größer als 1 sind (in Sonderfällen 1 Zeileneingaben).

|."1Kehrt jede Zeile um, sodass die Ergebnisse von invertiert werden whitespace_filter @: unfurl.

Python 2 , 143 132 Bytes

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]

Probieren Sie es online!

bIst in jeder Iteration der „Kopf“ der Zeichenfolge (erste n - 1 Zeilen) um 90 Grad gedreht: Wenn aist, [" NML", " OPK", "ABCDEFGHIJ"]dann bist ["ON", "PM", "KL"].

Um eine Zeichenfolge einmal zu entfalten, fügen wir die letzte Zeile von bto a[-1](giving "ABCDEFGHIJKL") hinzu und berechnen sie dann neu, a[:-1]indem wir den restlichen Zeichenfolgen in Leerzeichen hinzufügen b.

Wir beenden, indem wir versuchen, herauszufinden, bwann es leer ist.

Python 2 , 132 Bytes

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

Probieren Sie es online!

Gleiche Idee, anders geschrieben. Wir beenden, indem wir versuchen, a.pop(-2)wann anur ein Element hat.

Perl 5 , 155 Bytes

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

Probieren Sie es online!

Ein paar Bytes gespart, ohne die Logik wirklich zu verändern. Der Fluss unten ist im Grunde immer noch korrekt.

# Perl 5 , 163 Bytes

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

Probieren Sie es online!

Wie?

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