Biorąc pod uwagę ciąg, najpierw kwadrat go w następujący sposób:

Najpierw napisz ciąg.

abcde

Następnie napisz ciąg obrócony w lewo.

abcde
bcdea

Rób to dalej, dopóki nie napiszesz wierszy len (string) .

abcde
bcdea
cdeab
deabc
eabcd

Teraz przeczytaj następujący ciąg:

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

Co daje:

abcdeabcdcbaedcbcdeabaede

Wydrukuj ten ciąg.

Przypadki testowe

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

^{Proszę o komentarz, jeśli przypadek testowy jest niepoprawny.}

Pamiętaj, to jest kodowanie w golfa , więc wygrywa kod z najmniejszą liczbą bajtów.

JavaScript (ES7), 83 80 78 77 bajtów

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

Dodatkowy program zgodny z 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)

Wyjaśnienie

Wykorzystuje to fakt, że dane wyjściowe dla np. Ciągu 5 długości mogą być reprezentowane jako:

abcdeabcd cbaedcb cdeab aed e
012345678 7654321 23456 543 4

gdzie każda cyfra reprezentuje indeks w ciągu (zaczynając od 0), modulo długość ciągu. Innymi słowy, jeśli n jest długością łańcucha, zwiększamy indeks 2n - 1 razy, następnie zmniejszamy go 2 (n - 1) - 1 razy, a następnie zwiększamy go 2 (n - 2) - 1 razy itp. Można to uprościć do następującego algorytmu:

• Rozpocznij indeks i od -1 .
• Dla każdej liczby całkowitej x w zakresie [n ² ..1] :
  • Jeśli floor (sqrt (x)) ma taki sam parzystość (parzysty / nieparzysty) jak n , inkrementuje i .
  • W przeciwnym razie zmniejszenie i .
  • Dodaj znak o indeksie i mod n do wyniku.

Działa to, ponieważ floor (sqrt (x)) przełącza parzystości po 2 iteracjach 2n - 1 , a następnie 2 (n - 1) - 1 iteracjach itp.

Pyth , 15 bajtów

.Wp.(H0_CZ.<LQU

Program, który pobiera dane wejściowe "quoted string"i wypisuje wynik.

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe (zmodyfikowane dla wielu danych wejściowych).

Jak to działa

.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 (w CMD.EXE), 91 bajtów

Wymaga to terminala z działającym backspace ( \b) i nie będzie działać na repl.it ani ideone.com . Instrukcja print kończąca się przecinkiem oddziela dalsze wyniki spacją zamiast znaku nowej linii lub znaku powrotu. Backspace pozwala nam zastąpić przestrzeń oddzielającą.

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 bajtów

Wypróbuj na ideone.com lub repl.it (dzięki Oliver). Dane wejściowe muszą być ciągiem python, np '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

Cztery plastry dołączone przez pętlę ( s[i:], s[:n-i], r[i+2:], r[:n-i]) zostały uzyskane w czterech krawędziach spirali. Na przykład z 01234kwadratem jest:

01234
12340
23401
34012
40123

Więc bierzemy 01234, 0123, 210, 4321. Zmienna ijest indeksem lewej górnej wartości na każdym etapie procesu. W ostatniej spirali kilka plasterków może być pustych.

Galaretka , 11 10 bajtów

ẋ2µṖȮṖUµÐL

TryItOnline! lub wszystkie testy

W jaki sposób?

Niespirowany kwadrat to seria „górnych krawędzi i prawych krawędzi” i „dolnych krawędzi plus lewej krawędzi”, z których każdy jest odwrotnością poprzedniego przebiegu bez pierwszej i ostatniej litery, a pierwsza z nich jest wejściem plus wejściem bez ostatniej litery (np. wejście "abcde"ma wynik "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 bajtów

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

Wypróbuj online!

Wyjaśnienie:

 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 bajtów

"GX@q_YS]vGn1YL_GnoQ&Ple&S)

Puste wejście kończy się z błędem (wytwarzanie prawidłowego wyjścia).

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

C, 95 94 bajtów

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

Zainspirowany odpowiedzią @ETHproductions.

Perl, 99 bajtów

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

Biała spacja nie jest częścią programu i zapewnia czytelność.

Niezbyt wydajny kod. Powinienem w jakiś sposób skrócić pierwsze trzy wiersze, ale wszystko, co próbowałem zrobić, zawiodło. Ten trójskładnikowy operator również musi zostać jakoś naprawiony, ale dzięki temu udało mi się skrócić mój kod o około 10 bajtów, ponieważ mogłem tak dużo wyciąć.

Kod działa poprzez skompilowanie listy palindromów, oddzielonych liczbami parzystymi, które reprezentują wartości miejsca ciągu, który należy pobrać.

Tak właściwie , 21 13 bajtów

Algorytm ten jest w dużej mierze oparty na odpowiedzi galaretki Jonathana Allana . Istnieją dwa sposoby na wydrukowanie wyniku jako jednego ciągu. Zastosowane tutaj podejście powiela krok pośredni, a następnie dodaje go do bieżącej sumy w rejestrze 1 (domyślnie pusty ciąg znaków);;╕w funkcji, a następnie ╛na końcu. Drugim podejściem jest zduplikowanie pośredniego kroku, pozostawienie tych zduplikowanych kroków na stosie i zsumowanie ich w jeden ciąg na końcu; ;w funkcji, a następnie kΣna końcu.

Sugestie dotyczące gry w golfa mile widziane. Wypróbuj 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 bajtów

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

repl.it

Bezpośredni port mojej odpowiedzi na galaretkę ; tylko pełny program przyjmujący dane wejściowe (zamiast funkcji).
Jest print(x,end='')to instrukcja print, która nie wypisze domyślnej nowej linii.

Python 3, 93 bajty

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

Wypróbuj online!