101 프로그래밍을위한 작업에서 영감을 얻은 것은 너무나 쉽지 않거나 중복 된 작업입니다 (이런 것들을 찾기가 어렵습니다).

입력:

• 양의 정수 n >= 1.

산출:

• n 모든 새 줄은 이전 줄보다 하나의 별표가 있고 첫 번째 줄에서 별표로 시작합니다.

일반적인 규칙:

• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다.
• 이 과정은 C ++로 진행되므로 C ++로 솔루션을보고 싶어합니다.

테스트 사례 (n = 5) :

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

Vim, 8 바이트

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

판독 헤드 버퍼에 입력을 취하므로 입력이 15 인 경우 입력 한 다음 위의 코드를 입력하십시오. 이 바보 같은 규칙이지만 보인다 될 수 . 와 같은 레지스터에 입력 한 경우 앞에 (10)을 "a붙이면 @a됩니다. 시작 파일에서 가져 왔으면 D@"대신 (11)을 붙 입니다.

남용에 의존 :set autoindent기본적이며, vimgolf.com의 빔 (8)의 규칙과 기본 (모두가 어쨌든 사용).

• o <Esc>: 숫자 인수를 사용하여 텍스트가 공백으로 시작 :set autoindent하고을 가지고 있으면 Vim이 글리치하여 캐스케이드 인 덴트를 만듭니다.
• <C-V>{r*: 모든 공백을 *s 로 바꿉니다. 나는 블록 비주얼을 사용하여, 들여 쓰기 설정이 공백을 탭으로 자동으로 그룹화하더라도 여전히 올바른 수를 얻을 수 있도록합니다 *.
• J: o불행히도 맨 처음에 빈 줄이 남았습니다. 제거합니다.

자바 스크립트 (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
*
**
***
****
*****
******
*******

파이썬 2, 37 34 바이트

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

이데온

i로 초기화된다 1;
그런 exec다음 다음 코드 문자열을 실행하는 명령이므로 구성해야합니다.
문자열은 다음과 "print'*'*i;i+=1;"같지만 *다음은 문자열보다 우선하며 exec먼저 문자열 input()시간을 반복하도록 지시합니다 . 명령은 이제, 루프와 같은 역할을하는 긴 문자열 실행 다시 길이를 증가의 또 다른 문자열을 보내고 사용하여 문자를 반복 한 후 증가, 과를 .
execprint*'*'ii+=1

파이썬 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 바이트

편집 : 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 명이 절약되었습니다.

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(print) 로 전달하는 함수를 만듭니다 . 따라서 연속적 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.

하스켈, 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

피 이스, 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

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

TryAPL 온라인!

V , 8 바이트

Àé*hòlÄx

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 34 바이트

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

펄 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무엇 [\~] ...을하고 있는지 이해하지 못하는 경우 설명서를 참조하십시오 )

펄 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암시 적으로 작업 @ARGV잠수정의 외부 (인수 목록)
• ..은 IS 범위 연산자
• say 개행 포함
• x문자열을 반복하는 연산자 이며 perlop에 설명되어 있습니다.

펄, 19 바이트

@Ton Hospel 과 그의 솔루션 재 작업 덕분에 -4 바이트 !

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 키 스트로크

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

내가 확장 한 멋진 vim 답변 을 생각해 낸 @Udioica 에게 큰 신뢰 . 현상금을 얻기 위해이 답변에는 별표가 없습니다.

설명:

입력은 프로그램의 나머지 부분보다 먼저 입력됩니다. 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}.
                ...

꽤 편리합니다. 따라서 우리는로 한 문자 위로 이동 하고 ([y] nd to the this word)로 l텍스트 r*를 잡아 yE당깁니다.

이 버퍼를 닫으려면 바로 가기를 사용하여 파일을 저장하십시오 ZZ. 이제 공간을 시각적으로 선택하고 마치 마치 텍스트를 입력 한 것처럼 생겼습니다 @". "@"은 vim-keystrokes로 다음 레지스터를 실행하고 "yanking의 기본 레지스터"이기 때문에 작동합니다.

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이 0 일 때 종료되고, 그렇지 않으면 '*'인 ASCII 42를 인쇄합니다. 이데온에서 사용해보십시오

iostream을 포함하는 C ++ 58 바이트 + 19는 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
    . .

시간이 있으면 오늘 나중에 설명을 추가하겠습니다.