Inspirado por uma tarefa de programação 101, aqui está uma tarefa que, esperançosamente, não é muito fácil ou é uma duplicata (meio difícil de procurar coisas como essa).

Entrada:

• Um número inteiro positivo n >= 1.

Resultado:

• n linhas de asteriscos, em que cada nova linha possui um asterisco a mais que a linha anterior e começando com um asterisco na primeira linha.

Regras gerais:

• Isso é código-golfe, então a resposta mais curta em bytes vence.
• Como o curso é ministrado em C ++, estou ansioso para ver soluções em C ++.

Caso de teste (n = 5):

*
**
***
****
*****

Vim, 8 bytes

o <Esc><C-V>{r*J

Recebe entrada no buffer readahead; portanto, se a entrada for 15, digite-a e, em seguida, o código acima. Esta é uma regra tola, mas parece ser permitida . Se você tiver entrado em um registro como esse "a, basta ficar @ana frente (10). Se você o obteve no arquivo inicial, prefira D@"(11).

Depende do abuso de :set autoindent, que é o padrão nas regras do vimgolf.com e o padrão no Vim 8 (e todo mundo usa de qualquer maneira).

• o <Esc>: Com seu argumento numérico, se o seu texto começar com espaço em branco e você o tiver :set autoindent, o Vim sairá com falhas e criará uma cascata de recuo.
• <C-V>{r*: Transforme todos esses espaços em *s. Estou usando o bloco visual para que, mesmo que suas configurações de recuo ruim agrupem silenciosamente seus espaços em guias, você ainda obtenha o número certo de *s.
• J: Começando com, oinfelizmente, deixou uma linha em branco no topo. Isso remove.

JavaScript (ES6), 31 bytes

Este inclui uma quebra de linha principal e uma posterior.

Começamos com uma string scontendo apenas uma quebra de linha. Em seguida, processamos nchamadas recursivas, adicionando um asterisco no lado esquerdo dessa string a cada iteração. A concatenação de todas as seqüências intermediárias leva ao resultado esperado.

f=(n,s=`
`)=>n?s+f(n-1,'*'+s):s

Sem asterisco, 36 bytes

f=(n,s=`
`)=>n?s+f(n-1,atob`Kg`+s):s

05AB1E , 7 6 bytes

Usa a codificação CP-1252 .

'*×.p»

Versão de 8 bytes sem asterisco:

žQTè×.p»

Experimente online!

Explicação

Exemplo usando entrada n = 5

'*      # push "*"
        # STACK: "*"
  ×     # repeat input number times
        # STACK: "*****"
   .p   # get prefixes of string
        # STACK: ['*', '**', '***', '****', '*****']
     »  # join by newlines
        # implicit print

PowerShell, 21 bytes

1..$args[0]|%{'*'*$_}

Faz um loop da 1entrada $args[0], cada iteração usando a multiplicação de string para construir uma string com muitos $_asteriscos. O comportamento padrão para os implícitos Write-Outputno final é com uma nova linha para separador; portanto, obtemos isso de graça.

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 5
*
**
***
****
*****

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 2
*
**

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 7
*
**
***
****
*****
******
*******

Python 2, 37 34 bytes

i=1;exec"print'*'*i;i+=1;"*input()

Ideone

ié inicializado para 1;
em seguida, execcomandos para executar a seguinte cadeia de código, portanto, ela deve ser construída;
a cadeia é "print'*'*i;i+=1;"apenas a *seguinte: a cadeia tem precedência sobre exece instrui a repetir primeiro os input()tempos da cadeia ;
o execcomando agora executa a cadeia longa que age como um loop, printinserindo outra cadeia de comprimento crescente, usando novamente *para repetir o caractere '*'e depois incrementando icom i+=1.

Python 3, 41 bytes:
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; ou
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

Gelatina , 6 5 bytes

”*ẋþY

TryItOnline

Quão?

”*ẋþY - Main link: n
”*    - literal string "*"
   þ  - form outer product with the dyadic function:
  ẋ   -     repeat list (right input is an implicit range(n), Jelly defaults to 1-based)
            so the outer product is like:
            [[i*'*' for i in range(1,len("*")+1)] for x in range(1,n+1)]
    Y - join with line feeds
      - implicit print

Recompensa:
Não sei ao certo qual é a cláusula no ordinals, pois um personagem é uma pesquisa de um ordinal.
Pesquisa direta seria apenas 42Ọẋþ³Ypara 7 bytes - onde o ³-nos recebe o input)
Um método um pouco indireta curto seria, por 8 bytes , “)’Ọẋþ³Y- onde pesquisar ')'na página de código de geléia, que é 1-indexados de modo “)’produz 42.

