Programlama 101 için bir görevden esinlenilmiş, burada, umarım çok kolay olmayan veya yinelenen bir görev (bunun gibi şeyler aramak biraz zor).

Giriş:

• Olumlu bir tamsayı n >= 1.

Çıktı:

• n Her yeni çizginin, çizgiden daha önce bir çizgiden daha fazla yıldız işaretine sahip olduğu ve ilk çizgide bir yıldız işaretiyle başlayan yıldız çizgileri.

Genel kurallar:

• Bu kod golf, bayt cinsinden en kısa cevap kazanır
• Kurs C ++ 'da öğretildiğinden, C ++' da çözümleri görmeye istekliyim.

Test durumu (n = 5):

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

Vim, 8 bayt

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

Okuyucu okuma arabelleğindeki girdiyi alır, bu nedenle giriş 15 ise, bunu ve sonra yukarıdaki kodu yazarsınız. Bu saçma bir kuraldır, ama görünüyor edilecek izin . Eğer böyle bir sicile girdiyseniz "a, sadece @aöne geçersiniz (10). Bunu başlangıç ​​dosyasından aldıysanız, D@"yerine hazırlarsınız (11).

Vimgolf.com kurallarında varsayılan ve Vim 8'de varsayılan :set autoindentolan kötüye kullanımına güvenir (ve yine de herkes bunu kullanır).

• o <Esc>: Sayı argümanıyla, metniniz boşluk ile başlarsa ve sizde varsa :set autoindent, Vim artar ve bir girinti dizisi oluşturur.
• <C-V>{r*: Tüm bu boşlukları *s'ye çevirin . Blok görsel kullanıyorum, böylece kötü girintili ayarlarınız boşluklarınızı sekmeler halinde sessizce gruplandırsa bile, doğru sayıda *s elde edersiniz .
• J: oMaalesef, başlangıçta üstte boş bir satır kaldı. Bu onu kaldırır.

JavaScript (ES6), 31 bayt

Bu, hem öncü hem de takip eden bir satır sonu içerir.

sYalnızca satır sonu içeren bir dize ile başlıyoruz . Ardından nher yinelemede bu dizenin sol tarafına bir yıldız işareti ekleyerek özyinelemeli çağrıları işleriz. Tüm ara dizgilerin birleştirilmesi beklenen sonuca yol açar.

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

Yıldız olmadan, 36 bayt

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

05AB1E , 7 6 bayt

CP-1252 kodlamasını kullanır .

'*×.p»

8 byte yıldız işareti içermeyen sürüm:

žQTè×.p»

Çevrimiçi deneyin!

açıklama

Giriş kullanarak örnek n = 5

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

PowerShell, 21 bayt

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

Döngüler 1girişine $args[0], dizi çarpma işlemi kullanılarak her bir tekrar birçok bir dizi oluşturmak için $_yıldız. Write-OutputSonunda örtük olan için varsayılan davranış ayırıcı için yeni bir satırla olur, bu yüzden bunu bedavaya alırız.

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 bayt

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

Ideone

ibaşlatıldı 1;
daha sonra execaşağıdaki kod dizisini çalıştırmak için komutlar verin;
dize şu şekildedir , "print'*'*i;i+=1;"ancak *aşağıdaki dize önceliklidir execve ilk önce dize input()zamanlarını yinelemeyi ister ; komutu artık bir döngü gibi davranır uzun dize yürütür yine uzatılan başka dize ing kullanarak karakteri tekrarlamak sonra bir arttırılarak ile .
execprint*'*'ii+=1

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

Jöle , 6 5 bayt

”*ẋþY

TryItOnline

Nasıl?

”*ẋþ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:
Bir karakter beri, hiçbir sıra sayıları hüküm ne olduğundan emin değilim olduğu bir sıralı bir arama.
Doğrudan arama sadece 7 bayt42Ọẋþ³Y için olacaktır - burada bize girdiyi verir) Kısa, dolaylı bir yöntem, 8 bayt için , - jelin kod sayfasında 1 indeksli 42 sayfasını aradığımız yerde olur .³
“)’Ọẋþ³Y')'“)’

