Bu zorluk, bir dizi büyüyen ASCII-art okunu basmakla ilgilidir. Deseni kelimelerde açıklayacağım, ancak bu dizinin başlangıcının nasıl göründüğüne bakmak daha kolay olabilir:

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

N uzunluklu bir ok bir ok ucu ( <veya >) ve n-1kısa çizgiler ( -) içerir. Sağa bakan bir ok önce tire, sonra a >. Sola dönük bir okla başlar <ve ardından kısa çizgilerle izlenir. Seri, bir uzunluk nsağa bakan ok ve bunu takip eden bir uzunluk n sola bakan bir ok ve n'den 1'e kadar sonsuzluktan oluşur.

Meydan okumayı tamamlamak için bir girdi, bir tam sayı i >= 1alan ve ilk iokları çıkaran bir program veya işlev yazın . Oklar sağ sol çiftlerde değil, bireyseldir, bu nedenle i=3sizin için çıktı vermelisiniz:

>
<
->

Bir dizi listesi döndürebilir veya birbiri ardına yazdırabilirsiniz. Yazdırılıyorsa, oklar, örnekte olduğu gibi yeni bir satır olması gerekmeyen tutarlı bir sınırlayıcı tarafından sınırlandırılmalıdır.

Bu kod golf , yani en az bayt kazanır.

Tuval , 10 bayt

⇵-×<ｎ¹［↔｝］

Burada dene!

R , 69 bayt

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

Çevrimiçi deneyin!

• @Giuseppe sayesinde -5 bayt
• @Robert S. sayesinde -3 bayt

Java (JDK) , 81 bayt

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

Çevrimiçi deneyin!

açıklamalar

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 bayt

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

Çevrimiçi deneyin!

Düz eski özyineleme: string p= ">", collect p, <sonuncusu dışındakilerin hepsinin önünde pbir tane -ve önüne konan bir özyinelemeli çağrı ile başlayın p. nBu listenin ilk öğelerini al .

Düzenleme: @ xnor sayesinde -1 bayt.

Commodore BASIC V2 (C64), 94 bayt

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

Bayt sayısı hakkında tam olarak emin değil, bu geçerli programı yazmak için metin gösterimini temel alır. Diskte biraz daha kısa (91 bayt), çünkü BASIC V2 programların "tokenized" gösterimini kullanıyor.

Çevrimiçi Demo

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

Kendini değiştiren Brainfuck , 55 bayt

Girdiyi karakter kodu olarak alın.
Sadece 255'e kadar olan girişi destekler
. Satırları ayırmak için boş karakter kullanın.

Tesadüfen, tüm ok çizme karakterleri BF komutları olarak kullanılır. Ne yazık ki, herhangi bir bayt kaydetmiyor (şu anda).

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

Çevrimiçi deneyin!

açıklama

 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 bayt

ve bir hatayı düzelttiği için Jo King'e teşekkürler.

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

Çevrimiçi deneyin!

Pyth, 17 bayt

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

Çıktı, dizelerin bir listesidir. Burada çevrimiçi deneyin .

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 bayt

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

Çevrimiçi deneyin!

Her yinelemede iki ok dizgisi yaratan 0girişten döngüye kadar $ndöner. Bunlar daha sonra 0..--$ndoğru sayıda elementi çıkarmak için endekslenir .

KGlasier sayesinde 6 bayt kurtarıldı.

Python 3, 53 bayt

İlk codegolf cevabım.

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

Jo King sayesinde -10 bayt

Haskell , 51 44 bayt

^{Xnor sayesinde -7 bayt ( iterateliste-anlama) kullanarak !}

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

Çevrimiçi deneyin!

Açıklama / Ungolfed

do-Notation kullanmak bize bir tasarruf sağlar concatve infix-notation kullanmak, şunların çözülmesine neden olan noktasuz bir fonksiyon sağlar take:

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

Japt -m, 16 15 13 12 bayt

Shaggy sayesinde 1 bayt kaydedildi

g<i>)iUUz ç-

Çevrimiçi olarak test edin

Açıklama:

-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

Jöle , 15 bayt

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

Çevrimiçi deneyin!

MathGolf , 17 15 bayt

Jo King ve Kevin Cruijssen sayesinde 2 bayt kaydedildi

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

