Inspiriert von einer Aufgabe zum Programmieren von 101 ist hier eine Aufgabe, die hoffentlich nicht zu einfach oder doppelt ist (etwas schwierig, nach solchen Dingen zu suchen).

Eingang:

• Eine positive ganze Zahl n >= 1.

Ausgabe:

• n Zeilen mit Sternchen, wobei jede neue Zeile ein Sternchen mehr als die vorherige Zeile enthält und mit einem Sternchen in der ersten Zeile beginnt.

Allgemeine Regeln:

• Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.
• Da der Kurs in C ++ abgehalten wird, bin ich gespannt auf Lösungen in C ++.

Testfall (n = 5):

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

Vim, 8 Bytes

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

Übernimmt die Eingabe in den Readahead-Puffer. Wenn also die Eingabe 15 ist, würden Sie dies und dann den obigen Code eingeben. Dies ist eine dumme Regel, scheint aber erlaubt zu sein . Wenn Sie in ein Register wie eingegeben wurden "a, bleiben Sie einfach @avorne (10). Wenn Sie es aus der Startdatei erhalten haben, würden Sie D@"stattdessen (11) voranstellen .

Verlässt sich auf Missbrauch von :set autoindent, was in den Regeln von vimgolf.com und in Vim 8 standardmäßig ist (und jeder verwendet es trotzdem).

• o <Esc>: Wenn Ihr Text mit dem Argument number mit einem Leerzeichen beginnt und Sie dies :set autoindentgetan haben , wird Vim eine Kaskade von Einrückungen erzeugen.
• <C-V>{r*: Verwandle all diese Räume in *s. Ich verwende Block Visual, damit Sie auch dann die richtige Anzahl von *s erhalten , wenn Ihre miesen Einzugseinstellungen Ihre Leerzeichen stillschweigend in Tabulatoren gruppieren .
• J: Beginnend mit oleider links oben eine Leerzeile. Dadurch wird es entfernt.

JavaScript (ES6), 31 Byte

Dieser enthält sowohl einen führenden als auch einen nachfolgenden Zeilenumbruch.

Wir beginnen mit einer Zeichenfolge, sdie nur einen Zeilenumbruch enthält. Dann verarbeiten wir nrekursive Aufrufe und fügen bei jeder Iteration ein Sternchen auf der linken Seite dieser Zeichenfolge hinzu. Die Verkettung aller Zwischenzeichenfolgen führt zum erwarteten Ergebnis.

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

Ohne Sternchen 36 Bytes

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

05AB1E , 7 6 Bytes

Verwendet die CP-1252- Codierung.

'*×.p»

8 Byte No-Asterisk-Version:

žQTè×.p»

Probieren Sie es online!

Erläuterung

Beispiel mit Eingabe n = 5

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

PowerShell, 21 Byte

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

Schleifen von 1bis zur Eingabe $args[0], wobei jede Iteration eine Zeichenfolgenmultiplikation verwendet, um eine Zeichenfolge mit so vielen $_Sternchen zu erstellen. Das Standardverhalten für das implizite Write-Outputam Ende ist ein Zeilenvorschub für das Trennzeichen, daher erhalten wir das kostenlos.

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

iwird initialisiert zu 1;
dann execBefehle zum Ausführen der folgenden Code-Zeichenfolge, sodass sie erstellt werden muss;
Die Zeichenfolge hat "print'*'*i;i+=1;"jedoch *folgenden Vorrang vor der Zeichenfolge execund weist an, die Zeichenfolge zuerst zu wiederholen input().
der execBefehl führt nun den langen String , der wie eine Schleife wirkt, printing andere Saitenlänge zu erhöhen, wiederum unter Verwendung *der Zeichen zu wiederholen '*', dann Inkrementieren imit i+=1.

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

Gelee , 6 5 Bytes

”*ẋþY

TryItOnline

Wie?

”*ẋþ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

Bounty:
Ich bin mir nicht sicher , was die keine ordinals Klausel ist, da ein Zeichen ist ein Nachschlag von einer Ordnungs.
Die direkte Suche würde nur 42Ọẋþ³Yfür 7 Bytes erfolgen - wobei ³uns das die Eingabe bringt.)
Eine kurze, geringfügig indirekte Methode wäre für 8 Bytes : “)’Ọẋþ³Y- wobei wir ')'in Jellys Codepage suchen, die 1-indiziert ist und somit “)’42 ergibt.

C #, 42 Bytes

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

Volles Programm mit Testfall:

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._*"*

Probieren Sie es hier aus .

Erläuterung

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

Edit: 4 Bytes weniger basierend auf Rileys Kommentaren

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

Probieren Sie es online!

Beispiel ausführen : Die Eingabe erfolgt in einem unären Format, das für sed basierend auf diesem Konsens zulässig ist

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

*
**
***
****

In der Ausgabe ist ein führender Zeilenumbruch vorhanden, der jedoch vom OP zugelassen wird.

Erläuterung:

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

Gutes altes Matlab ...

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

Hat nachgestellte Leerzeichen. trilgibt Ihnen die untere Dreiecksmatrix.

edit: 2 bythes dank Luis Mendo gespeichert

C ++ - 92 96 Bytes

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

Probieren Sie es online aus

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

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.