Entrada:

Una cuerda

Salida:

1) Primero tomamos eliminar el carácter al final de la cadena de entrada hasta que nos queda una longitud que es un cuadrado (es decir, 1, 4, 9, 16, 25, 36, etc.)
Entonces abcdefghijklmnopqrstuvwxyz(longitud 26) se convierte en abcdefghijklmnopqrstuvwxy( longitud 25).

2) Luego colocamos esto en un cuadrado, una línea a la vez, de izquierda a derecha:

abcde
fghij
klmno
pqrst
uvwxy

3) Lo doblamos en las cuatro direcciones, de esta manera (seguimos desplegando hasta que el 'bloque' plegado exterior ya no tiene caracteres internos para desplegar):

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

Algunas cosas a tener en cuenta, cuando nos plegamos hacia afuera, básicamente reflejamos así (números agregados como aclaración, que representa los 'índices' en estos ejemplos):

Cuando doblamos el lado izquierdo:

 123    to:   321 123
fghij         ihgf   j

Cuando doblamos el lado derecho:

 123    to:    123 321
fghij         f   jihg

Cuando nos plegamos hacia arriba:

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

Cuando nos plegamos hacia abajo:

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

Reglas de desafío:

• Puede suponer que la entrada siempre tendrá al menos 1 carácter (que también será la salida).
• El formato de salida es flexible, por lo que puede imprimir en STDOUT o STDERR; regresar como string-array / list o character 2D-array; cadena simple con líneas nuevas; etc.
• La entrada solo contendrá caracteres alfanuméricos ( a-zA-Z0-9)
• También puede usar un carácter no alfanumérico para llenar los espacios en y / o alrededor de la salida de arte ASCII, como un punto ..
• Los espacios finales y una nueva línea final son opcionales.
• Continuamos desplegándonos hasta que el 'bloque' plegado exterior no tenga más centros para desplegar.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede utilizar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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++}╚

Pruébalo aquí!

Esto espera la entrada en la pila, por lo que, para facilitar su uso, agregué ,al principio. Eso puede causar problemas si la entrada contiene solo números, así que aquí hay un conjunto de pruebas para eso.

70 bytes √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚también funcionan, pero como ahora solo implementé √en cadenas y la documentación no mencionó que ocuparía la longitud, no lo contaré.

Explicación:

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

De carbón , 120 109 bytes

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

Pruébalo en línea! Tenga en cuenta que Ａdesde entonces se ha cambiado a ≔y el enlace refleja esto. Explicación:

       θ          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

Calcula h = int(sqrt(len(q))). ( Flooraún no se había implementado ...)

Ｆη⊞υ✂θ×ιη

Extrae los hsegmentos de longitud hde la entrada. (En realidad, no me molesto en truncar los cortes a la longitud h). Utilizo un forbucle en lugar de a Mapporque necesito Assignel resultado de Mapalguna parte y esto no es trivial cuando trato con a Slice.

Ｆ⁴«

El despliegue ocurre 4 veces, una vez para cada dirección (abajo, derecha, arriba, izquierda según lo codificado). La variable de bucle para este bucle es i.

   Ａυε

Tome una copia de la cadena en rodajas.

   Ｊ⁰¦⁰

Vuelva al origen del lienzo para que cada despliegue comience con el cuadrado h-por- hen el mismo lugar.

   Ｆ÷⁺¹η²«

Repetir (h+1)/2tiempos; una para cada despliegue, más una vez para el cuadrado original. La variable de bucle para este bucle es k.

          Ｆ⁴«

Repita 4 veces, una vez para cada lado del cuadrado desplegado. (No uso la variable de bucle l).

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

Imprima un lado del cuadrado desplegado. Dado que este es el kth despliegue, el lado del cuadrado es h-2ky aleja a los personajes kdel borde del cuadrado original.

             ↷

Pivote listo para imprimir el siguiente lado del cuadrado.

               Ｅε       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

Gire la cuerda en rodajas. (Sí, eso es ξ. ¡No lo uso a menudo!) ＥηTambién funcionaría para el exterior Map. La rotación también tiene el conveniente efecto secundario de truncar el ancho de la matriz h.

             ¶»

Después de imprimir el lado, el cursor se mueve fuera del borde del cuadrado. Imprimir un personaje menos falla para los cuadrados del lado 1 y, de todos modos, es menos golfoso. Habiendo pivotado previamente, la impresión de una nueva línea mueve convenientemente el cursor hacia la esquina.

            ﹪ι²         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

Voltee el cuadrado vertical u horizontalmente según corresponda.

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

Calcule el desplazamiento al siguiente despliegue.

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

Muévase horizontal o verticalmente al siguiente despliegue según corresponda.

Aquí hay un enlace a la versión de 97 bytes obtenida haciendo uso de todas las características más recientes de Charcoal, que incluyen Floor: ¡ Pruébelo en línea! El enlace es a la versión detallada del código.