Ce défi consiste à imprimer une série de flèches croissantes de type ASCII. Je vais décrire le motif avec des mots, mais il pourrait être plus facile de regarder à quoi ressemble le début de cette série:

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

Une flèche de longueur n contient une pointe de flèche ( <ou >) et des n-1tirets ( -). Une flèche orientée vers la droite a les tirets en premier, puis a >. Une flèche orientée vers la gauche commence par <et est suivie des tirets. La série se compose d'une longueur de nflèche orientée vers la droite suivie d'une longueur n de flèche orientée vers la gauche, avec n de 1 à l'infini.

Pour relever le défi, écrivez un programme ou une fonction qui prend une entrée, un entier i >= 1et génère les premières iflèches. Les flèches sont individuelles, pas dans des paires droite-gauche, donc pour i=3vous, vous devez sortir:

>
<
->

Vous pouvez renvoyer une liste de chaînes ou les imprimer l'une après l'autre. En cas d'impression, les flèches doivent être délimitées par un délimiteur cohérent, qui ne doit pas nécessairement être une nouvelle ligne comme dans l'exemple.

Il s'agit de code-golf , donc le moins d'octets gagne.

Toile , 10 octets

⇵-×<ｎ¹［↔｝］

Essayez-le ici!

R , 69 octets

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

Essayez-le en ligne!

• -5 octets grâce à @Giuseppe
• -3 octets grâce à @Robert S.

Java (JDK) , 81 octets

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

Essayez-le en ligne!

Explications

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 octets

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

Essayez-le en ligne!

Récursion ancienne: commencez par string p= ">", collect p, un <devant tout sauf le dernier caractère de pet un appel récursif avec un -mis devant p. Prenez les premiers néléments de cette liste.

Edit: -1 octet grâce à @xnor.

Commodore BASIC V2 (C64), 94 octets

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

Pas entièrement sûr du nombre d'octets, cela est basé sur la représentation textuelle pour taper le programme valide. Il est un peu plus court sur le disque (91 octets) car BASIC V2 utilise une représentation "tokenisée" des programmes.

Démo en ligne

Légèrement "non golfé":

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 auto-modifiable , 55 octets

Prenez l'entrée comme code de caractère.
Ne prend en charge la saisie que jusqu'à 255.
Utilisez un caractère nul pour séparer les lignes.

Par coïncidence, tous les caractères de dessin de flèche sont utilisés comme commandes BF. Malheureusement, il n'enregistre aucun octet (actuellement).

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

Essayez-le en ligne!

Explication

 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 octets

merci à et Jo King pour avoir corrigé un bug.

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

Essayez-le en ligne!

Pyth, 17 octets

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

La sortie est une liste de chaînes. Essayez-le en ligne ici .

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 octets

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

Essayez-le en ligne!

Boucles du 0haut vers l'entrée $n, chaque itération créant deux chaînes de flèches. Ceux-ci sont ensuite indexés avec 0..--$npour extraire le nombre correct d'éléments.

6 octets enregistrés grâce à KGlasier.

Python 3, 53 octets

Ma première réponse codegolf.

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

-10 octets grâce à Jo King

Haskell , 51 44 octets

^{-7 octets grâce à xnor (en utilisant iteratela compréhension de liste)!}

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

Essayez-le en ligne!

Explication / Non golfé

L'utilisation de do-notation nous permet d'économiser un concat, et l'utilisation de la notation infixe permet une fonction sans point avec take, annuler ceux-ci donnerait:

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

Japt -m, 16 15 13 12 octets

1 octet enregistré grâce à Shaggy

g<i>)iUUz ç-

Testez-le en ligne

Explication:

-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

Gelée , 15 octets

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

Essayez-le en ligne!

MathGolf , 17 15 octets

Enregistré 2 octets grâce à Jo King et Kevin Cruijssen

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

Essayez-le en ligne!

Explication

L'approche de 15 octets est différente de ma solution d'origine, je ne peux pas prendre le crédit de la mise en œuvre.

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

"<>"¬hUUz ç-)q

Essayez-le en ligne!

Mis à jour avec une toute nouvelle méthode.

Explication:

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

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

Essayez-le en ligne!

-3 octets avec idée en ASCII uniquement .

-1 avec \0au lieu de\n

-5 réarrangement des pièces

La sortie inclut une fin \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 octets

Renvoie une chaîne séparée par des espaces.

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

Essayez-le en ligne!

SNOBOL4 (CSNOBOL4) , 123 122 118 octets

	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	

Essayez-le en ligne!

V , 22 octets

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

Essayez-le en ligne!

Fusain , 16 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. J'avais trois solutions de 17 octets avant de finalement tomber sur celle-ci. Explication:

Ｎθ

Entrée n.

Ｆθ«

Répétez les ntemps, indexés 0.

⊘ι

Tracez une ligne de -s de longueur moitié de l'index (tronquée).

↓>

Dessinez la pointe de flèche et passez à la ligne suivante.

‖Ｔ»

Refléter tout, renversant les pointes de flèches.

Ｆθ‖Ｔ

La boucle ci-dessus a des nréflexions, mais nous avons besoin d'un nombre pair de réflexions, alors effectuez une autre nréflexion.

Nettoyer , 76 73 octets

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

Essayez-le en ligne!

Utilise le fait soigné qui ['-','-'..]est le même que ['--'..]pour économiser un peu.

JavaScript, 49 octets

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

Essayez-le en ligne!

Powershell, 51 octets

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

6502 code machine (C64), 49 octets

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

Encore un peu plus court que BASIC ;) Celui-ci n'a une plage de nombres que 255parce que la taille entière naturelle de la machine n'a que 8 bits.

Démo en ligne

Utilisation: SYS49152,[n](par exemple SYS49152,3pour l'exemple du défi)

Démontage commenté :

         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 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui renvoie une liste de lignes.

K (ngn / k) , 31 29 octets

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

Essayez-le en ligne!

nous créons d'abord des listes avec 0 au lieu de "<", 1 au lieu de "-"et 2 au lieu de ">":

{ } fonction avec argument x

x{... }\0appliquer les xtemps des fonctions internes , en commençant par une valeur initiale de 0et en préservant les résultats intermédiaires

|x sens inverse

2- remplacer 0 par 2 et vice versa, garder les 1 tels quels

1, ajouter un 1

(1=*x)_ est le premier de x égal à 1? si oui, supprimez un élément, sinon supprimez 0 élément (ne faites rien)

2,ajouter un 2 pour la ">"flèche initiale

x#nous avons un peu trop de listes, alors ne prenez que la première xd'entre elles

"<->" utiliser les éléments des listes (0/1/2) comme indices dans cette chaîne

05AB1E , 23 20 octets

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

Essayez-le en ligne!

Pour la première fois, utilisez 05AB1E ou toute autre langue de golf. Toutes les idées sont les bienvenues.

-3 de Kevin Cruijssen

C # (.NET Core) , 90 octets

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

Essayez-le en ligne!

Utilise un délégué Action pour extraire l'entrée et ne nécessite pas de retour.

Non golfé:

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 octets

Essayez-le en ligne! (Merci à @Oliver)

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

Rouge , 109 108 octets

-1 octet grâce à 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 #"-"]]]

Essayez-le en ligne!