Zainspirowany zadaniem programowania 101, oto zadanie, które, miejmy nadzieję, nie jest zbyt łatwe lub jest duplikatem (trochę trudno szukać takich rzeczy).

Wejście:

• Dodatnia liczba całkowita n >= 1.

Wynik:

• n linie gwiazdek, gdzie każda nowa linia ma jedną gwiazdkę więcej niż poprzednia linia, i zaczyna się od jednej gwiazdki w pierwszej linii.

Główne zasady:

• To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach.
• Ponieważ kurs jest nauczany w C ++, chętnie widzę rozwiązania w C ++.

Przypadek testowy (n = 5):

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

Vim, 8 bajtów

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

Pobiera dane wejściowe w buforze readahead, więc jeśli dane wejściowe to 15, wpisz to, a następnie kod powyżej. To jest głupia zasada, ale wydaje się być dozwolona . Jeśli masz dane wejściowe w rejestrze "a, po prostu trzymasz się @aprzodu (10). Jeśli masz go z pliku początkowego, D@"zamiast tego wstawisz (11).

Opiera się na nadużyciach :set autoindent, co jest domyślne w regulaminie vimgolf.com i domyślne w Vimie 8 (i i tak wszyscy go używają).

• o <Esc>: Za pomocą argumentu liczbowego, jeśli tekst zaczyna się od białych znaków, a ty tak :set autoindent, Vim drga i tworzy kaskadę wcięć.
• <C-V>{r*: Zamień wszystkie te spacje w *s. Używam blokowania wizualnego, więc nawet jeśli twoje kiepskie ustawienia wcięć cicho grupują spacje w tabulatory, nadal otrzymasz odpowiednią liczbę *s.
• J: Począwszy od oniestety pozostawił pustą linię na górze. To usuwa to.

JavaScript (ES6), 31 bajtów

Ten obejmuje zarówno wiodące, jak i końcowe łamanie linii.

Zaczynamy od łańcucha szawierającego tylko podział linii. Następnie przetwarzamy nwywołania rekurencyjne, dodając gwiazdkę po lewej stronie tego ciągu przy każdej iteracji. Łączenie wszystkich łańcuchów pośrednich prowadzi do oczekiwanego wyniku.

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

Bez gwiazdki 36 bajtów

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

05AB1E , 7 6 bajtów

Wykorzystuje kodowanie CP-1252 .

'*×.p»

8-bajtowa wersja bez gwiazdki:

žQTè×.p»

Wypróbuj online!

Wyjaśnienie

Przykład z wykorzystaniem danych wejściowych n = 5

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

PowerShell, 21 bajtów

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

Pętle od 1do wejścia $args[0], każda iteracja używa mnożenia łańcucha, aby utworzyć ciąg z tylu $_gwiazdek. Domyślne zachowanie niejawnego Write-Outputna końcu ma nowy wiersz separatora, więc otrzymujemy to za darmo.

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 bajtów

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

Ideone

ijest inicjowany 1;
następnie execpolecenia, aby wykonać następujący ciąg kodu, więc należy go zbudować;
ciąg jest następujący, "print'*'*i;i+=1;"ale *następujący ciąg ma pierwszeństwo przed execi nakazuje, aby najpierw powtórzyć ciąg znaków input(); komenda teraz wykonuje długi łańcuch, który działa jak pętla, ing inny ciąg wzrostem długości, ponownie używając powtórzyć znak , a następnie zwiększany o .
execprint*'*'ii+=1

Pyton 3, 41 bajtów:
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; lub
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

Galaretka , 6 5 bajtów

”*ẋþY

TryItOnline

W jaki sposób?

”*ẋþ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:
Nie jestem pewien, co to jest klauzula no ordinals, ponieważ postać jest odnośnikiem porządkowym.
Bezpośrednie wyszukiwanie byłoby po prostu 42Ọẋþ³Ydla 7 bajtów - gdzie ³dostaje nas dane wejściowe)
Krótka, nieco pośrednia metoda byłaby, dla 8 bajtów , “)’Ọẋþ³Y- gdzie szukamy ')'na stronie kodowej galaretki, która jest indeksowana 1, więc “)’daje 42.

