[Question]
  [
This challenge is about printing a series of growing ASCII-art arrows. I'll describe the pattern in words, but it might be easier to look at what the start of this series looks like:
```
>
<
->
<-
-->
<--
--->
<---
---->
<----
----->
<-----
------>
<------
...
```
An arrow with length n contains an arrowhead (`<` or `>`) and `n-1` dashes (`-`). A right-facing arrow has the dashes first, then a `>`. A left-facing arrow starts with `<`, and is followed by the dashes. The series consists of a length `n` right-facing arrow followed by a length n left-facing arrow, with n from 1 to infinity.
To complete the challenge, write a program or function that takes one input, an integer `i >= 1`, and outputs the first `i` arrows. Arrows are individual, not in right-left pairs, so for `i=3` you should output:
```
>
<
->
```
You can return a list of strings, or print them one after the other. If printing, the arrows must be delimited by some consistent delimiter, which doesn't have to be a newline as in the example.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins.
  
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 10 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
⇵-×<ｎ¹［↔｝］
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyMUY1LSVENyUzQyV1RkY0RSVCOSV1RkYzQiV1MjE5NCV1RkY1RCV1RkYzRA__,i=MTA_,v=8)
[Answer]
# [R](https://www.r-project.org/), 69 bytes
```
for(i in 1:scan()-1)cat('<'[i%%2],rep('-',i/2),'>'[!i%%2],'
',sep='')
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPwdCqODkxT0NT11AzObFEQ91GPTpTVdUoVqcotUBDXVddJ1PfSFNH3U49WhEirs6lrlOcWmCrrq7539D4PwA "R – Try It Online")
* -5 bytes thanks to @Giuseppe
* -3 bytes thanks to @Robert S.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 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!](https://tio.run/##bY7BTsMwDIbvfQqrUqWW0sB2XLrtsBMHTjsiDiFLJpfWqRJnEpr67CWrYAfEwf5l//Znd@qimu70OeMwOs/QpVpExl7YSJrRkXiQme5VCPCqkOCaAYzxo0cNgRUnuTg8wZC88sge6fz2DsqfQ7WMArwQHxyFOBgPdjtTs7ta50skBtw@S2xJVsevwGYQLrIYE4JticW6Xe3ztggF5Zu8CLukj3mTC29Go7jEun5aV5WcZrmcuTMhQVNuYXXTuv79A@DvlZ5KhBoSvpI/I1Yorc2Y8PfWP1vJW8wpu8U0fwM "Java (JDK) – 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
  );                  // 
}                     //
```
[Answer]
## Haskell, ~~41~~ 40 bytes
```
(`take`g">")
g p=p:('<':init p):g('-':p)
```
[Try it online!](https://tio.run/##BcFBCoAgEADAe69YJFAPnoMle0mHRNQWTZb0/W0zdxg1tSbZn2KuGWq6ijqUXQqwZzR610idJrDFYrTTyFaeQB088Et9wgoZNvlibqEMcZH5Bw "Haskell – 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.
[Answer]
# [Commodore BASIC V2](https://de.wikipedia.org/wiki/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](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22arrows.prg%22:%22data:;base64,AQgcCAAAhU46gUmyMaROOpFJrzGJMTqZIjwiOwA9CAEAkasoSbMzKYkyOoFKsjEuNaRJrTI6mSItIjs6ggBQCAIAkauoSa8xiTM6mSI+IjsAWAgDAJk6ggAAAA==%22%7D,%22vice%22:%7B%22-autostart%22:%22arrows.prg%22%7D%7D)
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
```
[Answer]
# [Self-modifying Brainfuck](https://soulsphere.org/hacks/smbf/), 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!](https://tio.run/##LY7NCoMwEITveYpFLFFs4g/0tuyLaA4xKvZQI5qD0PbZ01V6mZ2dgY/p7T5HN29Z/hbr9lzCBEl3pNnf36rmgLTOE/EVzgZABDn6ScIH5tEOoJyqgcD5YYxE9xaxVaiJCjR4Xl0QKU7x@oi4LU5nNCk0ZJBUZJ7gBfBgaOnXUO6vfrrk4nIaNpBdJVkWGX8 "Bash – 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
```
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##K6gsycjPM/r/P9vWgCu1IjVZqaAoM69EIVvVSEvdRl07Wx9I66pr14EF7NSts7VtDa2VtDLzCkpLNDT//7cEAA "Python 2 – Try It Online")
[Answer]
# Pyth, 17 bytes
```
m_W%d2+*\-/d2@"><
```
Output is a list of strings. Try it online [here](https://pyth.herokuapp.com/?code=m_W%25d2%2B%2A%5C-%2Fd2%40%22%3E%3C&input=8&debug=0).
```
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
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~62~~ ~~56~~ 50 bytes
```
param($n)(0..$n|%{($j='-'*$_)+'>';"<$j"})[0..--$n]
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVPU8NAT08lr0a1WkMly1ZdV11LJV5TW91O3VrJRiVLqVYzGiivq6uSF/v//39TAA "PowerShell – 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.*
[Answer]
# 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
[Answer]
# [Haskell](https://www.haskell.org/), ~~51~~ 44 bytes
-7 bytes thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor) (using `iterate` over list-comprehension)!
```
(`take`do b<-iterate('-':)"";[b++">",'<':b])
```
[Try it online!](https://tio.run/##DcuxDoIwEADQX7l0KQRLdMXi4qoTo5pwhSsQSmna8/etLG97M6aVnMsWWnjnomdcqR93MFotTBGZCqlkUwpxfZmqEjdxklo25lPmDRd/rA3DE8KXO44PDzVYOIiEI7Raw0R83z2T55Qv599gHU4pqyGEPw "Haskell – 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 ('-':) "" ]
```
[Answer]
# Japt `-m`, ~~16~~ ~~15~~ ~~13~~ 12 bytes
*Saved 1 byte thanks to [Shaggy](https://codegolf.stackexchange.com/users/58974/shaggy)*
```
g<i>)iUUz ç-
```
[Test it online](https://ethproductions.github.io/japt/?v=1.4.6&code=ZzxpPilpVVV6IOct&input=MTAKCi1tUg==)
## Explanation:
```
-m            // Map the program through [0...Input); U becomes the iterative number
g<i>)iUUz ç-  
 <i>          // ">" prepended with "<", creating "><"
