StringgnirtSStringgnirtSStringgnirtS

Question

Here is a relatively simple challenge for you.

Given a string of length N, output the string forwards, then backwards, then forwards, then backwards... etc. N times. For example, if your input was

Hello!

You should output:

Hello!!olleHHello!!olleHHello!!olleH

You may also optionally output one trailing newline.

Your submission may be either a full program or a function, and you may take input and output in any reasonable format. For example, you may take IO from STDIN/STDOUT, function arguments and return value, from a file, etc. You can safely assume that the input string will not be empty, and will only contain printable ASCII. You must output the new string on a single line. So, for example, if the output to the last example was

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

This would not be a valid solution!

Here are some more test cases:

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

Leaderboards

Since this is a code-golf challenge, standard loopholes are banned, and the shortest answer in bytes wins! However, this is also a competition to have the shortest answer in any particular langauge. While it's unlikely that a Java answer will beat an answer in perl, or some golfing language, it's still very impressive to have the shortest Java answer. So, you can use this leaderboard to see both

1. The shortest answer out of all languages, and

2. The shortest answer in each individual language.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

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

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

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

You can also make the language name a link which will then show up in the leaderboard snippet:

# [><>](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>

Answer 1

Vim, 39, 34 keystrokes

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

5 bytes saved thanks to @Lynn!

Here is a gif of it happening live: (Note that this gif is of a previous version since I haven't had time to re-record it yet).

And here is an explanation of how it works:

: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

On a side note, Y grabs an extra newline, which is usually an obnoxious feature. This is probably the first ever time that it has actually saved several bytes!

Answer 2

Python, 40 bytes

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

A recursive function. Prepends the input string s to the function of the reverse until the counter i exceed the length of s.

Answer 3

Brain-Flak, 418 378 228 bytes

This is my Brain-Flak masterpiece. It may not be well golfed but the challenge is the most difficult I have ever encountered.

Try it online!

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

Explanation

This explanation is now a bit outdated but it still does a pretty good job of explaining the program.

This explanation is going to go a little different from my regular explanation process. I am going to explain how I came about this result rather than explain the result in order. Here it goes:

Roller

After working at the problem a quite a bit I came up with this code:

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

This code (where n is the literal for some number. e.g. ()()) will take the item on the top of the stack and move it down n steps. With n as the stack height this will perform a stack "roll". i.e. move the top item to the bottom of the stack. Here's how it works:

We put the place we want to move the item to minus one on the stack. Why minus one? I don't know it just works that way.

(n[()])

We then loop until this number reaches zero keeping track of the loop with a ().

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

Each time we loop we pick up the top item and move the item underneath it to the other stack. This puts the number on top in its place.

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

All we need to do now is put the numbers we moved back. We switch to the off stack and push the number of runs the loop made.

(...<>)

We loop decrementing the newly pushed number until it reaches zero. Each time we move one number back.

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

Reverse

I next modified the roll to make a full stack reverse:

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

Once again n represents the depth of the reverse. That is the top n items on the stack will be reversed. How it works:

The reverse is just a fancily wrapped roller. We simply roll the top of the stack n times decrementing the depth of the roll by one each time.

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

Duplicate

In place duplication is hard. Really hard. After I figured out how to reverse the stack it still took a great deal of effort to come up with the duplication algorithm.

Here it is:

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

Its a bit of a big one but here's how it works:

Start by pushing n. n is the depth of the duplicate. We also open two parentheses. These allow us to store the value of the n in the scope until its needed again.

(((n)<

Next we loop n times each time pushing the top value of the stack to the off stack twice. This makes the initial duplicates for each number on the stack.

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

Now we have two copies of each number on the offstack. We need to separate these into two groups.

So we switch to the offstack and recall one of the ns we saved at the beginning.

<>>)

We loop n times.

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

Each time we move one copy to the mainstack.

({}<>)<>

And roll one copy to the bottom of the stack. (This assumes the offstack was empty to begin with making this duplicate not stack clean)

([][()])ROLLER

Once that is done we have split the original into two groups the "original" and a copy on the offstack (the copy is actually in reverse). So we just move the copy to the main stack and we can be done with it.

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

Skeleton program

Now that I have made all of the pieces of the program, I just have to insert them into a frame.

The frame doubles the text one less than the stack's height times Using duplicate.

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

And then reverses the stack in decreasing increments of the initial stack height from n^2-n to 0.

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

Answer 4

Jelly, 4 3 bytes

,Ṛṁ

Try it online! or Verify all test cases.

Saved a byte thanks to @Maltysen.

Explanation

,Ṛṁ  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

Answer 5

2sable, 3 bytes

Code:

gGÂ

Explanation:

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

Uses the CP-1252 encoding. Try it online!

Answer 6

PHP, 54 52 bytes

(49 bytes, but do not work if string contains '0')

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

(52 bytes)

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

(54 bytes)

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

Answer 7

J, 13 8 bytes

Saved 5 bytes thanks to miles!

#;@$];|.

This is a 5-train with the following verbs:

# ;@$ ] ; |.

The inner fork is composed of ] (identity), ; (link), and |. (reverse). Observe:

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

The outer two verbs make the rest of the train. # is, in this case, the size of the argument, that is, the length. The verb linking these is ;@$, or ravel over reshape. Observe:

   # '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

---

Old solution.

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

Simple enough. |. is reverse, and ^: is power conjunction, which repeats it's left verb (right hand) # of times. When the right argument is a verb, that verb is called on the argument. The right verb in this case is range from zero (i.) to the length (#). When raised to an array, the intermediate results are kept. All that needs to be done is to flatten the array with ,.

Intermediate results

   (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

Answer 8

Ruby, 39 bytes

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

I suck at Ruby. Golfing help is appreciated.

Ruby is a really nice language for this because of .reverse!

Explanation

I was hoping it would be someting simple like:

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

but because of boilerplate/challenge restriction it's longer.

What s.reverse! is very useful. s.reverse! is basically s = s.reverse!, meaning it also mutates s.

---

What each section of the program does is described below:

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

The thing about s.reverse! that is great is that everytime it is evaluated the string get's flipped. So as it replaces the string. s is modified!

Answer 9

Perl, 24 bytes

Includes +2 for -lp

Give input on STDIN:

rev.pl <<< Hello!

rev.pl:

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

Surprisingly this does not use the builtin reverse operator. That name is just soooo long, all solutions I could think of with reverse are at least 1 byte longer.

Answer 10

JavaScript (ES 6), 59 50 bytes

9 Bytes thanks to Hedi and Huntro.

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

recursive function.

Reversing the string takes almost half of the size (25 22 bytes!) ...
Why isn´t there a native way for that?

Answer 11

8088 Assembly, IBM PC DOS, 29 28 bytes

Assembled, xxd dump:

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

Unassembled listing:

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

Standalone PC DOS executable program. Input string via command line, output is console.

Answer 12

Minkolang, 17 bytes:

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

Try it here!

Explanation

$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.

Answer 13

Haskell, 40 36 32 Bytes

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

Example:

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

Even shorter (credit to Damien):

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

s>>[s,reverse s] cycles ["abc","cba",...] which is zipped to correct size and concatMap'ped with fst

Answer 14

Pip, 11 10 bytes

L#aORVRV:a

Try it online!

Explanation:

            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)

Answer 15

Perl 6,  31  30 bytes

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

Save one byte by misusing .ords, which returns a list of ordinals, then implicitly turn that into a number to create a range with.

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

Explanation:

# 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 ]
}

