Oto stosunkowo proste wyzwanie.

Biorąc pod uwagę ciąg o długości N , wypisz ciąg do przodu, następnie do tyłu, następnie do przodu, a następnie do tyłu ... itd. N razy. Na przykład, jeśli dane wejściowe były

Hello!

Powinieneś wypisać:

Hello!!olleHHello!!olleHHello!!olleH

Możesz także opcjonalnie wypisać jeden końcowy znak nowej linii.

Twoje zgłoszenie może być pełnym programem lub funkcją, a Ty możesz pobierać dane wejściowe i wyjściowe w dowolnym rozsądnym formacie . Na przykład, możesz wziąć IO z STDIN / STDOUT, argumenty funkcji i wartość zwracaną, z pliku itp. Możesz bezpiecznie założyć, że łańcuch wejściowy nie będzie pusty i będzie zawierał tylko ASCII do wydruku. Państwo musi wyjście nowy ciąg znaków w jednym wierszu. Na przykład, jeśli dane wyjściowe do ostatniego przykładu były

Hello!
!olleH
Hello!
!olleH
Hello!
!olleH

To nie byłoby prawidłowe rozwiązanie!

Oto kilka innych przypadków testowych:

Input:
a
Output:
a

Input:
abcd
Output:
abcddcbaabcddcba

Input:
OK!
Output:
OK!!KOOK!

Input:
4815162342
Output:
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Input:
PPCG
Output:
PPCGGCPPPPCGGCPP

Input:
42
Output:
4224

Liderów

Ponieważ jest to wyzwanie dla golfa , standardowe luki są zakazane, a najkrótsza odpowiedź w bajtach wygrywa! Jednak jest to również konkurencja, która ma najkrótszą odpowiedź w danym języku. Chociaż jest mało prawdopodobne, aby odpowiedź w języku Java pobiła odpowiedź w języku Perl lub jakimś języku golfowym, nadal bardzo imponująca jest najkrótsza odpowiedź w języku Java. Możesz więc użyć tego rankingu, aby zobaczyć oba

1. Najkrótsza odpowiedź spośród wszystkich języków oraz

2. Najkrótsza odpowiedź w każdym języku.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

# Perl, 43 + 2 (-p flag) = 45 bytes

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=93261,OVERRIDE_USER=31716;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Vim, 39 , 34 naciśnięcia klawiszy

:se ri
Y:s/./<C-r>"/g
<C-o>qqgJC<C-r>"<esc>gJ@qq@q

5 bajtów zapisanych dzięki @Lynn!

Oto gif z tego, co dzieje się na żywo: (Zwróć uwagę, że ten gif jest z poprzedniej wersji, ponieważ nie miałem jeszcze czasu, aby go ponownie nagrać).

A oto wyjaśnienie, jak to działa:

:se ri                  "Turn 'reverse indent' on.
Y                       "Yank this line
:s/./<C-r>"/g           "Replace every character on this line with the register
                        "We just yanked followed by a newline
<C-o>                   "Jump to our previous location
     qq                 "Start recording in register 'q'
       gJ               "Join these two lines
         C              "Delete this line, and enter insert mode
          <C-r>"<esc>   "Paste the line we just deleted backwards 
gJ                      "Join these two lines
  @q                    "Call macro 'q'. This will run until we hit the bottom of the buffer.
    q                   "Stop recording.
     @q                 "Start our recursive macro

Na marginesie, Ypobiera dodatkową nową linię , która zwykle jest wstrętna. Jest to prawdopodobnie pierwszy raz, kiedy rzeczywiście zaoszczędził kilka bajtów!

Python, 40 bajtów

f=lambda s,i=0:s[i:]and s+f(s[::-1],i+1)

Funkcja rekurencyjna. Przygotowuje ciąg wejściowy sdo funkcji rewersu, dopóki licznik nie iprzekroczy długości s.

Brain-Flak , 418 378 228 bajtów

To moje arcydzieło Brain-Flak. To może nie być dobrze gra w golfa, ale wyzwanie jest najtrudniejsze, jakie kiedykolwiek spotkałem.

Wypróbuj online!

