Medusa , 12 11 9 bytes

\P$'*
  i

Pruébalo en línea!

Explicación

El programa anterior es equivalente al siguiente pseudocódigo funcional:

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

El $(remodelar) crea una cadena de Nasteriscos. \Pcrea una función que toma una lista (o cadena) y pasa cada uno de sus prefijos a P(imprimir). Por lo tanto, esta opción se imprime sucesivamente cuerdas de 1a Nasteriscos.

R, 45 bytes

Para el enfoque de bucle:

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

Brachylog , 12 bytes

yke:"*"rj@w\

Pruébalo en línea!

Esto supone que una nueva línea final es aceptable

Explicación

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

Sin nueva línea final, 15 bytes

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

Pruébalo en línea!

Este funciona tomando todos los prefijos de "*" × Input.

Haskell, 35 38 bytes

Lista de comprensión gracias a nimi:

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

Versión antigua:

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

Versión alternativa:

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

Pyth, 7 bytes

VQ*\*hN

Perdí un byte gracias a @ETHproductions Pruébalo en línea

utilizando la técnica de @ PIetu1998

6, bytes

j*L*\*S

2sable , 24 11 bytes

>G')Ç>çJN×,

Pruébalo en línea!

¡Y no hay signos de asteriscos! Golfó del 24 al 11 gracias a @Emigna .

Explicación:

>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

Incluye +3 para -A

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

Pruébalo en línea!

Explicación:

{(({})[()]<                                                        >)}
#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

↑'*'⍴⍨¨⍳

↑ Matrificar la lista que consiste en

'*' la cuerda "*"

⍴⍨ remodelado por

¨ Cada uno de

⍳ los enteros 1 a través del argumento.

TryAPL en línea!

V , 8 bytes

Àé*hòlÄx

Pruébalo en línea!

JavaScript (ES6), 34 bytes

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

Perl 6 , 23 bytes

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

(Si se permite que la salida sea una lista de "líneas" sin líneas nuevas, .put for se puede eliminar)

Explicación:

# 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 la documentación producesi no comprende lo que [\~] ...está haciendo)

Perl 5, 22 20 bytes

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

Ejecútelo con el -Einterruptor para obtener say.

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

Escrito como un programa completo, se vería así:

use strict;
use feature 'say';

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

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

• shifte popimplícitamente trabajar en@ARGV (la lista de argumentos) fuera de los subs
• ..es el operador de rango
• say incluye una nueva línea
• xes un operador para repetir cadenas y se explica en perlop

Perl, 19 bytes

-4 bytes gracias a @Ton Hospel y su revisión de la solución.

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

Necesita bandera -E(o -M5.010) libre para ejecutarse. Toma un número de entrada:

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

J, 11 8 bytes

¡Guardado 3 bytes gracias a millas!

]\@#&'*'

Aquí hay una descomposición:

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

Ahora, este último se lee como "los prefijos ( ]\) de la cadena que consiste en xcopias de '*'". Observar:

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

Caso de prueba

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

Soluciones antiguas de 11 bytes

'*'#~"+1+i.

Esto es equivalente

'*' #~"0 1 + i.

1 + i.es el rango [1, x]. Luego, '*' #~"0aplicado a este rango formas (elemento) copias de '*'.

Programa de bonificación:

[:#&'*'\#&1

Esta es una bifurcación limitada #&'*'\aplicada al resultado #&1de la entrada. #&1da una matriz de xunos y #&'*'\formas '*'a los prefijos de esta matriz.

Casos de prueba

   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
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+

Vim, 22 , 18 pulsaciones de teclas

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

Gran crédito a @Udioica por llegar a una increíble respuesta vim que . Esta respuesta no contiene asteriscos, con la esperanza de ganar la recompensa.

Explicación:

La entrada se escribe antes que el resto del programa. A Udioica se le ocurrió este increíble truco. La escritura <n>O <esc>creará una pirámide de espacios y una línea vacía, siempre que haya :set autoindenthabilitado. Esta opción se activa de forma predeterminada en vim 8 y neovim, aunque no en versiones anteriores de vim. Como esto también crea una línea extra, usamosJ para unir esta línea con la siguiente, lo que efectivamente elimina la línea debajo de nosotros.

Ahora, en este punto, necesitamos reemplazar todos estos espacios con asteriscos. Si no me preocupara usar asteriscos en mi código, solo seleccionaría visualmente todo <C-v>{y escribiríar* , lo que reemplaza cada carácter de la selección con un asterisco. Pero no puedo hacer eso.

Entonces abrimos las páginas de ayuda a :h r. Lo interesante de esto es que en la ventana vim, esta página se muestra como:

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

Con el cursor en la primera 'r'. Sin embargo, el archivo en sí contiene este texto:

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

Muy conveniente Entonces nos movemos sobre un carácter con l, y tiramos el texto r*con yE([y] ank al [E] nd de esta palabra).

Para cerrar este búfer, usamos el acceso directo para guardar un archivo ZZ. Ahora, seleccionamos visualmente nuestros espacios y ejecutamos el texto extraído como si lo hubiéramos escrito al hacerlo @". Esto funciona porque "@" ejecuta el siguiente registro como pulsaciones de teclas vim y "es el registro predeterminado para la extracción".

C, 47 46 45 43 bytes

Toma información de la línea de comando

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

Básicamente si n no es 0 recurse en n-1. en la parte superior de la recursión donde n es 0, solo imprime una nueva línea, el bucle for termina cuando n es -1 o ~ n es cero; de lo contrario, imprime ASCII 42, que es '*'. Pruébalo en ideone

C ++ 58 Bytes + 19 para incluir iostream es 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

El recuento de bytes asume la codificación ISO 8859-1.

.+
$**
.
$`$&¶

Pruébalo en línea!

Explicación

.+
$**

Convierta la entrada Nen Nasteriscos.

.
$`$&¶

Reemplace cada asterisco con todo hasta ese asterisco (este es el $`$&) y un salto de línea (este el ¶).

MATL, 9 8 bytes

1 byte guardado gracias a @Luis

:"42@Y"c

Pruébalo en línea

Cubix , 22 bytes

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

¡Pruébalo en línea! Emite una nueva línea final.

Al principio no estaba seguro de que pudiera encajar en un cubo de 2, pero al final funcionó bien:

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

Agregaré una explicación cuando tenga tiempo, con suerte más tarde hoy.