R, 69 bytes

for(i in 1:scan()-1)cat('<'[i%%2],rep('-',i/2),'>'[!i%%2],'

',sep='')

Try it online!

• -5 bytes thanks to @Giuseppe


• -3 bytes thanks to @Robert S.

Canvas, 10 bytes

⇵-×<ｎ¹［↔｝］

Try it here!

Python 2, 53 bytes

k=-1

exec"print'<'[k%2:]+'-'*k+k%2*'>';k+=1;"*input()

Try it online!

Pyth, 17 bytes

m_W%d2+*-/d2@"><

Output is a list of strings. Try it online here.

m_W%d2+*-/d2@"><"dQ   Implicit: Q=eval(input())

                       Trailing "dQ inferred

m                  Q   Map [0-Q), as d, using:

          /d2            Floored division of d by 2

       *-               Repeat "-" the above number of times

      +                  Append to the above...

             @"><"d      Modular index d into "><" - yields ">" for even d, "<" for odd

                         - examples: d=4 gives "-->", d=7 gives "---<"

 _W                      Reverse the above if...

   %d2                   ... (d % 2) != 0

                       Implicit print result of the map

Commodore BASIC V2 (C64), 94 bytes

0inputn:fOi=1ton:oniaN1gO1:?"<";

1on-(i<3)gO2:fOj=1.5toi/2:?"-";:nE

2on-nOiaN1gO3:?">";

3?:nE

Not entirely sure about the byte count, this is based on the text representation for typing the valid program. It's a bit shorter on disk (91 bytes) because BASIC V2 uses a "tokenized" representation of programs.

Online Demo

Slightly "ungolfed":

0 inputn:fori=1ton:oniand1goto1:print"<";    :rem read n from user, loop to n, if odd skip "<"

1 on-(i<3)goto2:forj=1.5toi/2:print"-";:next :rem skip for i<3, print (i-1)/2 times "-"

2 on-notiand1goto3:print">";                 :rem if even skip ">"

3 print:next                                 :rem newline and next loop iteration

PowerShell, 62 56 50 bytes

param($n)(0..$n|%{($j='-'*$_)+'>';"<$j"})[0..--$n]

Try it online!

Loops from 0 up to input $n, each iteration creating two arrow strings. Those are then indexed with 0..--$n to pull out the correct number of elements.

Saved 6 bytes thanks to KGlasier.

Jelly, 15 bytes

ị⁾><;’H”-ẋƲṚ⁸¡)

Try it online!

Java (JDK), 81 bytes

n->{for(int i=0;i<n;)System.out.printf(i%2<1?"<%s%n":"%s>%n","-".repeat(i++/2));}

Try it online!

Explanations

n->{                  // int-accepting consumer

 for(int i=0;i<n;)    //  for each i from 0 to n-1 included

  System.out.printf(  //   output on stdout with a pattern

   i%2<1              //    if i is even:

    ?"<%s%n"          //     use the left-arrow pattern

    :"%s>%n",         //    else: use the right-arrow pattern

   "-".repeat(i++/2)  //    fill the pattern with i/2 dashes, and increment i

  );                  // 

}                     //

SNOBOL4 (CSNOBOL4), 123 122 118 bytes

	N =INPUT - 1

P	H =X / 2

	Y =DUPL('-',H)

	OUTPUT =EQ(H,X - H) Y '>'	:S(I)

	OUTPUT ='<' Y

I	X =LT(X,N) X + 1	:S(P)

END	

Try it online!

V, 22 bytes

i>

<Àñäkjjé-já-ñÀGjdG

Try it online!

Charcoal, 16 bytes

ＮθＦθ«⊘ι↓>‖Ｔ»Ｆθ‖Ｔ

Try it online! Link is to verbose version of code. I had three 17-byte solutions before I eventually stumbled over this one. Explanation:

Ｎθ

Input n.

Ｆθ«

Repeat n times, 0-indexed.

⊘ι

Draw a line of -s of length half the index (truncated).

↓>

Draw the arrowhead and move to the next line.

‖Ｔ»

Reflect everything, flipping the arrowheads.

Ｆθ‖Ｔ

The above loop has n reflections, but we need an even number of reflections, so perform another n reflections.

Japt -m, 16 bytes

"<>"¬hUu Uz ç-)q

Try it online!

Updated with a completely new method.

Explanation:

                    #Implicitly map over the range [0..input) as U

"<>"                #The string "<>"

    ¬               #Split into the array ["<",">"]

     hUu      )     #Replace the element at index U modulo 2 with:

             -      # The character '-'

            ç       # Repeated a number of times equal to

         Uz         #  U integer divided by 2

               q    #Join the array to a string

