कुछ विस्तारित तीर खींचें

Question

यह चुनौती बढ़ते ASCII- कला तीरों की एक श्रृंखला को छापने के बारे में है। मैं शब्दों में पैटर्न का वर्णन करूँगा, लेकिन यह देखना आसान हो सकता है कि इस श्रृंखला की शुरुआत कैसी दिखती है:

>
<
->
<-
-->
<--
--->
<---
---->
<----
----->
<-----
------>
<------
...

लंबाई n वाले तीर में एक तीर ( <या >) और n-1डैश ( -) होते हैं। एक दाएँ-बाएँ वाले तीर में पहले डैश हैं, फिर a >। एक बायां-सामने वाला तीर शुरू होता है <, और उसके बाद डैश होता है। श्रृंखला में एक लंबाई nदायां-बायां तीर होता है, जिसके बाद 1 n से अनंत तक लंबाई n बायाँ-सामने तीर होता है।

चुनौती को पूरा करने के लिए, एक प्रोग्राम या फ़ंक्शन लिखें जो एक इनपुट, एक पूर्णांक लेता है i >= 1, और पहला iतीर आउटपुट करता है । तीर व्यक्तिगत हैं, न कि दाएं-बाएं जोड़े में, इसलिए i=3आपको आउटपुट देना चाहिए:

>
<
->

आप तार की सूची वापस कर सकते हैं, या उन्हें एक के बाद एक प्रिंट कर सकते हैं। यदि मुद्रण, तीर को कुछ निरंतर सीमांकक द्वारा सीमांकित किया जाना चाहिए, जो उदाहरण के रूप में एक नई रूपरेखा नहीं है।

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट जीतती है।

Comments

संबंधित ।

— AdmBorkBork

क्या हमारे पास प्रत्येक पंक्ति से पहले / बाद में रिक्त स्थान हो सकते हैं?

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रैगोयर हां, व्हाट्सएप को पीछे छोड़ना ठीक है।

— पावेल

और हेडिंग व्हाट्सएप?

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रेयर हाँ, यह ठीक है।

— पावेल

Answer 1

कैनवस , 10 बाइट्स

⇵-×<ｎ¹［↔｝］

यहाँ यह कोशिश करो!

Comments

मैं किसी भी कैनवस को नहीं जानता, लेकिन क्या वह एक तीर-ड्राइंग बिलिन है जिसे मैं देख रहा हूं? ↔थोड़े ऐसा लगता है!

— पावेल

↔"रिवर्स ><

— हॉरिज़ॉन्टली

Answer 2

आर , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

• -5 बाइट्स @Giuseppe के लिए धन्यवाद
• -3 बाइट्स @Robert एस के लिए धन्यवाद।

Comments

strrepकरने के लिए अपने दूसरे तर्क coerces integerतो आप उपयोग कर सकते हैं /के स्थान पर%/%

— ग्यूसेप

आप इसके बजाय aपूरी तरह से अनुक्रमित करके पूरी तरह से छुटकारा पा सकते हैं 0...(n-1): इसे ऑनलाइन आज़माएं!

— ग्यूसेप

मैं एक बेवकूफ हूँ ... धन्यवाद! : D

— digEmAll

