Entrada:

Uma linha

Resultado:

1) Primeiro, pegamos o caractere remove no final da string de entrada até ficarmos com um comprimento quadrado (ou seja, 1, 4, 9, 16, 25, 36 etc.).
Assim, o abcdefghijklmnopqrstuvwxyzcomprimento 26 se tornaabcdefghijklmnopqrstuvwxy ( comprimento 25).

2) Em seguida, colocamos isso em um quadrado, uma linha de cada vez, da esquerda para a direita:

abcde
fghij
klmno
pqrst
uvwxy

3) Dobramos em todas as quatro direções, assim (continuamos a desdobrar até que o 'bloco' dobrado externo não tenha mais caracteres internos a serem desdobramentos):

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

Algumas coisas a serem observadas, quando dobramos para fora, basicamente refletimos assim (números adicionados como esclarecimento, que representam os 'índices' nesses exemplos):

Quando dobramos o lado esquerdo:

 123    to:   321 123
fghij         ihgf   j

Quando dobramos o lado direito:

 123    to:    123 321
fghij         f   jihg

Quando dobramos para cima:

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

Quando dobramos para baixo:

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

Regras do desafio:

• Você pode assumir que a entrada sempre terá pelo menos 1 caractere (que também será a saída).
• O formato de saída é flexível, para que você possa imprimir em STDOUT ou STDERR; retornar como string-array / list ou character 2D-array; cadeia única com novas linhas; etc.
• A entrada conterá apenas caracteres alfanuméricos ( a-zA-Z0-9)
• Você também pode usar um caractere não alfanumérico para preencher os espaços e / ou ao redor da saída da arte ASCII, como um ponto . .
• Espaços à direita e uma única nova linha à direita são opcionais.
• Continuamos a desdobrar até que o 'bloco' dobrado externo não tenha mais centros para desdobrar.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

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

Experimente aqui!

Isso espera a entrada na pilha, portanto, para facilitar o uso, adicionei ,no início. Isso pode causar problemas se a entrada contiver apenas números, então aqui está um conjunto de testes para isso.

70 bytes √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚também funcionam, mas como agora eu apenas implementei √em strings e a documentação não mencionou que iria atingir o tamanho que eu não vou contar.

Explicação:

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

Carvão , 120 109 bytes

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

Experimente online! Observe que Ａdesde então foi alterado para ≔e o link reflete isso. Explicação:

       θ          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))). ( Floorainda estava para ser implementado ...)

Ｆη⊞υ✂θ×ιη

Extrai as hfatias de comprimento hda entrada. (Na verdade, não me incomodo em truncar as fatias no comprimento h.) Uso um forloop em vez de um Mapporque preciso Assigndo resultado de Mapalgum lugar e isso não é trivial ao lidar com a Slice.

Ｆ⁴«

O desdobramento acontece 4 vezes, uma vez para cada direção (para baixo, direita, cima, esquerda, conforme codificado). A variável de loop para esse loop é i.

   Ａυε

Tire uma cópia da corda fatiada.

   Ｊ⁰¦⁰

Ir para trás à origem da tela de modo a que cada um se desdobrar começa com o h-by- hquadrado no mesmo lugar.

   Ｆ÷⁺¹η²«

Repita os (h+1)/2tempos; uma vez para cada desdobramento, mais uma vez para o quadrado original. A variável de loop para esse loop é k.

          Ｆ⁴«

Repita 4 vezes, uma vez para cada lado do quadrado desdobrado. (Eu não uso a variável loop l.)

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

Imprima um lado do quadrado desdobrado. Como esse é o kdécimo desdobramento, o lado do quadrado é h-2ke tira os caracteres kda borda do quadrado original.

             ↷

Pivô pronto para imprimir o próximo lado do quadrado.

               Ｅε       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 a corda fatiada. (Sim, é isso ξ. Eu não uso frequentemente!) ＥηTambém funcionaria para o exterior Map. A rotação também tem o efeito colateral conveniente de truncar a largura da matriz para h.

             ¶»

Depois de imprimir o lado, o cursor se afasta da borda do quadrado. A impressão de um caractere a menos falha nos quadrados do lado 1 e, de qualquer maneira, é menos eficiente. Depois de girar anteriormente, a impressão de uma nova linha convenientemente move o cursor de volta para o canto.

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

Vire o quadrado na vertical ou na horizontal, conforme apropriado.

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

Calcule o deslocamento para o próximo desdobramento.

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

Mova horizontalmente ou verticalmente para o próximo desdobramento, conforme apropriado.

Aqui está um link para a versão de 97 bytes obtida utilizando todos os recursos mais recentes do carvão vegetal, incluindo Floor: Experimente online! Link é a versão detalhada do código.