Meduza , 12 11 9 bajtów

\P$'*
  i

Wypróbuj online!

Wyjaśnienie

Powyższy program jest równoważny z następującym funkcjonalnym pseudokodem:

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

$(Reshape) tworzy ciąg Ngwiazdek. \Ptworzy funkcję, która pobiera listę (lub ciąg znaków) i przekazuje każdy ze swoich przedrostków do P(drukuj). Stąd, to sukcesywnie drukuje ciągi 1do Ngwiazdek.

R, 45 bajtów

W przypadku podejścia w pętli:

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

Brachylog , 12 bajtów

yke:"*"rj@w\

Wypróbuj online!

Zakłada się, że nowa linia końcowa jest dopuszczalna

Wyjaśnienie

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

Brak nowej linii, 15 bajtów

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

Wypróbuj online!

Ten działa, biorąc wszystkie prefiksy "*" × Input.

Haskell, 35 38 bajtów

Zrozumienie listy dzięki nim:

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

Stara wersja:

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

Alternatywna wersja:

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

Pyth, 7 bajtów

VQ*\*hN

Znalazłem bajt dzięki @ETHproductions Wypróbuj online

przy użyciu techniki @ PIetu1998

6 bajtów

j*L*\*S

2sable , 24 11 bajtów

>G')Ç>çJN×,

Wypróbuj online!

I żadnych śladów gwiazdek! Grał w golfa od 24 do 11 dzięki @Emigna .

Wyjaśnienie:

>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 bajtów

Obejmuje +3 za -A

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

Wypróbuj online!

Wyjaśnienie:

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

↑'*'⍴⍨¨⍳

↑ zmaterializuj listę składającą się z

'*' ciąg „*”

⍴⍨ przekształcony przez

¨ każdy z

⍳ liczby całkowite od 1 do argumentu.

Wypróbuj APL online!

V , 8 bajtów

Àé*hòlÄx

Wypróbuj online!

JavaScript (ES6), 34 bajty

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

Perl 6 , 23 bajtów

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

(Jeśli dane wyjściowe mogą być listą „linii” bez znaków nowej linii, .put for można je usunąć)

Wyjaśnienie:

# 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
}

(Zobacz dokumentację, producejeśli nie rozumiesz, co [\~] ...się dzieje)

Perl 5, 22 20 bajtów

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

Uruchom go za pomocą -Eprzełącznika, aby uzyskać say.

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

Napisany jako pełny program wyglądałby tak:

use strict;
use feature 'say';

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

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

• shifti popdomyślnie pracują nad @ARGV(listą argumentów) poza sub
• ..jest operatorem zasięgu
• say zawiera nową linię
• xjest operatorem do powtarzania ciągów i jest wyjaśnione w perlop

Perl, 19 bajtów

-4 bajty dzięki @Tonowi Hospelowi i jego przeróbce rozwiązania!

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

Potrzebuje wolnej flagi -E(lub -M5.010) do uruchomienia. Pobiera liczbę z danych wejściowych:

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

J, 11 8 bajtów

Zaoszczędzone 3 bajty dzięki kilometrom!

]\@#&'*'

Oto rozkład:

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

Teraz ten ostatni brzmi „przedrostki ( ]\) ciągu składającego się z xkopii '*'”. Przestrzegać:

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

Przypadek testowy

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

Starsze, 11-bajtowe rozwiązania

'*'#~"+1+i.

To jest równoważne

'*' #~"0 1 + i.

1 + i.jest zasięgiem [1, x]. Następnie '*' #~"0zastosowano do tego zakresu kształty (element) kopii '*'.

Program bonusowy:

[:#&'*'\#&1

To jest widelec z czapką #&'*'\zastosowany do wyniku danych #&1wejściowych. #&1daje tablicę xjedynek i #&'*'\kształty '*'do prefiksów tej tablicy.

Przypadki testowe

   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 klawiszy

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

Ogromne uznanie dla @Udioica za wymyślenie niesamowitej odpowiedzi vim, którą rozwinąłem. Ta odpowiedź nie zawiera gwiazdek, w nadziei na wygranie nagrody.

Wyjaśnienie:

Dane wejściowe są wpisywane przed pozostałą częścią programu. Udioica wymyślił tę niesamowitą sztuczkę. Pisanie <n>O <esc>spowoduje utworzenie piramidy spacji i jednej pustej linii, o ile :set autoindentwłączysz. Ta opcja jest domyślnie włączona w vimie 8 i neovimie, choć nie w starszych wersjach vima. Ponieważ tworzy to również dodatkową linię, używamy Jdo łączenia tej linii z następną, co skutecznie usuwa linię poniżej nas.

W tym momencie musimy zastąpić wszystkie te spacje gwiazdkami. Gdybym nie martwił się użyciem gwiazdek w kodzie, wybrałbym tylko wizualnie całą rzecz <C-v>{i typ r*, który zastępuje każdy znak zaznaczenia gwiazdką. Ale nie mogę tego zrobić.

Dlatego otwieramy strony pomocy na :h r. Interesującą rzeczą jest to, że w oknie vima ta strona jest wyświetlana jako:

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

Z kursorem na pierwszym „r”. Jednak sam plik faktycznie zawiera ten tekst:

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

Całkiem wygodne. Poruszamy się więc nad jednym znakiem li szarpamy tekst za r*pomocą yE([y] ank do [E] tego słowa).

Aby zamknąć ten bufor, używamy skrótu do zapisania pliku ZZ. Teraz wybieramy wizualnie nasze spacje i uruchamiamy szarpany tekst tak, jakbyśmy to zrobili @". Działa to, ponieważ „@” uruchamia następujący rejestr jako naciśnięcia klawiszy vim, a „jest domyślnym rejestrem dla szarpania.

C, 47 46 45 43 bajtów

Pobiera dane z wiersza poleceń

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

Zasadniczo, jeśli n nie jest równe 0, powtórz na n-1. u góry rekurencji, gdzie n wynosi 0, po prostu wypisuje nową linię, pętla for kończy się, gdy n wynosi -1 lub ~ n wynosi zero, w przeciwnym razie wypisuje ASCII 42, który jest „*”. Wypróbuj na ideone

C ++ 58 bajtów + 19 za włączenie iostream jest 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
*
**
***

Siatkówka , 14 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

.+
$**
.
$`$&¶

Wypróbuj online!

Wyjaśnienie

.+
$**

Zmień dane wejściowe Nw Ngwiazdki.

.
$`$&¶

Zamień każdą gwiazdkę na wszystko, włącznie z tą gwiazdką (to jest $`$&) i linefeed (to the ¶).

MATL, 9 8 bajtów

1 bajt zapisany dzięki @Luis

:"42@Y"c

Wypróbuj online

Cubix , 22 bajty

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

Przetestuj online! Generuje końcowy znak nowej linii.

Na początku nie byłem pewien, czy uda mi się dopasować to do 2-sześcianu, ale ostatecznie wszystko poszło dobrze:

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

Dodam wyjaśnienie, kiedy będę miał czas, mam nadzieję, że dzisiaj.