Dada una cadena, primero cuadrácela de la siguiente manera:

Primero, escribe la cadena.

abcde

A continuación, escriba la cadena girada una izquierda.

abcde
bcdea

Siga haciendo esto hasta que haya escrito líneas len (cadena) .

abcde
bcdea
cdeab
deabc
eabcd

Ahora, lee de la cadena así:

----+
+--+|
|+>||
|+-+|
+---+

Lo que da:

abcdeabcdcbaedcbcdeabaede

Imprime esta cadena.

Casos de prueba

abcdef -> abcdefabcdedcbafedcbcdefabcbafedefaf
cena! -> cena!cenanec!anena!cec!a!
ppcg -> ppcgppcppgcpcgpg
abc -> abcabacbc
ab -> abab
a -> a
 -> 

^{Comente si un caso de prueba es incorrecto.}

Recuerde, este es el código de golf , por lo que gana el código con el menor número de bytes.

JavaScript (ES7), 83 80 78 77 bytes

s=>s.repeat(l=s.length).replace(/./g,_=>s[(c-=--i**.5-l&1||-1)%l],c=-1,i=l*l)

Programa adicional compatible con ES3:

for(s=prompt(r=""),c=-1,l=s.length,i=l*l;i;)r+=s[(c-=l-Math.sqrt(i--)&1||-1)%l];alert(r)

Explicación

Esto aprovecha el hecho de que la salida para, por ejemplo, una cadena de longitud 5 se puede representar como:

abcdeabcd cbaedcb cdeab aed e
012345678 7654321 23456 543 4

donde cada dígito representa un índice en la cadena (comenzando en 0), modula la longitud de la cadena. En otras palabras, si n es la longitud de la cadena, incrementamos el índice 2n - 1 veces, luego lo disminuimos 2 (n - 1) - 1 veces, luego lo incrementamos 2 (n - 2) - 1 veces, etc. Esto se puede simplificar con el siguiente algoritmo:

• Comience el índice i en -1 .
• Para cada entero x en el rango [n ² ..1] :
  • Si floor (sqrt (x)) es de la misma paridad (par / impar) que n , incremente i .
  • De lo contrario, decremente i .
  • Agregue el carácter en el índice i mod n a la salida.

Esto funciona porque floor (sqrt (x)) cambia las paridades después de 2n - 1 iteraciones, luego 2 (n - 1) - 1 iteraciones, etc.

Pyth , 15 bytes

