Inspirado en una tarea para programar 101, aquí hay una tarea que, con suerte, no es demasiado fácil o es un duplicado (un poco difícil de buscar para cosas como esta).

Entrada:

• Un entero positivo n >= 1.

Salida:

• n líneas de asteriscos, donde cada nueva línea tiene un asterisco más que la línea anterior, y comienza con un asterisco en la primera línea.

Reglas generales:

• Este es el código de golf, por lo que la respuesta más corta en bytes gana.
• Como el curso se imparte en C ++, estoy ansioso por ver soluciones en C ++.

Caso de prueba (n = 5):

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

Vim, 8 bytes

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

Toma la entrada en el búfer de lectura readahead, por lo que si la entrada es 15, escribiría eso y luego el código anterior. Esta es una regla tonta, pero parece estar permitida . Si recibiste una entrada en un registro como "a, simplemente te quedarías @adelante (10). Si lo obtuvo del archivo de inicio, preferiría en su D@"lugar (11).

Se basa en el abuso de :set autoindent, que es predeterminado en las reglas de vimgolf.com y predeterminado en Vim 8 (y todos lo usan de todos modos).

• o <Esc>: Con su argumento numérico, si su texto comienza con un espacio en blanco, y lo tiene :set autoindent, Vim falla y crea una cascada de sangría.
• <C-V>{r*: Convierte todos esos espacios en *s. Estoy usando el bloque visual para que, incluso si su pésima configuración de sangría agrupa silenciosamente sus espacios en pestañas, aún obtendrá el número correcto de *s.
• J: Comenzando con odesafortunadamente dejó una línea en blanco en la parte superior. Esto lo quita.

JavaScript (ES6), 31 bytes

Este incluye un salto de línea inicial y final.

Comenzamos con una cadena que scontiene solo un salto de línea. Luego procesamos nllamadas recursivas, agregando un asterisco en el lado izquierdo de esta cadena en cada iteración. La concatenación de todas las cadenas intermedias conduce al resultado esperado.

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

Sin asterisco, 36 bytes

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

05AB1E , 7 6 bytes

Utiliza la codificación CP-1252 .

'*×.p»

Versión de 8 bytes sin asterisco:

žQTè×.p»

Pruébalo en línea!

Explicación

Ejemplo 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]|%{'*'*$_}

Recorre desde la 1entrada hasta $args[0]cada iteración utilizando la multiplicación de cadenas para construir una cadena de tantos $_asteriscos. El comportamiento predeterminado para lo implícito Write-Outputal final es con una nueva línea para el separador, por lo que lo obtenemos de forma gratuita.

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

Ideona

ise inicializa a 1;
luego execordena ejecutar la siguiente cadena de código, por lo que debe construirse;
la cadena es "print'*'*i;i+=1;"la *siguiente pero la cadena tiene prioridad sobre exece indica que primero se repitan los input()tiempos de la cadena ;
El execcomando ahora ejecuta la cadena larga que actúa como un bucle, printhaciendo otra cadena de longitud creciente, nuevamente usando *para repetir el carácter '*', y luego incrementando icon i+=1.

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

Jalea , 6 5 bytes

”*ẋþY

TryItOnline

¿Cómo?

”*ẋþ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:
No estoy seguro de cuál es la cláusula de no ordinales, ya que un personaje es una búsqueda de un ordinal.
La búsqueda directa sería solo 42Ọẋþ³Ypara 7 bytes , donde ³nos da la entrada.
Un método breve ligeramente indirecto sería, para 8 bytes , “)’Ọẋþ³Ydonde buscamos ')'en la página de códigos de Jelly, que está indexada en 1, por lo que “)’produce 42.

C #, 42 bytes

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

Programa completo con caso de prueba:

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

Pyth , 6 bytes

j._*"*

Pruébalo aquí .

Explicación

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 (n flag) = 21 bytes

Editar: 4 bytes menos según los comentarios de Riley

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

Pruébalo en línea!

Ejemplo de ejecución: la entrada está en formato unario, que para sed está permitido según este consenso

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

*
**
***
****

Una nueva línea principal está presente en la salida, pero esto está permitido por el OP.

Explicación:

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

El viejo Matlab ...

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

Tiene espacios en blanco al final. trilte da la matriz triangular inferior.

editar: ahorrado 2 bythes gracias a Luis Mendo

C ++ - 92 96 Bytes

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

Pruébalo en línea

Sin golf:

//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()); 
}

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.