Bei dieser Herausforderung geht es darum, eine Reihe von wachsenden ASCII-Kunstpfeilen zu drucken. Ich werde das Muster in Worten beschreiben, aber es könnte einfacher sein zu sehen, wie der Anfang dieser Serie aussieht:

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

Ein Pfeil mit der Länge n enthält eine Pfeilspitze ( <oder >) und n-1Striche ( -). Ein nach rechts zeigender Pfeil hat zuerst die Striche und dann a >. Ein nach links zeigender Pfeil beginnt mit <und wird von den Bindestrichen gefolgt. Die Serie besteht aus einem nach nrechts gerichteten Pfeil, gefolgt von einem nach links gerichteten Pfeil mit einer Länge von n von 1 bis unendlich.

Um die Herausforderung abzuschließen, schreiben Sie ein Programm oder eine Funktion, die eine Eingabe, eine Ganzzahl i >= 1und die ersten iPfeile ausgibt . Die Pfeile sind einzeln, nicht in Rechts-Links-Paaren. i=3Deshalb sollten Sie Folgendes ausgeben:

>
<
->

Sie können eine Liste von Zeichenfolgen zurückgeben oder nacheinander drucken. Beim Drucken müssen die Pfeile durch ein konsistentes Trennzeichen begrenzt werden, das nicht wie im Beispiel ein Zeilenumbruch sein muss.

Das ist Code-Golf , also gewinnen die wenigsten Bytes.

Canvas , 10 Bytes

⇵-×<ｎ¹［↔｝］

Probieren Sie es hier aus!

R , 69 Bytes

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

Probieren Sie es online!

• -5 Bytes dank @ Giuseppe
• -3 Bytes dank @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));}

Probieren Sie es online!

Erklärungen

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)

Probieren Sie es online!

Einfache alte Rekursion: Beginnen Sie mit string p= ">", collect p, a <vor allen Zeichen von pund einem rekursiven Aufruf mit einem -Zeichen vor p. Nimm die ersten nGegenstände dieser Liste.

Bearbeiten: -1 Byte dank @xnor.

Commodore BASIC V2 (C64), 94 Byte

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

Die Anzahl der Bytes ist nicht ganz sicher. Sie basiert auf der Textdarstellung für die Eingabe des gültigen Programms. Auf der Festplatte ist es etwas kürzer (91 Byte), da BASIC V2 eine "tokenisierte" Darstellung von Programmen verwendet.

Online Demo

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

Selbstmodifizierender Brainfuck , 55 Bytes

Eingabe als Zeichencode übernehmen.
Unterstützt nur Eingaben bis zu 255.
Verwenden Sie das Nullzeichen, um Zeilen zu trennen.

Zufällig werden alle pfeilzeichnenden Zeichen als BF-Befehle verwendet. Leider werden (derzeit) keine Bytes gespeichert.

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

Probieren Sie es online!

Erläuterung

 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

Vielen Dank an Jo King für die Fehlerbehebung.

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

Probieren Sie es online!

Pyth, 17 Bytes

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

Die Ausgabe ist eine Liste von Zeichenfolgen. Probieren Sie es hier online aus .

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]

Probieren Sie es online!

Schleifen von 0bis zu Eingabe $n, wobei jede Iteration zwei Pfeilzeichenfolgen erzeugt. Diese werden dann mit indexiert 0..--$n, um die richtige Anzahl von Elementen herauszuziehen.

6 Bytes gespart dank KGlasier.

Python 3, 53 Bytes

Meine erste Codegolf-Antwort.

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

-10 Bytes dank Jo King

Haskell , 51 44 Bytes

^{-7 Bytes dank xnor ( iterateüber Listenverständnis)!}

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

Probieren Sie es online!

Erklärung / Ungolfed

Die Verwendung von do-notation erspart uns eine concat, und die Verwendung der Infix-Notation ermöglicht eine punktfreie Funktion mit take:

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

Japt -m, 16 15 13 12 Bytes

1 Byte dank Shaggy gespeichert

