Thách thức này là về việc in một loạt các mũi tên nghệ thuật ASCII đang phát triển. Tôi sẽ mô tả mô hình bằng từ ngữ, nhưng có thể dễ dàng hơn để xem phần bắt đầu của loạt bài này trông như thế nào:

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

Một mũi tên có độ dài n chứa đầu mũi tên ( <hoặc >) và n-1dấu gạch ngang ( -). Một mũi tên quay phải có dấu gạch ngang trước, sau đó a >. Một mũi tên quay sang trái bắt đầu bằng <và được theo sau bởi dấu gạch ngang. Sê n-ri bao gồm một mũi tên phải dài theo sau là mũi tên dài n bên trái, với n từ 1 đến vô cùng.

Để hoàn thành thử thách, hãy viết chương trình hoặc hàm lấy một đầu vào, một số nguyên i >= 1và xuất các imũi tên đầu tiên . Mũi tên là riêng lẻ, không phải theo cặp bên trái, vì vậy i=3bạn nên xuất ra:

>
<
->

Bạn có thể trả về một danh sách các chuỗi hoặc in chúng lần lượt. Nếu in, các mũi tên phải được phân định bằng một số dấu phân cách nhất quán, không phải là một dòng mới như trong ví dụ.

Đây là mã golf , vì vậy ít byte nhất sẽ thắng.

Canvas , 10 byte

⇵-×<ｎ¹［↔｝］

Hãy thử nó ở đây!

R , 69 byte

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

Hãy thử trực tuyến!

• -5 byte nhờ @Giuseppe
• -3 byte nhờ @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));}

Hãy thử trực tuyến!

Giải thích

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)

Hãy thử trực tuyến!

Đệ quy đơn giản cũ: bắt đầu bằng chuỗi p= ">", thu thập p, <ở phía trước tất cả trừ char cuối cùng pvà một cuộc gọi đệ quy với một -đặt ở phía trước p. Lấy các nmục đầu tiên của danh sách này.

Chỉnh sửa: -1 byte nhờ @xnor.

Hàng hóa BASIC V2 (C64), 94 byte

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

Không hoàn toàn chắc chắn về số lượng byte, điều này dựa trên biểu diễn văn bản để nhập chương trình hợp lệ. Nó ngắn hơn một chút trên đĩa (91 byte) vì BASIC V2 sử dụng biểu diễn "tokenized" của các chương trình.

Demo trực tuyến

Hơi "vô dụng":

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 tự sửa đổi , 55 byte

Lấy đầu vào làm mã ký tự.
Chỉ hỗ trợ đầu vào tối đa 255.
Sử dụng ký tự null để phân tách các dòng.

Thật trùng hợp, tất cả các ký tự vẽ mũi tên được sử dụng làm lệnh BF. Thật không may, nó không lưu bất kỳ byte nào (hiện tại).

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

Hãy thử trực tuyến!

Giải trình

 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

cảm ơn và Jo King đã sửa lỗi.

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

Hãy thử trực tuyến!

Bình thường, 17 byte

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

Đầu ra là một danh sách các chuỗi. Hãy thử trực tuyến tại đây .

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]

Hãy thử trực tuyến!

Vòng lặp từ 0lên đến đầu vào $n, mỗi lần lặp tạo ra hai chuỗi mũi tên. Những cái đó sau đó được lập chỉ mục 0..--$nđể lấy ra số lượng phần tử chính xác.

Đã lưu 6 byte nhờ KGlasier.

Python 3, 53 byte

Câu trả lời đầu tiên của tôi.

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

-10 byte nhờ Jo King

Haskell , 51 44 byte

^{-7 byte nhờ xnor (sử dụng iteratetrên mức hiểu danh sách)!}

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

Hãy thử trực tuyến!

Giải thích / Ungolfed

Sử dụng dochú thích giúp chúng ta tiết kiệm concatvà sử dụng ký hiệu không cho phép một chức năng không điểm với take, hoàn tác những điều này sẽ mang lại:

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

Japt -m, 16 15 13 12 byte

Đã lưu 1 byte nhờ Shaggy

g<i>)iUUz ç-

Kiểm tra trực tuyến