C #, 42 bytes

f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

Programa completo com caso de teste:

using System;

namespace DrawAnAsteriskPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= null;
            f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

            Console.WriteLine(f(5));
        }
    }
}

Pitão , 6 bytes

j._*"*

Experimente aqui .

Explicação

j            Join by newlines
 ._          all prefixes of
    *        the result of repeating
      "*     the string "*"
             as many times as the implicit input 

GNU sed , 25 24 20 + 1 (sinalizador n) = 21 bytes

Edit: 4 bytes a menos com base em Riley comentários de

x;G;:;P;s:\n.:*\n:;t

Experimente online!

Exemplo de execução: a entrada está no formato unário, que para sed é permitido com base nesse consenso

me@LCARS:/PPCG$ sed -nf draw_triangle.sed <<< "0000"

*
**
***
****

Uma nova linha principal está presente na saída, mas isso é permitido pelo OP.

Explicação:

x;G             # prepend a newline to unary string
:               # start loop
   P            # print first line only
   s:\n.:*\n:   # shift one unary char from 2nd line to 1st, converted to a '*'
t               # repeat

Matlab, 26 23 bytes

Bom e velho Matlab ...

@(n)tril(repmat('*',n))

Tem espaços em branco à direita. trilfornece a matriz triangular inferior.

editar: economizou 2 bytes graças a Luis Mendo

C ++ - 92 96 bytes

#include<string>
int main(){int n;std::string s;scanf("%d",&n);for(;n--;)puts((s+="*").data());}

Experimente online

Ungolfed:

//this one hurts, but c++ strings are mutable
#include<string> 
int main(){
    int n;
    //this one hurts as well
    std::string s; 
    //read input to n
    //longer than 'std::cin>>n', but no #include<iostream> needed
    scanf("%d",&n); 
    // same as 'while(n--)', also characterwise, but way cooler
    for(;n--;) 
        //add a '*' the string
        //data() does the same as c_str()
        //puts automatically adds an '\n'
        puts((s+="*").data()); 
}

Água-viva , 12 11 9 bytes

\P$'*
  i

Experimente online!

Explicação

O programa acima é equivalente ao seguinte pseudocódigo funcional:

\            P      $       i        '*
map_prefixes(print, reshape(input(), '*'))

O $(remodelar) cria uma sequência de Nasteriscos. \Pcria uma função que pega uma lista (ou string) e passa cada um de seus prefixos para P(print). Assim, este sucessivamente imprime cordas 1da Nasteriscos.

R, 45 bytes

Para abordagem de loop:

for(i in 1:scan())cat(rep("*",i),"\n",sep="")

Braquilog , 12 bytes

yke:"*"rj@w\

Experimente online!

Isso pressupõe que uma nova linha à direita seja aceitável

Explicação

yk                The range [0, …, Input - 1]
  e               Take one element I of that range
   :"*"rj         Juxtapose "*" I times to itself
         @w       Write that string followed by a new line
           \      False: backtrack to another element of the range

Sem nova linha à direita, 15 bytes

-:"*"rj:@[f~@nw

Experimente online!

Este funciona usando todos os prefixos de "*" × Input.

Haskell, 35 38 bytes

Compreensão da lista graças a nimi:

f x=unlines[[1..n]>>"*"|n<-[1..x]]

Versão antiga:

f 0=""
f n=f(n-1)++([1..n]>>"*")++"\n"

Versão alternativa:

g n=([1..n]>>"*")++"\n"
f n=[1..n]>>=g

Pyth, 7 bytes

VQ*\*hN

Acabei com um byte graças a @ETHproductions Experimente online

usando a técnica de @ PIetu1998

6 bytes

j*L*\*S

2sable , 24 11 bytes

>G')Ç>çJN×,

Experimente online!

E nenhum sinal de asterisco! Jogou de 24 a 11 graças ao @Emigna .

Explicação:

>G')Ç>çJN×,
>            Push input+1
 G           For N in range (1,input+1)
  ')Ç>çJ     Push '*' by getting ascii code for ')' and adding 1
        Nx,  Print '*' repeated N times

Brain-Flak 75 Bytes

Inclui +3 para -A