(([])[()]){({}[()]<(({}(<()>))<{({}[()]<(({}()<(({}<>))>)<({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}>)>)}{}{}<>([]){{}({}<>)<>([])}{}<>>)>)}{}([(({}))]{({})({}[()])}{}){(({}[({}<>)<>])<<>({}<><{(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)>)}

Wyjaśnienie

To wyjaśnienie jest teraz trochę nieaktualne, ale nadal całkiem niezłą robotę wyjaśnia program.

To wyjaśnienie będzie nieco różnić się od mojego zwykłego procesu wyjaśniania. Wyjaśnię, jak doszedłem do tego wyniku, zamiast wyjaśnić wynik w kolejności. Oto jest:

Wałek

Po dłuższej pracy nad tym problemem wymyśliłem ten kod:

(n[()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>

Ten kod (gdzie n jest literałem dla pewnej liczby, np. ()()) Zabierze element na górę stosu i przesunie go w dół n kroków. Przy n jako wysokości stosu spowoduje to „przewrócenie” stosu. tzn. przesuń górny element na spód stosu. Oto jak to działa:

Kładziemy miejsce, w którym chcemy przenieść przedmiot, na minus jeden na stosie. Dlaczego minus jeden? Nie wiem, to po prostu działa w ten sposób.

(n[()])

Następnie zapętlamy, aż liczba osiągnie zero, śledząc pętlę za pomocą ().

{()<({}[()]<...>)>)>}{}

Za każdym razem, gdy zapętlamy się, wybieramy górny przedmiot i przenosimy go pod inny stos. To stawia numer na górze na swoim miejscu.

({}<({}<>)<>>)

Wszystko, co musimy teraz zrobić, to wprowadzić liczby, które cofnęliśmy. Przełączamy się na wyłączanie stosu i zwiększamy liczbę uruchomień wykonanej pętli.

(...<>)

Pętlimy zmniejszając nowo wypychaną liczbę, aż osiągnie zero. Za każdym razem cofamy o jeden numer.

{({}[()]<({}<>)<>>)}{}<>

Rewers

Następnie zmodyfikowałem rzut, aby odwrócić pełny stos:

(n){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}

Ponownie n oznacza głębokość rewersu. To znaczy, że n górnych elementów na stosie zostanie odwróconych. Jak to działa:

Rewers to po prostu zawinięty w rolkę walec. Po prostu nawijamy górę stosu n razy, zmniejszając za każdym razem głębokość rzutu o jeden.

(n){(({}[()])<ROLLER>)}{}

Duplikować

Powielanie na miejscu jest trudne. Naprawdę trudny. Po tym, jak wymyśliłem, jak odwrócić stos, nadal wymagało wiele wysiłku, aby wymyślić algorytm duplikacji.

Oto on:

(((n)<{({}[()]<(({}<>))<>>)}{}<>>)<{({}[()]<({}<>)<>([][()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>>)}{}<>([]){{}({}<>)<>([])}{}<>([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)

Jest trochę duży, ale oto jak to działa:

Zacznij od naciśnięcia n. n jest głębokością duplikatu. Otwieramy również dwa nawiasy. Pozwalają nam przechowywać wartość nw zakresie, dopóki nie będzie ponownie potrzebna.

(((n)<

Następnie zapętlamy n razy za każdym razem, przesuwając dwukrotnie najwyższą wartość stosu do stosu wyłączonego. To powoduje, że początkowe duplikaty dla każdej liczby na stosie.

{({}[()]<(({}<>))<>>)}{}

Teraz mamy dwie kopie każdego numeru na offstacku. Musimy je podzielić na dwie grupy.

Przechodzimy więc do offstacka i przypominamy sobie jedną z ns, które zapisaliśmy na początku.

<>>)

Zapętlamy n razy.

{({}[()]<...>)}{}

Za każdym razem przenosimy jeden egzemplarz do głównego nurtu.

({}<>)<>

I rzuć jedną kopię na spód stosu. (Zakłada się, że offstack był pusty, aby rozpocząć od tego, aby ten duplikat nie był czysty)

([][()])ROLLER

Po wykonaniu tej czynności podzieliliśmy oryginał na dwie grupy: „oryginał” i kopię na offstacku (kopia jest w rzeczywistości w odwrotnej kolejności). Po prostu przenosimy kopię do głównego stosu i możemy to zrobić.

([]){{}({}<>)<>([])}{}<>

Program szkieletowy

Teraz, kiedy stworzyłem wszystkie elementy programu, muszę tylko wstawić je do ramki.

Ramka podwaja tekst o jeden raz mniej niż wysokość stosu przy użyciu duplikatu.

(([])[()])
{
 ({}[()]<
  DUPLICATE 
 >)
>)}{}

A następnie odwraca stos w malejących przyrostach początkowej wysokości stosu z n ^ 2-n do 0.

(({}))
{
 (({}[()])<
  ({}<>)<>(({}))({<({}[()])><>({})<>}{})<>{}<>
  ({}<({}<>)<>>)<>({}<>)
  ({}<
   REVERSE
  >)
 >)
}{}{}

Galaretka , 4 3 bajty

,Ṛṁ

Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe.

Zapisano bajt dzięki @ Maltysen .

Wyjaśnienie

,Ṛṁ  Input: string S
 Ṛ    Reverse S
,     Join S with reverse of S. Makes a list [S, rev(S)]
  ṁ   Mold [S, rev(S)] to len(S) by repeating elements cyclically
      Return and print implicitly as a string

PHP, 54 52 bajty

(49 bajtów, ale nie działa, jeśli ciąg zawiera „0”)

for(;($a=$argv[1])[$i++];)echo$i%2?$a:strrev($a);

(52 bajty)

<?=str_pad('',strlen($a=$argv[1])**2,$a.strrev($a));

(54 bajty)

for(;$i++<strlen($a=$argv[1]);)echo$i%2?$a:strrev($a);

2sable , 3 bajty

Kod:

gGÂ

Wyjaśnienie:

g   # Get the length of the input
 G  # Do the following n - 1 times:
  Â # Bifurcate, which duplicates a and reverses the duplicate

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Rubin, 39 bajtów

->(s){s.reverse!.gsub(/./){s.reverse!}}

Obciągam Ruby. Pomoc w golfa jest doceniana.

Ruby jest naprawdę fajnym językiem z tego powodu .reverse!

Wyjaśnienie

Miałem nadzieję, że będzie to proste:

s.gsub(/./){s.reverse!}

ale ze względu na ogranicznik / wyzwanie jest dłuższy.

Co s.reverse!jest bardzo przydatne. s.reverse!jest w zasadzie s = s.reverse!, co oznacza, że ​​również mutuje s.

Działanie każdej sekcji programu opisano poniżej:

->(s){             # Lambda with argument s
      s.reverse!   # Reverse `s` see above for details
      .gsub(/./)   # Replace every character with...
      {s.reverse!} # the input reversed!

Zaletą s.reverse!tego jest to, że za każdym razem, gdy jest oceniany, łańcuch zostaje odwrócony. Tak jak zastępuje ciąg. sjest zmodyfikowany!

Perl, 24 bajty

Obejmuje +2 za -lp

Podaj dane na STDIN:

rev.pl <<< Hello!

rev.pl:

#!/usr/bin/perl -lp
s%.%s/.?/chop/eg;$`%eg

Nieoczekiwanie nie wykorzystuje to wbudowanego reverseoperatora. Ta nazwa jest po prostu bardzo długa, wszystkie rozwiązania, o których mogłem pomyśleć, reversesą co najmniej 1 bajt dłuższe.

J, 13 8 bajtów

Zaoszczędzone 5 bajtów dzięki kilometrom!

#;@$];|.

To jest 5 pociągów z następującymi czasownikami:

# ;@$ ] ; |.

Wewnętrzny rozwidlenie składa się z ](tożsamość), ;(link) i |.(rewers). Przestrzegać:

   (| ; |.) 'Hello!'
+------+------+
|Hello!|!olleH|
+------+------+

Dwa zewnętrzne czasowniki tworzą resztę pociągu. #jest w tym przypadku rozmiarem argumentu, czyli długością. Czasownik łączący nich jest ;@$albo ravelnad reshape. Przestrzegać:

   # 'Hello!'
6
   6 $ (] ; |.) 'Hello!'
+------+------+------+------+------+------+
|Hello!|!olleH|Hello!|!olleH|Hello!|!olleH|
+------+------+------+------+------+------+
   ; 6 $ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   6 ;@$ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ (] ; |.)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ ] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (#;@$];|.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

Stare rozwiązanie.

[:,|.^:(i.@#)

Wystarczająco proste. |.jest odwrotny i ^:jest koniunkcją mocy, która powtarza swój lewy czasownik (prawa ręka) # razy. Gdy właściwym argumentem jest czasownik, czasownik ten jest wywoływany w argumencie. Prawidłowy czasownik w tym przypadku ma zakres od zera ( i.) do długości ( #). Po podniesieniu do tablicy wyniki pośrednie są zachowywane. Wszystko, co trzeba zrobić, to spłaszczyć tablicę ,.

Wyniki pośrednie

   (i.@#) 'Hello!'
0 1 2 3 4 5
   |.^:0 1 2 3 4 5 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   |.^:(i.@#) 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   ([:,|.^:(i.@#)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

JavaScript (ES 6), 59 50 bajtów

9 bajtów dzięki Hedi i Huntro.

f=(s,n=1)=>s[n]?s+f([...s].reverse().join``,n+1):s

funkcja rekurencyjna.

Odwrócenie łańcucha zajmuje prawie połowę rozmiaru ( 25 22 bajtów!) ...
Dlaczego nie ma na to własnej metody?

Minkolang , 17 bajtów:

$oId$z$Dz[rz[O]].

Wypróbuj tutaj!

Wyjaśnienie

$o                   Read in whole input as characters
  Id                 Push the length of stack and duplicate
    $z               Pop top of stack and store in register (z)
      $D             Pop top of stack (n) and duplicate whole stack n-1 times
        z[     ]     z times, do the following:
          r          Reverse the stack
           z[O]      z times, pop the top of stack and output as character
                .    Stop.

8088 Montaż, IBM PC DOS, 29 28 bajtów

Zmontowany, xxdzrzut:

00000000: d1ee ac48 938a cbfc 518a cbf7 da78 01fd  ...H....Q....x..
00000010: acac b40e cd10 e2f9 59e2 ecc3            ........Y...

Niezmontowany wykaz:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load input string length into AL 
48          DEC  AX             ; remove leading space from length counter 
93          XCHG BX, AX         ; save input length to BL 
8A FB       MOV  BH, BL         ; string output counter in BH 
        S_LOOP: 
FC          CLD                 ; set direction forward 
8A CB       MOV  CL, BL         ; reset char counter in CL 
F7 DA       NEG  DX             ; flip DX to toggle fwd/back output 
78 01       JS   C_START        ; if positive, go forward 
FD          STD                 ; otherwise go backwards 
        C_START: 
AC          LODSB               ; adjust SI to first/last char
        C_LOOP: 
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
E2 F9       LOOP C_LOOP         ; continue looping through chars
FE CF       DEC  BH             ; decrement string count loop
75 EC       JNZ  S_LOOP         ; if not zero, continue loop
C3          RET                 ; exit to DOS

Samodzielny program wykonywalny DOS dla komputerów PC. Łańcuch wejściowy za pomocą wiersza poleceń, wyjściem jest konsola.

Pip , 11 10 bajtów

L#aORVRV:a

Wypróbuj online!

Wyjaśnienie:

            a is first cmdline argument (implicit)
L#a         Loop len(a) times:
      RV:a   Reverse a and assign back to a
   ORV       Output the reverse of a (since it needs to go forward first then backward)

Haskell, 40 36 32 bajtów

m s=take(length s^2)$cycle$s++reverse s

Przykład:

*Main> m "Hello!"
"Hello!!olleHHello!!olleHHello!!olleH"

Jeszcze krótszy (kredyt dla Damiena):

q s=zip(s>>[s,reverse s])s>>=fst

s >> [s, reverse s] cycles ["abc", "cba", ...], które jest spakowane do odpowiedniego rozmiaru i konkatMapowane z fst

Perl 6 ,  31  30 bajtów

{[~] (|($_,.flip)xx*)[^.chars]}

Zapisz jeden bajt niewłaściwie wykorzystując .ords, co zwraca listę rzędnych, a następnie domyślnie zamień go na liczbę, aby utworzyć zakres.

{[~] (|($_,.flip)xx*)[^.ords]}

Wyjaśnienie:

# bare block lambda with implicit parameter ｢$_｣
{
  # reduce using string concatenation operator ｢~｣
  [~]

  (
    # create a Slip
    |(
      # of the input, and its string reverse
      $_, .flip

    # list repeated infinitely
    ) xx *

  # get the values in the range from 0 up-to and excluding
  # the number of characters ｢0 ..^ +$_.ords｣
  )[ ^.ords ]
}

Stosowanie:

my &code = {[~] (|($_,.flip)xx*)[^.ords]}

say code 'a'; # a
say code 'abcd'; # abcddcbaabcddcba
say code 'OK!'; # OK!!KOOK!
say code 4815162342; # 4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Vim + coreutils, 32 naciśnięcia klawiszy

Nigdy nie możesz mieć zbyt wielu odpowiedzi Vima.

qqYv:!rev
Pjq@=len(@")
@q2dkv{gJ

Wyjaśnienie

qq               " Start recording macro
Y                " Yank (copy) line
v:!rev<CR>       " Reverse line with coreutils rev command
Pj               " Paste yanked line above this line
q                " Stop recording
@=len(@")<CR>@q  " Playback macro once for each character
2dk              " Delete last 3 lines
v{gJ             " Join lines

MATL, 13 12 8 bajtów

Pcha wszystkie elementy, łączy się na końcu.

td"tP]&h

td"  ]     %For loop over string length - 1 due to diff
   tP      %Push copy of string, reverse
      &h   %Concatenate entire stack horizontally

Wypróbuj online!

Stare wersje:

Zupełnie inne podejście, oparte na fprintf:

t"t1$0#YDP]x

t"        ]   % For loop over string
  t           % Duplicate string for printing:
   1$0#YD     % `fprintf` with 1 input, 0 output (i.e., to screen).
         P    % Reverse
           x  % Empty stack to prevent implicit output

Wersja oparta na odwróceniu ciągu szablonu

ttd"wPtbYc]Dx

t                 %Duplicate input, to create 'accumulator' string 
                  % (alongside the input string which will serve as 'template'
 td               %Duplicate input, diff to get an stringof size input-1
   "       ]      %For loop over size n-1 string (consumes diff'd string)
     wP           %Get 'template' string on top of stack, and reverse
       tb         %Duplicate template string, and switch with 'accumulator' string
         Yc       %Concatenate template string with accumulator. 
            Dx   %Display top element, delete template string to prevent implicit disp

Scala, 73 72 71 bajtów

def f(s:String)=for(i<-1 to s.length){print(if(i%2>0)s else s.reverse)}

To moja pierwsza próba gry w golfa, więc jestem pewien, że wprowadzono niezliczone ulepszenia.

Aktualizacja:

Oddalono o 1 bajt, usuwając nawiasy.

Dzięki Destructible Watermelon za sugestie, zgoliłem bajt.

Cubix , 52 bajty

Ap\:\;.#u/\:qqsoq(?;u.q..$u<../pB@u:\.....\(?q..s..p

Na sześcianie:

      A p \
      : \ ;
      . # u
/ \ : q q s o q ( ? ; u
. q . . $ u < . . / p B
@ u : \ . . . . . \ ( ?
      q . .
      s . .
      p . .

Ten był zabawny; są jeszcze bajty do zagrania w golfa, ale to na pewno zadziała.

Wypróbuj online!

wyjaśnienie:

Wejście z ABC

• /A: idź na północ i we wszystkich wejściach czytaj jako znaki; -1będzie na dole
• p\;.: usuń -1ze stosu
• u# : popchnij długość sznurka (liczba elementów na stosie)
• \:\:qq : dwukrotnie skopiuj długość łańcucha, przesuń dwie kopie na spód stosu

• pętla:

  • soq(?/<u : zamień górę stosu, ouptut górę stosu jako ASCII, przesuń górę (literę) na dół, zmniejsz stos do góry, skręć w prawo, jeśli nie jest zrobione, a następnie przenieś adres IP we właściwe miejsce.
  • na końcu pętli będzie wyglądał stos C B A 3 3 0

• ;u : pop top stosu C B A 3 3

• B : odwrotny stos 3 3 A B C
• p( : przesuń od dołu do góry i zmniejsz 3 A B C 2
• ?jeśli górna jest zero, idź prosto do @i zakończ
• jeszcze
  • psq:uq : przesuń od dołu do góry, zamień od góry i przejdź od góry do dołu dup i przesuń od góry do dołu 3 2 A B C 3
  • $u : pominąć u
  • < przywraca nas do pętli.

Interpretator

C (gcc) , 88 87 85 83 68 66 83 82 78 bajtów

-1 dzięki ceilingcat

Stara wersja

p,q;f(char*s){p=q=1;for(char*m=s--;*m;s[p+=q]*p?:(m++,p+=q=-q))putchar(s[p]);}

Wypróbuj online!

Krótsza wersja (lekko zepsuta)

Riffowanie w 76-bajtowym podejściu ASCII-tylko w komentarzach i -1-bajt z jego ulepszenia mojego ulepszenia.

Edycja: Ta wersja jest nieco zepsuta, ponieważ zakłada, że ​​każdy ciąg jest poprzedzony bajtem NULL, co nie zawsze jest prawdziwe. (Zobacz ostatni przypadek testowy w linku). Na razie powracam do wersji 83-bajtowej.

f(char*s){for(char*n=s-1,k=1;*s++;k=-k)for(;*(n+=k);)putchar(*n);}

Wypróbuj online!

Java, 127 111 88 bajtów

(s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?new StringBuffer(s).reverse():s;return r;};

Nie testowany program testowy

    public static void main(String[] args) {
    BiFunction<String, String, String> func = (s, r) -> {
        for (int i = 0; i++ < s.length();) {
            r += i % 2 < 1 ? new StringBuffer(s).reverse() : s;
        }
        return r;
    };
    System.out.println(func.apply("Hello!", ""));
}

R, 53 bajty

Zakłada, że ​​dane wejściowe są oddzielone spacjami lub znakami nowej linii dla każdego znaku.

cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")

Niektóre przypadki testowe:

> cat(rep(c(i<-scan(,""),rev(i)),len=length(i)^2),sep="")
1: h e l l o !
7: 
Read 6 items
hello!!ollehhello!!ollehhello!!olleh

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a
2: 
Read 1 item
a

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a b c d
5: 
Read 4 items
abcddcbaabcddcba

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: O K !
4: 
Read 3 items
OK!!KOOK!

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 8 1 5 1 6 2 3 4 2
11: 
Read 10 items
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: P P C G
5:    
Read 4 items
PPCGGCPPPPCGGCPP

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 2
3: 
Read 2 items
4224

PowerShell v2 +, 57 bajtów

param($a)-join(1..($x=$a.length)|%{($a[$x..0],$a)[$_%2]})

Nie ma naprawdę czystego sposobu na uzyskanie ciągów znaków lub odwrócenie ich, więc jest to dość długie.

Pobiera dane wejściowe $a, pętle od 1do $a.length(przechowywane w $xcelu użycia później). Każdej iteracji używamy pseudo-trójki do indeksowania do tablicy albo ( $aalbo $a[$x..0]odwróconej), w zależności od tego, czy nasza liczba wejściowa jest nieparzysta / parzysta [$_%2]. Wszystkie są zamknięte w pareny i zmontowane -joinrazem, tworząc jeden ciąg. Pozostaje to w przygotowaniu, a dane wyjściowe są niejawne.

PS C:\Tools\Scripts\golfing> .\stringgnirts.ps1 'TimmyD'
TimmyDDymmiTTimmyDDymmiTTimmyDDymmiT

Java, 151 bajtów

public static void r(String s){String t = new StringBuffer(s).reverse().toString();for(int i=0;i<s.length();i++){System.out.print(((i%2==1)?t:s));}}

}

Nie golfowany:

public static void r(String s) {
    String t = new StringBuffer(s).reverse().toString();
    for(int i = 0; i < s.length();i++) {
        System.out.print(((i % 2 == 1) ? t : s));
    }
}

C #, 94 bajtów

using System.Linq;string R(string n)=>string.Concat(n.SelectMany((c,i)=>1>i%2?n:n.Reverse()));

76 bajtów dla metody + 18 bajtów dla importu LINQ.

Jak to działa:

using System.Linq; // Required for LINQ extension methods.

string R(string n) => 
    string.Concat( // Concatenate the following chars into a single string
        n.SelectMany( // Enumerate each char in n, flattening the returned IEnumerable<char>'s into a single IEnumerable<char>
            /*IEnumerable<char> Lambda*/(/*char*/ c, /*int*/ i) => // i = index in n
                1 > i % 2 // Check if i is even or odd
                    ? n // if i is even, add n to the concat
                    : n.Reverse() // else reverse n and concat that
        )
    )
;

CJam , 10 bajtów

l_,({_W%}*

Wypróbuj online!

Wyjaśnienie

l            e# Read line
 _           e# Duplicate
  ,(         e# Length minus 1
    {   }*   e# Run code block that many times
     _       e# Duplicate
      W%     e# Reverse
             e# Implicitly display

Oktawa, 39 35 bajtów

@(x)[x'+~x;flip(x'+~x),''](1:end/2)

f('Hello!')
ans = Hello!!olleHHello!!olleHHello!!olleH

Wyjaśnienie:

@(x)            % Take x as input, inside apostrophes 'Hello!'
x'+~x           % Create a mesh of the ASCII-code of the input letters
                % For input `bcd` this will be:
                %    98    98    98
                %    99    99    99
                %   100   100   100
;flip(x'+~x)   % Concatenate vertically to create:
                %    98    98    98
                %    99    99    99
                %   100   100   100
                %   100   100   100
                %    99    99    99
                %    98    98    98
___,'']         % Short cut to convert ASCII-code to characters
(1:end/2)       % Display the first half of this array of letters, as a
                % horizontal string

Zaoszczędź 4 bajty dzięki Luisowi. ~xzamiast 0*xzapisanego jednego bajtu (działa, ponieważ wszystkie elementy x są niezerowe. flipzamiast flipudzapisanych kolejnych dwóch bajtów (nie wiedziałem, że flipistnieje).

bash + util-linux, 68 58 53 bajtów

y=$1;for((i;i<${#1};i++)){ echo -n $y;y=`rev<<<$y`;}

Wyjaśnienie

Dwie rzeczy z forpętlą:

• Jest widocznie nieudokumentowane sposób pisania forpętle gdzie są zastępowane przez doi donesłowa kluczowe z klamrami {i }. Konieczne jest miejsce po pierwszym nawiasie , a także średnik na końcu .
• Okazuje się, że w forpętlach w stylu „C” można po prostu zainicjować i;zamiast używać i=0;.
• ${#1}Część stanu i < ${#1}dotyczy na długość wejścia (pierwszego parametru $1). Zasadniczo można użyć ${#foo}do pobrania rozmiaru ciągu $foo.

Do tego:

• rev jest narzędziem w util-linux, które odwraca ciąg znaków.
• Musimy przekazać -nflagę, echoaby pozbyć się nowych linii.
• Wyrażenie rev<<<$yto nazywa się tutaj-ciągiem (patrz odpowiednia strona tldp.org ), który przekazuje zmienną $ydo standardowego wejścia rev.

Japt , 11 bajtów

ê1 pUÊ ¯Uʲ
ê1          // Append the reverse of the input to the input,
   pUÊ      // then repeat it input length times
       ¯Uʲ // and finally trim to length input length squared.

Wypróbuj online!

05AB1E , 7 bajtów

vDR}v}J

Wypróbuj online!

Będzie nadal nad tym pracować. Nie podoba mi się część „v}”, prawdopodobnie mogę tam zapisać bajt.

Wyjaśnienie

vDR}v}J

v         ; Iterates through each character
 D        ; Duplicate top of stack
  R       ; Push top of stack reversed
   }      ; end for loop
   v}     ; same as other v, effectively pops top of stack off
     J    ; Join everything together