Dada uma string, primeiro coloque-a da seguinte maneira:

Primeiro, escreva a string.

abcde

Em seguida, escreva a sequência girada uma para a esquerda.

abcde
bcdea

Continue fazendo isso até escrever linhas len (string) .

abcde
bcdea
cdeab
deabc
eabcd

Agora, leia a partir da string assim:

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

Que dá:

abcdeabcdcbaedcbcdeabaede

Imprima esta sequência.

Casos de teste

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

^{Por favor, comente se um caso de teste está incorreto.}

Lembre-se de que isso é código-golfe , portanto o código com o menor número de bytes vence.

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 bônus compatível com 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)

Explicação

Isso tira vantagem do fato de que a saída para, por exemplo, uma cadeia de comprimento 5 pode ser representada como:

abcdeabcd cbaedcb cdeab aed e
012345678 7654321 23456 543 4

onde cada dígito representa um índice na sequência (começando em 0), module o comprimento da sequência. Em outras palavras, se n é o comprimento da string, incrementamos o índice 2n - 1 vezes, depois o diminuímos 2 (n - 1) - 1 vezes, depois aumentamos 2 (n - 2) - 1 vezes, etc. Isso pode ser simplificado para o seguinte algoritmo:

• Inicie o índice i em -1 .
• Para cada número inteiro x no intervalo [n ² ..1] :
  • Se floor (sqrt (x)) tiver a mesma paridade (par / ímpar) que n , incremente i .
  • Caso contrário, diminua i .
  • Adicione o caractere no índice i mod n à saída.

Isso funciona porque floor (sqrt (x)) alterna paridades após 2n - 1 iterações, depois 2 (n - 1) - 1 iterações, etc.

Pitão , 15 bytes

.Wp.(H0_CZ.<LQU

Um programa que recebe a entrada "quoted string"e imprime o resultado.

Experimente online! ou verifique todos os casos de teste (modificados para várias entradas).

Como 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 (em CMD.EXE), 91 bytes

Isso requer um terminal com um backspace em funcionamento ( \b) e não funcionará em repl.it ou ideone.com . Uma declaração de impressão que termina em vírgula separa a saída adicional com espaço, em vez de uma nova linha ou retorno. O backspace nos permite substituir o espaço de separação.

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

Experimente em ideone.com ou repl.it (graças a Oliver). A entrada deve ser uma string python, por exemplo '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

Os quatro fatias anexas pelo circuito ( s[i:], s[:n-i], r[i+2:], r[:n-i]) são tomadas a partir de quatro bordas da espiral. Por exemplo, com 01234o quadrado é:

01234
12340
23401
34012
40123

Assim que nós tomamos 01234, 0123, 210, 4321. A variável ié o índice do valor superior esquerdo em cada etapa do processo. Na espiral final, várias fatias podem estar vazias.

Gelatina , 11 10 bytes

ẋ2µṖȮṖUµÐL

TryItOnline! ou todos os testes

Quão?

O quadrado não inspirado é uma série de execuções "borda superior mais borda direita" e "borda inferior mais borda esquerda", cada uma das quais é o inverso da execução anterior sem a primeira e a última letra e a primeira das quais é a entrada mais a entrada sem a última letra (por exemplo, a entrada "abcde"tem uma saída 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

Experimente online!

Explicação:

 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)

A entrada vazia sai com um erro (produzindo a saída correta).

Experimente online! Ou verifique todos os casos de teste .

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 pela resposta @ETHproductions.

Perl, 99 bytes

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

O espaço em branco não faz parte do programa e é fornecido para facilitar a leitura.

Código não extremamente eficiente. Eu deveria ser capaz de encurtar as três primeiras linhas de alguma forma, mas tudo o que tentei fazer falhou. Esse operador ternário também precisa ser corrigido de alguma forma, mas, dessa maneira, foi possível reduzir meu código em 10 bytes, porque eu poderia cortar muito.

O código funciona compilando uma lista de palíndromos, separados por números pares, que representam os valores de lugar da sequência a ser puxada.

Na verdade , 21 13 bytes

Esse algoritmo é amplamente baseado na resposta de Jonathan Allan Jelly . Há duas maneiras de imprimir o resultado como uma sequência. A abordagem usada aqui duplica uma etapa intermediária e a adiciona a um total em execução no registro 1 (uma sequência vazia por padrão); ;╕na função, depois ╛no final. A outra abordagem é duplicar uma etapa intermediária, deixar essas etapas duplicadas na pilha e somar em uma sequência no final; ;na função, depois kΣno final.

Sugestões de golfe são bem-vindas. Experimente online!

2*`dX;╕dXR`Y╛

Ungolfing

         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

Uma porta direta da minha resposta Jelly ; apenas um programa completo recebendo entrada (em vez de uma função).
A print(x,end='')é uma declaração de impressão que não irá imprimir a nova linha padrão.

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

Experimente online!