แรงบันดาลใจจากภารกิจในการเขียนโปรแกรม 101 นี่คืองานที่หวังว่าจะไม่ง่ายเกินไปหรือซ้ำซ้อน (ยากที่จะค้นหาสิ่งเช่นนี้)

การป้อนข้อมูล:

• n >= 1เป็นจำนวนเต็มบวก

เอาท์พุท:

• n บรรทัดของเครื่องหมายดอกจันที่ทุกบรรทัดใหม่มีเครื่องหมายดอกจันมากกว่าบรรทัดก่อนหน้าและเริ่มต้นด้วยเครื่องหมายดอกจันหนึ่งตัวในบรรทัดแรก

กฎทั่วไป:

• นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
• เนื่องจากหลักสูตรได้รับการสอนใน C ++ ฉันกระตือรือร้นที่จะเห็นวิธีแก้ปัญหาใน C ++

กรณีทดสอบ (n = 5):

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

เป็นกลุ่ม 8 ไบต์

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

รับอินพุตในบัฟเฟอร์ readahead ดังนั้นหากอินพุตเท่ากับ 15 คุณต้องพิมพ์และจากนั้นโค้ดด้านบน นี่คือกฎโง่ แต่ดูเหมือนว่าจะต้องได้รับอนุญาต หากคุณได้รับข้อมูลในการลงทะเบียนเช่น"aคุณจะ@aอยู่ข้างหน้า (10) หากคุณได้รับจากไฟล์เริ่มต้นคุณจะต้องเติมD@"แทน (11)

อาศัยการละเมิด:set autoindentซึ่งเป็นค่าเริ่มต้นในกฎvimgolf.comและค่าเริ่มต้นใน Vim 8 (และทุกคนใช้งานต่อไป)

• o <Esc>: ด้วยอาร์กิวเมนต์ number ถ้าข้อความของคุณเริ่มต้นด้วย whitespace และคุณมี:set autoindentVim บกพร่องและสร้างการเยื้องของการเยื้อง
• <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()

Ideone

iจะเริ่มต้นกับ1;
จากนั้นexecคำสั่งเพื่อรันสตริงของโค้ดต่อไปนี้ดังนั้นจึงต้องสร้าง
สตริงเป็น"print'*'*i;i+=1;"แต่สตริง*ต่อไปนี้จะมีความสำคัญมากกว่าexecและแนะนำให้ทำซ้ำinput()ครั้งสตริง; คำสั่งในขณะนี้ดำเนินการสายยาวซึ่งการกระทำเช่นวงไอเอ็นจีสตริงที่มีความยาวเพิ่มขึ้นอีกอีกครั้งโดยใช้การทำซ้ำตัวละครแล้วที่เพิ่มขึ้นด้วย
execprint*'*'ii+=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

TryItOnline

อย่างไร?

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

ค่าหัว:
ฉันไม่แน่ใจว่าไม่มีส่วนคำสั่งย่อยใดเนื่องจากตัวละครเป็นตัวค้นหาอันดับ
ค้นหาตรงก็จะเป็น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 ไบต์

แก้ไข: 4 ไบต์น้อยลงตามความคิดเห็นของRiley

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

ลองออนไลน์!

ตัวอย่างการรัน:อินพุตอยู่ในรูปแบบ unary ซึ่งสำหรับ 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ให้เมทริกซ์สามเหลี่ยมต่ำลง

แก้ไข: บันทึก 2 ไบต์ขอบคุณ Luis Mendo

C ++ - 92 96 ไบต์

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

ลองออนไลน์

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

แมงกะพรุน , 12 11 9 ไบต์

\P$'*
  i

ลองออนไลน์!

คำอธิบาย

โปรแกรมข้างต้นเทียบเท่ากับ pseudocode ที่ใช้งานได้

\            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×,

ลองออนไลน์!

และไม่มีสัญญาณของเครื่องหมายดอกจันใด ๆ ! ตีกอล์ฟ 24 ถึง 11 ขอบคุณ@Emigna @Emigna

คำอธิบาย:

>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 ไบต์

รวมถึง +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 ถึงอาร์กิวเมนต์

