Ця задача полягає у друкуванні серії зростаючих стрілок мистецтва ASCII. Я опишу візерунок словами, але може бути простіше подивитися, як виглядає початок цієї серії:

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

Стрілка довжиною n містить головку стрілки ( <або >) та n-1тире ( -). На стрілці правою стороною спочатку є тире, потім a >. Ліва стрілка починається з <, а за нею - тире. Серія складається зі nстрілки довжиною праворуч з наступною стрілкою довжиною n лівою стороною, з n від 1 до нескінченності.

Щоб виконати завдання, напишіть програму або функцію, яка займає один вхід, ціле число i >= 1та виводить перші iстрілки. Стрілки індивідуальні, не в парах зліва наліво, тому для i=3вас слід вивести:

>
<
->

Ви можете повернути список рядків або роздрукувати їх одна за одною. Якщо друкується, стрілки повинні бути обмежені деяким послідовним роздільником, який не повинен бути новим рядком, як у прикладі.

Це код-гольф , тому виграє найменше байтів.

Полотно , 10 байт

⇵-×<ｎ¹［↔｝］

Спробуйте тут!

R , 69 байт

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

Спробуйте в Інтернеті!

• -5 байт завдяки @Giuseppe
• -3 байти завдяки @Robert S.

Java (JDK) , 81 байт

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

Спробуйте в Інтернеті!

Пояснення

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 байт

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

Спробуйте в Інтернеті!

Звичайна стара рекурсія: почати з рядка p= ">", збирати p, а <перед усіма, крім останнього знака pта рекурсивного дзвінка, з одного, -поставленого перед p. Візьміть перші nпункти цього списку.

Редагувати: -1 байт завдяки @xnor.

Commodore BASIC V2 (C64), 94 байти

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

Не зовсім впевнений у кількості байтів, це засновано на поданні тексту для введення дійсної програми. Це трохи коротше на диску (91 байт), оскільки BASIC V2 використовує "токенізоване" представлення програм.

Демонстрація в Інтернеті

Трохи "невольф":

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 , 55 байт

Візьміть введення як код символу.
Підтримуйте лише введення до 255.
Використовуйте нульовий символ для розділення рядків.

Випадково всі символи малювання стрілки використовуються як команди BF. На жаль, він не зберігає жодного байти (на даний момент).

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

Спробуйте в Інтернеті!

Пояснення

 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 байти

дякую і Джо Кінгу за виправлення помилки.

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

Спробуйте в Інтернеті!

Піт, 17 байт

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

Вихід - це список рядків. Спробуйте його онлайн тут .

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 байт

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

Спробуйте в Інтернеті!

Петлі від 0введення до $nкожної ітерації, створюючи дві стрілки. Потім вони індексуються, 0..--$nщоб витягнути правильну кількість елементів.

Збережено 6 байт завдяки KGlasier.

Python 3, 53 байти

Моя перша відповідь кодогольфа.

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

-10 байт завдяки Джо Кінгу

Haskell , 51 44 байт

^{-7 байт завдяки xnor (за допомогою iterateрозуміння списків)!}

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

Спробуйте в Інтернеті!

Пояснення / Недозволений

Використання do-notation заощаджує нас concat, а використання infix-notation дозволяє функцію pointfree з take, скасування цих даних дасть:

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

Japt -m, 16 15 13 12 байт

Збережено 1 байт завдяки Шаггі

g<i>)iUUz ç-

Перевірте це в Інтернеті

Пояснення:

-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

Желе , 15 байт

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

Спробуйте в Інтернеті!

MathGolf , 17 15 байт

Збережено 2 байти завдяки Джо Кінгу та Кевіну Крейсейну

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

Спробуйте в Інтернеті!

Пояснення

15-байтовий підхід відрізняється порівняно з моїм оригінальним рішенням, я не можу брати жодної заслуги за реалізацію.

{                 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 байт

"<>"¬hUUz ç-)q

Спробуйте в Інтернеті!

Оновлено абсолютно новим методом.

Пояснення:

                  #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 байт

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

Спробуйте в Інтернеті!

-3 байти з ідеєю від ASCII .

-1 з \0замість\n

-5 перестановки деталей

Вихідні дані включають в себе трейлінг \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 байт

Повертає розділений пробілом рядок.

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

Спробуйте в Інтернеті!

SNOBOL4 (CSNOBOL4) , 123 122 118 байт

	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	

Спробуйте в Інтернеті!

V , 22 байти

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

Спробуйте в Інтернеті!

Вугілля деревне , 16 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. У мене було три 17-байтові рішення, перш ніж я врешті-решт наткнувся на це. Пояснення:

Ｎθ

Вхідні дані n.

Ｆθ«

Повторіть nразів, 0-індексується.

⊘ι

Накресліть лінію -s довжиною s половину індексу (усічена).

↓>

Намалюйте стрілку стрілки та перейдіть до наступного рядка.

‖Ｔ»

Відбийте все, перевернувши стрілки.

Ｆθ‖Ｔ

Вищеописаний цикл має nвідображення, але нам потрібна парна кількість відображень, тому виконайте ще одне nвідображення.

Чисто , 76 73 байт

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

Спробуйте в Інтернеті!

Використовує акуратний факт, ['-','-'..]такий самий, як ['--'..]трохи заощадити.

JavaScript, 49 байт

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

Спробуйте в Інтернеті!

Powershell, 51 байт

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

6502 код машини (C64), 49 байт

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

Ще трохи коротший, ніж BASIC ;) Цей має 255числовий діапазон лише до, тому що натуральний цілий розмір машини має лише 8 біт.

Демонстрація в Інтернеті

Використання: SYS49152,[n](наприклад, SYS49152,3приклад із завдання)

Прокоментували розбирання :

         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 байт

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

Спробуйте в Інтернеті!

Блок анонімного коду, який повертає список рядків.

К (нг / к) , 31 29 байт

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

Спробуйте в Інтернеті!

спочатку ми генеруємо списки з 0 замість "<", 1 замість "-"і 2 замість ">":

{ } функція з аргументом x

x{... }\0застосувати внутрішні xчаси функції , починаючи з початкового значення0 та зберігаючи проміжні результати

|x реверс

2- замініть 0 на 2 і навпаки, збережіть 1, якими вони є

1, подати а 1

(1=*x)_перша xдорівнює 1? якщо так, киньте один елемент, інакше скиньте 0 елементів (нічого не робити)

2,додайте 2 для початкової ">"стрілки

x#у нас є занадто багато списків, тому візьміть лише перший xз них

"<->" використовувати елементи списків (0/1/2) як індекси у цьому рядку

05AB1E , 23 20 байт

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

Спробуйте в Інтернеті!

Вперше використовуючи для цього 05AB1E або будь-яку іншу мову для гольфу. Будь-які ідеї вітаються.

-3 від Кевіна Круїссена

C # (.NET Core) , 90 байт

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

Спробуйте в Інтернеті!

Використовує делегата Action, щоб вивести вхід і не вимагати повернення.

Безголівки:

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 байт

Спробуйте в Інтернеті! (Спасибі @Oliver)

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

Червоний , 109 108 байт

-1 байт завдяки 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 #"-"]]]

Спробуйте в Інтернеті!