C #, 42 bayt

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

Test durumu ile tam program:

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 bayt

j._*"*

Burada dene .

açıklama

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 bayrağı) = 21 bayt

Düzenleme: Riley'nin yorumlarına göre 4 bayt daha az

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

Çevrimiçi deneyin!

Run örneği: giriş, bu fikir birliğine dayanarak sed için izin verilen unary biçimindedir.

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

*
**
***
****

Çıktıda önde gelen bir yeni satır var, ancak buna OP tarafından izin veriliyor.

Açıklama:

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 bayt

İyi yaşlı Matlab ...

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

İzleyen boşluklar var. trilsize alt üçgen matrisi verir.

düzenleme: kaydedilmiş 2 bythes sayesinde Luis Mendo

C ++ - 92 96 Bayt

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

Çevrimiçi deneyin

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

Denizanası , 12 11 9 bayt

\P$'*
  i

Çevrimiçi deneyin!

açıklama

Yukarıdaki program aşağıdaki işlevsel sözde kodla eşdeğerdir:

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

$( Yeniden şekillendirme) bir Nyıldız işareti oluşturur . \PBir liste (veya dize) alan ve ön eklerinin her birini P(yazdırma) ileten bir işlev yaratır . Bu nedenle, bu art arda dizileri basar 1için Nyıldız.

R, 45 bayt

Döngü yaklaşımı için:

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

Brachylog , 12 bayt

yke:"*"rj@w\

Çevrimiçi deneyin!

Bu, takip eden yeni bir çizginin kabul edilebilir olduğunu varsayar

açıklama

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

Sondaki yeni satır yok, 15 bayt

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

Çevrimiçi deneyin!

Bu, tüm öneklerini alarak çalışır "*" × Input.

Haskell, 35 38 bayt

Nimi sayesinde liste anlama:

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

Eski versiyon:

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

Alternatif sürüm:

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

Pyth, 7 Bayt

VQ*\*hN

@ETHproductions sayesinde bir bayt çaldı Çevrimiçi deneyin

@ PIetu1998 Tekniğini kullanarak

6, bayt

j*L*\*S

2sable , 24 11 bayt

>G')Ç>çJN×,

Çevrimiçi deneyin!

Ve hiçbir yıldız işareti yok! @Emigna sayesinde 24'ten 11'e kadar golf oynadı .

Açıklama:

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

İçin +3 içerir -A

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

Çevrimiçi deneyin!

Açıklama:

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

↑'*'⍴⍨¨⍳

↑ oluşan listeyi matrifiye etmek

'*' "*" dizesi

⍴⍨ tarafından yeniden şekillendirildi

¨ her biri

⍳ tamsayılar 1 argümanı ile.

TryAPL çevrimiçi!

V , 8 bayt

Àé*hòlÄx

Çevrimiçi deneyin!

JavaScript (ES6), 34 bayt

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

Perl 6 , 23 bayt

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

(Çıktının yeni satırlar olmadan "satır" listesi olmasına izin verilirse .put for )

Açıklama:

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

( produceNe [\~] ...yaptığını anlamadıysanız belgelere bakın )

Perl 5, 22 20 bayt

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

Almak için -Eanahtarı ile çalıştırın say.

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

Tam bir program olarak yazılmış gibi görünüyordu:

use strict;
use feature 'say';

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

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

• shiftve popdolaylı @ARGVolarak sübvansiyonlar dışında (argümanlar listesi) çalışmak
• ..bir aralık operatör
• say yeni bir satır içeriyor
• xdizeleri tekrarlayan bir operatördür ve perlop ile açıklanmıştır.

Perl, 19 bayt

@Ton Hospel ve çözümün tekrarı sayesinde -4 byte !

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

Çalıştırmak için ücretsiz -E(veya -M5.010) bayrak gerekir. Girişten bir sayı alır:

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

J, 11 8 bayt

Mil sayesinde 3 bayt kurtarıldı!

]\@#&'*'

İşte bir ayrışma:

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

