Sua tarefa é escrever um programa ou uma função que imprima um triângulo ASCII. Eles se parecem com isso:

|\
| \
|  \
----

Seu programa terá uma única entrada numérica n, com as restrições 0 <= n <= 1000. O triângulo acima tinha um valor de n=3.

O triângulo ASCII terá nbarras invertidas ( \) e barras verticais ( |), n+1linhas e traços ( -), e cada linha terá uma quantidade de espaços igual ao número da linha (com base em 0, ou seja, a primeira linha é a linha 0) além da linha final .

Exemplos:

Entrada:

4

Saída:

|\
| \
|  \
|   \
-----

Entrada:

0

Saída:

Nesse caso de teste, a saída deve estar vazia. Sem espaço em branco.

Entrada:

1

Saída:

|\
--

Entrada e saída devem ser exatamente como eu especifiquei.

Este é o código-golfe , então procure o código mais curto possível!

Gelatina , 14 bytes

’⁶x⁾|\jṄµ€Ṫ”-ṁ

Experimente online!

Como funciona.

’⁶x⁾|\jṄµ€Ṫ”-ṁ  Main link. Argument: n

        µ       Combine the links to the left into a chain.
         €      Map the chain over [1, ..., n]; for each k:
’                 Decrement; yield k-1.
 ⁶x               Repeat the space character k-1 times, yielding a string.
   ⁾\j            Join the character array ['|', '\'], separating by those spaces.
      Ṅ           Print the result, followed by a linefeed.
         Ṫ      Tail; extract the last line.
                This will yield 0 if the array is empty.
          ⁾-ṁ   Mold the character '-' like that line (or 0), yielding a string
                of an equal amount of hyphen-minus characters.  

C, 58 bytes

i;f(n){for(i=2*n;~i--;printf(i<n?"-":"|%*c\n",2*n-i,92));}

-

Graças à @Steadybox, os comentários sobre esta resposta me ajudaram a raspar alguns bytes na minha solução acima

Javascript (ES6), 97 85 81 75 74 bytes

n=>(g=(n,s)=>n?g(--n,`|${" ".repeat(n)}\\
`+s):s)(n,"")+"-".repeat(n&&n+1)

Acontece que eu não estava usando recursão suficiente

f=n=>(g=(n,s)=>n?g(--n,`|${" ".repeat(n)}\\
`+s):s)(n,"")+"-".repeat(n&&n+1)

console.log(f(0))
console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))

05AB1E , 16 15 16 bytes

Guardou um byte graças a Adnan

FðN×…|ÿ\}Dg'-×»?

Experimente online!

Explicação

F       }         # for N in range [0 ... input-1]
 ðN×              # push <space> repeated N times
    …|ÿ\          # to the middle of the string "|\"
         Dg       # get length of last string pushed
           '-×    # repeat "-" that many times
              »   # join strings by newline
               ?  # print without newline

V , 18 17 16 bytes

1 byte economizado graças ao @ nmjcman101 por usar outra maneira de não produzir nada se a entrada for 0

é\é|ÀñÙá ñÒ-xÀ«D

Experimente online!

Hexdump:

00000000: e95c e97c c0f1 d9e1 20f1 d22d 78c0 ab44  .\.|.... ..-x..D

Explicação (desatualizada)

Primeiro temos um loop para verificar se o argumento é 0. Nesse caso, o código abaixo é executado ( |\está escrito). Caso contrário, nada será gravado e o buffer estará vazio.

Àñ     ñ            " Argument times do:
  é\é|              " Write |\
      h             " Exit loop by creating a breaking error

Agora que chegamos ao topo do triângulo, precisamos criar seu corpo.

Àñ   ñ              " Argument times do:
  Ù                 " Duplicate line, the cursor comes down
   à<SPACE>         " Append a space

Agora temos uma linha extra na parte inferior do buffer. Isso deve ser substituído por -s.

Ó-                  " Replace every character with a -
   x                " Delete the extra '-'

Esta resposta seria mais curta se pudéssemos o que queremos para entrada 0

V , 14 13 bytes

é\é|ÀñÙá ñÒ-x