g             //   Get the char at index U, with index-wrapping
    i         // Insert:
     U        //   At index U, with index-wrapping
         ç-   //   "-" repeated:
      Uz      //     U/2 times
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
ị⁾><;’H”-ẋƲṚ⁸¡)
```
[Try it online!](https://tio.run/##ATYAyf9qZWxsef//4buL4oG@Pjw74oCZSOKAnS3huovGsuG5muKBuMKhKf/Dhysv4oKsxZLhuZj//zM "Jelly – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~17~~ 15 bytes
Saved 2 bytes thanks to Jo King and Kevin Cruijssen
```
{ï½'-*'>ï¥╛Å⌡\n
```
[Try it online!](https://tio.run/##y00syUjPz0n7/7/68PpDe9V1tdTtgIylj6bOPtz6qGdhTN7//4amAA "MathGolf – 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
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-m`, 14 bytes
```
"<>"¬hUUz ç-)q
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=Ijw+IqxoVVV6IOctKXE=&input=MTAKLVJt)
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
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~80~~ ~~77~~ ~~76~~ ~~74~~ 71 bytes
```
g(n,i,j){--n&&g(n);for(j=n%2,i=n/=2;putchar(~n?n---i*j?45:62-j*2:0););}
```
[Try it online!](https://tio.run/##DcfBCsIwDADQ@77CiyMpDbowPSyUfksp2LWwKENPo/569N1eppKzWQH11Tc8iHQc/0N5PHdoQc/sa9BLYHl93nlNO3w1KhFV1@J8W@5MzfFyRUHptqWqgKdjKMATytDtBw "C (gcc) – Try It Online")
-3 bytes with idea from [ASCII-only](https://codegolf.stackexchange.com/questions/177454/draw-some-expanding-arrows/177688?noredirect=1#comment430683_177688).
-1 with `\0` instead of `\n`
-5 rearranging parts
---
Output includes a trailing `\0`.
```
g(n,i,j){
    --n&&g(n);              //draw smaller arrows first (if n>1)
    for(j=n%2,i=n/=2;       //j:!(input parity); i:arrow len-1=ceil(input)/2-1
        putchar(~n          //if n>=0, arrow is not yet completed
                ? n---i*j   //if not first (j==1) or last (j==0) char of arrow:
                  ? 45      // output '-'
                  : 62-j*2  // otherwise, output the appropriate arrow head
                : 0););     //\0 after arrow complete. putchar returns 0; loop terminates
}
```
[Answer]
# 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!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/P1k4j3bbA1i5PV9c@W1tbzdA@wUaluqBWIUE7XaNAW11XXdMKSNkpqIP4mlbq6poa2bZA8n9yfl5xfk6qXk5@ukaahqmmJheqiKGBpuZ/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/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!](https://tio.run/##TcqxCsIwEAbg@e4p/u0STJGKLmKcWkigxIgJXFZnsYPvT7Sb3/x93utzfR17pwQfU64FA0bOFOAVexyYGvxU82JkEBcs062Wrfn5boLTXw8WDXIVOj9M/AtyETSOpPBLMeqShWKHcXvZ8pwm6v30BQ "SNOBOL4 (CSNOBOL4) – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), 22 bytes
```
i>
<Àñäkjjé-já-ñÀGjdG
```
[Try it online!](https://tio.run/##K/v/P9OOy0b6cMPhjYeXZGdlHV6pm3V4oS6Q1@CeleL@//9/YwA "V – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
ＮθＦθ«⊘ι↓>‖Ｔ»Ｆθ‖Ｔ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05orLb9IAchQqObiDCjKzCvR8EjMKUtN0cjUBEpChaxc8svzdBSU7JRAYkGpaTmpySUhRYl5xUDduRpAwVq4OVhk//83/69blgMA "Charcoal – 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.
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), ~~76~~ 73 bytes
```
import StdEnv,StdLib
$n=take n[s\\i<-inits['--'..],s<-[i++['>'],['<':i]]]
```
[Try it online!](https://tio.run/##JY2xDoIwFEV3v@INJNVACa6mOOlgwsZYOpRSzQvtw9hq4s/7JGG6OWc41wVvieMyvYOHaJEY43N5ZejzdKVPtU6H466gNtvZA@k0DKgkEuakhZSirk2VlNRYllqcham0UOKExhjus11DLdyDzQHJJ9hDAcemgQP/3GofieWt48uXbES3wXbIcvwD "Clean – Try It Online")
Uses the neat fact that `['-','-'..]` is the same as `['--'..]` to save a bit.
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (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](https://codegolf.stackexchange.com/a/177468/71420) ;) This one has a number range only up to `255` because the natural integer size of the machine has only 8 bits.
### [Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22arrows.prg%22:%22data:;base64,AMAgm7eiAIpKqJAFqTwg0v+pLcAA8AYg0v+I0PqKSrAFqT4g0v+pDSDS/+jkZdDXYA==%22%7D,%22vice%22:%7B%22-autostart%22:%22arrows.prg%22%7D%7D)
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
```
[Answer]
# JavaScript, 49 bytes
```
f=n=>--n?f(n,l='')+(n%2?`
<`+l:`
${l+='-'}>`):'>'
```
[Try it online!](https://tio.run/##VchBDsIgEADAO@/Q7G4oRuuNCHwFgmDabBYjphfj2@lVjzNr2lLPr@X5NtLuZYzqxHljJFSUiR0AaZTjHKK6Rc02qsOHtQMDXx/JgoeRm/TG5cTtgRWvROp3/lXxciYaOw "JavaScript (Node.js) – Try It Online")
[Answer]
# Powershell, 51 bytes
```
param($n)0..$n|%{'-'*$_+'>';'<'+'-'*$_}|?{$n---gt0}
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 39 bytes
```
{map {'<'x$_%2~'-'x$_/2~'>'x$_%%2},^$_}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwvzo3sUChWt1GvUIlXtWoTl0XxNAHMuzAIqpGtTpxKvG1/9M0jDXt7PSKEyutudI0jAygnP8A "Perl 6 – Try It Online")
Anonymous code block that returns a list of lines.
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~31~~ 29 bytes
```
{"<->"x#2,x{(1=*x)_1,2-|x}\0}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlrJRtdOqULZSKeiWsPQVqtCM95Qx0i3pqI2xqD2f5qCocl/AA "K (ngn/k) – Try It Online")
first we generate lists with 0 instead of `"<"`, 1 instead of `"-"`, and 2 instead of `">"`:
`{` `}` function with argument `x`
`x{`...`}\0` 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
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~23~~ 20 bytes
```
FNÉD„><è'-N;∍«s_iR},
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fze9wp8ujhnl2NodXqOv6WT/q6D20ujg@M6hW5/9/QwOD/wA "05AB1E – Try It Online")
First time using 05AB1E or any other golfing language for that matter. Any ideas welcome.
-3 from Kevin Cruijssen
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 90 bytes
```
a=>{for(int i=0;i<a;i++){var s=new String('-',i/2);Console.WriteLine(i%2<1?s+">":"<"+s);}}
```
[Try it online!](https://tio.run/##Nc29CsIwFEDh2T7FpSBNqPWnbqatFCdBFxWcQ0zlgiaQe61I8dlrEbqe4TuGMuOD7V@E7g7nD7F9KjAPTQQ1dBGxZjRQG0bvCnRcQQNlr8uqa3wQQwAslwoLrTBNZdfqAFQ6@4Yzh4EUSZbMcJFLtfOO/MPOrwHZHtBZgdO8WG0pjat4ExdxSlJ9v70an63HGxw1OiG7aNKIAWht4PnF7x2vczGCJ6tvf09KqaJBWC1/ "C# (.NET Core) – Try It Online")
Uses an [Action delegate](http://docs.microsoft.com/en-us/dotnet/api/system.action-1) to pull in the input and not require a return.
Ungolfed:
```
a => {
    for(int i = 0; i < a; i++)          // from [0, a)
    {
        var s = new String('-', i / 2);     // create string of dashes of length (a / 2)
        Console.WriteLine(i % 2 < 1 ?       // write arrow
                                s + ">" :       // if i is even: dashes plus ">"
                                "<" + s);       // if i is odd: "<" plus dashes
    }
}
```
[Answer]
# ES6, ~~96~~ ~~82~~ ~~79~~ 70 bytes
[Try it online!](https://tio.run/##JclRCsIwDADQf48REBLmou5TbMVzjOHC7CRjS0s3BE9fBd/vm@Qt65A1bbXFZyijK@Z8y8z3nOWDRh0vkhAfByXnUffNDa5wAaAKauAcUpAN9dhQ9c/feSAqQ7Q1zoHn@MIRzyfiKar1u57KFw "JavaScript (Node.js) – Try It Online") (Thanks to @Oliver)
```
n=>[...Array(n)].map((_,i)=>(i%2?"<":"")+"-".repeat(i/2)+(i%2?"":">"))
```
[Answer]
# [Red](http://www.red-lang.org), 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!](https://tio.run/##JYxBCsIwEEX3OcVnxJWUEl0IRTxEt8MsSjLBEIkhpIinj7bu3ud9XlXfZ/UsJkw9rNlxFq5adGmIyFxqzA1V/eqUS3SJy@LHd2wPbPDU0PYlaUI84owTrNl@cK/yodud0q8z7iJhgMWBBhKRHnAx/zqRCbDX/gU "Red – Try It Online")
]