Especificaciones

Dado un número n, genera una "flecha de meme" ASCII (mayor que el símbolo >) de tamaño n.

n siempre será un número entero positivo, mayor que 0.

Ejemplos

n = 2

\
 \
 /
/

n = 5

\
 \
  \
   \
    \
    /
   /
  /
 /
/

Código de muestra

Aquí hay un programa de muestra, escrito en Crystal, que devuelve los resultados correctos. Ejecútalo como ./arrow 10.

arrow.cr:

def f(i)
        i.times { |j|
                j.times { print ' ' }
                puts "\\"
        }
        i.times { |j|
                (i-j-1).times { print ' ' }
                puts '/'
        }
end

f(ARGV[0].to_i)

Reglas

• Este es el código de golf . La respuesta más corta gana. Sin embargo, no seleccionaré una respuesta, porque la respuesta más corta puede cambiar con el tiempo.
• Las lagunas estándar no están permitidas.

Lienzo , 2 bytes.

＼═

Pruébalo aquí!

C (gcc) , 56 bytes

f(n,i){for(i=-n;n;printf("%*c\n",i?++i+n:n--,i?92:47));}

Pruébalo en línea!

f(n,i){for(i=-n;i;printf("%*c\n",  ++i+n    ,  92   ));     //first print descending '\'s
       for(    ;n;printf("%*c\n",        n--,     47));}    // then print returning  '/'s

Python 2 , 54 bytes

f=lambda n,p='':n*'?'and p+'\\\n'+f(n-1,p+' ')+p+'/\n'

Pruébalo en línea!

Salidas con una nueva línea final.

05AB1E , 6 bytes

'\3.Λ∊

Pruébalo en línea!

Explicación

   .Λ    # draw
'\       # the string "\"
         # of length input
  3      # in the south-eastern direction
     ∊   # then vertically mirror it

C # (compilador interactivo de Visual C #) , 66 bytes

n=>new int[n*2].Select((a,b)=>"".PadLeft(b<n?b:n*2+~b)+"\\/"[b/n])

Guardado un byte gracias a @someone.

Pruébalo en línea!

C64Mini / C64 BASIC (y otras variantes de CBM BASIC), se utilizan 52 bytes BASIC tokenizados

 0INPUTN:N=N-1:FORI=0TON:PRINTTAB(I)"\":NEXT:FORI=NTO0STEP-1:PRINTTAB(I)"/":NEXT

Aquí está la versión no ofuscada para la explicación:

 0 INPUT N
 1 LET N=N-1
 2 FOR I=0 TO N
 3  PRINT TAB(I);"\"
 4 NEXT I
 5 FOR I=N TO 0 STEP -1
 6  PRINT TAB(I);"/"
 7 NEXT I

Cualquier número ingresado Nen la línea cero se reduce en uno ya que el TABcomando está indexado a cero; Los FOR/NEXTbucles en las líneas de la dos a la cuatro y de la cinco a la siete muestran la parte superior e inferior si la memeflecha respectivamente (representada por una fuente desplazada My desplazada Nen modo gráfico )

Ruby , 111 99 77 73 68 64 57 56 bytes

-12 bytes gracias a Benjamin Urquhart , -43 gracias a manatwork y -2 bytes gracias a Value Ink .

->i{s=[];puts (0...i).map{|j|s=(p=' '*j)+?/,*s;p+?\\},s}

Pruébalo en línea!

Explicación:

f=->i{                      # instead of a function, use a lambda
  s=[]                      # needs a helper variable *now*, for scope
  puts(                     # puts takes arbitrary num of args; \n after each
    (0...i).map{|j|         # not from 0 to i but from 0 to i-1 (*three* dots)
      s=(
        p=' '*j             # p will remain in scope inside of .map,
      )
      +?/                   # character literal instead of string
      ,*s                   # essentially appending to the array

      p+?\\                 # p is what's returned by .map, not s!

    },                      # up until here, 1st arg to display
    s                       # NOW, as the *2nd* arg, s is displayed
  )
}

Soluciones alternativas (pero más largas)

Un amigo leyó esta respuesta y luego trató de idear un par de enfoques más. Poniéndolos aquí también, para que no se pierdan en las grandes redes.

inyectar y no desplazar, 72 bytes

->n{puts (0...n).inject([]){|s,i|i=' '*(n-1-i);s.unshift i+?\\;s<<i+?/}}

Pruébalo en línea!

downto, inject y unshift, 80 bytes

->n{puts n.downto(1).map{|i|' '*(i-1)}.inject([]){|s,i|s<<i+?/;s.unshift i+?\\}}

Pruébalo en línea!

