Il tuo compito è scrivere un programma o una funzione che stampa un triangolo ASCII. Sembrano così:

|\
| \
|  \
----

Il tuo programma prenderà un singolo input numerico n, con i vincoli 0 <= n <= 1000. Il triangolo sopra aveva un valore di n=3.

Il triangolo ASCII avrà nbarre rovesciate ( \) e barre verticali ( |), n+1linee e trattini ( -), e ogni linea avrà una quantità di spazi pari al numero di linea (basato su 0, ovvero la prima riga è la linea 0) oltre alla riga finale .

Esempi:

Ingresso:

4

Produzione:

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

Ingresso:

0

Produzione:

In questo caso di test, l'output deve essere vuoto. Nessuno spazio bianco.

Ingresso:

1

Produzione:

|\
--

Input e output devono essere esattamente come ho specificato.

Questo è code-golf , quindi cerca il codice più corto possibile!

Gelatina , 14 byte

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

Provalo online!

Come funziona.

’⁶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 byte

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

-

Grazie a @Steadybox, i commenti su questa risposta mi hanno aiutato a radere qualche byte nella mia soluzione sopra

Javascript (ES6), 97 85 81 75 74 byte

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

Si scopre che non stavo usando una ricorsione quasi sufficiente

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 byte

Salvataggio di un byte grazie ad Adnan

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

Provalo online!

Spiegazione

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 byte

1 byte salvato grazie a @ nmjcman101 per l'utilizzo di un altro modo di non generare nulla se l'ingresso è 0

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

Provalo online!

hexdump:

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

Spiegazione (obsoleta)

Per prima cosa abbiamo un ciclo per verificare se l'argomento è 0. In tal caso, il codice seguente viene eseguito ( |\è scritto). Altrimenti, non viene scritto nulla e il buffer è vuoto.

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

Ora che abbiamo la parte superiore del triangolo, dobbiamo creare il suo corpo.

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

Ora abbiamo una riga in più nella parte inferiore del buffer. Questo deve essere sostituito con -s.

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

Questa risposta sarebbe più breve se potessimo ciò che vogliamo per l'input 0

V , 14 13 byte

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

Provalo online!

C #, 93 byte

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

Funzione anonima che restituisce il triangolo ASCII come stringa.

Programma completo con funzione non commentata, commentata e casi di test:

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 byte

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

Provalo online!

CJam , 24 22 21 byte

Salvato 1 byte grazie a Martin Ender

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

Provalo online!

Spiegazione

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 byte

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

PowerShell , 51 67 byte

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

Provalo online!

(Aumento di byte per tenere conto di nessuna nuova riga finale)

Accetta l'input $ne verifica che sia diverso da zero. Quindi scorre per costruire il triangolo e termina con una linea di -. Implicito Write-Outputaccade al completamento del programma.

Retina , 39 byte

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

Provalo online

Converti l'input decimale in unario. Sostituisci ciascuno 1con |<N-1 spaces>\¶, stampa e annulla sostituisci. Sostituisci ciascuno 1con un trattino e l'ultimo trattino con 2 trattini. Tadaa!

Lisp comune, 89 86 byte

Crea una funzione anonima che accetta l'ingresso n e stampa il triangolo su *standard-output*(stdout, per impostazione predefinita).

golfed

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

Sono sicuro di poterlo abbreviare in qualche modo.

C 101 93 75 byte

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

Versione Ungolfed

void f(int n)
{
  int i;

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

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

}

@Steadybox Grazie per aver sottolineato, ha molto senso.

Carbone , 15 byte

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

Provalo online!

Abbattersi

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

Salvato 2 byte grazie a @ETHproductions

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

Provalo online!

Spiegazione

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 byte

-13 byte grazie a bob

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

Provalo online!

originale: 33 byte

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

ungolfed

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

Provalo online!

Pyke, 18 17 byte

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

Provalo qui!

Python2, 73 byte

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

Un programma completo. Ho anche provato l'interpolazione di stringhe per l'ultima riga, ma si è rivelato essere un paio di byte più lunghi: /

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

Un'altra soluzione a 73 byte:

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

Casi test

0:

1:
|\
--

2:
|\
| \
---

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

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

MATL , 19 byte

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

Provalo 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 byte

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

Spiegazione

:~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 byte

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

Questo codice è conforme al n=0caso di prova se si considera solo STDOUT!
In effetti, la stopifnot(n>0)parte interrompe l'esecuzione dello script, viene visualizzato nulla da STDOUTma scrive Error: n > 0 is not TRUEa SDTERR.

Ungolfed:

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

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

Python 2 , 62 byte

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

Provalo online!

Stampa riga per riga, aggiungendo ogni volta un altro spazio prima della barra rovesciata. Se fosse consentita una funzione che non stampa, sarebbe probabilmente più breve.

JavaScript (ES6), 71 byte

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

Emette sulla console. Salvare 6 byte se la stampa sulla shell JavaScript SpiderMonkey è accettabile. Salvare 13 byte se la restituzione dell'output è accettabile.

Python 2 , 67 byte

Un'altra funzione in Python 2, usando rjust.

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

Provalo online!

Python 3 , 60 byte

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

Provalo online!

Altre due soluzioni con lo stesso numero di byte.

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 byte

$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;

$"è il separatore di elenco, il cui valore predefinito è "". $/è il separatore del record di output, il cui valore predefinito è "\ n". $_è la variabile del ciclo implicito.

Haskell , 82 65 byte

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

Provalo online! Uso:

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

O più bene:

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

Pyth, 23 18 byte

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

Suite di test disponibile online.
Grazie a Ven per il golf off 5 byte.

Spiegazione

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 (programma completo), 94 (uscita funzione), 79 (ritorno) byte

Programma completo

Non verrà eseguito in Chrome (poiché il processo non esiste apparentemente)
Non verrà eseguito in TIO (poiché il prompt apparentemente non è consentito)

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

Funziona con stampa ESATTA

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

Provalo online

Funzione con stringa di ritorno

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

Provalo online

La ripetizione dei caratteri in Javascript è stupida, così come la soppressione di nuove righe sull'output

Python 2 , 82 byte

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

Provalo online!

Più a lungo che l'altro Python risponde ma una funzione ricorsiva solo per essere diversi.

Mi sembra inutile usare due printaffermazioni ma non riesco a trovare un modo più breve per aggirarlo. Inoltre i exit()rifiuti 7 per fermarlo stampa il numero decrescente di -sotto il triangolo.