Lấy cảm hứng từ một nhiệm vụ để lập trình 101 đây là một nhiệm vụ hy vọng không quá dễ dàng hoặc là một bản sao (hơi khó để tìm kiếm những thứ như thế này).

Đầu vào:

• Một số nguyên dương n >= 1.

Đầu ra:

• n các dòng hoa thị, trong đó mỗi dòng mới có một dấu sao so với dòng trước và bắt đầu bằng một dấu hoa thị ở dòng đầu tiên.

Quy tắc chung:

• Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte thắng.
• Vì khóa học được dạy bằng C ++, tôi rất mong muốn được thấy các giải pháp trong C ++.

Trường hợp thử nghiệm (n = 5):

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

Vim, 8 byte

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

Lấy đầu vào trong bộ đệm readahead, vì vậy nếu đầu vào là 15, bạn sẽ nhập mã đó và sau đó là mã ở trên. Đây là một quy tắc ngớ ngẩn, nhưng dường như được cho phép . Nếu bạn có đầu vào trong một đăng ký như thế "a, bạn chỉ cần dán @aphía trước (10). Nếu bạn đã nhận được nó từ tệp bắt đầu, D@"thay vào đó bạn sẽ trả trước (11).

Dựa vào việc lạm dụng :set autoindent, được mặc định trong các quy tắc của vimgolf.com và mặc định trong Vim 8 (và mọi người đều sử dụng nó theo cách nào).

• o <Esc>: Với đối số số của nó, nếu văn bản của bạn bắt đầu bằng khoảng trắng và bạn có :set autoindent, Vim sẽ thoát ra và tạo một tầng thụt lề.
• <C-V>{r*: Biến tất cả các không gian đó thành *s. Tôi đang sử dụng khối trực quan để ngay cả khi cài đặt thụt lề tệ hại của bạn âm thầm nhóm các khoảng trống của bạn thành các tab, bạn vẫn sẽ nhận được số *s chính xác.
• J: Không omay bắt đầu với một dòng trống ở trên cùng. Điều này loại bỏ nó.

JavaScript (ES6), 31 byte

Điều này bao gồm cả một ngắt dòng hàng đầu và cuối.

Chúng tôi bắt đầu với một chuỗi schỉ chứa một ngắt dòng. Sau đó, chúng tôi xử lý ncác cuộc gọi đệ quy, thêm dấu hoa thị ở bên trái của chuỗi này ở mỗi lần lặp. Sự kết hợp của tất cả các chuỗi trung gian dẫn đến kết quả mong đợi.

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

Không có dấu hoa thị, 36 byte

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

05AB1E , 7 6 byte

Sử dụng mã hóa CP-1252 .

'*×.p»

Phiên bản không có dấu hoa thị 8 byte:

žQTè×.p»

Hãy thử trực tuyến!

Giải trình

Ví dụ sử dụng đầu vào 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]|%{'*'*$_}

Vòng lặp từ 1đầu vào $args[0], mỗi lần lặp sử dụng phép nhân chuỗi để xây dựng một chuỗi gồm nhiều $_dấu sao. Hành vi mặc định cho ẩn Write-Outputở cuối là với một dòng mới cho dấu phân cách, vì vậy chúng tôi nhận được điều đó miễn phí.

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 byte

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

Ý tưởng

iđược khởi tạo để 1;
sau đó execcác lệnh để thực thi chuỗi mã sau, do đó nó phải được xây dựng;
chuỗi là "print'*'*i;i+=1;"nhưng *chuỗi sau được ưu tiên hơn execvà hướng dẫn trước tiên lặp lại input()lần chuỗi ;
các execlệnh bây giờ thực hiện chuỗi dài mà hoạt động như một vòng lặp, printing một chuỗi tăng chiều dài, một lần nữa sử dụng *để lặp lại các nhân vật '*', sau đó incrementing ivới i+=1.

Python 3, 41 byte :
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; hoặc là
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

Thạch , 6 5 byte

”*ẋþY

Dùng thử

Làm sao?

”*ẋþ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:
Tôi không chắc mệnh đề không có thứ tự là gì, vì một nhân vật là một tra cứu của một thứ tự.
Tra cứu trực tiếp sẽ chỉ được 42Ọẋþ³Ycho 7 byte - nơi ³được chúng tôi đầu vào)
Một phương pháp hơi gián tiếp ngắn sẽ được, ví 8 byte , “)’Ọẋþ³Y- nơi chúng tôi tra cứu ')'trong trang mã thạch, mà là 1-lập chỉ mục để “)’mang lại 42.