g<i>)iUUz ç-

Testen Sie es online

Erläuterung:

-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

Gelee , 15 Bytes

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

Probieren Sie es online!

MathGolf , 17 15 Bytes

Dank Jo King und Kevin Cruijssen 2 Bytes gespart

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

Probieren Sie es online!

Erläuterung

Der 15-Byte-Ansatz unterscheidet sich von meiner ursprünglichen Lösung. Ich kann keine Anerkennung für die Implementierung geben.

{                 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

Probieren Sie es online!

Aktualisiert mit einer völlig neuen Methode.

Erläuterung:

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

Probieren Sie es online!

-3 Bytes mit der Idee von nur ASCII .

-1 mit \0statt\n

-5 Teile neu anordnen

Die Ausgabe enthält ein Trailing \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

Gibt eine durch Leerzeichen getrennte Zeichenfolge zurück.

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

Probieren Sie es 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	

Probieren Sie es online!

V , 22 Bytes

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

Probieren Sie es online!

Kohle , 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ich hatte drei 17-Byte-Lösungen, bevor ich schließlich über diese gestolpert bin. Erläuterung:

Ｎθ

Eingabe n.

Ｆθ«

Wiederholungszeiten n, 0-indiziert.

⊘ι

Zeichnen Sie eine Linie mit -der halben Länge des Index (abgeschnitten).

↓>

Zeichne die Pfeilspitze und gehe zur nächsten Zeile.

‖Ｔ»

Reflektiere alles und drehe die Pfeilspitzen um.

Ｆθ‖Ｔ

Die obige Schleife hat nReflexionen, aber wir brauchen eine gerade Anzahl von Reflexionen, führen Sie also weitere nReflexionen durch.

Sauber , 76 73 Bytes

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

Probieren Sie es online!

Verwendet die nette Tatsache, ['-','-'..]die gleichbedeutend ist ['--'..], um ein bisschen zu sparen.

JavaScript, 49 Bytes

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

Probieren Sie es online!

Powershell, 51 Bytes

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

6502 Maschinencode (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

Immer noch ziemlich viel kürzer als BASIC ;) Dieser hat einen Zahlenbereich nur bis zu, 255weil die natürliche Ganzzahlgröße der Maschine nur 8 Bit hat.

Online-Demo

Verwendung: SYS49152,[n] (zB SYS49152,3für das Beispiel aus der Challenge)

Kommentierte Demontage :

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

Probieren Sie es online!

Anonymer Codeblock, der eine Liste von Zeilen zurückgibt.

K (ngn / k) , 31 29 Bytes

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

Probieren Sie es online!

Zuerst generieren wir Listen mit 0 anstelle von "<", 1 anstelle von "-"und 2 anstelle von ">":

{ } Funktion mit Argument x

x{... }\0wende die inneren Funktionszeiten xan, beginnend mit einem Anfangswert von0 und die Zwischenergebnisse erhalten bleiben

|x umkehren

2- Ersetzen Sie 0 durch 2 und umgekehrt, und behalten Sie die Einsen bei

1, 1 voranstellen

(1=*x)_ ist der erste von x gleich 1? Wenn ja, lösche ein Element, andernfalls lösche 0 Elemente (mache nichts)

2, stellen Sie der Initiale eine 2 voran ">" Pfeil

x# Wir haben ein bisschen zu viele Listen, nehmen Sie also nur die erste x von ihnen

"<->" Verwenden Sie die Elemente der Listen (0/1/2) als Indizes in dieser Zeichenfolge

05AB1E , 23 20 Bytes

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

Probieren Sie es online!

Zum ersten Mal mit 05AB1E oder einer anderen Golfsprache. Irgendwelche Ideen willkommen.

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

Probieren Sie es online!

Verwendet einen Aktionsdelegaten , um die Eingabe abzurufen, und erfordert keine Rückgabe.

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

Probieren Sie es online! (Danke an @Oliver)

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

Rot , 109 108 Bytes

-1 Byte dank 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 #"-"]]]

Probieren Sie es online!