Data una stringa, prima quadrala come segue:

Innanzitutto, scrivi la stringa.

abcde

Quindi, scrivi la stringa ruotata di una a sinistra.

abcde
bcdea

Continua fino a quando non hai scritto le righe len (stringa) .

abcde
bcdea
cdeab
deabc
eabcd

Ora, leggi dalla stringa in questo modo:

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

Che dà:

abcdeabcdcbaedcbcdeabaede

Stampa questa stringa.

Casi test

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

^{Si prega di commentare se un caso di prova non è corretto.}

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

JavaScript (ES7), 83 80 78 77 byte

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

Programma bonus conforme a 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)

Spiegazione

Ciò si avvale del fatto che l'output, ad esempio, di una stringa di lunghezza 5 può essere rappresentato come:

abcdeabcd cbaedcb cdeab aed e
012345678 7654321 23456 543 4

dove ogni cifra rappresenta un indice nella stringa (a partire da 0), modulo la lunghezza della stringa. In altre parole, se n è la lunghezza della stringa, incrementiamo l'indice 2n - 1 volte, quindi lo diminuiamo 2 (n - 1) - 1 volte, quindi lo incrementiamo 2 (n - 2) - 1 volte, ecc. Questo può essere semplificato al seguente algoritmo:

• Inizia l'indice i da -1 .
• Per ogni numero intero x nell'intervallo [n ² ..1] :
  • Se floor (sqrt (x)) è della stessa parità (pari / dispari) di n , incrementare i .
  • Altrimenti, decrementa i .
  • Aggiungi il carattere all'indice i mod n all'output.

Questo funziona perché floor (sqrt (x)) cambia parità dopo 2n - 1 iterazioni, quindi 2 (n - 1) - 1 iterazioni, ecc.

Pyth , 15 byte

.Wp.(H0_CZ.<LQU

Un programma che accetta input di a "quoted string"e stampa il risultato.

Provalo online! oppure verifica tutti i casi di test (modificati per input multipli).

Come funziona

.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 (in CMD.EXE), 91 byte

Ciò richiede un terminale con un backspace funzionante ( \b) e non funzionerà su repl.it o ideone.com . Un'istruzione di stampa che termina con una virgola separa l'output ulteriore con spazio anziché una nuova riga o ritorno. Il backspace ci consente di sovrascrivere lo spazio di separazione.

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 byte

Provalo su ideone.com o repl.it (grazie a Oliver). L'input deve essere una stringa Python, ad es '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

I quattro fette allegate dal loop ( s[i:], s[:n-i], r[i+2:], r[:n-i]) sono tratti da quattro bordi della spirale. Ad esempio con 01234il quadrato è:

01234
12340
23401
34012
40123

Quindi prendiamo 01234, 0123, 210, 4321. La variabile iè l'indice del valore in alto a sinistra in ogni fase del processo. Nella spirale finale molte delle fette possono essere vuote.

Gelatina , 11 10 byte

ẋ2µṖȮṖUµÐL

TryItOnline! o tutti i test

Come?

Il quadrato senza stelle è una serie di "esecuzioni del bordo superiore più il bordo destro" e "del bordo inferiore più il bordo sinistro", ognuna delle quali è il contrario della corsa precedente senza la prima e l'ultima lettera, e la prima delle quali è l'input più l'input senza l'ultima lettera (ad es. input "abcde"ha un output di "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 byte

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

Provalo online!

Spiegazione:

 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 byte

"GX@q_YS]vGn1YL_GnoQ&Ple&S)

L'ingresso vuoto esce con un errore (produce l'output corretto).

Provalo online! Oppure verifica tutti i casi di test .

C, 95 94 byte

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]));}

Ispirato dalla risposta @ETHproductions.

Perl, 99 byte

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

Lo spazio bianco non fa parte del programma ed è fornito per la leggibilità.

Codice non estremamente efficiente. Dovrei essere in grado di accorciare le prime tre righe in qualche modo, ma tutto ciò che ho cercato di fare è fallito. Anche quell'operatore ternario deve essere corretto in qualche modo, ma farlo in questo modo ha permesso di accorciare il mio codice di circa 10 byte perché potevo tagliare così tanto.

Il codice funziona compilando un elenco di palindromi, separati da numeri pari, che rappresentano i valori di posizionamento della stringa da estrarre.

In realtà , 21 13 byte

Questo algoritmo si basa in gran parte sulla risposta Jelly di Jonathan Allan . Esistono due modi per stampare il risultato come una stringa. L'approccio utilizzato qui duplica un passaggio intermedio e quindi lo aggiunge a un totale parziale nel registro 1 (una stringa vuota per impostazione predefinita); ;╕nella funzione, quindi ╛alla fine. L'altro approccio è duplicare un passaggio intermedio, lasciare quei passaggi duplicati nello stack e sommarli in una stringa alla fine; ;nella funzione, quindi kΣalla fine.

Suggerimenti di golf benvenuti. Provalo 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 byte

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

repl.it

Una porta diretta della mia risposta Jelly ; solo un programma completo accetta input (anziché una funzione).
È print(x,end='')un'istruzione di stampa che non stamperà la nuova riga predefinita.

Python 3, 93 byte

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

Provalo online!