Experimente online!

C #, 93 bytes

n=>{var s=n>0?new string('-',n+1):"";while(n-->0)s="|"+new string(' ',n)+"\\\n"+s;return s;};

Função anônima que retorna o triângulo ASCII como uma string.

Programa completo com funções comentadas e não testadas:

using System;

class ASCIITriangles
{
    static void Main()
    {
      Func<int, string> f =
      n =>
      {
          // creates the triangle's bottom, made of dashes
          // or an empty string if n == 0
          var s = n > 0 ? new string('-', n + 1) : "";

          // a bottom to top process
          while ( n-- > 0)
          // that creates each precedent line
            s = "|" + new string(' ', n) + "\\\n" + s;

          // and returns the resulting ASCII art
          return s;
      };

      // test cases:
      Console.WriteLine(f(4));
      Console.WriteLine(f(0));
      Console.WriteLine(f(1));
    }
}

Python 2 , 69 bytes

lambda x:'\n'.join(['|'+' '*n+'\\'for n in range(x)]+['-'*-~x*(x>0)])

Experimente online!

CJam , 24 22 21 bytes

Guardado 1 byte graças a Martin Ender

ri_{S*'|\'\N}%\_g+'-*

Experimente online!

Explicação

ri                     e# Take an integer from input
  _                    e# Duplicate it
   {                   e# Map the following to the range from 0 to input-1
    S*                 e#   Put that many spaces
      '|               e#   Put a pipe
        \              e#   Swap the spaces and the pipe
         '\            e#   Put a backslash
           N           e#   Put a newline
            }%         e# (end of map block)
              \        e# Swap the top two stack elements (bring input to the top)
               _g+     e# Add the input's signum to itself. Effectively this increments any 
                       e#  non-zero number and leaves zero as zero.
                  '-*  e# Put that many dashes

SmileBASIC, 51 bytes

INPUT N
FOR I=0TO N-1?"|";" "*I;"\
NEXT?"-"*(N+!!N)

PowerShell , 51 67 bytes

param($n)if($n){1..$n|%{"|"+" "*--$_+"\"};write-host -n ('-'*++$n)}

Experimente online!

(Aumento de bytes para explicar a nova linha sem retorno)

Recebe a entrada $ne verifica se é diferente de zero. Em seguida, faz laços para construir o triângulo e termina com uma linha de -. Implícito Write-Outputacontece na conclusão do programa.

Retina , 39 bytes

.*
$*
*\`(?<=(.*)).
|$.1$* \¶
1
-
-$
--

Experimente online

Converta a entrada decimal em unário. Substitua cada um 1por |<N-1 spaces>\¶, imprima e desfaça a substituição. Substitua cada 1um com um hífen, e o último com dois hífens. Tadaa!

Lisp comum, 89 86 bytes

Cria uma função anônima que pega a entrada n e imprime o triângulo em *standard-output*(stdout, por padrão).

Golfe

(lambda(n)(when(< 0 n)(dotimes(i n)(format t"|~v@t\\~%"i))(format t"~v,,,'-<~>"(1+ n))))

Ungolfed

(lambda (n)
  (when (< 0 n)
    (dotimes (i n)
      (format t "|~v@t\\~%" i))
    (format t "~v,,,'-<~>" (1+ n))))

Tenho certeza de que poderia tornar isso mais curto de alguma forma.

C 101 93 75 bytes

f(n){i;for(i=0;i++<n;)printf("|%*c\n",i,92);for(;n--+1;)prin‌​tf("-");}

Versão ungolfed

void f(int n)
{
  int i;

  for(i=0;i++<n;)
    printf("|%*c\n",i,92);

  for(;n--+1;)
    printf("-");

}

@Steadybox Obrigado por apontar, faz muito sentido.

Carvão , 15 bytes

Ｎβ¿β«↓β→⁺¹β↖↖β»

Experimente online!

Demolir

Ｎβ¿β«↓β→⁺¹β↖↖β»
Ｎβ               assign input to variable β
   ¿β«         »  if β != 0:
      ↓β           draw vertical line β bars long
        →⁺¹β       draw horizontal line β+1 dashes long
            ↖      move cursor up one line and left one character
             ↖β    draw diagonal line β slashes long

Japonês , 20 bytes

Economizou 2 bytes graças a @ETHproductions

o@'|+SpX +'\Ãp-pUÄ)·

Experimente online!

Explicação

o@'|+SpX +'\Ãp-pUÄ)·
o                       // Creates a range from 0 to input
 @                      // Iterate through the array
  '|+                   // "|" + 
     SpX +              // S (" ") repeated X (index) times +
          '\Ã            // "\" }
             p-pU       // "-" repeated U (input) +1 times
                 Ä)·    // Join with newlines

J, 20 bytes

-13 bytes graças a bob

*#' \|-'{~3,~2,.=@i.

Experimente online!

original: 33 bytes

(#&'| \'@(1,1,~])"0 i.),('-'#~>:)

destroçado

(#&'| \' @ (1,1,~])"0 i.) , ('-'#~>:)

Experimente online!

Pyke, 18 17 bytes

I Fd*\|R\\s)Qh\-*

Experimente aqui!

Python2, 73 bytes

n=input()
w=0
exec'print"|"+" "*w+"\\\\"+("\\n"+"-"*-~n)*(w>n-2);w+=1;'*n

Um programa completo. Eu também tentei interpolação de strings para a última linha, mas acabou sendo alguns bytes a mais: /

exec'print"|%s\\\\%s"%(" "*w,("\\n"+"-"*-~n)*(w>n-2));w+=1;'*n

Outra solução em 73 bytes:

n=j=input()
exec'print"|"+" "*(n-j)+"\\\\"+("\\n"+"-"*-~n)*(j<2);j-=1;'*n

Casos de teste

0:

1:
|\
--

2:
|\
| \
---

3:
|\
| \
|  \
----

6:
|\
| \
|  \
|   \
|    \
|     \
-------

MATL , 19 bytes

?'\|- '2GXyYc!3Yc!)

Experimente online!

?         % Implicit input. If non-zero
  '\|- '  %   Push this string
  2       %   Push 2
  G       %   Push input
  Xy      %   Identity matrix of that size
  Yc      %   Prepend a column of 2's to that matrix
  !       %   Transpose
  3       %   Push 3
  Yc      %   Postpend a column of 3's to the matrix
  !       %   Transpose
  )       %   Index into string
          % Implicit end. Implicit display

QBIC , 41 bytes

:~a>0|[a|?@|`+space$(b-1)+@\`][a+1|Z=Z+@-

Explicação

:~a>0|  Gets a, and checks if a > 0
        If it isn't the program quits without printing anything
[a|     For b=1; b <= a; b++
?@|`+   Print "|"
space$  and a number of spaces
(b-1)   euqal to our current 1-based line - 1
+@\`    and a "\"
]       NEXT
[a+1|   FOR c=1; c <= a+1; c++
Z=Z+@-  Add a dash to Z$
        Z$ gets printed implicitly at the end of the program, if it holds anything
        The last string literal, IF and second FOR loop are closed implicitly.

R, 101 bytes

for(i in 1:(n=scan())){stopifnot(n>0);cat("|",rep(" ",i-1),"\\\n",sep="")};cat("-",rep("-",n),sep="")

Este código está em conformidade com o n=0caso de teste se você considerar apenas STDOUT!
Na verdade, a stopifnot(n>0)parte pára a execução do script, exibe nada STDOUT, mas escreve Error: n > 0 is not TRUEpara SDTERR.

Ungolfed:

for(i in 1:(n=scan()))
    {
    stopifnot(n>0)
    cat("|", rep(" ", i-1), "\\\n", sep = "")
    }

cat("-", rep("-", n), sep = "")

Python 2 , 62 bytes

n=input();s='\\'
exec"print'|'+s;s=' '+s;"*n
if n:print'-'*-~n

Experimente online!

Imprime linha por linha, sempre adicionando outro espaço antes da barra invertida. Se uma função que não imprime seria permitida, provavelmente seria mais curta.

JavaScript (ES6), 71 bytes

f=
n=>console.log(' '.repeat(n).replace(/./g,'|$`\\\n')+'-'.repeat(n+!!n))

<form onsubmit=f(+i.value);return!true><input id=i type=number><input type=submit value=Go!>

Saídas para o console. Economize 6 bytes se a impressão no shell SpiderMonkey JavaScript for aceitável. Salve 13 bytes se o retorno da saída for aceitável.

Python 2 , 67 bytes

Outra função no Python 2, usando rjust.

lambda n:('|'.join(map('\\\n'.rjust,range(n+2)))+'-'*-~n)[4:]*(n>0)

Experimente online!

Python 3 , 60 bytes

f=lambda n,k=0:k<n and'|'+' '*k+'\\\n'+f(n,k+1)or'-'[:n]*-~n

Experimente online!

Mais duas soluções com a mesma contagem de bytes.

f=lambda n,k=0:n and'|'+' '*k+'\\\n'+f(n-1,k+1)or-~k*'-'[:k]
f=lambda n,s='|':-~n*'-'[:n]if s[n:]else s+'\\\n'+f(n,s+' ')

Perl, 63 bytes

$n=shift;print'|',$"x--$_,"\\\n"for 1..$n;print'-'x++$n,$/if$n

Ungolfed:

$ perl -MO=Deparse triangle.pl
$n = shift @ARGV;
print '|', $" x --$_, "\\\n" foreach (1 .. $n);
print '-' x ++$n, $/ if $n;

$"é o separador de lista, cujo padrão é "". $/é o separador de registros de saída, cujo padrão é "\ n". $_é a variável implícita do loop.

Haskell , 82 65 bytes

g 0=""
g n=((take n$iterate(' ':)"\\\n")>>=('|':))++([0..n]>>"-")

Experimente online! Uso:

Prelude> g 4
"|\\\n| \\\n|  \\\n|   \\\n-----"

Ou melhor:

Prelude> putStr $ g 4
|\
| \
|  \
|   \
-----

Pitão, 23 18 bytes

VQ++\|*dN\\)IQ*\-h

Conjunto de testes disponível online.
Agradecimentos a Ven por jogar fora 5 bytes.

Explicação

VQ++\|*dN\\)IQ*\-h
 Q           Q    Q  [Q is implicitly appended, initializes to eval(input)]
       d             [d initializes to ' ' (space)]
VQ         )         For N in range(0, eval(input)):
      *dN             Repeat space N times
   +\|                Prepend |
  +      \\           Append \
                      Implicitly print on new line
            IQ       If (input): [0 is falsy, all other valid inputs are truthy]
                 hQ   Increment input by 1
              *\-     Repeat - that many times
                      Implicitly print on new line

