Questa sfida riguarda la stampa di una serie di frecce di arte ASCII in crescita. Descriverò il modello a parole, ma potrebbe essere più facile guardare come appare l'inizio di questa serie:

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

Una freccia con lunghezza n contiene una punta di freccia ( <o >) e n-1trattini ( -). Una freccia rivolta a destra ha prima i trattini, quindi a >. Una freccia rivolta a sinistra inizia con <ed è seguita dai trattini. La serie è composta da una nfreccia rivolta verso destra seguita da una lunghezza n freccia rivolta verso sinistra, con n da 1 a infinito.

Per completare la sfida, scrivi un programma o una funzione che accetta un input, un numero intero i >= 1e genera le prime ifrecce. Le frecce sono individuali, non nelle coppie destra-sinistra, quindi per i=3te dovresti produrre:

>
<
->

È possibile restituire un elenco di stringhe o stamparle una dopo l'altra. Se si stampa, le frecce devono essere delimitate da un delimitatore coerente, che non deve essere una nuova riga come nell'esempio.

Questo è code-golf , quindi vince meno byte.

Tela , 10 byte

⇵-×<ｎ¹［↔｝］

Provalo qui!

R , 69 byte

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

Provalo online!

• -5 byte grazie a @Giuseppe
• -3 byte grazie a @Robert S.

Java (JDK) , 81 byte

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

Provalo online!

spiegazioni

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 byte

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

Provalo online!

Semplice vecchia ricorsione: inizia con string p= ">", collect p, <a davanti a tutti tranne l'ultimo carattere di pe una chiamata ricorsiva con una -messa davanti p. Prendi i primi nelementi di questo elenco.

Modifica: -1 byte grazie a @xnor.

Commodore BASIC V2 (C64), 94 byte

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

Non del tutto sicuro del conteggio dei byte, questo si basa sulla rappresentazione testuale per la digitazione del programma valido. È un po 'più breve sul disco (91 byte) perché BASIC V2 utilizza una rappresentazione "tokenizzata" di programmi.

Demo online

Leggermente "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

Brainfuck automodificante , 55 byte

Prendi input come codice carattere.
Supporta solo input fino a 255.
Utilizzare il carattere null per separare le righe.

Per coincidenza, tutti i caratteri che disegnano frecce sono usati come comandi BF. Sfortunatamente, non salva alcun byte (attualmente).

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

Provalo online!

Spiegazione

 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 byte

grazie a e Jo King per aver corretto un bug.

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

Provalo online!

Pyth, 17 byte

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

L'output è un elenco di stringhe. Provalo online qui .

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 byte

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

Provalo online!

Passa da 0un input $nall'altro, ogni iterazione crea due stringhe di frecce. Questi vengono quindi indicizzati con 0..--$nper estrarre il numero corretto di elementi.

6 byte salvati grazie a KGlasier.

Python 3, 53 byte

La mia prima risposta da codegolf.

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

-10 byte grazie a Jo King

Haskell , 51 44 byte

^{-7 byte grazie a xnor (usando iterateoltre la comprensione della lista)!}

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

Provalo online!

Spiegazione / Non golf

L'uso di do-notation ci consente di salvare a concat, e l'uso di infix-notation consente una funzione senza punti take, annullando questi si otterrebbe:

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

Japt -m, 16 15 13 12 byte

Salvato 1 byte grazie a Shaggy

g<i>)iUUz ç-

Provalo online

Spiegazione:

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

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

Provalo online!

MathGolf , 17 15 byte

Salvato 2 byte grazie a Jo King e Kevin Cruijssen

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

Provalo online!

Spiegazione

L'approccio a 15 byte è diverso rispetto alla mia soluzione originale, non posso prendermi il merito per l'implementazione.

{                 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 byte

"<>"¬hUUz ç-)q

Provalo online!

Aggiornato con un metodo completamente nuovo.

Spiegazione:

                  #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 (cc) , 80 77 76 74 71 byte

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

Provalo online!

-3 byte con idea da ASCII .

-1 con \0anziché\n

-5 riorganizzazione delle parti

L'output include un finale \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 byte

Restituisce una stringa separata da spazio.

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

Provalo online!

SNOBOL4 (CSNOBOL4) , 123 122 118 byte

	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	

Provalo online!

V , 22 byte

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

Provalo online!

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Avevo tre soluzioni a 17 byte prima di incappare in questa. Spiegazione:

Ｎθ

Input n.

Ｆθ«

Ripetere i ntempi, indicizzati 0.

⊘ι

Disegna una linea di -s di lunghezza metà dell'indice (troncata).

↓>

Disegna la punta della freccia e passa alla riga successiva.

‖Ｔ»

Rifletti tutto, lanciando le punte delle frecce.

Ｆθ‖Ｔ

Il ciclo sopra ha nriflessi, ma abbiamo bisogno di un numero pari di riflessi, quindi esegui altri nriflessi.

Pulito , 76 73 byte

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

Provalo online!

Usa il fatto preciso che ['-','-'..]è lo stesso ['--'..]di risparmiare un po '.

JavaScript, 49 byte

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

Provalo online!

Powershell, 51 byte

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

6502 codice macchina (C64), 49 byte

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

Ancora un po 'più breve di BASIC ;) Questo ha un intervallo di numeri solo fino a 255quando la dimensione intera naturale della macchina ha solo 8 bit.

Demo online

Utilizzo: SYS49152,[n](ad es. SYS49152,3Per l'esempio della sfida)

Smontaggio commentato :

         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 byte

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

Provalo online!

Blocco di codice anonimo che restituisce un elenco di righe.

K (ngn / k) , 31 29 byte

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

Provalo online!

per prima cosa generiamo liste con 0 invece di "<", 1 invece di "-"e 2 invece di ">":

{ } funzione con argomento x

x{... }\0applica i xtempi delle funzioni interne , iniziando con un valore iniziale 0e preservando i risultati intermedi

|x inverso

2- sostituire 0 con 2 e viceversa, mantenere gli 1 così come sono

1, anteporre a 1

(1=*x)_è il primo di xuguale a 1? se sì, rilascia un elemento, altrimenti rilascia 0 elementi (non fare nulla)

2,anteporre un 2 per la ">"freccia iniziale

x#abbiamo un po 'troppo molte liste, in modo da prendere solo il primo xdi essi

"<->" usa gli elementi delle liste (0/1/2) come indici in questa stringa

05AB1E , 23 20 byte

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

Provalo online!

Prima volta che usi 05AB1E o qualsiasi altro linguaggio di golf per quella materia. Qualche idea benvenuta.

-3 da Kevin Cruijssen

C # (.NET Core) , 90 byte

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

Provalo online!

Utilizza un delegato Action per inserire l'input e non richiede un ritorno.

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 byte

Provalo online! (Grazie a @Oliver)

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

Rosso , 109 108 byte

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

Provalo online!