Tcl, 76 bytes

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

Try it online!

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

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

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

TeX-g, 73 71 64 43 41 bytes

TeX-g is a (La)TeX based code golf dialect draft written in TeX, that I work on every now and then. The following works with the code of commit 0fa354f (the latest commit as of writing this).

The byte count includes loading TeX-g and the definition of the function. The newline is part of the syntax and therefore counted.

The edit (64 -> 43 bytes) was possible because TeX-g got a function that defines macros taking NUL-terminated strings as input (was added in commit 0fa354f).

\input-g $2{~!{#1}\;_#1:!\tl_reverse:N!
}

Complete test file (just compile this with pdfTeX or LuaTeX), since this contains NUL-bytes in the string termination the following is a hexdump of the file:

00000000  5c 69 6e 70 75 74 2d 67  20 24 32 7b 7e 21 7b 23  |\input-g $2{~!{#|
00000010  31 7d 5c 3b 5f 23 31 3a  21 5c 74 6c 5f 72 65 76  |1}\;_#1:!\tl_rev|
00000020  65 72 73 65 3a 4e 21 0a  7d 0a 0a 32 48 65 6c 6c  |erse:N!.}..2Hell|
00000030  6f 21 00 0a 0a 32 61 00  0a 0a 32 61 62 63 64 00  |o!...2a...2abcd.|
00000040  0a 0a 32 4f 4b 21 00 0a  0a 32 34 32 00 0a        |..2OK!...242..|
0000004e

Human readable version with the NUL-bytes replaced by ^@:

\input-g $2{~!{#1}\;_#1:!\tl_reverse:N!
}

2Hello!^@

2a^@

2abcd^@

2OK!^@

242^@

J-uby, 36 bytes

:*%[:& &~(:-&(:**&:~)),:+@|:*]|:join

Attempt This Online!

LaTeX, 82 bytes

{\ExplSyntaxOn\gdef\a#1{\str_set:Nn\1{#1}\str_map_inline:Nn\1{\1\tl_reverse:N\1}}}

Complete test file:

\documentclass{article}

{\ExplSyntaxOn\gdef\a#1{\str_set:Nn\1{#1}\str_map_inline:Nn\1{\1\tl_reverse:N\1}}}

\begin{document}
\a{Hello!}

\a{a}

\a{abcd}

\a{OK!}

\a{42}
\end{document}

LaTeX in TeX Live 2025, 94 Bytes

An error is corrected, since the old code doesn't answer the question.

\ExplSyntaxOn\def\a#1{\int_step_inline:nn{\tl_count:n{#1}}{#1\tl_reverse:n{#1}}}\ExplSyntaxOff

Minimum Working Example (Using This Function):

\documentclass{minimal}

\ExplSyntaxOn\def\a#1{\int_step_inline:nn{\tl_count:n{#1}}{#1\tl_reverse:n{#1}}}\ExplSyntaxOff


\begin{document}
\a{hello!}
\end{document}

Swift 6, 66 65 bytes

let b={s in(0..<s.count).map{$0%2<1 ?s:""+s.reversed()}.joined()}

Bash, _{42 47} 38 bytes

yes "$1
`rev<<<$1`"|head -${#1}|rs -g0

Corrected and added test cases. Version 1.0 handled odd-length strings incorrectly.

Try it online! _{47bytes 42bytes}

Uiua, 8 bytes

♭⍥⇌°⊏↯⊸⧻

Test cases

Expanation

♭⍥⇌°⊏↯⊸⧻
      ⊸⧻ # Get the length, preserving the string
     ↯   # Copy the string N times
   °⊏    # Enumerate the list of strings
 ⍥⇌      # Reverse each string as many times as its index
♭        # Flatten the list of strings into one string

AWK, 54 bytes

{for(;i++<NF;)for(j=NF;j--;)printf i%2?$(NF-j):$(j+1)}

Attempt This Online!

{for(;i++<NF;)       # number of iterations from string length
for(j=NF;j--;)       # to traverse the string
printf               #
i%2?$(NF-j):$(j+1)}  # print forwards or backwards

Zsh, 52 bytes

set ${(s..)1}
for c;s+=${(j..)@}&&set ${(Oa)@}
<<<$s

Try it online!

(46 bytes, wrong) (41 bytes, wrong)

set ${(s..)1}        # split into characters
for c;
    s+=${(j..)@} &&  # join and append
    set ${(Oa)@}     # reverse (O)rder by (a)rray position
<<<$s

☾, 8 chars (27 bytes)

󷺹⋄⟞ᴙᓕ􍫇􌘇⨝

Note: ☾ uses a custom font, but you can run this code in the Web UI

Note: If you have a subscript without something indexable behind it, it just turns into a list. Thus ᓕ's modifier is [[0,1,…,len(arg)]], which means "on the outermost axis, get values at these indicies"; this works because it automatically mod's overflow indicies by the list length (2 in this case).

Pip, 9 bytes

R{R:\a}Ma

Attempt This Online!

Explanation

This solution is really weird...

R{R:\a}Ma
          ; a is first cmdline arg as a local variable; \a is the same, but global
       Ma ; Map this function over each character of a:
 {  \a}   ;   Take the global variable \a
  R:      ;   Reverse it in place
R         ;   Then reverse that (without modifying \a)
          ; Join the results together and autoprint (implicit)

Nekomata, 5 bytes

xᵐᵑ↔j

Attempt This Online!

xᵐᵑ↔j
x       Range from 0 to length of input - 1
 ᵐ      Map
  ᵑ       Apply the next function n times
   ↔        Reverse
    j   Concatenate

Thunno 2, 5 bytes

l{D¢r

Attempt This Online!

Explanation

l{D¢r  # Implicit input
l{     # Repeat length of input times:
  D¢   #  Print TOS without a newline, without popping
    r  #  Reverse for next iteration

Lua, 49 bytes

s=...print((s..s:reverse()):rep(#s):sub(1,#s*#s))

Try it online!

Arturo, 39 bytes

$->s[s loop size s=>[reverse prints<=]]

Try it

Python 3, 61 bytes

def b(x):
 f,q=len(x),''.join([x,x[::-1]]*f)
 return q[:f**2]

Try it online!

Thunno J, \$ 7 \log_{256}(96) \approx \$ 6 bytes

(actually 5.76 bytes but that doesn't show up on the leaderboard)

rDeKDrD

Attempt This Online!

Explanation

rDeKDrD  # Implicit input
r        # Reverse the input
 D       # Duplicate and get the length
  eK     # Loop through, popping the loop variable:
    Dr   #  Duplicate and reverse
      D  #  And duplicate (since this will get popped)
         # The J flag joins this list of strings
         # Implicit output

Thunno J, \$ 10 \log_{256}(96) \approx \$ 8.23 bytes

DLsDrZPsZG

Attempt This Online!

Explanation

DLsDrZPsZG  # Implicit input
DL          # Duplicate and get the length
  sDr       # Swap, duplicate, and reverse
     ZP     # Pair with the reversed copy
       sZG  # Extend this list to the length of the input
            # The J flag joins this list of strings
            # Implicit output

Java 8, 108 bytes

Even if there already is a better Java solution posted, here is a different approach using a single inline stream :

s->s.chars().mapToObj(e->"").reduce("",(a,b)->a.length()/s.length()%2<1?a+s:a+new StringBuffer(s).reverse())

Try it online!

And here is a janky stream solution avoiding the use of StringBuffer(s).reverse() (and exploiting the fact that the input and output can't contain \n), but requiring an additional substring because the result was containing two times the answer, sadly :( 149 bytes :

s->s.chars().mapToObj(e->""+(char)e).reduce(s.replaceAll(".","\n"),(a,b)->a.replace("\n",b+"\n"+b)).replace("\n","").substring(s.length()*s.length())

Lua, 59 51 bytes

Thanks @Steffan!

for x=0,arg[1]do a=arg[2]io.write(a,a:reverse())end

Attempt This Online!

K (ngn/k), 14 bytes

{,/(#1_x)|:\x}

Try it online!

• (#1_x)|:\x set up a n-dos scan, running |: (i.e., reverse) on the original input x a number of times equal to the length of the input minus 1
• ,/ flatten (and implicitly return) the above

JavaScript, 52 bytes

Without recursion:

s=>[...s].reverse().flatMap((c,i,l)=>i%2?l:s).join``

Try it:

f=s=>[...s].reverse().flatMap((c,i,l)=>i%2?l:s).join``

console.log(f('a'));
console.log(f('abcd'));
console.log(f('OK!'));
console.log(f('4815162342'));
console.log(f('PPCG'));
console.log(f('42'));

UPD 59 -> 52

Thanks to Shaggy for the new algorithm without recursion to reduce bytes count

Go, 162 bytes

import."strings"
func f(s string)string{o,i:=[]string{},0
for;i<len(s);i++{k:=""
if i%2>0{for i:=range s{k=s[i:i+1]+k}}else{k=s}
o=append(o,k)}
return Join(o,"")}

Attempt This Online!

Japt, 6 4 bytes

£zYÑ

Try it

£zYÑ     :Implicit input of string U
£        :Map each character at 0-based index Y
 z       :  Rotate U 90° clockwise
  YÑ     :    Y*2 times

Pyt, 6 bytes

ĐąŁ⇹ҏ*

Try it online!

Đ          implicit input; duplicate on stack
 ąŁ        get length of input string
   ⇹ҏ      palindromize the input string
     *     string multiplication; implicit print

Julia, 38 bytes

!x=x*join(x=reverse(x) for _=x[2:end])

Try it online!

Ly, 23 bytes

&iysp>l[<&s&o&lr&s>1-]p

Try it online!

At a high level, the code stores the input string in the "backup cell" restoring it, printing, reversing and re-saving each time through the loop. The loop counter is in a separate stack.

&iysp>l[<&s&o&lr&s>1-]p #
&i                      # Read the input onto the stack (as codepoints)
  ysp                   # Get the length, stash in the backup cell, pop from stack
     >l                 # Switch stacks, load the input lenght (loop counter)
        [         >1-]  # Loop, switch to loop counter stack, and decrement
         <&s            # Switch to the output stack, restore string from backup cell
           &o           # Print the stack
             &lr&s      # Restore string again, reverse stack and re-save
                      p # Delete loop counter to prevent it from printing

Vyxal, 4 bytes

(:₴Ṙ

Try it Online!

I was looking through old Keg answers of mine and saw that I could improve on my score here with its improvement language.

Explained

(:₴Ṙ
(    # for each character in the input:
 :₴  #     print the top of the stack without a newline, preserving it. For the first iteration, this will be the original input. 
   Ṙ #     reverse the top of the stack. This achieves the string reversing effect, as it alternates the direction of the string each iteration

Java (JDK), 68 bytes

s->{var r=""+s;for(int i=s.length();i-->1;)r+=s.reverse();return r;}

Try it online!

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!

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

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?

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

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

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

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

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.

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!

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.

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!

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!

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

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

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

Try it online!

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.

Swift 5, 70 bytes

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

Try it online!

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
]

Ohm v2, 5 bytes

lMDLR

Try it online!

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.

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

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!

PicoLisp, 70 bytes

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

Try it online!

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.

Factor, 62 bytes

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

Try it online!

Red, 43 bytes

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

Try it online!

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

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!

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!

ES7, 60 bytes

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

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

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!

><>, 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!

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

Add++, 23 bytes

L,dbRB]AbLdVß*GB VcGbUJ

Try it online!

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!

Pushy, 5 bytes

NL:"@

Try it online!

Explanation

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

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

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

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

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

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.

><>, 40 bytes

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

Try it online!

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

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

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

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!

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.

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

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

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

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!

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.

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!

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.

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

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

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!

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

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

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

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

Pyke, 8 7 bytes

VoI_Q(s

Try it here!

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.

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

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

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

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

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

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.

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

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

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

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.

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?

Groovy, 51 bytes

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

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!

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

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

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;

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

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!

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)

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

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

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.

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.