Javascript 101 (programa completo), 94 (saída de função), 79 bytes (retorno)

Programa completo

Não será executado no Chrome (como o processo aparentemente não existe)
Não será executado no TIO (pois o prompt aparentemente não é permitido)

x=prompt();s='';for(i=0;i<x;i++)s+='|'+' '.repeat(i)+`\\
`;process.stdout.write(s+'-'.repeat(x&&x+1))

Função com impressão EXATA

x=>{s='';for(i=0;i<x;)s+='|'+' '.repeat(i++)+`\\
`;process.stdout.write(s+'-'.repeat(x&&x+1))}

Experimente Online

Função com string de retorno

x=>{s='';for(i=0;i<x;)s+='|'+' '.repeat(i++)+`\\
`;return s+'-'.repeat(x&&x+1)}

Experimente Online

A repetição de caracteres em Javascript é idiota e também suprime novas linhas na saída

Python 2 , 82 bytes

def f(i,c=0):
 if c<i:print'|'+' '*c+'\\';f(i,c+1)
 print'-'*((c+1,c)[c<1]);exit()

Experimente online!

Mais tempo que o outro Python responde, mas uma função recursiva apenas para ser diferente.

Parece um desperdício usando duas printdeclarações, mas não consigo encontrar uma maneira mais curta de contornar isso. Também os exit()resíduos 7 para impedir a impressão de um número decrescente de -baixo do triângulo.