受编程101任务的启发，这是一个希望不太容易或重复的任务（有点难以搜索这样的东西）。

输入：

• 一个正整数n >= 1。

输出：

• n 星号行，其中每个新行都比前一行多一个星号，并且在第一行中以一个星号开头。

通用规则：

• 这是代码高尔夫球，因此最短的答案以字节为单位。
• 由于该课程是用C ++讲授的，所以我很想看到C ++的解决方案。

测试案例（n = 5）：

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

Vim，8个字节

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

在readahead缓冲区中接受输入，因此如果输入为15，则将其输入，然后输入上面的代码。这是一个愚蠢的规则，但似乎是允许的。如果您输入了类似的寄存器"a，则只需@a放在前面（10）。如果您是从起始文件中获得的，则可以添加D@"（11）。

依靠滥用:set autoindent，这在vimgolf.com规则中是默认值，而在Vim 8中是默认值（而且每个人都在使用它）。

• o <Esc>：使用数字参数，如果您的文本以空格开头，并且有:set autoindent，Vim会跳出并创建一系列缩进。
• <C-V>{r*：将所有这些空格变成*s。我正在使用块可视化，这样，即使您糟糕的缩进设置将空格无声地分组到制表符中，您仍然可以获得正确的*s数。
• J：很o遗憾，开头是空白。这将其删除。

JavaScript（ES6），31个字节

这包括前导和尾随的换行符。

我们从s仅包含换行符的字符串开始。然后，我们处理n递归调用，在每次迭代时在该字符串的左侧添加一个星号。所有中间字符串的串联导致预期结果。

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

不带星号的36个字节

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

05AB1E，7 6字节

使用CP-1252编码。

'*×.p»

8字节无星号版本：

žQTè×.p»

在线尝试！

说明

输入示例 n = 5

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

PowerShell，21字节

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

从循环1到输入$args[0]，每次迭代都使用字符串乘法来构造一个有这么多个$_星号的字符串。Write-Output最后的隐式默认行为是使用换行符作为分隔符，因此我们免费获得它。

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字节

i=1;exec"print'*'*i;i+=1;"*input()

伊迪奥

i初始化为1;
然后exec执行以下代码字符串的命令，因此必须对其进行构造；
字符串是"print'*'*i;i+=1;"但*后面的字符串优先于，exec并指示首先重复字符串input()时间；
的exec命令现在执行长串的作用就像一个循环，print荷兰国际集团增加的长度的另一个字符串，再次使用*重复的字符'*'，然后递增i用i+=1。

Python 3中，41个字节：
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; 要么
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

果冻，6 5 字节

”*ẋþY

在线试用

怎么样？

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

赏金：
我不知道no ordinals子句是什么，因为字符是对序数的查找。
直接查找也只是42Ọẋþ³Y为7个字节 -在³获取我们输入）
短略间接的方法是，为8个字节，“)’Ọẋþ³Y-我们查找')'在果冻的代码页，这是1 -索引，以便“)’产生42。

C＃，42个字节

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

带有测试用例的完整程序：

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个字节

j._*"*

在这里尝试。

说明

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标志）= 21字节

编辑：根据Riley的评论少4个字节

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

在线尝试！

运行示例：输入为一元格式，基于此共识允许sed

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

*
**
***
****

输出中存在前导换行符，但是OP允许这样做。

说明：

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字节

好老的Matlab ...

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

具有尾随空格。tril给您较低的三角矩阵。

编辑：通过路易斯·门多（Luis Mendo）保存了2个bythes

C ++- 92 96字节

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

在线尝试

取消高尔夫：

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

水母，12 11 9字节

\P$'*
  i

在线尝试！

说明

上面的程序等效于以下功能伪代码：

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

该$（重塑）创建的字符串N的星号。\P创建一个接受列表（或字符串）并将其每个前缀传递给P（打印）的函数。因此，这将连续打印字符串1到N星号。

R，45个字节

对于循环方法：

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

Brachylog，12个字节

yke:"*"rj@w\

在线尝试！

假设尾随新行是可以接受的

说明

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

无尾随新行，15字节

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

在线尝试！

这是通过使用的所有前缀来实现的"*" × Input。

Haskell，35 38字节

清单理解归功于nimi：

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

旧版本：

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

备用版本：

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

Pyth，7个字节

VQ*\*hN

感谢@ETHproductions敲低 了一个字节在线尝试

使用@ PIetu1998的技术