C #, 42 byte

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

Chương trình đầy đủ với trường hợp thử nghiệm:

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

Bình thường , 6 byte

j._*"*

Hãy thử nó ở đây .

Giải trình

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 (cờ n) = 21 byte

Chỉnh sửa: Giảm 4 byte dựa trên nhận xét của Riley

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

Hãy thử trực tuyến!

Chạy ví dụ: đầu vào ở định dạng đơn nguyên, cho phép sed được cho phép dựa trên sự đồng thuận này

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

*
**
***
****

Một dòng mới hàng đầu có mặt trong đầu ra, nhưng điều này được OP cho phép.

Giải trình:

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 byte

Tốt Matlab cũ ...

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

Có dấu vết trắng. trilcung cấp cho bạn ma trận tam giác thấp hơn.

chỉnh sửa: đã lưu 2 by nhờ Luis Mendo

C ++ - 92 96 byte

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

Dùng thử trực tuyến

Ung dung:

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

Sứa , 12 11 9 byte

\P$'*
  i

Hãy thử trực tuyến!

Giải trình

Chương trình trên tương đương với mã giả chức năng sau:

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

Các $(Reshape) tạo ra một chuỗi các Ndấu hoa thị. \Ptạo một hàm lấy danh sách (hoặc chuỗi) và chuyển từng tiền tố của nó sang P(in). Do đó, điều này liên tiếp in chuỗi 1để Ndấu hoa thị.

R, 45 byte

Đối với cách tiếp cận vòng lặp:

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

Brachylog , 12 byte

yke:"*"rj@w\

Hãy thử trực tuyến!

Điều này giả định rằng một dòng mới có thể chấp nhận được

Giải trình

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

Không có dòng mới, 15 byte

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

Hãy thử trực tuyến!

Điều này hoạt động bằng cách lấy tất cả các tiền tố của "*" × Input.

Haskell, 35 38 byte

Danh sách hiểu được nhờ nimi:

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

Phiên bản cũ:

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

Phiên bản thay thế:

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

Bình, 7 byte

VQ*\*hN

Bị mất một byte nhờ @ETHproductions Hãy thử trực tuyến

sử dụng Kỹ thuật của @ PIetu1998

6, byte

j*L*\*S

2sable , 24 11 byte

>G')Ç>çJN×,

Hãy thử trực tuyến!

Và không có dấu hiệu của bất kỳ dấu sao! Chơi gôn từ 24 đến 11 nhờ @Emigna .

Giải trình:

>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 byte

Bao gồm +3 cho -A

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

Hãy thử trực tuyến!

Giải trình:

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

APL Dyalog , 8 byte

↑'*'⍴⍨¨⍳

↑ danh sách bao gồm

'*' chuỗi "*"

⍴⍨ được định hình lại bởi

¨ mỗi

⍳ các số nguyên 1 thông qua đối số.

Dùng thử trực tuyến!

V , 8 byte

Àé*hòlÄx

Hãy thử trực tuyến!

JavaScript (ES6), 34 byte

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

Perl 6 , 23 byte

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

(Nếu đầu ra được phép là một danh sách "dòng" mà không có dòng mới .put for có thể được gỡ bỏ)

Giải trình:

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

(Xem tài liệu để producebiết nếu bạn không hiểu những gì [\~] ...đang làm)

Perl 5, 22 20 byte

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

Chạy nó với công -Etắc để có được say.

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

Được viết ra như một chương trình đầy đủ, nó sẽ trông như thế này:

use strict;
use feature 'say';

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

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

• shiftvà popngầm làm việc trên @ARGV(danh sách các đối số) bên ngoài subs
• ..là toán tử phạm vi
• say bao gồm một dòng mới
• xlà một toán tử để lặp lại các chuỗi và được giải thích trong perlop

Perl, 19 byte

-4 byte nhờ @TonMedel và giải pháp của anh ấy!

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

Cần cờ -E(hoặc -M5.010) miễn phí để chạy. Lấy một số từ đầu vào:

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

J, 11 8 byte

Lưu 3 byte nhờ dặm!

]\@#&'*'

Đây là một phân tách:

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

Bây giờ, cái cuối cùng này đọc là "tiền tố ( ]\) của chuỗi bao gồm các xbản sao của '*'". Quan sát:

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