JavaScript (ES6), 58 bytes

Returns a space-separated string.

n=>(g=p=>n--?k++&1?`<${p} `+g(p+'-'):p+'> '+g(p):'')(k='')

Try it online!

Haskell, 51 bytes

(`take`do b<-['-'<$[1..n]|n<-[0..]];[b++">",'<':b])

Try it online!

Explanation / Ungolfed

Using do-notation saves us a concat, using '-'<$[1..n] is shorter than replicate, and finally using infix-notation allows a pointfree function with take, undoing these would give:

f n = take n $ concat [ [b++">", '<':b] | n<-[0..], let b = replicate n '-' ]

Haskell, 41 bytes

(`take`g"")

g p=(p++">"):('<':p):g('-':p)

Try it online!

Plain old recursion: start with an emtpy string p, collect p with a right arrow, a left arrow with p and a recursive call with p one - longer. Take the first n items of this list.

Powershell, 51 bytes

param($n)0..$n|%{'-'*$_+'>';'<'+'-'*$_}|?{$n---gt0}

05AB1E, 23 bytes

FN2%D"><"è'-N2÷∍«s_iR},

Try it online!

First time using 05AB1E or any other golfing language for that matter. Any ideas welcome.

Java 123 bytes

n->{String l="",r="";for(int c=0;c<n;c++)System.out.println(c%2==0?r=c==0?">":c==1?"<":"-"+r:(l+=c==0?">":c==1?"<":"-"));}

Clean, 76 73 bytes

import StdEnv,StdLib

$n=take n[s\i<-inits['--'..],s<-[i++['>'],['<':i]]]

Try it online!

Uses the neat fact that ['-','-'..] is the same as ['--'..] to save a bit.

6502 machine code (C64), 49 bytes

00 C0 20 9B B7 A2 00 8A 4A A8 90 05 A9 3C 20 D2 FF A9 2D C0 00 F0 06 20 D2 FF 

88 D0 FA 8A 4A B0 05 A9 3E 20 D2 FF A9 0D 20 D2 FF E8 E4 65 D0 D7 60

Still quite a bit shorter than BASIC ;) This one has a number range only up to 255 because the natural integer size of the machine has only 8 bits.

Online demo

Usage: SYS49152,[n] (e.g. SYS49152,3 for the example from the challenge)

Commented disassembly:

         00 C0       .WORD $C000        ; load address

.C:c000  20 9B B7    JSR $B79B          ; get unsigned byte from commandline

.C:c003  A2 00       LDX #$00           ; main loop counter

.C:c005   .loop:

.C:c005  8A          TXA                ; loop counter to accumulator

.C:c006  4A          LSR A              ; divide by 2, shift lowest bit to C

.C:c007  A8          TAY                ; result to Y

.C:c008  90 05       BCC .toright       ; C clear -> counter even, skip '<'

.C:c00a  A9 3C       LDA #$3C           ; load character '<'

.C:c00c  20 D2 FF    JSR $FFD2          ; output character

.C:c00f   .toright:

.C:c00f  A9 2D       LDA #$2D           ; load character '-'

.C:c011  C0 00       CPY #$00           ; counter/2 == 0 ? then no dashes

.C:c013  F0 06       BEQ .skipdashes

.C:c015   .printdashes:

.C:c015  20 D2 FF    JSR $FFD2          ; output character

.C:c018  88          DEY                ; decrement Y

.C:c019  D0 FA       BNE .printdashes   ; not 0 yet -> repeat

.C:c01b   .skipdashes:

.C:c01b  8A          TXA                ; loop counter to accumulator

.C:c01c  4A          LSR A              ; shift lowest bit to C

.C:c01d  B0 05       BCS .toleft        ; C set -> counter odd, skip '>'

.C:c01f  A9 3E       LDA #$3E           ; load character '>'

.C:c021  20 D2 FF    JSR $FFD2          ; output character

.C:c024   .toleft:

.C:c024  A9 0D       LDA #$0D           ; load newline character

.C:c026  20 D2 FF    JSR $FFD2          ; output character

.C:c029  E8          INX                ; next loop iteration

.C:c02a  E4 65       CPX $65            ; compare to command line argument

.C:c02c  D0 D7       BNE .loop          ; not reached yet -> repeat main loop

.C:c02e  60          RTS                ; exit

Perl 5, 44 bytes

map{$_/=2;say'<'x/./,'-'x$_,'>'x!$&}0..<>-1

Try it online!

Japt -m, 16 15 13 bytes

g"><" iUUz ç-

Test it online

Perl 6, 39 bytes

{map {'<'x$_%2~'-'x$_/2~'>'x$_%%2},^$_}

Try it online!

Anonymous code block that returns a list of lines.