6，字节

j*L*\*S

2sable，24 11字节

>G')Ç>çJN×,

在线尝试！

而且没有任何星号的迹象！感谢@Emigna从24到11打高尔夫球。

说明：

>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

脑筋急躁 75字节

包括+3 -A

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

在线尝试！

说明：

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

↑'*'⍴⍨¨⍳

↑ 使包含以下内容的列表具体化

'*' 字符串“ *”

⍴⍨ 重塑

¨ 每一个

⍳ 通过参数的整数1。

在线尝试APL！

V，8字节

Àé*hòlÄx

在线尝试！

JavaScript（ES6），34个字节

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

Perl 6、23个字节

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

（如果允许输出为不包含换行符的“行”列表，则.put for 可以将其删除）

说明：

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

（produce如果您不了解[\~] ...正在做什么，请参阅文档）

Perl 5中，22 20个字节

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

用-E开关来运行它say。

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

作为一个完整的程序写出来，它看起来像这样：

use strict;
use feature 'say';

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

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

• shift并pop在@ARGVsubs之外隐式地处理（参数列表）
• ..是范围运算符
• say 包括换行符
• x是重复字符串的运算符，在perlop中有解释

Perl，19个字节

-4个字节感谢@Ton Hospel和他对解决方案的重做！

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

需要free -E（或-M5.010）标志才能运行。从输入中获取一个数字：

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

J，11 8字节

多亏了英里，节省了3个字节！

]\@#&'*'

这是一个分解：

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

现在，最后一个读为“ ]\由”的x副本组成的字符串的前缀（）'*'。观察：

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

测试用例

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

较旧的11字节解决方案

'*'#~"+1+i.

这是等效的

'*' #~"0 1 + i.

1 + i.是范围[1, x]。然后，'*' #~"0将的形状（元素）副本应用于'*'。

奖励计划：

[:#&'*'\#&1

这是#&'*'\应用于#&1输入结果的带顶叉。#&1给出的阵列x的，并且#&'*'\形状'*'此阵列的前缀。

测试用例

   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次的击键

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

巨大的信贷@Udioica能想出一个真棒VIM答案，我扩大了。这个答案不包含任何星号，以期赢得赏金。

说明：

在程序的其余部分之前输入输入。Udioica想出了这个很棒的技巧。<n>O <esc>只要:set autoindent启用，键入将创建空格和一条空行的金字塔。默认情况下，此选项在vim 8和neovim中启用，尽管较早版本的vim没有。由于这还会创建一条额外的行，因此我们J可以将该行与下一行合并，从而有效地删除了我们下面的行。

现在，我们需要将所有这些空格替换为星号。如果我不担心在代码中使用星号，则只需在视觉上选择整个内容<C-v>{并输入r*，即可用星号替换所选内容的每个字符。但是我做不到。

因此，我们打开了帮助页面:h r。有趣的是，在vim窗口中，此页面显示为：

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

将光标放在第一个“ r”上。但是，文件本身实际上包含以下文本：

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

很方便 因此，我们使用移至一个字符l，并r*使用yE（将单词[[y] ank移至该单词的[E] nd]）将文本移至该字符。

要关闭此缓冲区，我们使用快捷方式保存文件ZZ。现在，我们以视觉方式选择我们的空格，并运行带阴影的文本，就像我们通过键入来键入它一样@"。之所以有效，是因为“ @”将以下寄存器作为vim-keystrokes运行，而“”是拉动的默认寄存器。

C，47 46 45 43字节

从命令行获取输入

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

基本上，如果n不为0，则对n-1进行递归。在n为0的递归顶部，它只是打印换行符，for循环在n为-1或〜n为零时终止，否则打印ASCII 42，即*。在ideone上尝试

C ++ 58字节+ 19（包括iostream）为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
*
**
***

视网膜，14字节

字节数假定为ISO 8859-1编码。

.+
$**
.
$`$&¶

在线尝试！

说明

.+
$**

将输入N变成N星号。

.
$`$&¶

将所有星号替换为直到该星号（包括该星号）的所有内容（这是 $`$&）和换行符（这是¶）。

MATL， 9 8字节

@Luis节省了1个字节

:"42@Y"c

在线尝试

Cubix，22个字节

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

在线测试！输出尾随换行符。

刚开始我不确定是否可以将它安装在2个多维数据集上，但最终效果很好：

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

有时间的时候，我会补充说明，希望今天晚些时候。