ลองใช้ออนไลน์!

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

เรียกใช้งานกับสวิทช์ที่จะได้รับ-Esay

$ 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ทำงานโดยปริยาย@ARGV(รายการอาร์กิวเมนต์) นอกหมวดย่อย
• ..เป็นผู้ประกอบการช่วง
• say รวมถึงการขึ้นบรรทัดใหม่
• xเป็นผู้ประกอบการที่จะทำซ้ำสตริงและมีการอธิบายใน perlop

Perl, 19 ไบต์

-4 ไบต์ขอขอบคุณ@Ton Hospelและการทำงานซ้ำของโซลูชัน!

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

ต้องการแฟล็ก-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 keystrokes

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

เครดิตมากถึง@Udioicaสำหรับการค้นหาคำตอบที่น่าประทับใจที่ฉันได้รับ คำตอบนี้ไม่มีเครื่องหมายดอกจันใด ๆ โดยหวังว่าจะได้รับรางวัล

คำอธิบาย:

อินพุตถูกพิมพ์ก่อนส่วนที่เหลือของโปรแกรม Udioica คิดค้นเคล็ดลับสุดยอดนี้ขึ้นมา การพิมพ์<n>O <esc>จะสร้างปิรามิดของช่องว่างและบรรทัดว่างหนึ่งบรรทัดตราบใดที่คุณ:set autoindentเปิดใช้งาน ตัวเลือกนี้มาตามค่าเริ่มต้นใน vim 8 และ neovim แม้ว่าจะไม่ใช่ vim เวอร์ชั่นที่เก่ากว่า เนื่องจากสิ่งนี้ยังสร้างบรรทัดพิเศษเราจึงใช้Jในการเข้าร่วมบรรทัดนี้กับบรรทัดถัดไปซึ่งมีประสิทธิภาพเพียงลบบรรทัดด้านล่างเราออก

ตอนนี้ถึงจุดนี้เราต้องแทนที่ช่องว่างเหล่านี้ทั้งหมดด้วยเครื่องหมายดอกจัน ถ้าฉันไม่กังวลเกี่ยวกับการใช้เครื่องหมายดอกจันในรหัสของฉันฉันจะเลือกสิ่งทั้งหมด<C-v>{และประเภทr*ทั้งหมดซึ่งจะแทนที่อักขระของการเลือกแต่ละตัวด้วยเครื่องหมายดอกจัน แต่ฉันทำอย่างนั้นไม่ได้

:h rดังนั้นเราจึงเปิดขึ้นหน้าความช่วยเหลือไป สิ่งที่น่าสนใจเกี่ยวกับสิ่งนี้คือในหน้าต่างเป็นกลุ่มหน้านี้จะแสดงเป็น:

                            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 และ "เป็นการลงทะเบียนเริ่มต้นสำหรับ yanking

C, 47 46 45 43 43 ไบต์

รับอินพุตจากบรรทัดรับคำสั่ง

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

โดยพื้นฐานแล้วถ้า n ไม่ได้ 0 จะจ่ายคืนใน n-1 ที่ด้านบนของการเรียกคืนโดยที่ n เป็น 0 เพียงพิมพ์บรรทัดใหม่สำหรับลูปจะสิ้นสุดเมื่อ 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เครื่องหมายดอกจัน

.
$`$&¶

แทนที่เครื่องหมายดอกจันแต่ละอันด้วยทุกอย่างจนถึงและรวมถึงเครื่องหมายดอกจัน (นี่คือ$`$&) และ linefeed (นี่คือ¶)

MATL, 9 8 ไบต์

บันทึก 1 ไบต์ขอบคุณ @Luis

:"42@Y"c

ลองออนไลน์

Cubix , 22 ไบต์

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

ทดสอบออนไลน์!เอาต์พุตบรรทัดใหม่ที่ต่อท้าย

ตอนแรกฉันไม่แน่ใจว่าฉันจะเอามันเข้ากับ 2-cube ได้ แต่ในที่สุดมันก็ใช้ได้ดี:

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

ฉันจะเพิ่มคำอธิบายเมื่อฉันมีเวลาหวังว่าวันนี้ภายหลัง