Ispirato da un'attività per la programmazione 101, ecco un'attività che si spera non sia troppo facile o che sia un duplicato (è un po 'difficile cercare cose come questa).

Ingresso:

• Un numero intero positivo n >= 1.

Produzione:

• n linee di asterischi, in cui ogni nuova riga ha un asterisco in più rispetto alla riga precedente e inizia con un asterisco nella prima riga.

Regole generali:

• Questo è code-golf, quindi vince la risposta più breve in byte.
• Poiché il corso è tenuto in C ++, non vedo l'ora di vedere soluzioni in C ++.

Caso di prova (n = 5):

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

Vim, 8 byte

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

Accetta l'input nel buffer readahead, quindi se l'input è 15, dovresti digitare quello e quindi il codice sopra. Questa è una regola sciocca, ma sembra essere consentita . Se hai inserito un registro come "a, ti limiteresti a rimanere @ain primo piano (10). Se lo avessi ottenuto dal file di avvio, avresti D@"invece anteposto (11).

Si basa sull'abuso di :set autoindent, che è predefinito nelle regole di vimgolf.com e predefinito in Vim 8 (e tutti lo usano comunque).

• o <Esc>: Con il suo argomento numerico, se il tuo testo inizia con uno spazio bianco e lo hai :set autoindent, Vim si blocca e crea una cascata di rientri.
• <C-V>{r*: Trasforma tutti quegli spazi in *s. Sto usando il blocco visivo in modo che, anche se le impostazioni del rientro scadente raggruppano silenziosamente i tuoi spazi in schede, otterrai comunque il giusto numero di *s.
• J: A partire da opurtroppo ha lasciato una riga vuota in alto. Questo lo rimuove.

JavaScript (ES6), 31 byte

Questo include un'interruzione di linea sia iniziale che finale.

Iniziamo con una stringa scontenente solo un'interruzione di riga. Quindi nelaboriamo le chiamate ricorsive, aggiungendo un asterisco sul lato sinistro di questa stringa ad ogni iterazione. La concatenazione di tutte le stringhe intermedie porta al risultato atteso.

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

Senza asterisco, 36 byte

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

05AB1E , 7 6 byte

Utilizza la codifica CP-1252 .

'*×.p»

Versione senza asterisco a 8 byte:

žQTè×.p»

Provalo online!

Spiegazione

Esempio di input 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]|%{'*'*$_}

Passa da un 1input $args[0]all'altro, ogni iterazione utilizza la moltiplicazione di stringhe per costruire una stringa di tanti $_asterischi. Il comportamento predefinito per l'implicito Write-Outputalla fine è con una nuova riga per il separatore, quindi lo otteniamo gratuitamente.

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

Ideone

iè inizializzato a 1;
quindi execcomanda di eseguire la seguente stringa di codice, quindi deve essere costruita;
la stringa è "print'*'*i;i+=1;"la *seguente ma la stringa ha la precedenza su exece indica di ripetere prima i input()tempi della stringa ;
il execcomando ora esegue la stringa lunga che agisce come un ciclo, printinserendo un'altra stringa di lunghezza crescente, usando nuovamente *per ripetere il carattere '*', quindi incrementando icon i+=1.

Pitone 3, 41 byte:
def f(n):i=1;exec("print('*'*i);i+=1;"*n) ; o
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

Gelatina , 6 5 byte

”*ẋþY

TryItOnline

Come?

”*ẋþ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:
Non sono sicuro di quale sia la clausola no ordinals, dal momento che un personaggio è una ricerca di un ordinale.
La ricerca diretta sarebbe solo 42Ọẋþ³Yper 7 byte - dove ³ci arriva l'input)
Un metodo breve e leggermente indiretto sarebbe, per 8 byte , “)’Ọẋþ³Y- dove cerchiamo ')'nella tabella codici di jelly, che è 1-indicizzata, quindi “)’produce 42.

C #, 42 byte

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

Programma completo con test case:

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 byte

j._*"*

Provalo qui .

Spiegazione

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 flag) = 21 byte

Modifica: 4 byte in meno sulla base dei commenti di Riley

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

Provalo online!

Esempio di esecuzione: l'input è in formato unario, che per sed è consentito in base a questo consenso

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

*
**
***
****

Nell'output è presente una nuova riga principale, ma ciò è consentito dall'OP.

Spiegazione:

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

Buon vecchio Matlab ...

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

Ha spazi bianchi finali. trilti dà la matrice triangolare inferiore.

modifica: salvato 2 bythes grazie a Luis Mendo

C ++ - 92 96 byte

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

Provalo online

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

Meduse , 12 11 9 byte

\P$'*
  i

Provalo online!

Spiegazione

Il programma sopra è equivalente al seguente pseudocodice funzionale:

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

L' $(Reshape) crea una serie di Nasterischi. \Pcrea una funzione che accetta un elenco (o una stringa) e passa ciascuno dei suoi prefissi a P(stampa). Quindi, questo stampa successivamente stringhe di 1a Nasterischi.

R, 45 byte

Per l'approccio ad anello:

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

Brachylog , 12 byte

yke:"*"rj@w\

Provalo online!

Ciò presuppone che una nuova riga finale sia accettabile

Spiegazione

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

Nessuna nuova riga finale, 15 byte

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

Provalo online!

Questo funziona prendendo tutti i prefissi di "*" × Input.

Haskell, 35 38 byte

Comprendi la lista grazie a nimi:

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

Vecchia versione:

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

