Su tarea es escribir un programa o una función que imprima un triángulo ASCII. Se ven así:

|\
| \
|  \
----

Su programa tomará una sola entrada numérica n, con las restricciones 0 <= n <= 1000. El triángulo anterior tenía un valor de n=3.

El triángulo ASCII tendrá nbarras invertidas ( \) y barras verticales ( |), n+1líneas y guiones ( -), y cada línea tendrá una cantidad de espacios igual al número de línea (basado en 0, es decir, la primera línea es la línea 0) además de la última línea. .

Ejemplos:

Entrada:

4

Salida:

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

Entrada:

0

Salida:

En este caso de prueba, la salida debe estar vacía. Sin espacios en blanco.

Entrada:

1

Salida:

|\
--

La entrada y salida deben ser exactamente como las especifiqué.

Este es el código de golf , ¡así que busca el código más corto posible!

Jalea , 14 bytes

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

Pruébalo en línea!

Cómo 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));}

-

Gracias a @Steadybox, los comentarios de esta respuesta me ayudaron a reducir algunos bytes en mi solución anterior.

Javascript (ES6), 97 85 81 75 74 bytes

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

Resulta que no estaba usando suficiente recursión

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

Salvó un byte gracias a Adnan

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

Pruébalo en línea!

Explicación

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 guardado gracias a @ nmjcman101 por usar otra forma de no generar nada si la entrada es 0

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

Pruébalo en línea!

Hexdump:

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

Explicación (obsoleta)

Primero tenemos un ciclo para verificar si el argumento es 0. Si es así, el siguiente código se ejecuta ( |\está escrito). De lo contrario, no se escribe nada y el búfer está vacío.

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

Ahora que tenemos la parte superior del triángulo, necesitamos crear su cuerpo.

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

Ahora tenemos una línea extra en la parte inferior del búfer. Esto tiene que ser reemplazado con -s.

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

Esta respuesta sería más corta si pudiéramos ingresar lo que queramos 0

V , 14 13 bytes

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

Pruébalo en línea!

C #, 93 bytes

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

Función anónima que devuelve el triángulo ASCII como una cadena.

Programa completo con función no comentada y comentada y casos de prueba:

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

Pruébalo en línea!

CJam , 24 22 21 bytes

Guardado 1 byte gracias a Martin Ender

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

(Aumento de bytes para no tener en cuenta la nueva línea final)

Toma entrada $ny verifica que no sea cero. Luego realiza un bucle para construir el triángulo y termina con una línea de -. Implícito Write-Outputsucede al finalizar el programa.

Retina , 39 bytes

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

Pruébalo en línea

Convierta la entrada decimal a unario. Reemplace cada uno 1con |<N-1 spaces>\¶, imprimir y deshacer reemplazar. Reemplace cada uno 1con un guión, y el último guión con 2 guiones. Tadaa!

Lisp común, 89 86 bytes

Crea una función anónima que toma la entrada n e imprime el triángulo en *standard-output* (stdout, por defecto).

Golfed

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

Sin golf

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

Estoy seguro de que podría hacer esto más corto de alguna manera.

C 101 93 75 bytes

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

Versión sin golf

void f(int n)
{
  int i;

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

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

}

@ Steadybox Gracias por señalar, tiene mucho sentido.

Carbón de leña , 15 bytes

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

Pruébalo en línea!

Descompostura

Ｎβ¿β«↓β→⁺¹β↖↖β»
Ｎβ               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

Japt , 20 bytes

Guardado 2 bytes gracias a @ETHproductions

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

Pruébalo en línea!

Explicación

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 gracias a bob

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

Pruébalo en línea!

original: 33 bytes

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

sin golf

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

Pruébalo en línea!

Pyke, 18 17 bytes

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

Pruébalo aquí!

Python2, 73 bytes

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

Un programa completo También probé la interpolación de cadenas para la última línea, pero resultó ser un par de bytes más: /

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

Otra solución a 73 bytes:

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

Casos de prueba

0:

1:
|\
--

2:
|\
| \
---

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

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

MATL , 19 bytes

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

Pruébalo en línea!

?         % 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+@-

Explicación

:~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 cumple con el n=0caso de prueba si solo lo considera STDOUT!
De hecho, la stopifnot(n>0)parte detiene la ejecución del script, no se muestra nada a STDOUTpero escribe Error: n > 0 is not TRUEa SDTERR.

Sin golf:

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

Pruébalo en línea!

Imprime línea por línea, cada vez que agrega otro espacio antes de la barra diagonal inversa. Si se permitiera una función que no se imprime, probablemente sería más corta.

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

Salidas a la consola. Ahorre 6 bytes si la impresión en el shell SpiderMonkey JavaScript es aceptable. Ahorre 13 bytes si devolver la salida es aceptable.

Python 2 , 67 bytes

Otra función en Python 2, usando rjust.

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

Pruébalo en línea!

Python 3 , 60 bytes

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

Pruébalo en línea!

Dos soluciones más con el mismo número 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

Sin golf:

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

$"es el separador de lista, que por defecto es "". $/es el separador de registro de salida, que por defecto es "\ n". $_es la variable de bucle implícito.

Haskell , 82 65 bytes

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

Pruébalo en línea! Uso:

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

O más amablemente:

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

Pyth, 23 18 bytes

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

Conjunto de pruebas disponible en línea.
Gracias a Ven por jugar golf 5 bytes.

Explicación

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 (Salida de función), 79 (Retorno) bytes

Programa completo

No se ejecutará en Chrome (ya que aparentemente el proceso no existe)
No se ejecutará en TIO (ya que aparentemente no se permite la solicitud)

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

Función con impresión EXACTA

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

Pruébalo en línea

Función con cadena de retorno

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

Pruébalo en línea

La repetición de caracteres en Javascript es tonta y también lo es la supresión de nuevas líneas en la salida

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

Pruébalo en línea!

Más tiempo que el otro Python responde pero una función recursiva solo para ser diferente.

Se siente un desperdicio usar dos print declaraciones, pero no puedo encontrar una forma más corta de evitarlo. También los exit()desperdicios 7 para detener su impresión disminuyendo el número de -debajo del triángulo.