이 과제는 성장하는 ASCII 아트 화살표를 인쇄하는 것입니다. 패턴을 단어로 설명하지만이 시리즈의 시작 부분이 어떤지보다 쉽게 ​​볼 수 있습니다.

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

길이가 n 인 화살표는 화살촉 ( <또는 >)과 n-1대시 ( -)를 포함합니다. 오른쪽을 향한 화살표에는 먼저 대시가 있고 그 다음에 a가 >있습니다. 왼쪽 방향 화살표는로 시작하고 <그 뒤에 대시가옵니다. 이 시리즈는 길이 n오른쪽 오른쪽 화살표와 길이 n 왼쪽 화살표로 구성되며 n은 1부터 무한대까지입니다.

과제를 완료하려면 하나의 입력 인 integer i >= 1를 사용하고 첫 번째 i화살표를 출력 하는 프로그램이나 함수를 작성하십시오 . 화살표는 오른쪽 왼쪽 쌍이 아닌 개별적이므로 i=3출력해야합니다.

>
<
->

문자열 목록을 반환하거나 하나씩 인쇄 할 수 있습니다. 인쇄하는 경우 화살표는 일관된 구분 기호로 구분되어야하며, 예와 같이 줄 바꿈 일 필요는 없습니다.

이것은 code-golf 이므로 가장 적은 바이트가 이깁니다.

캔버스 , 10 바이트

⇵-×<ｎ¹［↔｝］

여기 사용해보십시오!

R , 69 바이트

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

온라인으로 사용해보십시오!

• @Giuseppe 덕분에 -5 바이트
• @Robert S 덕분에 -3 바이트

자바 (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
  );                  // 
}                     //

하스켈, 41 40 바이트

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

온라인으로 사용해보십시오!

일반 오래된 재귀 : 문자열로 시작 p= ">", 수집 p하는 <모든 앞에하지만 마지막 문자에서 p와 하나 개의 재귀 호출 -앞에 넣어 p. n이 목록 의 첫 번째 항목을 가져 가십시오 .

편집 : @xnor 덕분에 -1 바이트.

코모도어 베이직 V2 (C64), 94 바이트

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

바이트 수에 대해 완전히 확신 할 수없는 것은 유효한 프로그램을 입력하기위한 텍스트 표현을 기반으로합니다. BASIC V2는 "토큰 화 된"프로그램 표현을 사용하기 때문에 디스크에서 약간 짧습니다 (91 바이트).

온라인 데모

약간 "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 , 55 바이트

문자 코드로 입력하십시오.
최대 255 개의 입력 만 지원
합니다. 줄을 구분하려면 null 문자를 사용하십시오.

우연히도 모든 화살표 그리기 문자는 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

파이썬 2 , 54 바이트

버그 수정에 대한 and and King에게 감사합니다.

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올바른 수의 요소를 꺼내기 위해 색인을 생성 합니다.

KGlasier 덕분에 6 바이트를 절약했습니다.

파이썬 3, 53 바이트

내 첫 번째 골프 골프 답변.

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

Jo King 덕분에 -10 바이트

하스켈 , 51 44 바이트

^{xnor 덕분에 -7 바이트 ( iterate목록 이해 를 통해)!}

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

온라인으로 사용해보십시오!

설명 / 언 골프

do-notation을 사용하면 a가 절약 concat되고 infix-notation을 사용하면을 사용하여 pointfree 함수를 사용할 수 있습니다 take.

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

Japt -m, 16 15 13 12 바이트

Shaggy 덕분에 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 바이트

Jo King과 Kevin Cruijssen 덕분에 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

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

온라인으로 사용해보십시오!

ASCII 전용 아이디어로 -3 바이트 .

\0대신 -1\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
}

자바 스크립트 (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.

Ｆθ«

n0- 인덱스 반복 횟수.

⊘ι

-길이가 절반 인 s의 선을 그립니다 (잘라 짐).

↓>

화살촉을 그리고 다음 줄로 이동하십시오.

‖Ｔ»

화살촉을 뒤집어 모든 것을 반영하십시오.

Ｆθ‖Ｔ

The above loop has n reflections, but we need an even number of reflections, so perform another n reflections.

Clean, 76 73 bytes

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

Try it online!

Uses the neat fact that ['-','-'..] is the same as ['--'..] to save a bit.

JavaScript, 49 bytes

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

Try it online!

Powershell, 51 bytes

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

6502 machine code (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

Still quite a bit shorter than BASIC ;) This one has a number range only up to 255 because the natural integer size of the machine has only 8 bits.

Online demo

Usage: SYS49152,[n] (e.g. SYS49152,3 for the example from the challenge)

Commented disassembly:

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

Try it online!

Anonymous code block that returns a list of lines.

K (ngn/k), 31 29 bytes

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

Try it online!

first we generate lists with 0 instead of "<", 1 instead of "-", and 2 instead of ">":

{ } function with argument x

x{...}\0 apply the inner function x times, starting with an initial value of 0 and preserving intermediate results

|x reverse

2- replace 0 with 2 and vice versa, keep the 1s as they are

1, prepend a 1

(1=*x)_ is the first of x equal to 1? if yes, drop one element, otherwise drop 0 elements (do nothing)

2, prepend a 2 for the initial ">" arrow

x# we have a little too many lists, so take only the first x of them

"<->" use the lists' elements (0/1/2) as indices in this string

05AB1E, 23 20 bytes

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

Try it online!

First time using 05AB1E or any other golfing language for that matter. Any ideas welcome.

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

Try it online!

Uses an Action delegate to pull in the input and not require a return.

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

Try it online! (Thanks to @Oliver)

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

Red, 109 108 bytes

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

Try it online!