Usage:

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

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

Answer 16

Vim + coreutils, 32 keystrokes

You can never have too many Vim answers.

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

Explanation

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

Answer 17

MATL, 13 12 8 bytes

Pushes all elements, combines in the end.

td"tP]&h

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

Try it online!

---

Old versions:

Completely different approach, based on 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

---

Version based on reversing a template string

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

Answer 18

Scala, 73 72 71 bytes

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

This is my first attempt at code golfing, so I'm sure there are countless improvements.

Update:

Golfed away 1 byte by removing brackets.

Thanks to Destructible Watermelon for suggestion, shaved off a byte.

Answer 19

Cubix, 52 bytes

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

On a cube:

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

This one was fun; there are bytes still to be golfed out of this but this will definitely work.

Try it online!

explanation:

Input of ABC

• /A : go north and read in all inputs as characters; -1 will be at the bottom
• p\;. : remove the -1 from the stack
• u# : push the string length (number of items on the stack)
• \:\:qq : dup the string length twice, push two copies to bottom of stack

• loop:

  • soq(?/<u : swap top of stack, ouptut top of stack as ASCII, push top (letter) to bottom, decrement top of stack, turn right if not done, then move IP to the right place.
  • at end of loop, the stack will look like C B A 3 3 0

• ;u : pop top of stack C B A 3 3

• B : reverse stack 3 3 A B C
• p( : move bottom to top and decrement 3 A B C 2
• ? if top is zero, go straight to @ and terminate
• else
  • psq:uq : move bottom to top, swap top and move top to bottom dup, and move top to bottom 3 2 A B C 3
  • $u : skip u
  • < puts us back into the loop.

Interpreter

Answer 20

C (gcc), 88 87 85 83 68 66 83 82 78 bytes

-1 thanks to ceilingcat

Old version

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

Try it online!

Shorter version (slightly broken)

Riffing on the 76 byte approach by ASCII-only in the comments, and -1 byte from his tweak of my tweak.

Edit: This version is slightly broken in that it assumes that every string is preceded by a NULL byte, which is not always true. (See last test case in link). Reverting to the 83 byte version for now.

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

Try it online!

Answer 21

Dyalog APL, 8 bytes

∊≢⍴⊂,⊂∘⌽

∊ flatten

≢ the tally

⍴ cyclically reshaping

⊂ the enclosed argument

, followed by

⊂∘⌽ the enclosed reversed argument

TryAPL online!

-1 byte thanks to jimmy23013.

Answer 22

PowerShell v2+, 57 bytes

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

No real clean way to get string lengths or reverse 'em, so this is pretty lengthy.

Takes input $a, loops from 1 to $a.length (stored in $x for use later). Each iteration we use a pseudo-ternary to index into an array of either $a or $a[$x..0] (i.e., reversed), based on whether our input number is odd/even [$_%2]. These are all encapsulated in parens and -joined together to form a single string. That's left on the pipeline, and output is implicit.

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

Answer 23

Japt, 11 bytes

ê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.

Try it online!

Answer 24

05AB1E, 7 bytes

vDR}v}J