Giải trình:

-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

Thạch , 15 byte

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

Hãy thử trực tuyến!

MathGolf , 17 15 byte

Đã lưu 2 byte nhờ Jo King và Kevin Cruijssen

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

Hãy thử trực tuyến!

Giải trình

Cách tiếp cận 15 byte khác với giải pháp ban đầu của tôi, tôi không thể nhận bất kỳ tín dụng nào cho việc thực hiện.

{                 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

Hãy thử trực tuyến!

Cập nhật với một phương pháp hoàn toàn mới.

Giải trình:

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

Hãy thử trực tuyến!

-3 byte với ý tưởng chỉ từ ASCII .

-1 \0thay vì\n

-5 sắp xếp lại các bộ phận

Đầu ra bao gồm một dấu \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

Trả về một chuỗi được phân tách bằng dấu cách.

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

Hãy thử trực tuyến!

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	

Hãy thử trực tuyến!

V , 22 byte

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

Hãy thử trực tuyến!

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Tôi đã có ba giải pháp 17 byte trước khi cuối cùng tôi vấp phải giải pháp này. Giải trình:

Ｎθ

Đầu vào n.

Ｆθ«

Lặp lại nnhiều lần, 0 chỉ mục.

⊘ι

Vẽ một dòng có -độ dài bằng một nửa chỉ số (cắt ngắn).

↓>

Vẽ đầu mũi tên và di chuyển đến dòng tiếp theo.

‖Ｔ»

Phản ánh tất cả mọi thứ, lật đầu mũi tên.

Ｆθ‖Ｔ

Vòng lặp trên có các nphản xạ, nhưng chúng ta cần một số phản xạ chẵn, vì vậy thực hiện các nphản xạ khác .

Sạch , 76 73 byte

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

Hãy thử trực tuyến!

Sử dụng thực tế gọn gàng ['-','-'..]giống như ['--'..]để tiết kiệm một chút.

JavaScript, 49 byte

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

Hãy thử trực tuyến!

Powershell, 51 byte

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

Mã máy 6502 (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

Vẫn còn khá ngắn hơn BASIC một chút ;) Cái này có phạm vi số chỉ tối đa 255vì kích thước nguyên tự nhiên của máy chỉ có 8 bit.

Bản demo trực tuyến

Cách sử dụng: SYS49152,[n](ví dụ: ví SYS49152,3dụ từ thử thách)

Nhận xét tháo gỡ :

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

Hãy thử trực tuyến!

Khối mã ẩn danh trả về một danh sách các dòng.

K (ngn / k) , 31 29 byte

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

Hãy thử trực tuyến!

đầu tiên chúng tôi tạo danh sách bằng 0 thay vì "<", 1 thay vì "-"và 2 thay vì ">":

{ } chức năng với đối số x

x{... }\0áp dụng xthời gian chức năng bên trong , bắt đầu bằng giá trị ban đầu 0và bảo toàn kết quả trung gian

|x đảo ngược

2- thay 0 bằng 2 và ngược lại, giữ nguyên số 1

1, trả trước 1

(1=*x)_đầu tiên xbằng 1? nếu có, bỏ một phần tử, nếu không thì thả 0 phần tử (không làm gì cả)

2,trả trước 2 cho ">"mũi tên ban đầu

x#chúng ta có một chút quá nhiều danh sách, vì vậy hãy chỉ là người đầu tiên xtrong số họ

"<->" sử dụng các phần tử của danh sách (0/1/2) làm chỉ mục trong chuỗi này

05AB1E , 23 20 byte

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

Hãy thử trực tuyến!

Lần đầu tiên sử dụng 05AB1E hoặc bất kỳ ngôn ngữ chơi gôn nào khác cho vấn đề đó. Mọi ý tưởng đều được chào đón.

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

Hãy thử trực tuyến!

Sử dụng một đại biểu hành động để kéo đầu vào và không yêu cầu trả lại.

Ung dung:

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

Hãy thử trực tuyến! (Cảm ơn @Oliver)

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

Màu đỏ , 109 108 byte

-1 byte nhờ vào 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 #"-"]]]

Hãy thử trực tuyến!