Este desafío consiste en imprimir una serie de flechas de arte ASCII en crecimiento. Describiré el patrón en palabras, pero podría ser más fácil ver cómo se ve el comienzo de esta serie:

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

Una flecha con longitud n contiene una punta de flecha ( <o >) y n-1guiones ( -). Una flecha hacia la derecha tiene los guiones primero, luego a >. Una flecha hacia la izquierda comienza con <, y es seguida por los guiones. La serie consiste en una longitud nde flecha hacia la derecha seguida de una longitud n flecha hacia la izquierda, con n de 1 a infinito.

Para completar el desafío, escriba un programa o función que tome una entrada, un número entero i >= 1y genere las primeras iflechas. Las flechas son individuales, no en pares derecha-izquierda, por lo i=3que debe generar:

>
<
->

Puede devolver una lista de cadenas o imprimirlas una tras otra. Si imprime, las flechas deben estar delimitadas por algún delimitador consistente, que no tiene que ser una nueva línea como en el ejemplo.

Este es el código de golf , por lo que gana menos bytes.

Lienzo , 10 bytes.

⇵-×<ｎ¹［↔｝］

Pruébalo aquí!

R , 69 bytes

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

Pruébalo en línea!

• -5 bytes gracias a @Giuseppe
• -3 bytes gracias 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));}

Pruébalo en línea!

Explicaciones

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)

Pruébalo en línea!

Recurrencia simple: comience con string p= ">", collect p, un <delante de todos menos el último carácter de py una llamada recursiva con un -puesto delante p. Tome los primeros nelementos de esta lista.

Editar: -1 byte gracias a @xnor.

Commodore BASIC V2 (C64), 94 bytes

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

No estoy completamente seguro sobre el recuento de bytes, esto se basa en la representación de texto para escribir el programa válido. Es un poco más corto en el disco (91 bytes) porque BASIC V2 usa una representación "simbólica" de programas.

Demo en línea

Ligeramente "sin golf":

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 modificable , 55 bytes

Tomar entrada como código de caracteres.
Solo admite entradas de hasta 255.
Utilice caracteres nulos para separar líneas.

Casualmente, todos los caracteres de dibujo de flecha se utilizan como comandos BF. Desafortunadamente, no guarda ningún byte (actualmente).

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

Pruébalo en línea!

Explicación

 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

Gracias a Jo King por arreglar un error.

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

Pruébalo en línea!

Pyth, 17 bytes

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

La salida es una lista de cadenas. Pruébelo en línea aquí .

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]

Pruébalo en línea!

Recorre desde 0arriba hasta la entrada $n, cada iteración crea dos cadenas de flechas. Luego se indexan 0..--$npara extraer el número correcto de elementos.

Guardado 6 bytes gracias a KGlasier.

Python 3, 53 bytes

Mi primera respuesta codegolf.

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

-10 bytes gracias a Jo King

Haskell , 51 44 bytes

^{-7 bytes gracias a xnor (usando iteratemás de comprensión de la lista)!}

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

Pruébalo en línea!

Explicación / Ungolfed

El uso de do-notation nos ahorra a concat, y el uso de notación de infijo permite una función de punto libre take, deshaciendo esto daría:

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

Japt -m, 16 15 13 12 bytes

Guardado 1 byte gracias a Shaggy

g<i>)iUUz ç-

Pruébelo en línea

Explicación:

-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

Jalea , 15 bytes

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

Pruébalo en línea!

MathGolf , 17 15 bytes

Guardado 2 bytes gracias a Jo King y Kevin Cruijssen

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

Pruébalo en línea!

Explicación

El enfoque de 15 bytes es diferente en comparación con mi solución original, no puedo tomar ningún crédito por la implementación.

{                 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

Pruébalo en línea!

Actualizado con un método completamente nuevo.

Explicación:

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

Pruébalo en línea!

-3 bytes con idea de ASCII solamente .

-1 con en \0lugar de\n

-5 reordenamiento de piezas

La salida incluye un 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

Devuelve una cadena separada por espacios.

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

Pruébalo en línea!

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	

Pruébalo en línea!

V , 22 bytes

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

Pruébalo en línea!

Carbón , 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Tenía tres soluciones de 17 bytes antes de encontrarme con esta. Explicación:

Ｎθ

Entrada n.

Ｆθ«

Repetir nveces, 0 indexado.

⊘ι

Dibuje una línea de -s de longitud que sea la mitad del índice (truncada).

↓>

Dibuja la punta de flecha y pasa a la siguiente línea.

‖Ｔ»

Refleja todo, volteando las puntas de flecha.

Ｆθ‖Ｔ

El bucle anterior tiene nreflexiones, pero necesitamos un número par de reflexiones, así que realice otras nreflexiones.

Limpio , 76 73 bytes

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

Pruébalo en línea!

Utiliza el hecho claro que ['-','-'..]es lo mismo ['--'..]que ahorrar un poco.

JavaScript, 49 bytes

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

Pruébalo en línea!

Powershell, 51 bytes

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

Código de 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

Todavía bastante más corto que BASIC ;) Este tiene un rango de números solo hasta255 porque el tamaño entero natural de la máquina tiene solo 8 bits.

Demostración en línea

Uso: SYS49152,[n](por ejemplo, SYS49152,3para el ejemplo del desafío)

Desmontaje comentado :

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

Pruébalo en línea!

Bloque de código anónimo que devuelve una lista de líneas.

K (ngn / k) , 31 29 bytes

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

Pruébalo en línea!

primero generamos listas con 0 en lugar de "<", 1 en lugar de "-"y 2 en lugar de ">":

{ } funcionar con argumento x

x{... }\0aplique los xtiempos de la función interna , comenzando con un valor inicial 0y preservando los resultados intermedios

|x marcha atrás

2- reemplace 0 con 2 y viceversa, mantenga los 1 como están

1, anteponer un 1

(1=*x)_es el primero de xigual a 1? en caso afirmativo, suelte un elemento; de lo contrario, suelte 0 elementos (no haga nada)

2,anteponer un 2 para la ">"flecha inicial

x#tenemos demasiadas listas, así que tome solo la primera xde ellas

"<->" usa los elementos de las listas (0/1/2) como índices en esta cadena

05AB1E , 23 20 bytes

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

Pruébalo en línea!

La primera vez que usa 05AB1E o cualquier otro lenguaje de golf para el caso. Cualquier idea bienvenida.

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

Pruébalo en línea!

Utiliza un delegado de acción para extraer la entrada y no requiere un retorno.

Sin golf:

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

Pruébalo en línea! (Gracias a @Oliver)

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

Rojo , 109108 bytes

-1 byte gracias 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 #"-"]]]

Pruébalo en línea!