Wenn Sie eine Zeichenfolge haben, kreuzen Sie sie zuerst wie folgt an:

Schreiben Sie zuerst die Zeichenfolge.

abcde

Als nächstes schreiben Sie die Zeichenfolge gedreht um eins nach links.

abcde
bcdea

Mach so weiter, bis du len (string) Zeilen geschrieben hast .

abcde
bcdea
cdeab
deabc
eabcd

Lesen Sie nun aus der Zeichenfolge wie folgt:

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

Welches gibt:

abcdeabcdcbaedcbcdeabaede

Diesen String drucken.

Testfälle

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

^{Bitte kommentieren Sie, wenn ein Testfall nicht korrekt ist.}

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit der geringsten Anzahl von Bytes.

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)

Bonus ES3-konformes Programm:

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)

Erläuterung

Dies nutzt die Tatsache aus, dass die Ausgabe für z. B. eine Zeichenfolge der Länge 5 wie folgt dargestellt werden kann:

abcdeabcd cbaedcb cdeab aed e
012345678 7654321 23456 543 4

wobei jede Ziffer einen Index in der Zeichenfolge darstellt (beginnend mit 0), modulieren Sie die Länge der Zeichenfolge. Mit anderen Worten, wenn n die Länge der Zeichenkette ist, erhöhen wir den Index 2n - 1 Mal, verringern ihn 2 (n - 1) - 1 Mal und erhöhen ihn 2 (n - 2) - 1 Mal usw. Dies kann mit dem folgenden Algorithmus vereinfacht werden:

• Starten Sie den Index i bei -1 .
• Für jede ganze Zahl x im Bereich [n ² ..1] :
  • Wenn floor (sqrt (x)) die gleiche Parität (gerade / ungerade) wie n hat , inkrementiere i .
  • Andernfalls dekrementiere i .
  • Fügen Sie das Zeichen am Index i mod n zur Ausgabe hinzu.

Dies funktioniert, weil floor (sqrt (x)) die Paritäten nach 2n - 1 Iterationen, dann nach 2 (n - 1) - 1 Iterationen usw. wechselt.

Pyth , 15 Bytes

.Wp.(H0_CZ.<LQU

Ein Programm, das die Eingabe von a "quoted string" und das Ergebnis druckt.

Probieren Sie es online! oder überprüfen Sie alle Testfälle (geändert für Mehrfacheingabe).

Wie es funktioniert

.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

Dies erfordert ein Terminal mit einem funktionierenden Backspace ( \b) und funktioniert nicht auf repl.it oder ideone.com . Eine print-Anweisung, die mit einem Komma endet, trennt die weitere Ausgabe durch Leerzeichen anstelle einer neuen Zeile oder eines Return. Mit der Rücktaste können wir den Trennungsraum überschreiben.

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

Probiere es auf ideone.com oder repl.it aus (danke an Oliver). Die Eingabe muss eine Python-Zeichenfolge sein, z '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

Die vier Scheiben durch die anhängenden Schleife ( s[i:], s[:n-i], r[i+2:], r[:n-i]) von vier Rand der Spirale aufgenommen. Zum Beispiel mit 01234dem Quadrat ist:

01234
12340
23401
34012
40123

So nehmen wir 01234, 0123, 210, 4321. Die Variable iist der Index des Werts oben links in jedem Schritt des Prozesses. In der letzten Spirale können mehrere Scheiben leer sein.

Jelly , 11 10 Bytes

ẋ2µṖȮṖUµÐL

TryItOnline! oder alle Tests

Wie?

Das nicht rotierte Quadrat ist eine Reihe von Läufen mit "Oberkante plus Rechtskante" und "Unterkante plus Linkskante", wobei jeder Lauf die Umkehrung des vorherigen Laufs ohne den ersten und letzten Buchstaben ist und der erste davon ist ist die Eingabe plus die Eingabe ohne den letzten Buchstaben (zB Eingabe "abcde"hat eine Ausgabe von "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

Probieren Sie es online!

Erläuterung:

 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)

Die leere Eingabe wird mit einem Fehler beendet (die korrekte Ausgabe wird erstellt).

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

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

Inspiriert von @ETHproductions Antwort.

Perl, 99 Bytes

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

Whitespace ist nicht Teil des Programms und dient der Lesbarkeit.

Nicht sehr effizienter Code. Ich sollte in der Lage sein, die ersten drei Zeilen irgendwie zu verkürzen, aber alles, was ich versuchte, schlug fehl. Dieser ternäre Operator muss auch irgendwie korrigiert werden, aber auf diese Weise konnte ich meinen Code um etwa 10 Byte verkürzen, weil ich so viel ausschneiden konnte.

Der Code erstellt eine Liste von Palindromen, die durch gerade Zahlen getrennt sind und die Stellenwerte der zu ziehenden Zeichenfolge darstellen.

Eigentlich , 21 13 Bytes

Dieser Algorithmus basiert größtenteils auf Jonathan Allans Jelly-Antwort . Es gibt zwei Möglichkeiten, das Ergebnis als eine Zeichenfolge zu drucken. Der hier verwendete Ansatz dupliziert einen Zwischenschritt und addiert ihn dann zu einer laufenden Summe in Register 1 (standardmäßig eine leere Zeichenfolge). ;╕in der funktion, dann ╛am ende. Der andere Ansatz besteht darin, einen Zwischenschritt zu duplizieren, diese doppelten Schritte auf dem Stapel zu belassen und sie am Ende zu einer Zeichenfolge zu summieren. ;in der funktion, dann kΣam ende.

Golfvorschläge sind willkommen. Probieren Sie es 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

Ein direkter Port meiner Gelee-Antwort ; Es wird nur ein vollständiges Programm eingegeben (und keine Funktion).
Das print(x,end='')ist eine print - Anweisung , die die Standard - Newline nicht gedruckt wird.

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

Probieren Sie es online!