.Wp.(H0_CZ.<LQU

Un programa que toma la entrada de a "quoted string"e imprime el resultado.

Pruébalo en línea! o verificar todos los casos de prueba (modificado para entrada múltiple).

Cómo funciona

.Wp.(H0_CZ.<LQU  Program. Input: Q
            L U  Map over [0, 1, 2, 3, ..., Q-1] (implicit input):
          .< Q     Q left-shifted by that many characters
                 Call this X
.W               While
   .(H0          popping the first element of X (mutates X in-place)
  p              and printing it with no trailing newline is truthy:
         Z           X = 
        C            X transposed
       _             reversed

Python 2.7 (en CMD.EXE), 91 bytes

Esto requiere un terminal con un espacio de retroceso que funcione ( \b), y no funcionará en repl.it o ideone.com . Una declaración de impresión que termina en una coma separa más resultados con espacio en lugar de una nueva línea o retorno. El retroceso nos permite sobrescribir el espacio de separación.

s=input();r=s[::-1];n=len(s)-1;i=0
while i<=n:print'\b'+s[i:]+s[:n-i]+r[i+2:]+r[:n-i],;i+=2

Python 2.7, 96 bytes

Pruébelo en ideone.com o repl.it (gracias a Oliver). La entrada debe ser una cadena de Python, por ejemplo 'cena!'.

s=input();r=s[::-1];n=len(s)-1;i=0;S=''
while i<=n:S+=s[i:]+s[:n-i]+r[i+2:]+r[:n-i];i+=2
print S

Los cuatro rebanadas adjuntas por el bucle ( s[i:], s[:n-i], r[i+2:], r[:n-i]) se toman de cuatro bordes de la espiral. Por ejemplo con 01234el cuadrado es:

01234
12340
23401
34012
40123

Así que tomamos 01234, 0123, 210, 4321. La variable ies el índice del valor superior izquierdo en cada paso del proceso. En la espiral final, varias de las rodajas pueden estar vacías.

Jalea , 11 10 bytes

ẋ2µṖȮṖUµÐL

TryItOnline! o todas las pruebas

¿Cómo?

El cuadrado sin espiral es una serie de corridas de "borde superior más borde derecho" y "borde inferior más borde izquierdo", cada una de las cuales es el reverso de la ejecución anterior sin la primera y la última letra, y la primera de las cuales es la entrada más la entrada sin la última letra (por ejemplo, la entrada "abcde"tiene una salida de "abcdeabcd" + "cbaedcb" + "cdeab" + "aed" + "e").

ẋ2µṖȮṖUµÐL - Main link: s                            e.g. abcde
ẋ2         - repeat s twice                          e.g. abcdeabcde
  µ    µ   - monadic chain separation
        ÐL - repeat until results are no longer unique:
   Ṗ       -     remove the last character                abcdeabcd / cbaedcb / cdeab / aed / e   / ""
    Ȯ      -     print z (with no linefeed) and return z
     Ṗ     -     remove the last character                abcdeabc  / cbaedc  / cdea  / ae  / ""  / ""
      U    -     reverse                                  cbaedcba  / cdeabc  / aedc  / ea  / ""  / "" <- no longer unique.

05AB1E, 12 bytes

2×[DõQ#¨D?¨R

Pruébalo en línea!

Explicación:

 2×[DõQ#¨D?¨R
               # Implicit input
 2×            # Repeat twice
   [           # Begin infinite loop
┏>  DõQ#       # If empty string, break
┃       ¨      # Remove last character
┃        D     # Duplicate
┃         ?    # Print with no newline and pop
┃          ¨   # Remove last character
┃           R  # Reverse
┗━━━━━━━━━━━━┛ # Implicit end infinite loop

MATL , 27 bytes

"GX@q_YS]vGn1YL_GnoQ&Ple&S)

La entrada vacía sale con un error (produciendo la salida correcta).

Pruébalo en línea! O verificar todos los casos de prueba .

C, 95 94 bytes

i,j,k,l;f(char*s){for(k=-1,l=i=strlen(s);i--;)for(j=i*2;~j--;putchar(s[(k+=(l-i)%2*2-1)%l]));}

Inspirado por la respuesta de @ETHproductions.

Perl, 99 bytes

$_=<>;
chop;
@a=split//;
print(@a[$%,(@f=1-($b=@a-$%)..$b-3),$b-1?$b-2:(),reverse@f]),$%+=2 until$%>@a

El espacio en blanco no es parte del programa y se proporciona para facilitar la lectura.

Código no extremadamente eficiente. Debería poder acortar las tres primeras líneas de alguna manera, pero todo lo que intenté hacer falló. Ese operador ternario también debe repararse de alguna manera, pero tenerlo de esta manera hizo posible acortar mi código en unos 10 bytes porque podía cortar mucho.

El código funciona compilando una lista de palíndromos, separados por números pares, que representan los valores de posición de la cadena que se extraerá.

En realidad , 21 13 bytes

Este algoritmo se basa en gran medida en la respuesta Jelly de Jonathan Allan . Hay dos formas de imprimir el resultado como una cadena. El enfoque utilizado aquí duplica un paso intermedio y luego lo agrega a un total acumulado en el registro 1 (una cadena vacía por defecto); ;╕en la función, luego ╛al final. El otro enfoque es duplicar un paso intermedio, dejar esos pasos duplicados en la pila y sumarlos en una cadena al final; ;en la función, luego kΣal final.

Sugerencias de golf bienvenidas. Pruébalo en línea!

2*`dX;╕dXR`Y╛

No golfista

         Implicit input s.
2*       Push a string that repeats s two times.
`...`Y   Call the following function until there is no change from the last call
  dX       Discard the last element. Call this new string m.
  ;╕       Duplicate m and add it to the running total in register 1.
  dXR      Discard the last element again and reverse the string.
╛        Push the unspiralled string from register 1 to the stack.
         Implicit return.

Python 3, 59 bytes

x=input()*2
while x:x=x[:-1];print(x,end='');x=x[:-1][::-1]

repl.it

Un puerto directo de mi respuesta Jelly ; solo un programa completo que toma datos (en lugar de una función).
El print(x,end='')es una declaración de impresión que no imprimirá la nueva línea predeterminada.

Python 3, 93 bytes

s=input();r,n,i=s[::-1],len(s)-1,0
while n-i:print(s[i:]+s[:n-i]+r[i+2:]+r[:n-i],end='');i+=2

Pruébalo en línea!