{(({})[()]<{({}[()]<(((((()()()){}()){})){}{})>)}{}((()()()()()){})>)}{}

Experimente online!

Explicação:

{(({})[()]<                                                        >)}
#reduce the top element by one until it is 0 after doing the following
#Push this element back on to act as a counter for the next step.
#(counts down from input to 0 we'll call this counter)

           {({}[()]<                          >)}
           #reduce the top element by one until it is 0 after doing the following
           #(counts down from counter to 0)

                    (((((()()()){}()){})){}{})  
                    #push 42 (the ASCII code for *)

                                                 {}
                                                 #pop the counter used to push
                                                 #the right number of *s

                                                   ((()()()()()){})
                                                   #push a 10 (newline)

                                                                      {}
                                                                      #pop the null byte

Dyalog APL , 8 bytes

↑'*'⍴⍨¨⍳

↑ matricular a lista que consiste em

'*' a corda "*"

⍴⍨ remodelado por

¨ cada um

⍳ os inteiros 1 através do argumento

TryAPL online!

V , 8 bytes

Àé*hòlÄx

Experimente online!

JavaScript (ES6), 34 bytes

f=x=>x?f(x-1)+`
`+'*'.repeat(x):''

Perl 6 , 23 bytes

{.put for [\~] '*'xx$_}

(Se a saída puder ser uma lista de "linhas" sem novas linhas .put for  possam ser removidas)

Explicação:

# bare block lambda with implicit parameter ｢$_｣
{
  .put            # print with trailing newline
    for           # for every one of the following
      [\~]        # produce using concatenation operator
        '*' xx $_ # list repeat '*' by the input
}

(Consulte a documentação para producese você não entender o que [\~] ...está fazendo)

Perl 5, 22 20 bytes

say"*"x$_ for 1..pop

Execute-o com o -Einterruptor para obter say.

$ perl -E 'say"*"x$_ for 1..pop' 5
*
**
***
****
*****

Escrito como um programa completo, ficaria assim:

use strict;
use feature 'say';

# get the argument
my $limit = pop @ARGV;

foreach my $i (1 .. $limit) { 
    say "*" x $i; 
}

• shifte poptrabalhar implicitamente @ARGV(a lista de argumentos) fora dos subs
• ..é o operador de alcance
• say inclui uma nova linha
• xé um operador para repetir strings e é explicado no perlop

Perl, 19 bytes

-4 bytes graças a @Ton Hospel e seu retrabalho da solução!

eval"s//*/;say;"x<>

Precisa de sinalizador gratuito -E(ou -M5.010) para executar. Pega um número da entrada:

perl -E 'eval"s//*/;say;"x<>' <<< "5"

J, 11 8 bytes

Economizou 3 bytes graças a milhas!

]\@#&'*'

Aqui está uma decomposição:

(]\@#&'*') x
x (]\@#) '*'
]\ (x # '*')

Agora, este último lê como "os prefixos ( ]\) da string que consiste em xcópias de '*'". Observar:

   5 ]\@# '*'
*
**
***
****
*****
   ]\ 5# '*'
*
**
***
****
*****
   ]\ 5 # '*'
*
**
***
****
*****
   ]\@#&'*' 5
*
**
***
****
*****

Caso de teste

   f =: ]\@#&'*'
   f 3
*
**
***
   f 5
*
**
***
****
*****
   f 1
*
   f 2
*
**
   f &. > ;/1+i.10
+-+--+---+----+-----+------+-------+--------+---------+----------+
|*|* |*  |*   |*    |*     |*      |*       |*        |*         |
| |**|** |**  |**   |**    |**     |**      |**       |**        |
| |  |***|*** |***  |***   |***    |***     |***      |***       |
| |  |   |****|**** |****  |****   |****    |****     |****      |
| |  |   |    |*****|***** |*****  |*****   |*****    |*****     |
| |  |   |    |     |******|****** |******  |******   |******    |
| |  |   |    |     |      |*******|******* |*******  |*******   |
| |  |   |    |     |      |       |********|******** |********  |
| |  |   |    |     |      |       |        |*********|********* |
| |  |   |    |     |      |       |        |         |**********|
+-+--+---+----+-----+------+-------+--------+---------+----------+

Soluções mais antigas de 11 bytes

'*'#~"+1+i.

Isso é equivalente

'*' #~"0 1 + i.

1 + i.é o intervalo [1, x]. Em seguida, '*' #~"0aplicado a esse intervalo, forma cópias (elemento) de '*'.