Versione alternativa:

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

Pyth, 7 byte

VQ*\*hN

Cancellato un byte grazie a @ETHproductions Provalo online

usando la tecnica di @ PIetu1998

6 byte

j*L*\*S

2 file , 24 11 byte

>G')Ç>çJN×,

Provalo online!

E nessun segno di asterischi! Giocato a golf dalle 24 alle 11 grazie a @Emigna .

Spiegazione:

>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

Include +3 per -A

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

Provalo online!

Spiegazione:

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

↑'*'⍴⍨¨⍳

↑ maturare l'elenco composto da

'*' la stringa "*"

⍴⍨ rimodellato da

¨ ciascuno di

⍳ gli interi 1 tramite l'argomento.

ProvaAPL online!

V , 8 byte

Àé*hòlÄx

Provalo online!

JavaScript (ES6), 34 byte

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

Perl 6 , 23 byte

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

(Se l'output può essere un elenco di "righe" senza le nuove righe .put for può essere rimosso)

Spiegazione:

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

(Vedi la documentazione per producese non capisci cosa [\~] ...sta facendo)

Perl 5, 22 20 byte

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

Eseguilo con l' -Einterruttore per ottenere say.

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

Scritto come un programma completo sarebbe simile al seguente:

use strict;
use feature 'say';

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

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

• shifte poplavorare implicitamente su @ARGV(l'elenco degli argomenti) al di fuori dei sottotitoli
• ..è l' operatore di gamma
• say include una nuova riga
• xè un operatore per ripetere le stringhe ed è spiegato in perlop

Perl, 19 byte

-4 byte grazie a @Ton Hospel e alla sua rielaborazione della soluzione!

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

Ha bisogno di bandiera libera -E(o -M5.010) per funzionare. Prende un numero dall'input:

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

J, 11 8 byte

Salvato 3 byte grazie alle miglia!

]\@#&'*'

Ecco una decomposizione:

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

Ora, quest'ultimo si legge come "i prefissi ( ]\) della stringa costituita da xcopie di '*'". Osservare:

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

Caso di prova

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

Soluzioni precedenti a 11 byte

'*'#~"+1+i.

Questo è equivalente

'*' #~"0 1 + i.

1 + i.è la gamma [1, x]. Quindi, '*' #~"0applicato a questa gamma forme (elementi) copie di '*'.

Programma bonus:

[:#&'*'\#&1

Questa è una forcella chiusa #&'*'\applicata al risultato #&1dell'input. #&1fornisce un array di xquelli e #&'*'\forme '*'ai prefissi di questo array.

Casi test

   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
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+

Tasti Vim, 22 , 18

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

Enorme merito a @Udioica per aver trovato una fantastica risposta vim che ho ampliato. Questa risposta non contiene alcun asterisco, nella speranza di vincere la taglia.

Spiegazione:

L'input viene digitato prima del resto del programma. Udioica ha inventato questo fantastico trucco. La digitazione <n>O <esc>creerà una piramide di spazi e una riga vuota, purché tu abbia :set autoindentabilitato. Questa opzione è attiva di default in vim 8 e neovim, sebbene non nelle versioni precedenti di vim. Dal momento che questo crea anche una linea aggiuntiva, usiamo Jper unire questa linea con quella successiva, che effettivamente rimuove la linea sotto di noi.

Ora a questo punto, dobbiamo sostituire tutti questi spazi con asterischi. Se non fossi preoccupato di usare gli asterischi nel mio codice, selezionerei visivamente l'intera cosa <C-v>{e il tipo r*, che sostituisce ogni carattere della selezione con un asterisco. Ma non posso farlo.

Quindi apriamo le pagine di aiuto per :h r. La cosa interessante di questo è che nella finestra di vim, questa pagina viene visualizzata come:

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

Con il cursore sulla prima 'r'. Tuttavia, il file stesso contiene effettivamente questo testo:

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

Abbastanza conveniente. Quindi spostiamo su un carattere con le strappiamo il testo r*con yE([y] ank alla [E] nd di questa parola).

Per chiudere questo buffer, utilizziamo il collegamento per salvare un file ZZ. Ora, selezioniamo visivamente i nostri spazi ed eseguiamo il testo strappato come se lo avessimo digitato facendo @". Questo funziona perché "@" esegue il seguente registro come tasti di scelta rapida e "è il registro predefinito per lo strappo.

C, 47 46 45 43 byte

Riceve input dalla riga di comando

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

Fondamentalmente se n non è 0 ricorrere a n-1. nella parte superiore della ricorsione dove n è 0 stampa solo una nuova riga, il ciclo for termina quando n è -1 o ~ n è zero, altrimenti stampa ASCII 42 che è '*'. Provalo su ideone

C ++ 58 byte + 19 per includere 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
*
**
***

Retina , 14 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

.+
$**
.
$`$&¶

Provalo online!

Spiegazione

.+
$**

Trasforma l'input Nin Nasterischi.

.
$`$&¶

Sostituisci ogni asterisco con tutto fino a incluso l'asterisco (questo è il $`$&) e un avanzamento riga (questo il ¶).

MATL, 9 8 byte

1 byte salvato grazie a @Luis

:"42@Y"c

Provalo online

Cubix , 22 byte

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

Provalo online! Emette una nuova riga finale.

All'inizio non ero sicuro di riuscire a farlo stare su un cubo 2, ma alla fine ha funzionato bene:

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

Aggiungerò una spiegazione quando avrò tempo, si spera più tardi oggi.