@Giuseppe: मैंने भी केवल रॉबर्ट एस के हटाए गए प्रश्न पर ध्यान दिया है। मैं स्ट्रेप के बजाय प्रतिनिधि का उपयोग कर सकता हूं और 3 बाइट्स बचा सकता हूं ... (

— फेसपालम

Answer 3

जावा (JDK) , 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण

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

Comments

System.out

— candied_orange

@candied_orange यह स्व-निहित नहीं है।

— ओलिवियर ग्रेजायर

इस तरह से कैसे किया ?

— कैंडिड_ऑरेंज

@candied_orange यह समान है: आयात गणना में आवश्यक हैं।

— ओलिवियर ग्रेजायर

क्यों नहीं import java.util.function.*;गिनता?

— कैंडिड_ऑरेंज

Answer 4

हास्केल, 41 40 बाइट्स

(`take`g">")
g p=p:('<':init p):g('-':p)

इसे ऑनलाइन आज़माएं!

सादे पुराने प्रत्यावर्तन: स्ट्रिंग के साथ शुरू p= ">", कलेक्ट p, एक <लेकिन सभी के सामने के अंतिम चार में pऔर एक के साथ एक पुनरावर्ती कॉल -के सामने डाल p। nइस सूची के पहले आइटम को लें ।

संपादित करें: -1 बाइट @xnor के लिए धन्यवाद।

Comments

एक बाइट को बचाने के लिए एक अजीब बदलाव ।

— xnor

Answer 5

कमोडोर बेसिक V2 (C64), 94 बाइट्स

0inputn:fOi=1ton:oniaN1gO1:?"<";
1on-(i<3)gO2:fOj=1.5toi/2:?"-";:nE
2on-nOiaN1gO3:?">";
3?:nE

बाइट गिनती के बारे में पूरी तरह से निश्चित नहीं है, यह मान्य कार्यक्रम टाइप करने के लिए पाठ प्रतिनिधित्व पर आधारित है। यह डिस्क (91 बाइट्स) पर थोड़ा छोटा है क्योंकि BASIC V2 कार्यक्रमों के "टोकन" प्रतिनिधित्व का उपयोग करता है।

ऑनलाइन डेमो

थोड़ा "अधूरा":

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 6

सेल्फ-मॉडिफाइंग ब्रेनफक , 55 बाइट्स

चरित्र कोड के रूप में इनपुट लें।
केवल 255 तक इनपुट का समर्थन
करें। अलग लाइनों के लिए अशक्त वर्ण का उपयोग करें।

संयोगवश, सभी तीर-रेखा वाले वर्णों को BF कमांड के रूप में उपयोग किया जाता है। दुर्भाग्य से, यह किसी भी बाइट (वर्तमान में) को नहीं बचाता है।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

 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 7

पायथन 2 , 54 बाइट्स

बग को ठीक करने के लिए और जो किंग का धन्यवाद।

k=0
exec"print k%2*'<'+k/2*'-'+~k%2*'>';k+=1;"*input()

इसे ऑनलाइन आज़माएं!

Comments

आपके बाणों में बहुत सारे डैश हैं; केवल हर दूसरे को डेश द्वारा लंबा करना चाहिए।

— xnor

54 बाइट्स

— टीएसटी

Answer 8

पायथ, 17 बाइट्स

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

आउटपुट स्ट्रिंग्स की एक सूची है। इसे यहाँ ऑनलाइन आज़माएँ ।

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 9

पॉवरशेल , 62 56 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

0ऊपर से इनपुट तक लूप्स $n, प्रत्येक एरोशन दो एरो स्ट्रिंग्स बनाते हैं। तत्पश्चात 0..--$nतत्वों की सही संख्या निकालने के लिए उन्हें अनुक्रमित किया जाता है।

केजलसियर को 6 बाइट्स दिए गए।

Comments

अपने स्वयं के समाधान के साथ मेसिंग करते हुए मुझे आप पर कुछ बाइट्स काटने का एक तरीका मिला: कोष्ठक में लूप लपेटकर और सीधे अनुक्रमण करके 4 बाइट्स बचा सकता है। यानी param($n)(0..$n|%{($j='-'*$_++)+'>';"<$j"})[0..--$n]। इसलिए अब आपको $xदो बार लिखने की जरूरत नहीं है ।

— केजलसियर

इसके अलावा, आप का उपयोग नहीं कर से दो और बाइट्स बचा सकता है ++में ($j='-'*$_++)आप का उपयोग नहीं करते के रूप में $_कहीं और।

— केजलसियर

@Klasier भयानक - स्पष्ट गोल्फ के लिए धन्यवाद! :)

— AdmBorkBork

Answer 10

पायथन 3, 53 बाइट्स

मेरा पहला कोडगोल्फ जवाब।

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

