Qualle , 12 11 9 Bytes

\P$'*
  i

Probieren Sie es online!

Erläuterung

Das obige Programm entspricht dem folgenden funktionalen Pseudocode:

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

Die $(Umformung) erzeugt eine Reihe von NSternchen. \PErstellt eine Funktion, die eine Liste (oder einen String) aufnimmt und jedes ihrer Präfixe an P(print) übergibt . Auf diese Weise werden nacheinander Zeichenfolgen 1mit NSternchen gedruckt .

R, 45 Bytes

Für den Loop-Ansatz:

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

Brachylog , 12 Bytes

yke:"*"rj@w\

Probieren Sie es online!

Dies setzt voraus, dass eine abschließende neue Zeile akzeptabel ist

Erläuterung

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

Keine nachgestellte neue Zeile, 15 Bytes

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

Probieren Sie es online!

Dieser funktioniert mit allen Präfixen von "*" × Input.

Haskell, 35 38 Bytes

Listenverständnis dank nimi:

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

Alte Version:

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

Alternative Version:

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

Pyth, 7 Bytes

VQ*\*hN

Ausgeflippt dank @ETHproductions Probieren Sie es online aus

mit @ PIetu1998's Technik

6 Bytes

j*L*\*S

2sable , 24 11 Bytes

>G')Ç>çJN×,

Probieren Sie es online!

Und keine Sternchen! Golfen von 24 bis 11 dank @Emigna .

Erläuterung:

>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

Beinhaltet +3 für -A

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

Probieren Sie es online!

Erläuterung:

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

↑'*'⍴⍨¨⍳

↑ matrify die Liste bestehend aus

'*' die Saite "*"

⍴⍨ umgestaltet von

¨ jeder von

⍳ die ganzen Zahlen 1 durch das Argument.

TryAPL online!

V , 8 Bytes

Àé*hòlÄx

Probieren Sie es online!

JavaScript (ES6), 34 Byte

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

Perl 6 , 23 Bytes

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

(Wenn die Ausgabe eine Liste von "Zeilen" sein .put for darf, ohne dass Zeilenumbrüche entfernt werden können)

Erläuterung:

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

(In der Dokumentation finden produceSie Informationen, wenn Sie nicht verstehen, was Sie [\~] ...tun.)

Perl 5, 22 20 Bytes

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

Führen Sie es mit dem -ESchalter zu bekommen say.

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

Geschrieben als volles Programm würde es so aussehen:

use strict;
use feature 'say';

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

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

• shiftund popimplizit an @ARGV(der Liste der Argumente) außerhalb von subs arbeiten
• ..ist der Bereichsoperator
• say Beinhaltet einen Zeilenumbruch
• xist ein Operator zum Wiederholen von Strings und wird in Perlop erklärt

Perl, 19 Bytes

-4 Bytes dank @Ton Hospel und seiner Überarbeitung der Lösung!

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

Benötigt freie -E(oder -M5.010) Flagge zum Laufen. Nimmt eine Zahl aus der Eingabe:

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

J 11 8 Bytes

Dank Meilen 3 Bytes gespart!

]\@#&'*'

Hier ist eine Zerlegung:

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

Dieser letzte lautet nun "die Präfixe ( ]\) der Zeichenfolge, die aus xKopien von '*'" besteht. Beobachten:

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

Testfall

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

Ältere 11-Byte-Lösungen

'*'#~"+1+i.

Das ist äquivalent

'*' #~"0 1 + i.

1 + i.ist die Reichweite [1, x]. Anschließend werden '*' #~"0auf diesen Bereich Formen (Element) von Kopien angewendet '*'.

Bonusprogramm:

[:#&'*'\#&1

Dies ist eine Gabelung mit einer Kappe, #&'*'\die auf das Ergebnis #&1der Eingabe angewendet wird . #&1Gibt ein Array von xEinsen und #&'*'\Formen '*'für die Präfixe dieses Arrays an.

Testfälle

   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 Tastenanschläge

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

Vielen Dank an @Udioica für die fantastische Antwort, die ich erweitert habe. Diese Antwort enthält keine Sternchen, in der Hoffnung, das Kopfgeld zu gewinnen.

Erläuterung:

Die Eingabe wird vor dem Rest des Programms eingegeben. Udioica hat sich diesen tollen Trick ausgedacht. Wenn Sie tippen, <n>O <esc>wird eine Pyramide von Leerzeichen und eine leere Zeile erstellt, sofern Sie dies :set autoindentaktiviert haben. Diese Option ist in vim 8 und neovim standardmäßig aktiviert, jedoch nicht in älteren Versionen von vim. Da hierdurch auch eine zusätzliche Zeile erstellt wird, verbinden wir Jdiese Zeile mit der nächsten, wodurch die unter uns liegende Zeile entfernt wird.

Jetzt müssen wir alle diese Leerzeichen durch Sternchen ersetzen. Wenn ich mir keine Sorgen um die Verwendung von Sternchen in meinem Code machen würde, würde ich einfach das Ganze <C-v>{und den Typ visuell auswählen r*, wodurch jedes Zeichen der Auswahl durch ein Sternchen ersetzt wird. Das kann ich aber nicht.

Also öffnen wir die Hilfeseiten zu :h r. Das Interessante daran ist, dass diese Seite im vim-Fenster angezeigt wird als:

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

Mit dem Cursor auf das erste 'r'. Die Datei selbst enthält jedoch tatsächlich den folgenden Text:

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

Ziemlich praktisch. Also bewegen wir uns mit über ein Zeichen lund ziehen den Text r*mit yE([y] ank an das [E] nd dieses Wortes).

Um diesen Puffer zu schließen, verwenden wir die Verknüpfung, um eine Datei zu speichern ZZ. Jetzt wählen wir visuell unsere Leerzeichen aus und führen den gezerrten Text so aus, als hätten wir ihn eingegeben @". Dies funktioniert, weil "@" das folgende Register als vim-keystrokes ausführt und "das Standardregister für das Ziehen ist.

C 47 46 45 43 Bytes

Übernimmt Eingaben von der Kommandozeile

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

Grundsätzlich gilt, wenn n nicht 0 ist, n-1 erneut. am oberen Rand der Rekursion, wo n 0 ist, wird nur eine neue Zeile ausgegeben, die for-Schleife wird beendet, wenn n -1 ist oder ~ n Null ist, andernfalls wird ASCII 42 ausgegeben, was '*' ist. Probiere es auf ideone aus

C ++ 58 Bytes + 19 für das Einschließen von iostream ist 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

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

.+
$**
.
$`$&¶

Probieren Sie es online!

Erläuterung

.+
$**

Verwandeln Sie die Eingabe Nin NSternchen.

.
$`$&¶

Ersetzen Sie jedes Sternchen durch alles bis einschließlich dieses Sternchens (dies ist das $`$&) und eines Zeilenvorschubs (dies ist das ¶).

MATL, 9 8 Bytes

1 Byte gespart dank @Luis

:"42@Y"c

Probieren Sie es online

Cubix , 22 Bytes

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

Online testen! Gibt eine nachgestellte Newline aus.

Anfangs war ich mir nicht sicher, ob ich das auf einen 2-Würfel bringen könnte, aber am Ende hat es gut geklappt:

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

Ich werde eine Erklärung hinzufügen, wenn ich Zeit habe, hoffentlich später heute.