C #, 42 bajty

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

Pełny program z przypadkiem testowym:

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 bajtów

j._*"*

Wypróbuj tutaj .

Wyjaśnienie

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 (flaga n) = 21 bajtów

Edycja: 4 bajty mniej na podstawie komentarzy Riley

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

Wypróbuj online!

Uruchom przykład: dane wejściowe są w formacie jednoargumentowym, który dla sed jest dozwolony na podstawie tego konsensusu

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

*
**
***
****

W wyjściu znajduje się wiodąca nowa linia, ale jest to dozwolone przez PO.

Wyjaśnienie:

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 bajtów

Dobry stary Matlab ...

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

Ma końcowe białe spacje. trildaje niższą trójkątną matrycę.

edycja: zapisane 2 bajty dzięki Luisowi Mendo

C ++ - 92 96 bajtów

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

Wypróbuj online

Nie golfowany:

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

Meduza , 12 11 9 bajtów

\P$'*
  i

Wypróbuj online!

Wyjaśnienie

Powyższy program jest równoważny z następującym funkcjonalnym pseudokodem:

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

$(Reshape) tworzy ciąg Ngwiazdek. \Ptworzy funkcję, która pobiera listę (lub ciąg znaków) i przekazuje każdy ze swoich przedrostków do P(drukuj). Stąd, to sukcesywnie drukuje ciągi 1do Ngwiazdek.

R, 45 bajtów

W przypadku podejścia w pętli:

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

Brachylog , 12 bajtów

yke:"*"rj@w\

Wypróbuj online!

Zakłada się, że nowa linia końcowa jest dopuszczalna

Wyjaśnienie

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

Brak nowej linii, 15 bajtów

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

Wypróbuj online!

Ten działa, biorąc wszystkie prefiksy "*" × Input.

Haskell, 35 38 bajtów

Zrozumienie listy dzięki nim:

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

Stara wersja:

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

Alternatywna wersja:

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

Pyth, 7 bajtów

VQ*\*hN

Znalazłem bajt dzięki @ETHproductions Wypróbuj online

przy użyciu techniki @ PIetu1998

6 bajtów

j*L*\*S

2sable , 24 11 bajtów

>G')Ç>çJN×,

Wypróbuj online!

I żadnych śladów gwiazdek! Grał w golfa od 24 do 11 dzięki @Emigna .

Wyjaśnienie:

>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 bajtów

Obejmuje +3 za -A

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

Wypróbuj online!

Wyjaśnienie:

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

↑'*'⍴⍨¨⍳

↑ zmaterializuj listę składającą się z

'*' ciąg „*”

⍴⍨ przekształcony przez

¨ każdy z

⍳ liczby całkowite od 1 do argumentu.

Wypróbuj APL online!

V , 8 bajtów

Àé*hòlÄx

Wypróbuj online!

JavaScript (ES6), 34 bajty

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

Perl 6 , 23 bajtów

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

(Jeśli dane wyjściowe mogą być listą „linii” bez znaków nowej linii, .put for można je usunąć)

Wyjaśnienie:

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

(Zobacz dokumentację, producejeśli nie rozumiesz, co [\~] ...się dzieje)

Perl 5, 22 20 bajtów

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

Uruchom go za pomocą -Eprzełącznika, aby uzyskać say.

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

Napisany jako pełny program wyglądałby tak:

use strict;
use feature 'say';

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

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

• shifti popdomyślnie pracują nad @ARGV(listą argumentów) poza sub
• ..jest operatorem zasięgu
• say zawiera nową linię
• xjest operatorem do powtarzania ciągów i jest wyjaśnione w perlop

Perl, 19 bajtów

-4 bajty dzięki @Tonowi Hospelowi i jego przeróbce rozwiązania!

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

Potrzebuje wolnej flagi -E(lub -M5.010) do uruchomienia. Pobiera liczbę z danych wejściowych:

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

J, 11 8 bajtów

