Эта задача касается печати серии растущих стрелок ASCII-art. Я опишу шаблон словами, но может быть проще взглянуть на то, как выглядит начало этой серии:

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

Стрелка длиной 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 байта благодаря @ Роберту С.

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()

Попробуйте онлайн!

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

Мой первый ответ Codegolf.

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

-10 байт благодаря Джо Кингу

Haskell , 51 44 байта

^{-7 байт благодаря xnor (используя iterateover-list-compceptionsion)!}

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

Попробуйте онлайн!

Объяснение / Ungolfed

Использование do-notation спасает нас concat, а использование infix-notation позволяет использовать функцию pointfree, отмена takeкоторой даст:

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

Джапт -m, 16 15 13 12 байт

Сохранено 1 байт благодаря Shaggy

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='')

Попробуйте онлайн!

СНОБОЛ4 (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 длины, равной половине индекса (усеченной).

↓>

Нарисуйте стрелку и перейдите к следующей строке.

‖Ｔ»

Отражать все, переворачивая стрелки.

Ｆθ‖Ｔ

Вышеуказанный цикл имеет 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},^$_}

Попробуйте онлайн!

Блок анонимного кода, который возвращает список строк.

K (нгн / к) , 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);}}

Попробуйте онлайн!

Использует делегат действия для ввода ввода и не требует возврата.

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

Попробуйте онлайн! (Спасибо @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 #"-"]]]

Попробуйте онлайн!