Especificações

Dado um número n, produza uma "seta de meme" ASCII (símbolo maior que >) , de tamanho n.

n sempre será um número inteiro positivo, maior que 0.

Exemplos

n = 2

\
 \
 /
/

n = 5

\
 \
  \
   \
    \
    /
   /
  /
 /
/

Código de amostra

Aqui está um programa de amostra, escrito em Crystal, que retorna os resultados corretos. Execute-o 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)

Regras

• Isso é código-golfe . A resposta mais curta vence. No entanto, não selecionarei uma resposta, porque a resposta mais curta pode mudar com o tempo.
• As brechas padrão não são permitidas.

Tela , 2 bytes

＼═

Experimente aqui!

C (gcc) , 56 bytes

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

Experimente online!

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'

Experimente online!

Saídas com uma nova linha à direita.

05AB1E , 6 bytes

'\3.Λ∊

Experimente online!

Explicação

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

C # (compilador interativo do Visual C #) , 66 bytes

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

Guardou um byte graças a @someone.

Experimente online!

C64Mini / C64 BASIC (e outras variantes do CBM BASIC), 52 bytes BASIC tokenizados usados

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

Aqui está a versão não ofuscada para exaplantion:

 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

Qualquer número inserido Nna linha zero é reduzido em um, pois o TABcomando é indexado a zero; Os FOR/NEXTloops nas linhas de dois a quatro e de cinco a sete saem da parte superior e inferior se a memeseta respectivamente (representada por uma fonte deslocada Me deslocada Nno modo gráfico )

Ruby , 111 99 77 73 68 64 57 56 bytes

-12 bytes graças a Benjamin Urquhart , -43 graças a manatwork e -2 bytes graças a Value Ink .

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

Experimente online!

Explicação:

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

Soluções alternativas (mas mais longas)

Um amigo leu essa resposta e tentou criar mais algumas abordagens. Colocá-los aqui também, para que não se percam nas vastas interwebs.

injetar e não mudar, 72 bytes

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

Experimente online!

downto, injetar e não mudar, 80 bytes

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

Experimente online!

intrigante, dois loops não aninhados, 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]}
}

Experimente online!

Perl 5 -p , 36 bytes

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

Experimente online!

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

Experimente online

Consulta T-SQL, 96 bytes

Para fazer este trabalho online, tive que fazer algumas pequenas alterações. Os espaços no início de uma linha não são exibidos no snippet online. Então, eu estou usando ascii 160 em vez disso. Ao executar no Management Studio, é possível alterar as configurações para mostrar o resultado como texto, o que resultaria nos espaços corretos neste script publicado.

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

Experimente online

PowerShell , 44 41 bytes

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

Experimente online!

MarioLANG , 719 677 bytes

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

Experimente online!

Isso foi mais difícil do que o esperado ...

brainfuck , 125 bytes

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

Experimente online!

++++++++++[->+>+++++++++>+++<<<]>>++>++>    ; 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
]

Carvão , 5 bytes

↘Ｎ‖Ｍ↓

Experimente online! Link é a versão detalhada do código. Explicação:

↘Ｎ

Insira um número e imprima uma linha diagonal de \s desse comprimento.

‖Ｍ↓

Reflita a linha verticalmente.

APL (NARS), 40 caracteres, 80 bytes

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

teste:

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

Retina 0.8.2 , 32 bytes

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

Experimente online!Explicação:

.+
$* ¶$&$* 

Gere duas linhas de n espaços.

\G.
¶$`\

Transforme a linha superior em um \ diagonal.

r`.\G
$'/¶

Transforme a linha inferior em uma /diagonal.

C (gcc) , 67 65 bytes

-2 bytes graças ao ceilingcat

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

Experimente online!

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)+'/'"

Experimente online!

PowerShell , 50 bytes

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

Experimente online!

Irá procurar fazê-lo para que ele só passe pelo intervalo uma vez. Nada mal para o método sem cérebro.

Galho, 115 bytes

Constrói a string para trás, "retornando" no final.

Usa uma macro para gerar todos os resultados.

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

Essa macro deve estar em um arquivo e importada assim:

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

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

Você pode experimentá-lo em https://twigfiddle.com/5hzlpz (clique em "Mostrar resultado bruto").

Haskell , 52 49 bytes

-3 bytes graças ao Sriotchilism O'Zaic .

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

Experimente online!

MATL, 14 13 12 bytes

Xy92*t45-Pvc

1 Byte salvo graças a @LuisMendo

Explicação

        % 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

Experimente no MATL Online

Python 3 , 90 83 bytes

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

Experimente online!

-7 bytes graças a @squid

Rockstar, 133 bytes

Experimente online aqui !

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

Como a Rockstar não é famosa por operações com strings, é necessário muito código para fazê-lo (recursivamente, foi ainda mais longo).

O tamanho da seta é considerado como entrada.

PHP ,79 63. 61 bytes

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

Experimente online!

Recursivo em 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

Explicação: (linhas giradas com base no ponto inicial)

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

Experimente online!

Python 2 , 63 bytes

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

Experimente online!

Stax , 10 bytes

Ç₧¥╗M'gQ9⌂

Execute e depure

SimpleTemplate , 100 bytes

Este foi um desafio bastante divertido, mas alguns erros no idioma dificultaram a otimização.

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

Basicamente, percorre os valores para trás, trabalhando a corda do meio para fora.

Como deve ser a resposta

Devido aos erros, o código não estava sendo interpretado corretamente.

É assim que o código seria, se o compilador não tivesse nenhum erro (86 bytes):

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

Bem, pelo menos a solução funciona: x

JavaScript (Node.js) , 42 bytes (se uma nova linha à direita for permitida)

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

Experimente online!

JavaScript (Node.js) , 48 46 bytes

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

Experimente online!