Zaoszczędzone 3 bajty dzięki kilometrom!

]\@#&'*'

Oto rozkład:

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

Teraz ten ostatni brzmi „przedrostki ( ]\) ciągu składającego się z xkopii '*'”. Przestrzegać:

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

Przypadek testowy

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

Starsze, 11-bajtowe rozwiązania

'*'#~"+1+i.

To jest równoważne

'*' #~"0 1 + i.

1 + i.jest zasięgiem [1, x]. Następnie '*' #~"0zastosowano do tego zakresu kształty (element) kopii '*'.

Program bonusowy:

[:#&'*'\#&1

To jest widelec z czapką #&'*'\zastosowany do wyniku danych #&1wejściowych. #&1daje tablicę xjedynek i #&'*'\kształty '*'do prefiksów tej tablicy.

Przypadki testowe

   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 klawiszy

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

Ogromne uznanie dla @Udioica za wymyślenie niesamowitej odpowiedzi vim, którą rozwinąłem. Ta odpowiedź nie zawiera gwiazdek, w nadziei na wygranie nagrody.

Wyjaśnienie:

Dane wejściowe są wpisywane przed pozostałą częścią programu. Udioica wymyślił tę niesamowitą sztuczkę. Pisanie <n>O <esc>spowoduje utworzenie piramidy spacji i jednej pustej linii, o ile :set autoindentwłączysz. Ta opcja jest domyślnie włączona w vimie 8 i neovimie, choć nie w starszych wersjach vima. Ponieważ tworzy to również dodatkową linię, używamy Jdo łączenia tej linii z następną, co skutecznie usuwa linię poniżej nas.

W tym momencie musimy zastąpić wszystkie te spacje gwiazdkami. Gdybym nie martwił się użyciem gwiazdek w kodzie, wybrałbym tylko wizualnie całą rzecz <C-v>{i typ r*, który zastępuje każdy znak zaznaczenia gwiazdką. Ale nie mogę tego zrobić.

Dlatego otwieramy strony pomocy na :h r. Interesującą rzeczą jest to, że w oknie vima ta strona jest wyświetlana jako:

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

Z kursorem na pierwszym „r”. Jednak sam plik faktycznie zawiera ten tekst:

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

Całkiem wygodne. Poruszamy się więc nad jednym znakiem li szarpamy tekst za r*pomocą yE([y] ank do [E] tego słowa).

Aby zamknąć ten bufor, używamy skrótu do zapisania pliku ZZ. Teraz wybieramy wizualnie nasze spacje i uruchamiamy szarpany tekst tak, jakbyśmy to zrobili @". Działa to, ponieważ „@” uruchamia następujący rejestr jako naciśnięcia klawiszy vim, a „jest domyślnym rejestrem dla szarpania.

C, 47 46 45 43 bajtów

Pobiera dane z wiersza poleceń

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

Zasadniczo, jeśli n nie jest równe 0, powtórz na n-1. u góry rekurencji, gdzie n wynosi 0, po prostu wypisuje nową linię, pętla for kończy się, gdy n wynosi -1 lub ~ n wynosi zero, w przeciwnym razie wypisuje ASCII 42, który jest „*”. Wypróbuj na ideone

C ++ 58 bajtów + 19 za włączenie iostream jest 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
*
**
***

Siatkówka , 14 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

.+
$**
.
$`$&¶

Wypróbuj online!

Wyjaśnienie

.+
$**

Zmień dane wejściowe Nw Ngwiazdki.

.
$`$&¶

Zamień każdą gwiazdkę na wszystko, włącznie z tą gwiazdką (to jest $`$&) i linefeed (to the ¶).

MATL, 9 8 bajtów

1 bajt zapisany dzięki @Luis

:"42@Y"c

Wypróbuj online

Cubix , 22 bajty

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

Przetestuj online! Generuje końcowy znak nowej linii.

Na początku nie byłem pewien, czy uda mi się dopasować to do 2-sześcianu, ale ostatecznie wszystko poszło dobrze:

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

Dodam wyjaśnienie, kiedy będę miał czas, mam nadzieję, że dzisiaj.