Trường hợp thử nghiệm

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

Các giải pháp cũ hơn, 11 byte

'*'#~"+1+i.

Điều này là tương đương

'*' #~"0 1 + i.

1 + i.là phạm vi [1, x]. Sau đó, '*' #~"0áp dụng cho các bản sao hình dạng (phần tử) này '*'.

Chương trình thưởng:

[:#&'*'\#&1

Đây là một ngã ba giới hạn #&'*'\được áp dụng cho kết quả của #&1đầu vào. #&1đưa ra một mảng của xnhững cái và #&'*'\hình dạng '*'cho các tiền tố của mảng này.

Các trường hợp thử nghiệm

   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 tổ hợp phím

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

Khoản tín dụng lớn cho @Udioica khi đưa ra câu trả lời vim tuyệt vời mà tôi đã mở rộng. Câu trả lời này không chứa bất kỳ dấu sao nào, với hy vọng giành được tiền thưởng.

Giải trình:

Đầu vào được gõ trước phần còn lại của chương trình. Udioica đã đưa ra thủ thuật tuyệt vời này. Gõ <n>O <esc>sẽ tạo ra một kim tự tháp của không gian và một dòng trống, miễn là bạn đã :set autoindentbật. Tùy chọn này được bật theo mặc định trong vim 8 và neovim, mặc dù không phải là phiên bản cũ hơn của vim. Vì điều này cũng tạo ra một dòng bổ sung, chúng tôi sử dụng Jđể tham gia dòng này với dòng tiếp theo, điều này thực sự chỉ loại bỏ dòng bên dưới chúng tôi.

Bây giờ tại thời điểm này, chúng ta cần thay thế tất cả các không gian này bằng dấu hoa thị. Nếu tôi không lo lắng về việc sử dụng dấu hoa thị trong mã của mình, tôi sẽ chỉ chọn trực quan toàn bộ <C-v>{và loại r*, thay thế từng ký tự của vùng chọn bằng dấu hoa thị. Nhưng tôi không thể làm điều đó.

Vì vậy, chúng tôi mở ra các trang trợ giúp :h r. Điều thú vị về điều này là trong cửa sổ vim, trang này được hiển thị dưới dạng:

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

Với con trỏ trên 'r' đầu tiên. Tuy nhiên, bản thân tệp thực sự chứa văn bản này:

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

Khá tiện lợi. Vì vậy, chúng tôi di chuyển qua một ký tự lvà kéo văn bản r*bằng yE([y] ank đến [E] nd của từ này).

Để đóng bộ đệm này, chúng tôi sử dụng phím tắt để lưu tệp ZZ. Bây giờ, chúng tôi trực quan chọn không gian của mình và chạy văn bản được kéo dài như thể chúng tôi đã gõ nó bằng cách thực hiện @". Điều này hoạt động vì "@" chạy thanh ghi sau dưới dạng vim-keystrokes và "là thanh ghi mặc định cho việc kéo dài.

C, 47 46 45 43 byte

Lấy đầu vào từ dòng lệnh

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

Về cơ bản nếu n không bằng 0 lặp lại trên n-1. ở đầu đệ quy trong đó n bằng 0, nó chỉ in một dòng mới, vòng lặp for chấm dứt khi n bằng -1 hoặc ~ n bằng 0, nếu không, nó in ASCII 42 là '*'. Hãy thử nó trên ideone

C ++ 58 Byte + 19 để bao gồm iostream là 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
*
**
***

Võng mạc , 14 byte

Số lượng byte giả định mã hóa ISO 8859-1.

.+
$**
.
$`$&¶

Hãy thử trực tuyến!

Giải trình

.+
$**

Biến đầu Nvào thành Ndấu sao.

.
$`$&¶

Thay thế mỗi dấu hoa thị bằng mọi thứ lên đến và bao gồm cả dấu sao đó (đây là $`$&) và một dòng cấp dữ liệu (đây là ¶).

MATL, 9 8 byte

Lưu 1 byte nhờ @Luis

:"42@Y"c

Dùng thử trực tuyến

Khối , 22 byte

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

Kiểm tra nó trực tuyến! Xuất ra một dòng mới.

Lúc đầu, tôi không chắc mình có thể đặt cái này vừa với khối 2 khối, nhưng cuối cùng thì nó cũng hoạt động tốt:

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

Tôi sẽ thêm một lời giải thích khi tôi có thời gian, hy vọng sau ngày hôm nay.