Wyzwanie polega na wydrukowaniu serii rosnących strzałek ASCII. Opiszę wzór w słowach, ale może być łatwiej spojrzeć na to, jak wygląda początek tej serii:

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

Strzała o długości n zawiera grot strzałki ( <lub >) i n-1myślniki ( -). Strzałka skierowana w prawo ma najpierw myślniki, a następnie >. Strzałka skierowana w lewo zaczyna się od <, a po niej następuje myślnik. Seria składa się z długości nstrzałki skierowanej w prawo, a następnie długości n strzałki skierowanej w lewo, od n od 1 do nieskończoności.

Aby ukończyć wyzwanie, napisz program lub funkcję, która pobiera jedno wejście, liczbę całkowitą i >= 1i wyprowadza pierwsze istrzałki. Strzały są indywidualne, a nie w parach prawy-lewy, dlatego i=3powinieneś wypisać:

>
<
->

Możesz zwrócić listę ciągów lub wydrukować je jeden po drugim. Podczas drukowania strzałki muszą być rozdzielane pewnym spójnym separatorem, który nie musi być znakiem nowej linii, jak w przykładzie.

To jest golf golfowy , więc wygrywa najmniej bajtów.

Płótno , 10 bajtów

⇵-×<ｎ¹［↔｝］

Wypróbuj tutaj!

R , 69 bajtów

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

Wypróbuj online!

• -5 bajtów dzięki @Giuseppe
• -3 bajty dzięki @Robert S.

Java (JDK) , 81 bajtów

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

Wypróbuj online!

Objaśnienia

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

Haskell, 41 40 bajtów

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

Wypróbuj online!

Zwykła stara rekurencja: zacznij od string p= ">", zbierz p, a <przed wszystkimi znakami oprócz ostatniego char pi rekurencyjne wywołanie z jednym -wstawionym przed p. Weź pierwsze nelementy z tej listy.

Edycja: -1 bajt dzięki @xnor.

Commodore BASIC V2 (C64), 94 bajty

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

Nie do końca pewny co do liczby bajtów, jest to oparte na reprezentacji tekstu do wpisania poprawnego programu. Na dysku jest nieco krótszy (91 bajtów), ponieważ BASIC V2 używa „tokenizowanej” reprezentacji programów.

Demo online

Nieznacznie „bez golfa”:

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

Samo-modyfikujący Brainfuck , 55 bajtów

Wprowadź dane jako kod znakowy.
Obsługuje tylko dane wejściowe do 255.
Do oddzielenia wierszy użyj znaku null.

Przypadkowo wszystkie znaki rysujące strzałki są używane jako polecenia BF. Niestety nie zapisuje żadnych bajtów (obecnie).

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

Wypróbuj online!

Wyjaśnienie

 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

Python 2 , 54 bajty

dzięki i Jo King za naprawienie błędu.

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

Wypróbuj online!

Pyth, 17 bajtów

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

Dane wyjściowe to lista ciągów znaków. Wypróbuj online tutaj .

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

PowerShell , 62 56 50 bajtów

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

Wypróbuj online!

Pętle od 0do wejścia $n, każda iteracja tworzy dwa ciągi strzałek. Są one następnie indeksowane, 0..--$naby wyciągnąć prawidłową liczbę elementów.

Zaoszczędzono 6 bajtów dzięki KGlasier.

Python 3, 53 bajty

Moja pierwsza odpowiedź codegolfa.

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

-10 bajtów dzięki Jo King

Haskell , 51 44 bajtów

^{-7 bajtów dzięki xnor (użycie iterateponad listy)!}

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

Wypróbuj online!

Wyjaśnienie / Niegolfowany

Użycie do-notacji pozwala nam zaoszczędzić a concat, a użycie notacji infiksowej pozwala na bezfunkcyjną funkcję z take, cofnięcie ich dałoby:

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

Japt -m, 16 15 13 12 bajtów

Zaoszczędził 1 bajt dzięki Kudłatemu

g<i>)iUUz ç-

Przetestuj online

Wyjaśnienie:

-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

Galaretka , 15 bajtów

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

Wypróbuj online!

MathGolf , 17 15 bajtów