intrigante, dos bucles no anidados, 127 bytes

->n{
r=->s,c{s[0..-(c+1)],s[-c..-1]=s[c..-1],s[0..c-1];s};
n.times{|i|puts r[' '*n+?\\,n-i]}
n.times{|i|puts r[' '*n+?/,i+1]}
}

Pruébalo en línea!

Perl 5 -p , 36 bytes

$\=($q=$"x$_)."\\
$\$q/
"while$_--}{

Pruébalo en línea!

Código T-SQL, 80 bytes

DECLARE @ INT=3

,@z INT=0
x:PRINT
space(@-abs(@-@z-.5))+char(92-@z/@*45)SET
@z+=1IF @z<@*2GOTO x

Pruébalo en línea

Consulta T-SQL, 96 bytes

Para que esto funcione en línea, tuve que hacer algunas modificaciones menores. Los espacios al comienzo de una fila no se muestran en el fragmento en línea. Así que estoy usando ascii 160 en su lugar. Cuando se ejecuta en el estudio de administración, es posible cambiar la configuración para mostrar el resultado como texto, lo que daría como resultado los espacios correctos en este script publicado.

DECLARE @ INT=3
SELECT space(@-abs(@-number-.5))+char(92-number/@*45)FROM
spt_values WHERE number<@*2and'p'=type

Pruébalo en línea

PowerShell , 44 41 bytes

filter f{if($_){'\'
--$_|f|%{" $_"}
'/'}}

Pruébalo en línea!

MarioLANG , 719 677 bytes

+
+
+
+
+
+         ((((+)+++++)))<
+>======================"
+)++++++)+++++++++++((-[!)
========================#=-
) ![-    <+;)+++)---)++++)<
)=#======"=================
) >)+)+((!
+ "======#
         <))))).(((((((<
 ========">============"
>)+)+((-[!+))        -[!((((((((.)).))))+(-[!)
"========#=============#====================#<
!)                                          <
#==========================================="
                  >(((((.)))>
                  "========<"========
 ![-)).))).(((((((![-    ))+![-((+)+)<((![<
 #================#=========#========"==#="===
 >                                   !  >-!
 "===================================#  "=#

Pruébalo en línea!

Esto fue más difícil de lo esperado ...

brainfuck , 125 bytes

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

Pruébalo en línea!

++++++++++[->+>+++++++++>+++<<<]>>++>++>    ; Initialize with " \"
,                                           ; Get input
[->                                         ; loop and decrement n 
    [->+<<<.>>]                             ; output number of spaces, copy n
    <<<.                                    ; output \
    <.                                      ; output newline
    >>>>                                    
    >[-<+>]<+                               ; copy copy of n back to original place 
<]
<<[--<<+>>]<<+>>                            ; change "\" to "/"
>>>                             
[                                           ; second loop for bottom half
 -                                          ; decrement n
 [-<+<.>>]                                  ; output n spaces
 <<<<<.>.                                   ; output \ and newline
 >>>[->+<]>                                 ; copy n back
]

Carbón de leña , 5 bytes

↘Ｎ‖Ｍ↓

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

↘Ｎ

Ingrese un número e imprima una línea diagonal de \s de esa longitud.

‖Ｍ↓

Refleja la línea verticalmente.

APL (NARS), 40 caracteres, 80 bytes

{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}

prueba:

  h←{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}
  h 2
\ 
 \
 /
/ 
  h 5
\    
 \   
  \  
   \ 
    \
    /
   / 
  /  
 /   
/    

Retina 0.8.2 , 32 bytes

.+
$* ¶$&$* 
\G.
¶$`\
r`.\G
$'/¶

Pruébalo en línea! Explicación:

.+
$* ¶$&$* 

Genera dos líneas de nespacios.

\G.
¶$`\

Convierte la línea superior en una \diagonal.

r`.\G
$'/¶

Convierta la línea inferior en una /diagonal.

C (gcc) , 67 65 bytes

-2 bytes gracias a ceilingcat

f(n,i){for(i=~n;i++<n;)i&&printf("%*c\n",n-abs(i)+1,"/\\"[i<0]);}

Pruébalo en línea!

Python 2 , 85 84 81 80 75 bytes

def a(n):l="for i in range(n):print' '*";exec l+"i+'\\\\'\n"+l+"(n+~i)+'/'"

Pruébalo en línea!

PowerShell , 50 bytes

param($n)0..--$n|%{' '*$_+'\'}
$n..0|%{' '*$_+'/'}

Pruébalo en línea!

Buscará hacerlo para que solo atraviese el rango una vez. Sin embargo, no está mal para el método sin cerebro.

Ramita, 115 bytes

Construye la cadena hacia atrás, "devolviéndola" al final.

Utiliza una macro para generar todos los resultados.

{%macro a(N,s="")%}{%for i in N..1%}{%set s=('%'~i~'s
'~s~'%'~i~'s
')|format('\\','/')%}{%endfor%}{{s}}{%endmacro%}

Esta macro tiene que estar en un archivo e importarse así:

{% import 'macro.twig' as a %}

{{ a.a(<value>) }}

Puede probarlo en https://twigfiddle.com/5hzlpz (haga clic en "Mostrar resultado bruto").

Haskell , 52 49 bytes

-3 bytes gracias al Sriotchilism O'Zaic .

unlines.g
g 0=[]
g n="\\":map(' ':)(g$n-1)++["/"]

Pruébalo en línea!

MATL, 14 13 12 bytes

Xy92*t45-Pvc

1 Byte guardado gracias a @LuisMendo

Explicación

        % Implicitly grab the input as an integer
Xy      % Create an identity matrix this size
92*     % Multiply by 92 (ASCII for '\')
t       % Duplicate the matrix
45-     % Subtract 45 from every element yielding 47 (ASCII for '/') on the diagonal
        % and -45 everywhere else
P       % Vertically flip this matrix
v       % Vertically concatenate the two matrices
c       % Convert to characters (negative numbers are replaced with a space)
        % Implicitly display the result

Pruébelo en MATL Online

Python 3 , 90 83 bytes

lambda n:'\n'.join([' '*i+'\\'for i in range(n)]+[' '*(n+~i)+'/'for i in range(n)])

Pruébalo en línea!

-7 bytes gracias a @squid

Rockstar, 133 bytes

Pruébelo en línea aquí !

F takes N,S
If N is 0
Give back N

Say S+"\"
Let T be S+" "
Let M be N-1
F taking M,T
Say S+"/"

Listen to X
F taking X,""

Dado que Rockstar no es famoso por las operaciones de cadena, se necesita relativamente mucho código para hacerlo (recursivamente fue aún más largo).

El tamaño de la flecha se toma como entrada.

PHP ,79 63 61 bytes

function f($x,$s=''){if($x)echo"$s\\
",f($x-1,"$s "),"$s/
";}

Pruébalo en línea!

Recursivo en PHP.

-12 bytes por @manatwork

\ / \ /> , 74 bytes

jp100o
-84*}!o:?!x1
@+:q:p=?x:o~$:0(pa"\/"q?$~}}:
x2-:p$1-y$:0(?
.{suh?!;2

Explicación: (líneas giradas según el punto de inicio)

jp100o                        //setup
:?!x1-84*}!                   //add leading spaces, loop and decrement until 0
~$:0(pa"\/"q?$~}}:@+:q:p=?x:o //add correct slash, go back to loop or switch sides
$:0(?x2-:p$1-y                //flip direction state or continue to print
{suh?!;2.                     //remove extra data and print stack

Python 3 , 55 bytes

f=lambda n,i="":n and i+"\\\n"+f(n-1,i+" ")+i+"/\n"or""

Pruébalo en línea!

Python 2 , 63 bytes

f=lambda n,s='':n and f(n-1,~-n*' '+'\\\n'+s+~-n*' '+'/\n')or s

Pruébalo en línea!

Stax , 10 bytes

Ç₧¥╗M'gQ9⌂

Ejecutar y depurarlo

SimpleTemplate , 100 bytes

Este fue un desafío bastante divertido, pero algunos errores en el lenguaje dificultaron la optimización.

{@set_ argv.0}{@while_}{@callstr_repeat intoS" ",_}{@setO S,"\\\n",O,S,"/\n"}{@incby-1_}{@/}{@echoO}

Básicamente, recorre los valores hacia atrás, trabajando la cadena desde la mitad.

Cómo debería ser la respuesta

Debido a los errores, el código no se interpretaba correctamente.

Así sería el código, si el compilador no tuviera ningún error (86 bytes):

{@forfrom argv.0to0step-1}{@callrepeat intoS" ",_}{@setO S,"\\
",O,S,"/
"}{@/}{@echoO}

Oh, bueno, al menos la solución funciona: x

JavaScript (Node.js) , 42 bytes (si se permite el rastreo de una nueva línea)

n=>(F=s=>n--?s+`\\
`+F(s+" ")+s+`/
`:"")``

Pruébalo en línea!

JavaScript (Node.js) , 48 46 bytes

n=>(F=s=>s+`\\
${--n?F(s+" ")+`
`:""}${s}/`)``

Pruébalo en línea!