-10 बाइट्स जो किंग को धन्यवाद

Answer 11

हास्केल , 51 44 बाइट्स

^{X7 के लिए -7 बाइट्स धन्यवाद ( iterateसूची-समझ से अधिक का उपयोग करके )!}

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण / अनलॉक्ड

का उपयोग करते हुए do-इनोटेशन हमें बचाता है concat, और इनफ़िक्स-नोटेशन का उपयोग करने के साथ एक पॉइंटफ्री फ़ंक्शन की अनुमति देता है, इनको takeदेने से:

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

Answer 12

जाप -m, 16 15 13 12 बाइट्स

झबरा के लिए धन्यवाद 1 बाइट बचाया

g<i>)iUUz ç-

इसे ऑनलाइन टेस्ट करें

स्पष्टीकरण:

-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

Comments

12 बाइट्स

— झबरा

@ शगुन हा! बहुत चालाक, धन्यवाद!

— ओलिवर

Answer 13

जेली , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

टाई का उपयोग करके 1 बाइट: TIO ।

— हाइपरनेत्रिनो

Answer 14

मैथॉल्फ , 17 15 बाइट्स

जो किंग और केविन क्रूज़सेन के लिए धन्यवाद 2 बाइट्स बचाए

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

इसे ऑनलाइन आज़माएं!

व्याख्या

मेरे मूल समाधान की तुलना में 15-बाइट दृष्टिकोण अलग है, मैं कार्यान्वयन के लिए कोई क्रेडिट नहीं ले सकता।

{                 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

Comments

if/elseMathGolf में कैसे काम करता है ? मुझे पता है कि कैसे-के बिना-और-और-बिना-अगर बयान काम करते हैं, लेकिन मैथॉल्फ में एक {...} और {...} कैसे बनाएं ¿? (हो सकता है कि मैं इसे यहाँ के बजाय चैट में पोस्ट करूँ .. लेकिन मेरे पास शायद 1 बाइट की बचत हो सकती है अगर मैं

— इफ़-इफ़

@ केविनक्रूजसेन मुझे लगता है कि यह अगले दो कमांड / ब्लॉक के साथ काम करता है। उदाहरण ¿121 को धक्का देगा यदि सही है, 2 और, ¿Å3*Å1+एक जोड़ देगा यदि सही और अगले तत्व को ट्रिपल करता है

— जो राजा

@ केविनक्रूजसेन अगर / और कोड से दो ऑपरेटरों या ब्लॉक को पॉप करता है। जो किंग उनके उदाहरण में सही है, लेकिन आप भी कर सकते हैं ¿{"foo"}{"bar"}या कर सकते हैं ¿1{2}।

— अधिकतम

@JoKing मैं स्लिपिंग ऑपरेटरों के लिए डॉक्स को ठीक करने के लिए एक TODO जोड़ूंगा।

— अधिकतम

@ केविनक्रूजसेन के समाधान का उपयोग करते हुए 15 बाइट्स

— जो किंग

Answer 15

जाप -m , 14 बाइट्स

"<>"¬hUUz ç-)q

इसे ऑनलाइन आज़माएं!

पूरी तरह से नई विधि के साथ अद्यतन किया गया।

स्पष्टीकरण:

                  #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

Comments

çऑटो अपने पहले पैरामीटर को एक स्ट्रिंग में डाल देता है, जिससे आप ड्रॉप कर सकते हैं '।

— ओलिवर

uइंडेक्स रैपिंग के लिए आपको विधि की आवश्यकता नहीं है इसलिए यह 14 बाइट्स हो सकता है।

— झबरा

Answer 16

सी (जीसीसी) , 80 77 76 74 71 बाइट्स

g(n,i,j){--n&&g(n);for(j=n%2,i=n/=2;putchar(~n?n---i*j?45:62-j*2:0););}

इसे ऑनलाइन आज़माएं!

केवल ASCII से विचार के साथ -3 बाइट्स ।

के \0बजाय -1 के साथ\n

-5 पुर्ज़े के पुर्जे

---

आउटपुट में एक अनुगामी शामिल है \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
}

