Esse desafio consiste em imprimir uma série de setas crescentes da arte ASCII. Descreverei o padrão em palavras, mas pode ser mais fácil ver como é o início desta série:

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

Uma seta com comprimento n contém uma ponta de seta ( <ou >) e n-1traços ( -). Uma seta voltada para a direita tem os traços primeiro, depois a >. Uma seta voltada para a esquerda começa com <e é seguida pelos traços. A série consiste em uma nseta voltada para a direita, seguida de uma seta voltada para a esquerda, com n de 1 ao infinito.

Para concluir o desafio, escreva um programa ou função que use uma entrada, um número inteiro i >= 1e solte as primeiras isetas. As setas são individuais, não em pares direita-esquerda, portanto, i=3você deve gerar:

>
<
->

Você pode retornar uma lista de cadeias ou imprimi-las uma após a outra. Se estiver imprimindo, as setas devem ser delimitadas por algum delimitador consistente, que não precisa ser uma nova linha, como no exemplo.

Isso é código-golfe , e o menor número de bytes vence.

Tela , 10 bytes

⇵-×<ｎ¹［↔｝］

Experimente aqui!

R , 69 bytes

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

Experimente online!

• -5 bytes graças a @Giuseppe
• -3 bytes graças a @Robert S.

Java (JDK) , 81 bytes

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

Experimente online!

Explicações

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 bytes

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

Experimente online!

Recursão antiga simples: comece com string p= ">", colete p, a <na frente de todos, exceto o último caractere de pe uma chamada recursiva com uma -colocada na frente dep . Pegue os primeiros nitens desta lista.

Edit: -1 byte graças a @xnor.

Comodoro BASIC V2 (C64), 94 bytes

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

Não totalmente certo sobre a contagem de bytes, isso se baseia na representação de texto para digitar o programa válido. É um pouco menor no disco (91 bytes) porque o BASIC V2 usa uma representação de programas "tokenizada".

Demo Online

Ligeiramente "não-destruído":

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

Brainfuck auto-modificável , 55 bytes

Tome entrada como código de caractere.
Somente suporta entrada de até 255.
Use caracteres nulos para separar linhas.

Coincidentemente, todos os caracteres de desenho de seta são usados ​​como comandos BF. Infelizmente, ele não salva nenhum bytes (atualmente).

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

Experimente online!

Explicação

 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 bytes

obrigado ao e Jo King por corrigir um erro.

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

Experimente online!

Pitão, 17 bytes

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

Saída é uma lista de strings. Experimente online aqui .

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 bytes

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

Experimente online!

Loops de 0até entrada $n, cada iteração criando duas seqüências de setas. Esses são indexados com 0..--$npara extrair o número correto de elementos.

Economizou 6 bytes graças ao KGlasier.

Python 3, 53 bytes

Minha primeira resposta codegolf.

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

-10 bytes graças a Jo King

Haskell , 51 44 bytes

^{-7 bytes graças ao xnor (usando iteratemais de lista de compreensão)!}

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

Experimente online!

Explicação / Ungolfed

O uso de do-notation nos salva a concat, e o uso de infix-notation permite uma função sem ponto take, desfazendo isso daria:

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

Japt -m, 16 15 13 12 bytes

Guardado 1 byte graças a Shaggy

g<i>)iUUz ç-

Teste on-line

Explicação:

-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

Gelatina , 15 bytes

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

Experimente online!

MathGolf , 17 15 bytes

Economizou 2 bytes graças a Jo King e Kevin Cruijssen

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

Experimente online!

Explicação

A abordagem de 15 bytes é diferente em comparação com a minha solução original, não posso levar nenhum crédito pela implementação.

{                 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

Japonês -m , 14 bytes

"<>"¬hUUz ç-)q

Experimente online!

Atualizado com um método completamente novo.

Explicação:

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

Experimente online!

-3 bytes com ideia somente de ASCII .

-1 com em \0vez de\n

-5 peças reorganizando

A saída inclui um final \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 bytes

Retorna uma string separada por espaço.

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

Experimente 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	

Experimente online!

V , 22 bytes

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

Experimente online!

Carvão , 16 bytes

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

Experimente online! Link é a versão detalhada do código. Eu tinha três soluções de 17 bytes antes de me deparar com essa. Explicação:

Ｎθ

Entrada n.

Ｆθ«

nTempos de repetição , indexados em 0.

⊘ι

Desenhe uma linha de -s de comprimento com metade do índice (truncado).

↓>

Desenhe a ponta da seta e vá para a próxima linha.

‖Ｔ»

Reflita tudo, lançando as pontas das setas.

Ｆθ‖Ｔ

O loop acima tem nreflexões, mas precisamos de um número par de reflexões; portanto, faça outras nreflexões.

Limpo , 76 73 bytes

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

Experimente online!

Usa o fato puro que ['-','-'..]é o mesmo que ['--'..]economizar um pouco.

JavaScript, 49 bytes

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

Experimente online!

Powershell, 51 bytes

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

Código da máquina 6502 (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

Ainda um pouco menor que o BASIC ;) Esse número tem um intervalo apenas até 255porque o tamanho inteiro natural da máquina possui apenas 8 bits.

Demonstração online

Uso: SYS49152,[n](por exemplo, SYS49152,3para o exemplo do desafio)

Desmontagem comentada :

         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},^$_}

Experimente online!

Bloco de código anônimo que retorna uma lista de linhas.

K (ngn / k) , 31 29 bytes

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

Experimente online!

primeiro, geramos listas com 0 em vez de "<", 1 em vez de "-"e 2 em vez de ">":

{ } função com argumento x

x{... }\0aplique os xtempos da função interna , começando com um valor inicial de0 e preservando resultados intermediários

|x marcha ré

2- substitua 0 por 2 e vice-versa, mantenha os 1s como estão

1, anexar um 1

(1=*x)_é o primeiro xigual a 1? se sim, solte um elemento, caso contrário, solte 0 elementos (não faça nada)

2,coloque um 2 na ">"seta inicial

x#temos um pouco demais listas, de modo a ter apenas o primeiro xdeles

"<->" use os elementos das listas (0/1/2) como índices nessa sequência

05AB1E , 23 20 bytes

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

Experimente online!

Primeira vez usando 05AB1E ou qualquer outro idioma de golfe para esse assunto. Todas as idéias são bem-vindas.

-3 de Kevin Cruijssen

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

Experimente online!

Usa um delegado de Ação para receber a entrada e não exigir um retorno.

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

ES6, 96 82 79 70 bytes

Experimente online! (Graças a @Oliver)

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

Vermelho , 109 108 bytes

-1 byte graças a 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 #"-"]]]

Experimente online!