Try it online!

Will continue to work on it. I don't really like the "v}" part of it, can probably save a byte there.

Explanation

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

Answer 25

brainfuck, 71 49 43 bytes

,[>+[>+<-],]>[<<[<]>[.>]>-[<<[.<]>[>]>-<]>]

Try it online!

Thanks to Jo King for saving 6 bytes.

[Tape: [Letters], 0, counter]
,[          while input
  >+        increment old counter
  [>+<-]    move counter to next position
  ,         input next
]
>[          while counter
  <<[<]>    go to first letter
  [.>]      print word forwards
  >-        decrement counter
  [         if counter
    <<      go to last letter
    [.<]    print word backwards
    >[>]>-  decrement counter
    <       exit if
  ]
  >         go to counter
]

Answer 26

Keg, 6 bytes

(^(:,"

How it works

    Implicit Reversed Input
(   Runs X times, where X is the length of the stack
^   Reverse the stack
(   Runs X times, where X is the length of the stack
:,  Prints the top item of the stack as a character
"   Rolls the stack to the right (puts the top of the stack to the bottom)
    Ending brackets get auto-completed

Try it Online!

Answer 27

Java, 151 bytes

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

}

Ungolfed:

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

Answer 28

Java, 127 111 88 bytes

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

Ungolfed test program

    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!", ""));
}

Answer 29

CJam, 10 bytes

l_,({_W%}*

Try it online!

Explanation

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

Answer 30

R, 53 bytes

Assumes that the input is space- or newline-separated for each character.

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

Some test cases:

> 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

Answer 31

Octave, 39 35 bytes

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

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

Explanation:

@(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

Saved 4 bytes thanks to Luis. ~x instead of 0*x saved one byte (works because all elements of x are non-zero. flip instead of flipud saved another two bytes (I didn't know flip existed).

Answer 32

C#, 94 bytes

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

76 bytes for the method + 18 bytes for LINQ import.

How it works:

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

Answer 33

bash + util-linux, 68 58 53 bytes

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

Explanation

Two things with the for loop:

• There is an apparently undocumented way of writing for loops where one replaces the do and done keywords with curly braces { and }. The space after the first bracket is necessary, and the semicolon at the end is also necessary.
• It turns out that in the "C-style" for loops, you can just initialize with i; instead of using i=0;.
• The ${#1} part of the condition i < ${#1} refers to the length of our input (the first parameter $1). In general, you can use ${#foo} to retrieve the size of the string $foo.

Additionally:

• rev is the tool in util-linux that reverses a string.
• We need to pass the -n flag to echo to get rid of newlines.
• The expression rev<<<$y is called a here-string (see this relevant tldp.org page), which passes the variable $y to the standard input of rev.

Answer 34

Excel VBA, 59 Bytes

Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window

a=[A1]:For i=1To Len(a):?IIf(i mod 2,a,StrReverse(a));:Next

Answer 35

Pushy, 5 bytes

NL:"@

Try it online!

Explanation

N          \ Suppress newlines in printing
 L:        \ Len(String) times do:
   "       \    Print
    @      \    Reverse

Answer 36

CJam, 15 10 bytes

q_,{_W%}*;

Explanation:

e.g input: "hello"
q //reads input, pushes to the stack. Stack: hello
  _ //duplicates it. Stack: hello, hello
   , //finds the length.  Stack: hello, 5
    { //starts a block.
     _ //duplicates the input. WouldBeStack: hello hello
      W // -1. WouldBeStack: hello -1
       % // Reverse (-1 = reverse, % = select every nth item). WouldBeStack: hello olleh
         } //end the block. Stack: hello, 5, {_W%}
           * //repeat the block for length times. Stack: hello, olleh, hello, olleh, hello, olleh
              ; //discard the last element

Try it online!

Answer 37

Add++, 23 bytes

L,dbRB]AbLdVß*GB VcGbUJ

Try it online!

Answer 38

Perl 6, 25 bytes

{S:g{.}=$++%2??.flip!!$_}

Try it online!

-4 bytes thanks to Jo (the) King!

---

Perl 6, 29 bytes

{S:g/./{$/.to%2??$_!!.flip}/}

Wanted to avoid a concatenation, so this just substitutes every character S:g/./ ... / with either the input $_ or its reverse .flip depending on whether the match position $/.to is odd or even %2.

Try it online!

Answer 39

Gol><>, 16 bytes

iEv
|;>lFrllKRo~

Try it online!

How it works

iEv

i    Take input as a char
 E   If the last input was EOF, pop; otherwise skip once
iEv  Take all input until EOF, then move to the next line

|;>lFrllKRo~

  >           Move right
   l          Push stack length (== string length)
    F         Pop x and repeat up to matching `|` x times

              [...string]
     r        Reverse stack
              [...rstring]
      ll      Push n, n+1
              [...rstring n n+1]
        K     Pop x and push copy of top x elements
              [...rstring n ...rstring n]
         R    Pop x and repeat the next instruction x times
          o   Pop and print as char
         Ro   Pop n and print n chars in reverse order
              [...rstring n]
           ~  Pop and discard
              [...rstring]

|             End `F` loop
 ;            Halt

Alternative solution, 16 bytes

iEv
|;>lFrlFLko|

Try it online!

How it works

iEv           Same as above

|;>lFrlFLko|

   l          Push n
    F         Pop n, repeat outer loop n times
     r        Reverse stack
      l       Push n
       F      Pop n, repeat inner loop n times
        L     Push loop counter (refers to the inner loop)
         k    Pop x and copy the x-th element to the top
          o   Pop and print as char
           |  Close inner loop
|             Close outer loop
 ;            Halt

Answer 40

SNOBOL4 (CSNOBOL4), 107 91 bytes

	O =N =INPUT
I	X =LT(X,SIZE(N) - 1) X + 1	:F(O)
	N =REVERSE(N)
	O =O N	:(I)
O	OUTPUT =O
END

Try it online!

This should now be fairly close to Suever's MATL solution.

Answer 41

Tcl, 77 bytes

proc S {s i\ 0} {if $i<[string le $s] {set s $s[S [string rev $s] [incr i]]}}

Try it online!

---

Tcl, 88 bytes

proc S s {time {append r [expr [incr i]%2?"$s":"[string rev $s]"]} [string le $s]
set r}

Try it online!

---

Tcl, 91 bytes

proc S s {append r $s
time {set r $r[set s [string rev $s]]} [expr [string le $s]-1]
set r}

Try it online!

Answer 42

Cubix, 24 bytes

..@wA#s?sBp\).W\oq>(?v()

Try it online!

Unwraps onto the following cube

    . .
    @ w
A # s ? s B p \
) . W \ o q > (
    ? v
    ( )

Watch it run

• A# Take all from input and push the number of items on the stack. This includes the -1 for the end of input.
• s? Swap the TOS and test value
  • wsBp\((? If negative (end of word), change lane to the right, swap TOS, reverse stack, bring botton of stack to the top, decrement twice and test
    • W#@ If 0 (repetitions finished) change lane to the left, redundant count of stack and halt
    • v)>()W If still positive, redirect down, increment, redirect right, decrement, increment and shift lane right back into the print loop
  • \oq>()W If positive, reflect left, output character, push TOS to bottom, redirect right, increment, decrement and shift lane left into the print loop

Answer 43

Pip, 20 17 bytes

Fi,#a{i%2?ORVaOa}

Try it online!

(RV reverses iterable). The program outputs the string on even steps and the reverse on odd steps

Answer 44

C# (Visual C# Interactive Compiler), 43 bytes

s=>s.SelectMany((_,i)=>i%2<1?s:s.Reverse())

Try it online!

Answer 45

K (oK), 18 bytes

Solution:

,//(#x)#(,;|)@\:x:

Try it online!

Explanation:

Apply enlist , and reverse | to the input and take length-of-input from this

,//(#x)#(,;|)@\:x: / the solution
                x: / store input as x
             @\:   / apply (@) each-left (\:)
        ( ; )      / two-item list
           |       / reverse
         ,         / enlist
       #           / take
   (  )            / do this together
    #x             / count x
,//                / flatten (,/) until converges

Answer 46

Zsh, 46 41 bytes

repeat $#1 s+=$1${(j::)${(Oas::)1}}
<<<$s

Try it online! Try it online!

       ${(Oas::)1}
       ${       1}    # take first parameter
         (  s::)      # split into characters
         (Oa   )      # reverse order
${(j::)           }   # join

Answer 47

Python2, 109 99 89 bytes

def f(s,o=''):
 r=s[::-1]
 for i in range(len(s)):
  if i%2==0:o+=s
  else:o+=r
 return o

Try it online!

or

Python2, 53 bytes

Saved 36 bytes, thanks to Jonathan French's solution:

lambda s:''.join(s[::~i%2*2-1]for i in range(len(s)))

Try it online!

Answer 48

PowerShell, 44 bytes

-join(($a=$args)|%{$a;$a=$a[-1..-$a.Count]})

Try it online!

Takes input via splatting, essentially making it an array of chars.

Answer 49

Wren, 39 bytes

Beats Python by 1 byte.

Fn.new{|n|(n=n[-1..0]).map{n=n[-1..0]}}

Try it online!

Explanation

Fn.new{|n|                            } // Anonymous function with n
          (n=n[-1..0])                  // Step 1. Set n as the reverse of n
                                        // Before the mapping of every item
                                        // in this list. Why? Because the
                                        // initialization in the map function
                                        // is done *before* the value is returned.

                      .map{          }  // Step 2. Map every item in this list
                           n=n[-1..0]   // to the current state of this string
                                        // reversed.
```

Answer 50

Ruby, 34 bytes

->s{s.each_char{$><<s;s.reverse!}}

Try it online!

This goes through each character of the string (a loop that runs as many times as the length of the string) and prints the string, and then reverses it.

$><<s is a golfed version of print s. It appends (<<) the value (s) to stdout ($>).

Answer 51

Java 8 bytecode, 412 bytes (403 bytes + -noverify)

Hexdump because it's unprintables all the way down:

00000000: cafe babe 0003 002d 0020 0a00 0c00 040c  .......-. ......
00000010: 0017 001f 0100 1628 5b4c 6a61 7661 2f6c  .......([Ljava/l
00000020: 616e 672f 5374 7269 6e67 3b29 560c 000e  ang/String;)V...
00000030: 0010 0100 063c 696e 6974 3e07 0011 0100  .....<init>.....
00000040: 0570 7269 6e74 0100 066c 656e 6774 6807  .print...length.
00000050: 0015 0100 0443 6f64 6501 0004 6d61 696e  .....Code...main
00000060: 0700 1609 0009 0002 0100 0772 6576 6572  ...........rever
00000070: 7365 0100 0a53 6f75 7263 6546 696c 6501  se...SourceFile.
00000080: 001a 2829 4c6a 6176 612f 6c61 6e67 2f53  ..()Ljava/lang/S
00000090: 7472 696e 6742 7566 6665 723b 0100 136a  tringBuffer;...j
000000a0: 6176 612f 696f 2f50 7269 6e74 5374 7265  ava/io/PrintStre
000000b0: 616d 0100 0328 2949 0a00 0600 140c 0007  am...()I........
000000c0: 001c 0100 106a 6176 612f 6c61 6e67 2f53  .....java/lang/S
000000d0: 7973 7465 6d01 0016 6a61 7661 2f6c 616e  ystem...java/lan
000000e0: 672f 5374 7269 6e67 4275 6666 6572 0100  g/StringBuffer..
000000f0: 036f 7574 0a00 0c00 1d07 000a 0c00 0500  .out............
00000100: 1c0a 000c 001a 0100 1528 4c6a 6176 612f  .........(Ljava/
00000110: 6c61 6e67 2f53 7472 696e 673b 2956 0c00  lang/String;)V..
00000120: 0800 1201 0000 0100 154c 6a61 7661 2f69  .........Ljava/i
00000130: 6f2f 5072 696e 7453 7472 6561 6d3b 0020  o/PrintStream;.
00000140: 0019 0006 0000 0000 0001 0009 000b 0003  ................
00000150: 0001 000a 0000 0031 0004 0001 0000 0025  .......1.......%
00000160: bb00 0c59 2a03 32b7 001b 59b6 0018 3b59  ...Y*.2...Y...;Y
00000170: b200 0d5f b600 13b6 0001 c484 0000 ffff  ..._............
00000180: 1a9a ffee b100 0000 0000 0100 0f00 0000  ................
00000190: 0200 1e 

Jasmin assembly code:

.source ""
.class Code
.super java/io/PrintStream
.method public static main([Ljava/lang/String;)V
    .limit stack 4
    .limit locals 1
    new java/lang/StringBuffer
    dup
    aload_0
    iconst_0
    aaload
    invokenonvirtual java/lang/StringBuffer/<init>(Ljava/lang/String;)V
    dup
    invokevirtual java/lang/StringBuffer/length()I
    istore_0
    Loop:
        dup
        getstatic java/lang/System/out Ljava/io/PrintStream;
        swap
        invokevirtual java/io/PrintStream/print(Ljava/lang/String;)V
        invokevirtual java/lang/StringBuffer/reverse()Ljava/lang/StringBuffer;
        iinc 0 -1
        iload_0
        ifne Loop
        return
.end method

What CFR thinks this decompiles to (it's actually mostly correct this time):

/*
 * Decompiled with CFR 0.148.
 */

import java.io.PrintStream;

class Code
extends PrintStream {
    public static void main(String[] arrstring) {
        StringBuffer stringBuffer = new StringBuffer(arrstring[0]);
        StringBuffer stringBuffer2 = stringBuffer;
        int n = stringBuffer.length();
        do {
            System.out.print((String)((Object)stringBuffer2));
            stringBuffer2 = stringBuffer2.reverse();
        } while (--n != 0);
    }
}

Needs -noverify because the JVM will just kinda cast it anyways, allowing me to save on needing the (Ljava/lang/Object;)V descriptor

Answer 52

PHP, 54 bytes

while($i++<strlen($s=$argv[1])){echo$s;$s=strrev($s);}

There are a lot of ways to do that, in almost every language I guess.

---

These two are my favourites:

an evil eval (62 bytes)

eval(str_repeat('echo$s;$s=strrev($s);',strlen($s=$argv[1])));

and a substr solution (69 bytes)

<?=substr(str_repeat(($s=$argv[1]).strrev($s),$n=strlen($s)),-$n*$n);

---

and while we´re at unsensible coding, take these 61:

$s=$argv[1];L:echo$s;$s=strrev($s);if(++$i<strlen($s))goto L;

Answer 53

Brachylog, 16 bytes

l-I,?r:?r:Ij@2hc

Try it online!

Explanation

l-I,                I = length(Input) - 1
    ?r              Reverse the Input
      :?r           The list [Input, Reverse of the Input]
         :Ij        Append I times that list to itself
            @2h     Split in half and take the first part
               c    Concatenate into a string

Answer 54

Retina, 27 bytes

Byte count assumes ISO 8859-1 encoding.

.
±$_
O$^`(?(\G)[^±]|±)

±

Try it online!

Explanation

.
±$_

Replace each character with the entire input, preceded by ± to separate copies.

O$^`(?(\G)[^±]|±)

The regex matches the characters in every other copy, by either matching a ± that is not adjacent to the previous match, or a non-± that is. These characters are reversed. Since each copy is the same width that is identical to reversing each copy individually.

±

Remove the separators.

Answer 55

Straw, 10 bytes

<:(:>"),*&

Try it online!

<:(:>"),*&
<          Take the input       (Stack: ["", input])
 :         Duplicate            (Stack: ["", input, input])
  (        Start a string
   :       Duplicate
    >      Output
     "     Reverse
      )    End the string       (Stack: ["", input, input, ':>"'])
       ,   Swap                 (Stack: ["", input, ':>"', input])
        *  Unary multiplication (Stack: ["", input, ':>"'*length of input])
         & Evaluate             (Stack: ["", input])

Answer 56

Pyth, 6 bytes

Vzp~_z

Try it online!

Explanation

Vzp~_z
Vz      For every character in z (the input)
  p  z  Print z
   ~_z  Reverse z

Answer 57

Pyke, 8 7 bytes

VoI_Q(s

Try it here!

Answer 58

Lua, 66 bytes

function f(s,i)j=i or 0return#s>j and s..f(s:reverse(),j+1)or''end

Try it on ideone!

Answer 59

Julia, 42 bytes

h(s,l=1)=l==endof(s)?s:s*h(reverse(s),l+1)

Recursive function with counter variable l. If it is equal to the length of the string s, simply return it, otherwise concatenate (s*...) it with h(reverse(s),...) while incrementing the counter l+1.

Answer 60

><>, 34 bytes

l::f1.>1!<-{:o$61.
:?!;1-$:?^~r:@@

Input for using the -v flag.

Explanation

l::f1.Captures the length of the input, and creates two copies of it. One of the copies is used to keep track of the number of loops, the other one is used in the loop that prints the string. After that, the program teleports to the end of the second line, wraps around, and enters the main loop.

:?!;1-$ Checks if the program has printed the string n times, and if so, it terminates. Otherwise, it decrements the number of strings remaining.

:?^~r:@@ Checks if the program is done printing one iteration of the loop. If so, it reverses the string.

>1!<-{:o$61. Prints the next character in the string, and decrements the index. Teleports back to previous conditional.

Try it online!

Answer 61

Vitsy, 10 bytes

Wl\[::ZYr]

W          Grab a line from STDIN.
 l\[     ] Store the length of the stack as x, do the stuff in brackets x times.
    ::     Clone the current stack twice.
      Z    Output the current stack.
       Y   Pop and dump this stack, returning back to previous.
        r  Reverse the current stack.

Try it online!

Answer 62

Haxe, 121 118 117 bytes

function R(s:String){var r="",o="",l=s.length;for(i in-l+1...1)r+=s.charAt(-i);for(i in 0...l)o+=i%2<1?s:r;trace(o);}

Reverting the string took a lot of bytes :(

Testcases

R("a")
a

R("Hello!")
Hello!!olleHHello!!olleHHello!!olleH

R("4815162342")
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Answer 63

><>, 40 bytes

<v?(0:i
l\~l&r
$<v!?:-1}o:
;^>~rl&1-:&?!

Try it online!

Answer 64

Vimscript - 109 bytes

@DJMcMayhem already beat me to it, but because I did it anyway, here's my losing answer. I thought reversing a string would be easier though!

fu A(s)
let i=0
wh(i<len(a:s))
exe "norm A". [a:s,join(reverse(split(a:s,'\zs')),'')][i%2]
let i+=1
endw
endf

Ungolfed

function! A(s)
  let reversed=join(reverse(split(a:s,'\zs    ')),'')
  let both=[a:s,reversed]
  let i=0
  while(i<len(a:s))
    exe "norm a".both[i%2]
    let i+=1
  endwhile
endfunction

Answer 65

Implicit, 10 bytes

'¯^(]%\[´ö

Try it online!

Explanation:

'¯^(]%\[´ö
'           « read string               »;
 ¯          « copy to memory            »;
  ^         « push string length        »;
   (......  « infinite loop             »;
    ]       «  pull string to stack     »;
     %      «  print string             »;
      \     «  reverse it               »;
       [    «  put it back in memory    »;
        ´   «  decrement string length  »;
         ö  «  exit w/o implicit output if top of stack falsy, shortcut for )&  »;

Answer 66

Japt, 6 bytes

ʲîUpw

Try it

ʲîUpw     :Implicit input of string U
Ê          :Length
 ²         :Squared
  î        :Repeat to that length
   Up      :  Append to U
     w     :    Reverse U

Answer 67

ES7, 60 bytes

b=>{for(c=b,d=0;d++<b.length;)c+=d%2?b:b.reverse();return c}

Answer 68

APL(NARS), 23 chars, 46 bytes

{⍵{⍵≤1:⍺⋄⍺,(⌽⍺)∇⍵-1}≢⍵}

test:

  f←{⍵{⍵≤1:⍺⋄⍺,(⌽⍺)∇⍵-1}≢⍵}
  f ,'a'
a
  f 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
  f 'abcd'
abcddcbaabcddcba
  f 'OK!'
OK!!KOOK!

Answer 69

PicoLisp, 70 bytes

(de f(s)(for n(size s)(prin(if(= 1(% n 2))s(pack(reverse(chop s)))))))

Try it online!

Answer 70

Red, 43 bytes

func[s][foreach c s[prin copy s reverse s]]

Try it online!

Answer 71

Factor, 62 bytes

: f ( x -- x ) [ length ] keep [ dup write reverse ] repeat ; 

Try it online!

Answer 72

Gaia, 10 bytes

:l┅r¦iv?¦$

Try it online!

:		| duplicate input
 l		| take length
  ┅		| push range 1,2,3,...l
    r¦		| modulo 2 1,0,1,...l%%2
      iv?¦	| if truthy, push same, else push reverse
          $	| join with no separator and display

Answer 73

Ohm v2, 5 bytes

lMDLR

Try it online!

Answer 74

Swift 5, 70 bytes

{a in String(zip(0..., a).flatMap{$0.0%2==0 ?a:String(a.reversed())})}

Try it online!

Answer 75

Lua, 62 bytes

a=arg[1]for i=1,#a do io.write(i%2==1 and a or a:reverse())end

Try it online!

Full program, take input as argument.

Answer 76

Kotlin, 67 bytes

{s->Array(s.length){if(it%2>0)s.reversed()else s}.joinToString("")}

• Initialize an array of s.length elements.
• Choose direction based on index
• Concat it all together

Try it online!

Answer 77

Julia 1.0, 35 bytes

s->for _=s print(s);s=reverse(s)end

Try it online!

Loops over the input string characters and each iteration prints and reverses the string.

Answer 78

Keg, 8 bytes

᠀:(⑴;|⑩⑶

Try it online!

I found this to be quite a fun little answer to write.

Explained

᠀:(⑴;|⑩⑶
᠀:          #Take input as a string (otherwise numbers won't work correctly) and duplicate it, because:
  (⑴        #We then push the length of that string onto the stack. The ⑴ op pops the top however, which is why duplication was needed. This will be the loop count of our for loop, started with "("
    ;       #Decrement that length to avoid off by one error
     |      #Branch to the body of the for loop
      ⑩⑶    #Print the item without popping and then reverse that item

Oh unicode... why'd y'all have to be so unevenly widthed for?

Answer 79

Burlesque, 15 bytes

saS[jJ<-_+cyj.+

Try it online!

sa  # Length of input
S[  # Squared
jJ  # Duplicate the input
<-  # Reverse it
_+  # Join them
cy  # Repeat infinitely
j.+ # Take the first length-squared characters

Answer 80

C++ (gcc), 112 bytes

#import<bits/stdc++.h>
int f(std::string&s){for(int x=s.length();x--;std::reverse(&s[0],&*end(s)))std::cout<<s;}

Requires a non-const, mutable std::string. It reverses the string after every iteration and prints it.

-3 bytes thanks to ceilingcat!

Try it online!

Answer 81

Ruby, 43 bytes

f=->s,i=s.size{$><<s
i<2||f[s.reverse,i-1]}

See it on eval.in: https://eval.in/642616

Answer 82

Actually, 12 bytes

;;l)Rkp;)αHΣ

Try it online!

Explanation:

;;l)Rkp;)αHΣ
;;l           dupe string twice, use one copy to get length (call it L)
   )          move length to bottom of stack
    R         reverse one copy of string
     k        pop entire stack and push as list
      p       pop L from list
       ;)     dupe L, move one copy to bottom
         α    repeat each element (the forward and reversed string) of the list L times
          H   first L elements in list (trim off excess elements)
           Σ  concatenate

Answer 83

Groovy, 51 bytes

def d(s){s.size().times{print(it%2?s.reverse():s)}}

Answer 84

Lua 5.1, 70 Bytes

function f(s)return(s..s:reverse()):rep(#s/2)..(#s%2==1 and s or"")end

Had odd numbers not been possible, I could have done it in 48 bytes by sheering off the ..(#s%2==1 and s or""), but the test cases prevented that.

This was the shortest of three methods I tried, the others being.

function f(s)local o return s:gsub(".",function()o=~o return o and s or s:reverse()end)end

and

function f(s)local o,t t=""for _ in s:gmatch(".")do o,t=~o,t..(o and s:reverse()or s)end return t end

the locals were added in those two examples, for confidence that this function would always work.

Answer 85

C#, 137 bytes

void S(string i){Console.WriteLine(string.Join("",i.Select((c,n)=>(n%2==0)?i:i.Reverse()).Select(x=>new string(x.ToArray())).ToList()));}

Ungolfed:

void S(string i)
{
    Console.WriteLine(string.Join("",
    i.Select((c, n) => (n%2 == 0) ? i : i.Reverse()).Select(x => new 
    string(x.ToArray())).ToList()));
}

Answer 86

Java, 68 bytes

b->s->{for(int i=b.reverse().length();i-->0;)s.append(b.reverse());}

Or if the 2nd argument isn't allowed, 79 bytes:

b->{String s="";for(int i=b.reverse().length();i-->0;)s+=b.reverse();return s;}

Testing and ungolfed

import java.util.function.BiConsumer;
import java.util.function.Function;

public class Main {

  public static void main(String[] args) {

    // Shortest version
    BiConsumer<StringBuilder, StringBuilder> f = (in, out) -> {
      in.reverse();
      for (int i = in.length(); i-- > 0;) {
        out.append(in.reverse());
      }
    };
    // Longer version
    Function<StringBuilder, String> g = in -> {
      String out = "";
      in.reverse();
      for(int i = in.length(); i-->0; ) {
        out+=in.reverse();
      }
      return out;
    };

    test(f, "Hello!");
    System.out.println(g.apply(new StringBuilder("Hello!")));
  }

  static void test(BiConsumer<StringBuilder,StringBuilder> f, String txt) {
    StringBuilder result = new StringBuilder();
    f.accept(new StringBuilder(txt), result);
    System.out.println(result);
  }
}

Answer 87

Swift 2.2 127 bytes

let x={(s:String) in var b = "";for var i in 1...s.characters.count {b += i%2==1 ?s:String(s.characters.reverse());};print(b);}

unGolfed

let x={(s:String) in
  var b = "";
  for var i in 1...s.characters.count {
    b += i%2==1 ?s:String(s.characters.reverse());
  };
  print(b);
}

Answer 88

PHP, 54 bytes

while($c++-strlen($s=$argv[1]))echo$c%2?$s:strrev($s);

I thought of this one myself before looking at other people's answers and then realised it's pretty much a combination of Crypto's and Titus' solutions... Well, I wanted to post it anyway :-)

Answer 89

Python 3, 84 70 67 characters

def s(d,i=1):
 t=d[::(i%2)*2-1]
 if i<len(d):t+=s(d,i+1)
 return t

Answer 90

VBScript, 88 bytes

a=WScript.Arguments(0)
For i=1 To Len(a)
WScript.StdOut.Write a
a=StrReverse(a)
Next

Note: This does require the script execute using cscript.exe. For example...

cscript.exe rev.vbs Hello!

Answer 91

C++ (gcc), 91 bytes

void f(string s){ for(int i = 0; i++ < s.size(); reverse(s.begin(), s.end())) cout << s;  }

Try it online!