Zaoszczędzono 2 bajty dzięki Jo King i Kevin Cruijssen

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

Wypróbuj online!

Wyjaśnienie

Podejście 15-bajtowe różni się od mojego oryginalnego rozwiązania, nie mogę przypisać sobie żadnego uznania za wdrożenie.

{                 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 bajtów

"<>"¬hUUz ç-)q

Wypróbuj online!

Zaktualizowany o całkowicie nową metodę.

Wyjaśnienie:

                  #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

C (gcc) , 80 77 76 74 71 bajtów

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

Wypróbuj online!

-3 bajty z pomysłem tylko z ASCII .

-1 z \0zamiast\n

-5 przestawianie części

Dane wyjściowe obejmują końcowe \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
}

JavaScript (ES6), 58 bajtów

Zwraca ciąg rozdzielony spacjami.

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

Wypróbuj online!

SNOBOL4 (CSNOBOL4) , 123 122 118 bajtów

	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	

Wypróbuj online!

V , 22 bajtów

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

Wypróbuj online!

Węgiel drzewny , 16 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Miałem trzy 17-bajtowe rozwiązania, zanim w końcu natknąłem się na to. Wyjaśnienie:

Ｎθ

Wejście n.

Ｆθ«

nCzasy powtórzeń , indeksowane 0.

⊘ι

Narysuj linię -s o długości połowy wskaźnika (obciętą).

↓>

Narysuj grot strzałki i przejdź do następnej linii.

‖Ｔ»

Odzwierciedlaj wszystko, obracając groty strzał.

Ｆθ‖Ｔ

Powyższa pętla ma nodbicia, ale potrzebujemy parzystej liczby odbić, więc wykonaj kolejne nodbicia.

Czysty , 76 73 bajtów

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

Wypróbuj online!

Korzysta ze zgrabnego faktu, który ['-','-'..]jest taki sam, jak ['--'..]trochę zaoszczędzić.

JavaScript, 49 bajtów

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

Wypróbuj online!

PowerShell, 51 bajtów

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

Kod maszynowy 6502 (C64), 49 bajtów

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

Nadal jest nieco krótszy niż BASIC ;) Ten ma zakres liczbowy tylko do tego, 255ponieważ naturalna liczba całkowita maszyny ma tylko 8 bitów.

Demo online

Zastosowanie: SYS49152,[n](np. SYS49152,3Na przykład z wyzwania)

Skomentowany demontaż :

         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 bajtów

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

Wypróbuj online!

Anonimowy blok kodu, który zwraca listę wierszy.

K (ngn / k) , 31 29 bajtów

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

Wypróbuj online!

najpierw generujemy listy z 0 zamiast "<", 1 zamiast "-"i 2 zamiast ">":

{ } funkcja z argumentem x

x{... }\0zastosuj xczasy funkcji wewnętrznych , zaczynając od wartości początkowej 0i zachowując wyniki pośrednie

|x rewers

2- zamień 0 na 2 i odwrotnie, zachowaj 1s takimi, jakie są

1, przygotuj 1

(1=*x)_jest pierwszy xrówny 1? jeśli tak, upuść jeden element, w przeciwnym razie upuść 0 elementów (nic nie rób)

2,wstaw 2 dla początkowej ">"strzałki

x#mamy trochę za dużo list, więc weź tylko pierwszą xz nich

"<->" użyj elementów list (0/1/2) jako wskaźników w tym ciągu

05AB1E , 23 20 bajtów

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

Wypróbuj online!

Po raz pierwszy skorzystaj z 05AB1E lub innego języka golfowego. Wszelkie pomysły są mile widziane.

-3 od Kevina Cruijssena

C # (.NET Core) , 90 bajtów

a=>{for(int i=0;i<a;i++){var s=new String('-',i/2);Console.WriteLine(i%2<1?s+">":"<"+s);}}

Wypróbuj online!

Używa delegata akcji, aby pobrać dane wejściowe i nie wymaga powrotu.

Nie golfowany:

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

ES6, 96 82 79 70 bajtów

Wypróbuj online!(Dzięki @Oliver)

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

Czerwony , 109 108 bajtów

-1 bajt dzięki 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 #"-"]]]

Wypróbuj online!