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.

Haskell, 41 40 bytes

(`take`g">")

g p=p:('<':init p):g('-':p)

Try it online!

Plain old recursion: start with string p = ">", collect p, a < in front of all but the last char of p and a recursive call with one - put in front of p. Take the first n items of this list.

Edit: -1 byte thanks to @xnor.

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 "%s" in the pattern with i/2 dashes, and increment i

  );                  // 

}                     //

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

Python 2, 54 bytes

thanks to the and Jo King for fixing a bug.

k=0

exec"print k%2*'<'+k/2*'-'+~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

Python 3, 53 bytes

My first codegolf answer.

lambda x:[i%2*"<"+i//2*"-"+~i%2*">"for i in range(x)]

-10 bytes thanks to Jo King

Self-modifying Brainfuck, 55 bytes

Take input as character code.

Only support input up to 255.

Use null character to separate lines.

Coincidentally, all arrow-drawing characters are used as BF commands. Unfortunately, it doesn't save any bytes (currently).

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

Try it online!

Explanation

 Code  |              Memory         | Output | Comment

-------+-----------------------------+--------+--------------------------

       | '<' '>' '-' [0]  0   0   0  |        |

>>,    | '<' '>' '-'  0   0  [x]  0  |        |

[      |                             |        |

       | '<' '>' '-'  l   0  [x]  0  |        | l = arrow length

<<[-<  |                             |        | copy l to next cell

.>>+<] |                             |        | and print '-'

       | '<' '>' '-' [0]  l   x   0  | -----  | there are l '-'s

<<.    | '<' [>] '-'  0   l   x   0  | >      |

>>.+   | '<' '>' '-' [1]  l   x   0  | <null> |

>>-    | '<' '>' '-'  1   l  [y]  0  |        | y=x-1

[      |                             |        | execute if y>0

<<<<<. | [<] '>' '-'  1   l   y   0  | <      |

>>>>   | '<' '>' '-'  1  [l]  y   0  |        |

[-<+<. |                             |        |

>>]    | '<' '>' '-'  L  [0]  y   0  | -----  | L=l+1

.      | '<' '>' '-'  L  [0]  y   0  | <null> |

>-<]>] |                             |        | decrement y

<>-    |                             |        | do nothing, used as data

Haskell, 51 44 bytes

^{-7 bytes thanks to xnor (using iterate over list-comprehension)!}

(`take`do b<-iterate('-':)"";[b++">",'<':b])

Try it online!

Explanation / Ungolfed

Using do-notation saves us a concat, and using infix-notation allows a pointfree function with take, undoing these would give:

f n = take n $ concat [ [b++">", '<':b] | b <- iterate ('-':) "" ]

Japt -m, 16 15 13 bytes

g"><" iUUz ç-

Test it online

Explanation:

-m              // Map the program through [0...Input); U becomes the item

g"><" iUUz ç-

 "><"           // Literal "><"

g               //   Get the char at index U (with wrapping)

      i         // Insert:

       U        //   At index U (with wrapping)

           ç-   //   "-" repeated:

        Uz      //     U/2 times

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!

MathGolf, 17 15 bytes

Saved 2 bytes thanks to Jo King and Kevin Cruijssen

{ï½'-*'>ï¥╛Å⌡n

Try it online!

Explanation

The 15-byte approach is different compared to my original solution, I can't take any credit for the implementation.

{                 start block or arbitrary length

 ï                index of current loop, or length of last loop

  ½               pop a : push(a//2 if int else a/2)

   '-             push single character "-"

     *            pop a, b : push(a*b)

      '>           push single character ">"

        ï         index of current loop, or length of last loop

         ¥        modulo 2

          ╛       if without else

           Å      start block of length 2

            ⌡     decrement twice

                 swap top elements

              n   newline char, or map array with newlines

Japt -m, 14 bytes

"<>"¬hUUz ç-)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 ["<",">"]

     hU     )     #Replace the element at index U with wrapping:

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

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.

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.

JavaScript, 49 bytes

f=n=>--n?f(n,l='')+(n%2?`

<`+l:`

${l+='-'}>`):'>'

Try it online!

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 6, 39 bytes

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

Try it online!

Anonymous code block that returns a list of lines.

K (ngn/k), 31 29 bytes

{"<->"x#2,x{(1=*x)_1,2-|x}}

Try it online!

first we generate lists with 0 instead of "<", 1 instead of "-", and 2 instead of ">":

{ } function with argument x

x{...} apply the inner function x times, starting with an initial value of 0 and preserving intermediate results

|x reverse

2- replace 0 with 2 and vice versa, keep the 1s as they are

1, prepend a 1

(1=*x)_ is the first of x equal to 1? if yes, drop one element, otherwise drop 0 elements (do nothing)

2, prepend a 2 for the initial ">" arrow

x# we have a little too many lists, so take only the first x of them

"<->" use the lists' elements (0/1/2) as indices in this string

05AB1E, 23 20 bytes

FNÉD„><è'-N;∍«s_iR},

Try it online!

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

-3 from Kevin Cruijssen

ES6, 96 82 79 70 bytes

Try it online! (Thanks to @Oliver)

n=>[...Array(n)].map((_,i)=>(i%2?"<":"")+"-".repeat(i/2)+(i%2?"":">"))

Red, 109 108 bytes

-1 byte thanks to NK1406

func[n][repeat i n[print reduce[pick[pad/with pad/left/with]k: i% 2 + 1

pick copy"<>"k i / 2 + k - 1 #"-"]]]

Try it online!

C (gcc), 127 95 + 26 = 121 bytes

i,j;f(x){for(i=0;i<x;putchar(10),i+=2){for(j=0;E;printf(">n%c",x-i-1?60:9);for(j=0;x-i-1&&E;}}

Try it online!

Compile with -DE=j<i/2;++j)putchar(45)

-6 bytes from Logern

Yay mismatched parentheses!

Ungolfed:

void f(int x) {

	for (int i = 0; i < x; i += 2) {

		for (int j = 0; j < i/2; ++j) {

			printf("-");

		}

		printf(">n");

		if (x - i - 1) { // Test for last loop: only print <-- if x is even

			printf("<");

			for (int j = 0; j < i/2; ++j) {

				printf("-");

			}

		}

		else {

			printf("t"); // This is the 9 in the x-i-1?60:9

		}

		printf("n");

	}

}

			

Try it online!

Powershell, 51 bytes

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

Perl 5, 44 bytes

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

Try it online!