Şimdi, bu sonuncusu " kopyalarından ]\oluşan dizgenin öneki ( ) " olarak okuyor . Gözlemek:x'*'

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

Test durumu

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

Daha eski, 11 bayt çözümler

'*'#~"+1+i.

Bu eşdeğerdir

'*' #~"0 1 + i.

1 + i.aralığı [1, x]. Daha sonra '*' #~"0bu aralığa uygulanan şekiller (eleman) kopyaları '*'.

Bonus programı:

[:#&'*'\#&1

Bu, girişin #&'*'\sonucuna uygulanan kapaklı bir çataldır #&1. bunlardan #&1bir dizi verir xve bu dizinin öneklerine #&'*'\şekil '*'verir.

Test durumları

   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 tuş vuruşlarını

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

Genişlediğim harika bir vim cevabıyla geldiğim için @Udioica'ya büyük kredi . Bu cevap, ödül kazanma umuduyla hiçbir yıldız işareti içermez.

Açıklama:

Giriş, programın geri kalanından önce yazılır. Udioica bu harika numara ile geldi. Yazma <n>O <esc>, :set autoindentetkinleştirdiğiniz sürece boşluk piramitleri ve bir boş satır oluşturur . Bu seçenek vim 8 ve neovim'de varsayılan olarak açıktır, ancak vim'in eski sürümleri değildir. Bu ayrıca fazladan bir çizgi oluşturduğundan, Jbu çizgiyi bir sonraki çizgiye dahil etmek için kullanırız, bu da sadece altındaki çizgiyi etkili bir şekilde kaldırır.

Şimdi bu noktada, tüm bu boşlukları yıldızlarla değiştirmemiz gerekiyor. Kodumdaki yıldızları kullanma konusunda endişeli olmasaydım , seçimin her karakterini yıldız işaretiyle değiştiren her şeyi <C-v>{ve türü görsel olarak r*seçerdim. Ama bunu yapamam.

Böylece yardım sayfalarını açarız :h r. Bununla ilgili ilginç olan şey, vim penceresindeki bu sayfanın şu şekilde gösterilmesidir:

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

İmleci ilk 'r' üzerine getirin. Ancak, dosyanın kendisi aslında bu metni içerir:

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

Oldukça uygun. Bu yüzden birlikte bir karakter üzerinde hareket lve metin yank r*ile yE(bu kelimenin [E] olarak nd arasında [y] ank).

Bu tamponu kapatmak için, bir dosyayı kaydetmek için kısayolu kullanıyoruz ZZ. Şimdi, görsel olarak boşluklarımızı seçiyoruz ve yazılan yazıyı, yazmış gibi yapıyoruz @". Bu çalışır çünkü "@", aşağıdaki sicili vim-keystrokes olarak çalıştırır ve "yanking için varsayılan sicildir."

C, 47 46 45 43 bayt

Komut satırından girdi alır

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

Temel olarak n, 0 değilse, n-1 üzerinde tekrar eder. n'nin 0 olduğu özyinelemenin en üstünde sadece yeni bir satır yazdırılır, for döngüsü n-1 veya ~ n olduğunda sıfır olur, aksi takdirde '*' olan ASCII 42'yi yazdırır. İdeone üzerinde dene

C ++ 58 Bayt + 19, iostream dahil olmak üzere 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 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

.+
$**
.
$`$&¶

Çevrimiçi deneyin!

açıklama

.+
$**

Girişini çevirin Niçine Nyıldızlarla.

.
$`$&¶

Her yıldız işareti, bu yıldız işareti (bu $`$&) ve bir satır beslemesi (bu) dahil olmak üzere her şeyle değiştirin ¶.

MATL, 9 8 bayt

@Luis sayesinde 1 bayt kurtarıldı

:"42@Y"c

Çevrimiçi Deneyin

Cubix , 22 bayt

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

Çevrimiçi test edin! Sonunda yeni bir satır çıktısı.

İlk başta bunu bir 2-küpün üzerine sığdırabileceğime emin değildim ama sonunda iyi sonuç verdi:

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

Vaktim olduğunda, umarım bugün daha sonra bir açıklama ekleyeceğim.