Çevrimiçi deneyin!

açıklama

15 baytlık yaklaşım orijinal çözümümden farklı, uygulama için kredi alamıyorum.

{                 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 bayt

"<>"¬hUUz ç-)q

Çevrimiçi deneyin!

Tamamen yeni bir yöntemle güncellendi.

Açıklama:

                  #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 bayt

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

Çevrimiçi deneyin!

Sadece ASCII'den gelen fikri olan -3 bayt .

-1 ile \0yerine\n

-5 parçaları yeniden düzenleme

Çıktı bir iz içerir \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 bayt

Boşluklu bir dize döndürür.

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

Çevrimiçi deneyin!

SNOBOL4 (CSNOBOL4) , 123 122 118 bayt

	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	

Çevrimiçi deneyin!

V , 22 bayt

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

Çevrimiçi deneyin!

Kömür , 16 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Sonunda bunun üzerine gelmeden önce üç adet 17 baytlık çözümüm vardı. Açıklama:

Ｎθ

Giriş n.

Ｆθ«

n0 indeksli zamanları tekrarlayın .

⊘ι

-Dizinin yarısı uzunluğunda bir çizgi çizin (kesilmiş).

↓>

Ok ucunu çizin ve bir sonraki satıra geçin.

‖Ｔ»

Ok uçlarını çevirerek her şeyi yansıtın.

Ｆθ‖Ｔ

Yukarıdaki döngünün nyansımaları vardır, ancak eşit sayıda yansımaya ihtiyacımız var, bu yüzden başka bir nyansıma gerçekleştirin .

Temiz , 76 73 bayt

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

Çevrimiçi deneyin!

Biraz tasarrufta ['-','-'..]olduğu gibi aynı gerçeği kullanır ['--'..].

JavaScript, 49 bayt

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

Çevrimiçi deneyin!

Powershell, 51 bayt

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

6502 makine kodu (C64), 49 bayt

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

Yine oldukça daha kısa bit BASIC ;) Bu sadece kadar bir sayı aralığı vardır 255makinenin doğal tam sayı boyutu sadece 8 bit sahip bulunmaktadır.

Çevrimiçi demo

Kullanım: SYS49152,[n](örneğin SYS49152,3, meydan okumadan gelen örnek için)

Yorum yapılan sökme :

         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 bayt

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

Çevrimiçi deneyin!

Satır listesini döndüren adsız kod bloğu.

K (ngn / k) , 31 29 bayt

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

Çevrimiçi deneyin!

ilk önce 0 yerine "<", 1 yerine 1 "-"ve 2 yerine liste oluştururuz ">":

{ } argümanlı fonksiyon x

x{... }\0iç fonksiyon xsürelerini başlangıç ​​değeri ile başlayan 0ve ara sonuçların korunmasıyla uygulayın

|x ters

2- 0'ı 2 ile değiştirin ve tam tersi, 1leri olduğu gibi bırakın

1, 1 hazırlamak

(1=*x)_ilkidir x1'e eşit? eğer evet ise, bir elementi bırakın, aksi takdirde 0 elementi bırakın (hiçbir şey yapmayın)

2,ilk ">"ok için bir 2 hazırlayın

x#çok fazla listemiz var, o yüzden sadece xbunlardan birincisini alın

"<->" listelerin elemanlarını (0/1/2) bu dizgede indeks olarak kullanın

05AB1E , 23 20 bayt

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

Çevrimiçi deneyin!

Bu konuda 05AB1E veya başka bir golf dilini ilk kez kullanıyorsanız. Herhangi bir fikir hoş geldiniz.

-3 Kevin Cruijssen tarafından

C # (.NET Core) , 90 bayt

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

Çevrimiçi deneyin!

Girişi çekmek için bir Eylem temsilcisi kullanır ve iade gerektirmez.

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 bayt

Çevrimiçi deneyin! (@Oliver sayesinde)

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

Kırmızı , 109 108 bayt

NK1406 sayesinde -1 bayt

func[n][repeat i n[print reduce[pick[pad/with pad/left/with]k: i% 2 + 1
pick copy"<>"k i / 2 + k - 1 #"-"]]]

Çevrimiçi deneyin!