Votre tâche consiste à écrire un programme ou une fonction qui imprime un triangle ASCII. Ils ressemblent à ceci:

|\
| \
|  \
----

Votre programme prendra une seule entrée numérique n, avec les contraintes 0 <= n <= 1000. Le triangle ci-dessus avait une valeur de n=3.

Le triangle ASCII aura des nbarres obliques inverses ( \) et des barres verticales ( |), des n+1lignes et des tirets ( -), et chaque ligne aura un nombre d'espaces égal au numéro de ligne (basé sur 0, c'est-à-dire que la première ligne est la ligne 0) en plus de la ligne finale .

Exemples:

Contribution:

4

Sortie:

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

Contribution:

0

Sortie:

Dans ce cas de test, la sortie doit être vide. Pas d'espace.

Contribution:

1

Sortie:

|\
--

L'entrée et la sortie doivent être exactement comme je l'ai spécifié.

C'est du code-golf , alors visez le code le plus court possible!

Gelée , 14 octets

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

Essayez-le en ligne!

Comment ça marche.

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

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

-

Merci à @Steadybox qui les commentaires sur cette réponse m'ont aidé à raser quelques octets dans ma solution ci-dessus

Javascript (ES6), 97 85 81 75 74 octets

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

Il s'avère que je n'utilisais pas assez de récursivité

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 octets

Un octet enregistré grâce à Adnan

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

Essayez-le en ligne!

Explication

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 octets

1 octet enregistré grâce à @ nmjcman101 pour avoir utilisé une autre façon de ne rien produire si l'entrée est 0

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

Essayez-le en ligne!

Hexdump:

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

Explication (obsolète)

Nous avons d'abord une boucle pour vérifier si l'argument l'est 0. Si c'est le cas, le code ci-dessous s'exécute ( |\est écrit). Sinon, rien n'est écrit et le tampon est vide.

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

Maintenant que nous avons atteint le sommet du triangle, nous devons créer son corps.

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

Nous avons maintenant une ligne supplémentaire au bas du tampon. Cela doit être remplacé par l' -art.

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

Cette réponse serait plus courte si nous pouvions tout ce que nous voulons pour l'entrée 0

V , 14 13 octets

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

Essayez-le en ligne!

C #, 93 octets

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

Fonction anonyme qui renvoie le triangle ASCII sous forme de chaîne.

Programme complet avec fonction non testée et commentée et cas de 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 octets

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

Essayez-le en ligne!

CJam , 24 22 21 octets

1 octet enregistré grâce à Martin Ender

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

Essayez-le en ligne!

Explication

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 octets

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

PowerShell , 51 67 octets

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

Essayez-le en ligne!

(Augmentation d'octets pour ne pas prendre en compte la nouvelle ligne)

Prend l'entrée $net vérifie qu'elle est différente de zéro. Boucle ensuite pour construire le triangle et termine avec une ligne de -. Implicite Write-Outputse produit à la fin du programme.

Rétine , 39 octets

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

Essayez-le en ligne

Convertissez l'entrée décimale en unaire. Remplacez chacun 1par |<N-1 spaces>\¶, imprimez et annulez le remplacement. Remplacez chacun 1par un trait d'union et le dernier trait d'union par 2 traits d'union. Tadaa!

Lisp commun, 89 86 octets

Crée une fonction anonyme qui prend l'entrée n et imprime le triangle sur *standard-output*(stdout, par défaut).

Golfé

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

Non golfé

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

Je suis sûr que je pourrais raccourcir cela d'une façon ou d'une autre.

C 101 93 75 octets

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

Version non golfée

void f(int n)
{
  int i;

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

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

}

@Steadybox Merci de l'avoir signalé, cela a beaucoup de sens.

Fusain , 15 octets

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

Essayez-le en ligne!

Panne

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

Enregistré 2 octets grâce à @ETHproductions

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

Essayez-le en ligne!

Explication

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 octets

-13 octets grâce à bob

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

Essayez-le en ligne!

original: 33 octets

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

non golfé

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

Essayez-le en ligne!

Pyke, 18 17 octets

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

Essayez-le ici!

Python2, 73 octets

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

Un programme complet. J'ai également essayé l'interpolation de chaînes pour la dernière ligne, mais il s'est avéré être plus long de quelques octets: /

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

Une autre solution à 73 octets:

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

Cas de test

0:

1:
|\
--

2:
|\
| \
---

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

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

MATL , 19 octets

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

Essayez-le en ligne!

?         % 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 octets

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

Explication

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

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

Ce code est conforme au n=0cas de test si vous ne considérez que STDOUT!
En effet, la stopifnot(n>0)partie arrête l'exécution du script, affiche rien à STDOUTmais écrit Error: n > 0 is not TRUEà SDTERR.

Non golfé:

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

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

Python 2 , 62 octets

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

Essayez-le en ligne!

Imprime ligne par ligne, en ajoutant à chaque fois un autre espace avant la barre oblique inverse. Si une fonction qui n'imprimait pas était autorisée, ce serait probablement plus court.

JavaScript (ES6), 71 octets

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

Sorties vers la console. Économisez 6 octets si l'impression sur le shell JavaScript SpiderMonkey est acceptable. Enregistrez 13 octets si le retour de la sortie est acceptable.

Python 2 , 67 octets

Une autre fonction en Python 2, utilisant rjust.

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

Essayez-le en ligne!

Python 3 , 60 octets

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

Essayez-le en ligne!

Deux autres solutions avec le même nombre d'octets.

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 octets

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

Non golfé:

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

$"est le séparateur de liste, qui est par défaut "". $/est le séparateur d'enregistrement de sortie, qui est par défaut "\ n". $_est la variable de boucle implicite.

Haskell , 82 65 octets

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

Essayez-le en ligne! Usage:

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

Ou plus joliment:

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

Pyth, 23 18 octets

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

Suite de tests disponible en ligne.
Merci à Ven d' avoir joué 5 octets.

Explication

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 (programme complet), 94 (sortie de fonction), 79 (retour) octets

Programme complet

Ne fonctionnera pas dans Chrome (car le processus n'existe pas apparemment)
Ne fonctionnera pas dans TIO (car l'invite n'est apparemment pas autorisée)

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

Fonction avec impression EXACT

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

Essayez-le en ligne

Fonction avec chaîne de retour

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

Essayez-le en ligne

La répétition de caractères en Javascript est stupide, tout comme la suppression des sauts de ligne en sortie

Python 2 , 82 octets

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

Essayez-le en ligne!

Plus longtemps que l'autre Python répond mais une fonction récursive juste pour être différent.

Cela me semble inutile d'utiliser deux printdéclarations, mais je ne peux pas trouver un moyen plus court de contourner cela. Aussi les exit()déchets 7 pour l'empêcher d'imprimer un nombre décroissant de -sous le triangle.