Comments

यह स्पष्ट हो सकता है idk

— ASCII- केवल

इतना करीब: /

— एएससीआईआई-केवल

@ ASCII- केवल हाँ, यह स्पष्ट होना चाहिए, भले ही यह bytecount के लिए कोई फर्क नहीं पड़ता हो। उस दूसरे बिंदु के लिए .. विचार के लिए धन्यवाद! उस के साथ 78 से नीचे ट्रिम करने के लिए प्रबंधित।

— attinat

दुःख की बात है कि टर्नरीज़ के संयोजन से मदद नहीं मिलती

— ASCII-only

XD आपके पास अभी भी !n--पहले कोडब्लॉक में है

— ASCII-only

Answer 17

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!

Answer 18

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!

Answer 19

V, 22 bytes

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

Try it online!

Comments

This looks like some weird scandinavian language

— Pavel

Answer 20

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.

Answer 21

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.

Answer 22

JavaScript, 49 bytes

f=n=>--n?f(n,l='')+(n%2?`
<`+l:`
${l+='-'}>`):'>'

Try it online!

Comments

Wow, pretty cool

— Limbo

...but it throws on 10000, meanwhile my ES6 solution is still works :D Anyway, your solution is very cool)

— Limbo

Answer 23

Powershell, 51 bytes

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

Answer 24

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

Answer 25

Perl 6, 39 bytes

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

Try it online!

Anonymous code block that returns a list of lines.

Answer 26

K (ngn/k), 31 29 bytes

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

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

Comments

I would like to ask for an explanation (I haven't started learning K yet, I don't know which version to start with...)

— Galen Ivanov

@GalenIvanov i tried to write an explanation, i hope it makes sense. thanks for your interest in my favourite language :) there are multiple implementations with different advantages and disadvantages (kx's original, kona, oK and i'm working on my own). would you like to join the apl chat room so i can give you more details?

— ngn

Thank you, I'm already there

— Galen Ivanov

Answer 27

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

Comments

Welcome to the world of 05AB1E, and nice first answer. +1 from me. :) "><" can be „>< to save a byte. There are builtins for 1, 2, and 3 char strings, being ', „, and … respectively. Here is a 18 bytes alternative I came up with, but perhaps it could be golfed a bit more. If you haven't seen it yet, we have a tips for golfing in 05AB1E page, and also feel free to ask anything in the chat.

— Kevin Cruijssen

@KevinCruijssen Thanks so much for your ideas. I don't feel right just using your code, as it feels fairly different from mine, but I did use the idea of modulo 2 as checking for if a number is odd. I also use the two char string idea. I would not mind at all if you posted the 18 byte version on your own.

— nedla2004

I've posted my answer in that case. :)

— Kevin Cruijssen

Answer 28

C# (.NET Core), 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!

Uses an Action delegate 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
    }
}

Comments

89 bytes

— Embodiment of Ignorance

@EmbodimentofIgnorance Doesn't work, missing the first ">" output string.

— Meerkat

How about this instead?

— Embodiment of Ignorance

Answer 29

ES6, 96 82 79 70 bytes

Try it online! (Thanks to @Oliver)

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

Comments

Welcome to PPCG! By default, taking input as a variable is disallowed; you have to either make it a function (just stick a i=> in front of your code!) or from a command-line argument or STDIN or something.

— HyperNeutrino

@HyperNeutrino okay, edited answer. However, the most voted answer contains only the body of the function, but ok. Anyway I'm outsider)

— Limbo

Can you link it? I don't think any of them are invalid, at least not the top few.

— HyperNeutrino

A few more bytes: Try it online

— Oliver

A few more bytes if you re-arrange that last ternary operator and remove the center parenthesis: Try it online

— Oliver

Answer 30

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!

Comments

-1 for removing a space

— NK1406

@NK1406 Thank you! I didn't know this is valid.

— Galen Ivanov