Eingang:

Ein Faden

Ausgabe:

1) Zuerst entfernen wir das Zeichen am Ende der Eingabe-Zeichenkette, bis wir eine Länge haben, die ein Quadrat ist (dh 1, 4, 9, 16, 25, 36 usw.).
Also abcdefghijklmnopqrstuvwxyz(Länge 26) wird abcdefghijklmnopqrstuvwxy( Länge 25).

2) Dann setzen wir dies in ein Quadrat, eine Zeile nach der anderen, von links nach rechts:

abcde
fghij
klmno
pqrst
uvwxy

3) Wir falten es in alle vier Richtungen (wir entfalten solange, bis der äußere gefaltete 'Block' keine inneren Zeichen mehr hat, die sich entfalten könnten):

      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Einige Dinge, die zu beachten sind, wenn wir nach außen klappen, spiegeln wir im Grunde wie folgt wider (Zahlen zur Verdeutlichung hinzugefügt, die die 'Indizes' in diesen Beispielen darstellen):

Wenn wir die linke Seite ausklappen:

 123    to:   321 123
fghij         ihgf   j

Wenn wir die rechte Seite falten:

 123    to:    123 321
fghij         f   jihg

Wenn wir nach oben klappen:

            3q
            2l
            1g
  b   to:    b
 1g         1
 2l         2
 3q         3
  v          v

Wenn wir nach unten klappen:

 b          b
1g         1
2l         2
3q         3
 v   to:    v
           3q
           2l
           1g

Herausforderungsregeln:

• Sie können davon ausgehen, dass die Eingabe immer mindestens 1 Zeichen hat (dies ist auch die Ausgabe).
• Das Ausgabeformat ist flexibel, sodass Sie auf STDOUT oder STDERR drucken können. Rückgabe als String-Array / Liste oder Zeichen-2D-Array; Einzelsaite mit Zeilenumbrüchen; etc.
• Die Eingabe enthält nur alphanumerische Zeichen ( a-zA-Z0-9)
• Sie können auch ein nicht alphanumerisches Zeichen verwenden, um die Leerzeichen in und / oder um die ASCII-Kunst-Ausgabe herum aufzufüllen, wie z .. B. einen Punkt .
• Nachgestellte Leerzeichen und eine einzelne nachgestellte neue Zeile sind optional.
• Wir setzen die Entfaltung fort, bis der äußere gefaltete 'Block' keine Zentren mehr zum Entfalten hat.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

Input: abcdefghijklmnopqrstuvwxy
Output:
      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Input: A
Ouput:
A

Input: ThisIsATest
Output:
  I
 Thi
Is sI
 ATe
  I

Input: HowAboutAVeryLongExampleWhichIsAlsoAnEvenSquareInsteadOfOddOneAndExceeds64Chars
Output:

               An
               ch
              xamp
              i  I
              o  E
              quar
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
            HowAbout
      oLyreVA      noLyreV
  xampl    Eg      el    Examp
hci  Is    hW      As    hi  Ihc
nAo  Ev    sl      ev    so  EnA
  quare    Sn      Ie    Squar
      Odaetsn      fOdaets
            OddOneAn
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
              xamp
              i  I
              o  E
              quar
               An
               ch

Input: Lenght7
Output:
Le
ng

Input: abc
Output:
a

SOGL V0.12 , 75 Bytes

l√u²m√lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚

Probieren Sie es hier aus!

Dies erwartet die Eingabe auf dem Stapel, so dass ich ,zu Beginn aus Gründen der Benutzerfreundlichkeit hinzugefügt habe . Das kann zu Problemen führen, wenn die Eingabe nur Zahlen enthält. Hier ist eine Testsuite dafür.

70 Bytes √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚funktionieren auch, aber da ich erst jetzt √Strings implementiert habe und in der Dokumentation nicht erwähnt wurde, dass es die Länge überschreiten würde, werde ich es nicht zählen.

Erläuterung:

creating a square from the input

l       get the length of the input
 √      get its square root
  u     floor that
   ²    square it
    m   mold the input to that length
     √  convert it to a square

creating the unfoldings of the square - the idea is to cut out the inner squares to a new array

lH»{                              } (length-1)//2 times do
    ā;                                push an empty array below ToS
      l⁾                              push ToS.length - 2 (ToS here is the square or the previous unfolding)
        :A                            save a copy of that in the variable A
          ∫B                    }     repeat that amount of times, saving iteration on B - cutting the inner square to the empty array
            a{                 }        variable A times do
              bIw                         get the b+1th row of the previous unfolding
                 FIW                      get the (current loops iteration + 1)th character of that
                    h                     swap the 2 items below ToS - so the stack now is [..., prevUnfolding, newArray, character]
                     Fbž                  at [current loops iteration; b] insert that character in the array
                        ;                 swap the top 2 items - the stack now is [..., newArray, prevUnfolding]
                         FIbI@ž           at [current loops iteration+1; b+1] insert a space
                                 ;    get the now not empty array ontop of the stack

add the horizontal unfoldings

¹                    wrap the stack in an array
 K                   push the 1st item of that, which will function as the canvas
  ⁴{              }  iterate over a copy of the remaining items
    ē2\⌡               repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        ±                reverse the array horizontally
         e{  }         repeat e times
           @Κ            add a space before ToS
              ;⁴┼┼     add that horizontally before and after the canvas

add the veertical unfoldings

