Triângulos ASCII

30

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 , então procure o código mais curto possível!

Okx
fonte
4
Precisa ser um programa ou pode ser uma função?
8603
7
Eu acho que seria melhor se caso 0pode ter qualquer saída inesperada uma vez que é um caso extremo (especialmente desde que você solicitou que o número de traços deve ser um a mais que o número de entrada)
Kritixi Lithos
4
@Okx Com frequência, há perguntas em que o solicitante diz "programa", mas realmente significa programa ou função. Você pode querer esclarecer que você está pedindo um programa completo
fənɛtɪk
9
Eu definitivamente iria para o programa e função. Essa é a regra padrão se nada mais for especificado. Eu também removeria o caso 0-edge, pois é uma violação direta de " n + 1 linhas e traços (-) ".
Stewie Griffin
3
O desafio seria muito simples sem a exceção size = 0. Parte do desafio é descobrir uma maneira de explicar isso com a menor quantidade de código extra.
12Me21

Respostas:

3

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.  
Dennis
fonte
11

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

Albert Renshaw
fonte
1
Eu consegui chegar aos 68, estava muito orgulhosa de mim mesma .. e então eu rolei :( - Muito bem!
Quentin
1
Muito agradável! Tenha +1
Steadybox
Eu tenho 2*nlá duas vezes e isso me incomoda, alguém pode pensar em uma maneira inteligente de encurtá-lo de alguma forma?
Albert Renshaw
7

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

Jan
fonte
6

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
Emigna
fonte
ð×.svy¦…|ÿ\}¹>'-×», acho que minha ideia .snão foi tão boa quanto eu pensava. Bom uso de ÿ, não vi isso antes.
Magic Octopus Urn
@carusocomputing: eu considerei .s, além de começar, <Ýð×mas tive problemas com o caso especial desses métodos.
Emigna
FðN×…|ÿ\}Dg'-×»para 15 bytes
Adnan,
@ Adnan: Boa captura com Dg! Obrigado :)
Emigna
.stambém resultou em matrizes aninhadas e nivelamento, o que exigiu mais bytes.
Urna de polvo mágico
5

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!

Kritixi Lithos
fonte
Eu não deveria ter tentado tanto por um byte Experimente online!
precisa saber é o seguinte
@ nmjcman101 Ah, «claro. Inteligente! :)
Kritixi Lithos
4

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));
    }
}
adrianmp
fonte
3

Python 2 , 69 bytes

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

Experimente online!

Cajado
fonte
Se você estiver imprimindo, poderá salvar alguns bytes mudando para python3, removendo "".joine substituindo-o pelo *operador e pelo separgumento na função sleep, entãolambda x:print(*['|'+' '*n+'\\'for n in range(x)]+['-'*-~x*(x>0)],sep="\n")
sagiksp
3

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
Gato de negócios
fonte
2

SmileBASIC, 51 bytes

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

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.

AdmBorkBork
fonte
O programa imprime uma nova linha à direita, mas pedi que a saída fosse exatamente como especificada, desculpe!
Okx
@Okx Alterado ao custo de 16 bytes.
AdmBorkBork 8/17/17
2

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!

mbomb007
fonte
2

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.

djeis
fonte
2

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.

Abel Tom
fonte
1
Você pode economizar alguns bytes substituindo constantes de caracteres pelo valor ASCII e movendo o primeiro i ++ no corpo do loop. E por que é printf("%c",'_');tão detalhado?
Jens
@Jens stimmt, Danke sehr :) Atualizado
Abel Tom
Isso pode ser reduzido para 74 bytes:i;f(n){for(i=0;i++<n;)printf("%c%*c\n",124,i,92);for(;n--+1;)printf("-");}
Steadybox 8/17
Para 69 bytes, na verdade:i;f(n){for(i=0;i++<n;)printf("|%*c\n",i,92);for(;n--+1;)printf("-");}
Steadybox 8/17
@Steadybox 68: n--+1pode ser encurtado para~n--
Albert Renshaw
2

Carvão , 15 bytes

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

Experimente online!

Demolir

Nβ¿β«↓β→⁺¹β↖↖β»
Nβ               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
Mike Bufardeci
fonte
Comentário muito tardio, mas o fechamento »pode ser omitido.
DLosc
2

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
Oliver
fonte
1
Agradável! Você pode salvar um byte pressionando a última linha antes de ingressar: o@'|+SpX +'\Ãp'-pUÄ)·e devido a um bug (realmente um efeito colateral não intencional das funções automáticas), é possível remover o 'in '-.
ETHproductions
Na verdade, é assim com todas as letras minúsculas, não apenas p. Isso é para que você pode fazer por exemplo, m*2dobrar cada elemento, ou mp2aos quadrados cada
ETHproductions
2

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!

Jonah
fonte
25 bytes com*,&'-' '|',.'\'{."0~_1-i.
milhas
22 bytes com*,&'-' '|',.' \'{~=@i.
bob
@bob Isso foi muito inteligente para usar matriz identidade
milhas
@ Bob obrigado pela sugestão. Eu atualizei a publicação
Jonah
1

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:
|\
| \
|  \
|   \
|    \
|     \
-------
Yytsi
fonte
Peço desculpas pelo meu comentário anterior, agora as funções são permitidas.
Okx
@Okx Sem problemas. Isso permanece como um programa completo. Eu não acho que eu vou olhar para a forma de uma solução função :)
Yytsi
1

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
Luis Mendo
fonte
1

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.
steenbergh
fonte
1

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 = "")
Frédéric
fonte
1
Pode querer corrigir a ortografia de ungolfed
fənɛtɪk
1

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.

xnor
fonte
Aparentemente, as funções não precisam ser impressas.
Yytsi 9/02
1

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.

Neil
fonte
Esse regex é engenhoso. Primeiro tentei algo nesse sentido. Não sei sobre o $`padrão, mas não sei se ainda pensaria nisso. Agradável.
Janeiro
1

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!

PidgeyUsedGust
fonte
1

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+' ')
Dennis
fonte
1

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.

Andy Lester
fonte
1
provavelmente poderia economizar alguns lendo a entrada de stdin? $n=<>?
Ven
1

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
|\
| \
|  \
|   \
-----
Laikoni
fonte
1

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
Mike Bufardeci
fonte
@ Ven Obrigado! Você pode cortar o último |por um byte adicional.
Mike Bufardeci 22/02
0

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

fəˈnɛtɪk
fonte
0

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.

ElPedro
fonte
Você pode fazer -~c*(c>0)na última linha para salvar 3 bytes :) #
408 Yytsi
Ou ainda melhor: c and-~c.
Yytsi