Programa de bônus:

[:#&'*'\#&1

Este é um garfo com tampa #&'*'\aplicado ao resultado da #&1entrada.#&1fornece uma variedade de xunidades e#&'*'\ formas formas'*' para os prefixos dessa matriz.

Casos de teste

   f1 =: '*'#~"+1+i.
   f2 =: [:#&'*'\#&1
   f1 1
*
   f2 2
*
**
   f1 3
*
**
***
   f2 4
*
**
***
****
   f2 5
*
**
***
****
*****
   f1 5
*
**
***
****
*****
   (f1;f2)3
+---+---+
|*  |*  |
|** |** |
|***|***|
+---+---+
   f1;f2
f1 ; f2
   (f1;f2)5
+-----+-----+
|*    |*    |
|**   |**   |
|***  |***  |
|**** |**** |
|*****|*****|
+-----+-----+
   (f1;f2)10
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+

Teclas Vim, 22 , 18

O <esc>J:h r<cr>lyEZZ<C-v>{@"

Crédito enorme para @Udioica por ter encontrado uma resposta impressionante do vim que eu expandi. Esta resposta não contém nenhum asterisco, na esperança de ganhar a recompensa.

Explicação:

A entrada é digitada antes do restante do programa. Udioica veio com esse truque incrível. A digitação <n>O <esc>criará uma pirâmide de espaços e uma linha vazia, desde que você tenha :set autoindentativado. Esta opção é ativada por padrão no vim 8 e no neovim, embora não nas versões mais antigas do vim. Como isso também cria uma linha extra, usamosJ para associá-la à próxima, o que efetivamente remove a linha abaixo de nós.

Agora, neste ponto, precisamos substituir todos esses espaços por asteriscos. Se eu não estivesse preocupado com o uso de asteriscos no meu código, selecionaria visualmente tudo <C-v>{e digitariar* , que substituem cada caractere da seleção por um asterisco. Mas eu não posso fazer isso.

Então, abrimos as páginas de ajuda para :h r. O interessante sobre isso é que, na janela do vim, esta página é exibida como:

                            r
r{char}         Replace the character under the cursor with {char}.
                ...

Com o cursor no primeiro 'r'. No entanto, o próprio arquivo realmente contém este texto:

                            *r*
r{char}         Replace the character under the cursor with {char}.
                ...

Bastante conveniente. Então, passamos um caractere com l, e puxamos o texto r*com yE([y] ank para o [E] e esta palavra).

Para fechar esse buffer, usamos o atalho para salvar um arquivo ZZ. Agora, selecionamos visualmente nossos espaços e executamos o texto arrancado como se o tivéssemos digitado @". Isso funciona porque "@" executa o seguinte registro como pressionamentos de tecla vim e "é o registro padrão para puxar.

C, 47 46 45 43 bytes

Recebe entrada da linha de comando

f(n){for(n&&f(n-1);~n;putchar(n--?42:10));}

Basicamente, se n não for 0, recursão em n-1. na parte superior da recursão, em que n é 0, apenas imprime uma nova linha; o loop for termina quando n é -1 ou ~ n é zero; caso contrário, imprime o ASCII 42, que é '*'. Experimente em ideone

C ++ 58 bytes + 19 para incluir o iostream é 77

#include<iostream>
int f(int n){for(n&&f(n-1);~n;std::cout<<(n--?"*":"\n"));}

main(c,v)char**v;
{
    f(atoi(v[1]));
}

a.exe 3
*
**
***

Retina , 14 bytes

A contagem de bytes assume a codificação ISO 8859-1.

.+
$**
.
$`$&¶

Experimente online!

Explicação

.+
$**

Transforme a entrada Nem Nasteriscos.

.
$`$&¶

Substitua cada asterisco por tudo, inclusive esse asterisco (este é o $`$&) e um avanço de linha (este ¶).

MATL, 9 8 bytes

1 byte salvo graças a @Luis

:"42@Y"c

Experimente Online

Cubix , 22 bytes

?(.;I:^;/-.@o;(!\>'*oN

Teste online! Gera uma nova linha à direita.

No começo, eu não tinha certeza de que conseguiria encaixar isso em um cubo 2, mas no final funcionou bem:

    ? (
    . ;
I : ^ ; / - . @
o ; ( ! \ > ' *
    o N
    . .

Vou acrescentar uma explicação quando tiver tempo, espero hoje mais tarde.