;                get the copy of the foldings above the canvas
 0E              reset the variable E to 0
   {         }   iterate the copy of the foldings
    ē2\⌡           repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        №            reverse the array vertically
         :h++      add that vertically before and after the canvas
              ╚  center the canvas vertically

Holzkohle , 120 109 Bytes

ＡＩ§⪪ＩＸＬθ⁰·⁵.⁰ηＦη⊞υ✂θ×ιηＦ⁴«ＡυεＪ⁰¦⁰Ｆ÷⁺¹η²«Ｆ⁴«Ｆ⁻η⁺κꧧεκ⁺μκ↷Ａ⮌ＥεＥε§ξν嶻Ａ⎇﹪ι²Ｅε⮌λ⮌εεＡ⎇‹ι²⁻⁺²⁺κκη⁻η⁺κκκ¿﹪ι²Ｍκ¹Ｍ¹κ

Probieren Sie es online! Beachten Sie, dass Ａseitdem geändert wurde ≔und der Link dies widerspiegelt. Erläuterung:

       θ          Input string
      Ｌ           Length
     Ｘ  ⁰·⁵       Raise to the power 0.5
    Ｉ             Cast to string
   ⪪       .      Split on the decimal point
  §         ⁰     Take the first element (integer part)
 Ｉ                Cast to integer
Ａ            η    Assign to h

Berechnet h = int(sqrt(len(q))). ( Floorwar noch nicht implementiert ...)

Ｆη⊞υ✂θ×ιη

Extrahiert die hLängenschnitte haus der Eingabe. (Eigentlich störe ich nicht daran, die Slices auf Länge zu kürzen h.) Ich verwende foreher eine Schleife als eine, Mapweil ich Assigndas Ergebnis des MapIrgendwo brauche, und das ist nicht trivial, wenn ich mit einer zu tun habe Slice.

Ｆ⁴«

Die Entfaltung erfolgt viermal, einmal für jede Richtung (nach unten, rechts, oben, links, wie codiert). Die Schleifenvariable für diese Schleife ist i.

   Ａυε

Nehmen Sie eine Kopie der aufgeschnittenen Schnur.

   Ｊ⁰¦⁰

Springe zurück zum Ursprung der Leinwand, so dass jede Entfaltung mit dem h-by- hQuadrat an derselben Stelle beginnt .

   Ｆ÷⁺¹η²«

Wiederholen Sie die (h+1)/2Zeiten; einmal für jede Entfaltung plus einmal für das ursprüngliche Quadrat. Die Schleifenvariable für diese Schleife ist k.

          Ｆ⁴«

Wiederholen Sie diesen Vorgang viermal für jede Seite des entfalteten Quadrats. (Ich benutze die Schleifenvariable nicht l.)

             Ｆ⁻η⁺κκ         Loop h-2k times, loop variable `m`
                    §εκ     Take the `k`th row
                   §   ⁺μκ  Take the `k+m`th column
                            Implicitly print the character

Drucken Sie eine Seite des entfalteten Quadrats. Da dies die kdritte Entfaltung ist, ist die Seite des Quadrats h-2kund kentfernt Zeichen vom Rand des ursprünglichen Quadrats.

             ↷

Drehpunkt bereit, um die nächste Seite des Quadrats zu drucken.

               Ｅε       Map over the array (element `m`, index `n`)
                 Ｅε     Map over the array (element `x`, index `p`)
                   §ξν  Take the `n`th element of `x`
              ⮌         Reverse
             Ａ        ε Replace the array with the result

Den aufgeschnittenen Faden drehen. (Ja, das ist eine ξ. Ich kann es nicht oft benutzen!) ＥηWürde auch für das Äußere funktionieren Map. Die Drehung hat auch den praktischen Nebeneffekt, dass die Breite des Arrays auf abgeschnitten wird h.

             ¶»

Nach dem Drucken der Seite bewegt sich der Cursor vom Rand des Quadrats weg. Das Drucken eines Zeichens weniger schlägt für Felder der Seite 1 fehl und ist ohnehin weniger golfen. Nachdem zuvor gedreht wurde, bewegt das Drucken einer neuen Zeile den Cursor bequem zurück in die Ecke.

            ﹪ι²         Take `i` modulo 2
           ⎇            Choose either
                   ⮌ε   Reverse the array
               Ｅε       Map over the array (element `l`, index `m`)
                 ⮌λ     Reverse each element
          Ａ          ε  Replace the array with the result

Drehen Sie das Quadrat je nach Bedarf vertikal oder horizontal.

           ⎇‹ι²                 If `i` < 2
                  ⁺κκ           Double `k`
                ⁺²              Add 2
               ⁻     η          Subtract `h`
                        ⁺κκ     Else double `k`
                      ⁻η        Subtract from `h`
          ≔                κ    Assign back to `k`.

Berechnen Sie die Verschiebung zur nächsten Entfaltung.

           ﹪ι²          Take `i` modulo 2
          ¿             If not zero
              Ｍκ¹       `k` across and 1 down
                 Ｍ¹κ    Else 1 across and `k` down

Bewegen Sie sich je nach Bedarf horizontal oder vertikal zur nächsten Entfaltung.

Hier ist ein Link zu der 97-Byte-Version, die Sie erhalten, wenn Sie die neuesten Funktionen von Charcoal nutzen Floor: Probieren Sie es online aus! Link ist eine ausführliche Version des Codes.