Inspired by a task for Programming 101, here's a challenge that hopefully isn't too easy.
n >= 1.n lines of asterisks, where every new line has one asterisk more than the line before, and starting with one asterisk in the first line.* ** *** **** ***** This is code-golf, so shortest answer in bytes wins.
o <Esc><C-V>{r*J Takes input in the readahead buffer, so if input is 15, you would type that and then the code above. This is a silly rule, but seems to be allowed. If you got input in a register like "a, you'd just stick @a in front (10). If you got it from the start file, you'd prepend D@" instead (11).
Relies on abuse of :set autoindent, which is default in vimgolf.com rules and default in Vim 8 (and everyone uses it anyway).
o <Esc>: With its number argument, if your text starts with whitespace, and you have :set autoindent, Vim glitches out and creates a cascade of indent.<C-V>{r*: Turn all those spaces into *s. I'm using block visual so that, even if your lousy indent settings silently group your spaces into tabs, you'll still get the right number of *s.J: Starting with o unfortunately left a blank line at the top. This removes it.
-u NONE to see this by myself... It didn't work, it seems autoindent is on in the default vimrc, not vim 8 itself so I had to turn it in manually. But, hats off for the ingenuity of this answer! But why is there only one space per new line? Why does it only work with spaces but not with other characters? I still have much to learn it seems :) \$\endgroup\$ O <Esc> won't require J at the end. \$\endgroup\$ This one includes both a leading and a trailing line-break.
We start with a string s containing only a line-break. Then we process n recursive calls, adding an asterisk on the left side of this string at each iteration. The concatenation of all intermediate strings leads to the expected result.
f=(n,s=` `)=>n?s+f(n-1,'*'+s):s f=(n,s=` `)=>n?s+f(n-1,atob`Kg`+s):s 
s. You can make it slightly less cryptic with n?s+f(n-1,'*'+s):s. \$\endgroup\$ Uses CP-1252 encoding.
'*×.p» 8 byte no-asterisk version:
žQTè×.p» Explanation
Example using input n = 5
'* # push "*" # STACK: "*" × # repeat input number times # STACK: "*****" .p # get prefixes of string # STACK: ['*', '**', '***', '****', '*****'] » # join by newlines # implicit print 
10žQSè×.p» is a logical extension of this answer to get what you wanted for the bounty and it is only 10 bytes. Give Emigna the bounty if nobody beats 10 bytes haha. \$\endgroup\$ TžQè×.p» is 8 bytes even. \$\endgroup\$ » and that is a command specifically for merging a lists with delimiters into a string (and S would ruin that). But a lot of 05AB1E commands do vectorize, yes. \$\endgroup\$ 1.."$args"|%{'*'*$_} Loops from 1 to input $args, each iteration using string multiplication to construct a string of that many $_ asterisks. Default behavior for the implicit Write-Output at the end is with a newline for separator, so we get that for free.
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 * ** *** **** ***** ****** ******* -1 byte thanks to Veskah.
i=1;exec"print'*'*i;i+=1;"*input() i is initialised to 1;
then exec commands to execute the following string of code, so it must be constructed;
the string is "print'*'*i;i+=1;" but the * following the string takes precedence over the exec and instructs to first repeat the string input() times;
the exec command now executes the long string which acts like a loop, printing another string of increasing length, again using * to repeat the character '*', then incrementing i with i+=1.
Python 3, 41 bytes:
def f(n):i=1;exec("print('*'*i);i+=1;"*n); or
lambda n,i=1:exec("print('*'*i);i+=1;"*n)
”*ẋþY ”*ẋþ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:
I'm not sure what the no ordinals clause is, since a character is a lookup of an ordinal.
Direct lookup would just be 42Ọẋþ³Y for 7 bytes - where the ³ gets us the input)
A short slightly indirect method would be, for 8 bytes, “)’Ọẋþ³Y - where we lookup ')' in jelly's code page, which is 1-indexed so “)’ yields 42.
f=n=>n<1?"":f(n-1)+"\n"+new string('*',n); Full program with 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)); } } } 
j._*"* j Join by newlines ._ all prefixes of * the result of repeating "* the string "*" as many times as the implicit input Edit: 4 bytes less based on Riley's comments
x;G;:;P;s:\n.:*\n:;t Run example: the input is in unary format, which for sed is allowed based on this consensus
me@LCARS:/PPCG$ sed -nf draw_triangle.sed <<< "0000" * ** *** **** A leading newline is present in the output, but this is allowed by the OP.
Explanation:
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 
Print before the substitution and a leading newline is allowed you don't need /0$/. If a newline isn't allowed you can still save a byte with x;G;:;/*/P;s:\n.:*\n:;t. I asked about a leading newline, but haven't heard back yet. \$\endgroup\$ Good old Matlab...
@(n)tril(repmat('*',n)) Has trailing whitespaces. tril gives you the lower triangular matrix.
edit: saved 2 bythes thanks to Luis Mendo
#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()); } 
\P$'* i The above program is equivalent to the following functional pseudocode:
\ P $ i '* map_prefixes(print, reshape(input(), '*')) The $ (reshape) creates a string of N asterisks. \P creates a function which takes a list (or string) and passes each of its prefixes to P (print). Hence, this successively prints strings of 1 to N asterisks.
For loop approach:
for(i in 1:scan())cat(rep("*",i),"\n",sep="") List comprehension thanks to nimi:
f x=unlines[[1..n]>>"*"|n<-[1..x]] Old version:
f 0="" f n=f(n-1)++([1..n]>>"*")++"\n" Alternate version:
g n=([1..n]>>"*")++"\n" f n=[1..n]>>=g 
([1..n]>>"*") instead of replicate n'*' to save a byte. I also count only 39 bytes. \$\endgroup\$ f 0="" which is counted as one byte, but shown as two bytes/characters in some text editors. \$\endgroup\$ f x=unlines[[1..n]>>"*"|n<-[1..x]]. \$\endgroup\$ yke:"*"rj@w\ This assumes that a trailing new line is acceptable
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 -:"*"rj:@[f~@nw This one works by taking all prefixes of "*" × Input.
VQ*\*hN Knocked off a byte thanks to @ETHproductions Try it online
6, bytes
j*L*\*S 
"*" with \*. \$\endgroup\$ j*L\*S (incluSive range, multiply each *L by "*" \*, join by newline) Pyth inserts an implicit Q in the end. \$\endgroup\$ >G')Ç>çJN×, And no sign of any asterisks! Golfed from 24 to 11 thanks to @Emigna.
Explanation:
>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 
õVYI doesn't affect your code in any way and can be removed. 1+ is the same as >. If you create the asterisk in the loop you can also remove UX. Using × instead of the inner loop saves even more bytes. Without changing method you can get this down to 11 bytes or less. \$\endgroup\$ Includes +3 for -A
{(({})[()]<{({}[()]<(((((()()()){}()){})){}{})>)}{}((()()()()()){})>)}{} Explanation:
{(({})[()]< >)} #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 
↑'*'⍴⍨¨⍳ ↑ matrify the list consisting of
'*' the string "*"
⍴⍨ reshaped by
¨ each of
⍳ the integers 1 through the argument.
⌸ can be a single byte: (,⍕⊢)⌸⍳ \$\endgroup\$ 7 bytes<sup>SBCS</sup>. \$\endgroup\$ 
Àé hòlÄ! \$\endgroup\$ <M-@><M-i>*h<M-r>l<M-D>x (m stands for meta, which means alt). All of those are pretty good mnemonics for what the command does. \$\endgroup\$ f=x=>x?f(x-1)+` `+'*'.repeat(x):'' 
{.put for [\~] '*'xx$_} ( If the output is allowed to be a list of "lines" without newlines .put for can be removed )
# 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 } ( See documentation for produce if you don't understand what [\~] ... is doing )
say"*"x$_ for 1..pop Run it with the -E switch to get say.
$ perl -E 'say"*"x$_ for 1..pop' 5 * ** *** **** ***** Written out as a full program it would look like this:
use strict; use feature 'say'; # get the argument my $limit = pop @ARGV; foreach my $i (1 .. $limit) { say "*" x $i; } shift and pop implicitly work on @ARGV (the list of arguments) outside of subs.. is the range operatorsay includes a newlinex is an operator to repeat strings and is explained in perlop
-E flag counts as 1 extra byte. \$\endgroup\$ perl -E 'say"*"x$_ for 1..<>' <<< 5 \$\endgroup\$ -E is free (as it replaces -e which would be needed anyway). If you really want to take the number from the command line (why not, even if <> is 1 byte shorter, and allowed), you should use pop instead of shift (2 bytes shorter)! Anyway, welcome on PPCG, happy to see you golfing! \$\endgroup\$ -4 bytes thanks to @Ton Hospel and his rework of the solution!
eval"s//*/;say;"x<> Needs free -E (or -M5.010) flag to run. Takes a number from input :
perl -E 'eval"s//*/;say;"x<>' <<< "5" eval the same length as the for solution (using <> instead of pop) with eval"s//*/;say;"x<> \$\endgroup\$ Saved 3 bytes thanks to miles!
]\@#&'*' Here is a decomposition:
(]\@#&'*') x x (]\@#) '*' ]\ (x # '*') Now, this last one reads as "the prefixes (]\) of the string consisting of x copies of '*'". Observe:
5 ]\@# '*' * ** *** **** ***** ]\ 5# '*' * ** *** **** ***** ]\ 5 # '*' * ** *** **** ***** ]\@#&'*' 5 * ** *** **** ***** f =: ]\@#&'*' f 3 * ** *** f 5 * ** *** **** ***** f 1 * f 2 * ** f &. > ;/1+i.10 +-+--+---+----+-----+------+-------+--------+---------+----------+ |*|* |* |* |* |* |* |* |* |* | | |**|** |** |** |** |** |** |** |** | | | |***|*** |*** |*** |*** |*** |*** |*** | | | | |****|**** |**** |**** |**** |**** |**** | | | | | |*****|***** |***** |***** |***** |***** | | | | | | |******|****** |****** |****** |****** | | | | | | | |*******|******* |******* |******* | | | | | | | | |********|******** |******** | | | | | | | | | |*********|********* | | | | | | | | | | |**********| +-+--+---+----+-----+------+-------+--------+---------+----------+ '*'#~"+1+i. This is equivalent
'*' #~"0 1 + i. 1 + i. is the range [1, x]. Then, '*' #~"0 applied to this range shapes (element) copies of '*'.
Bonus program:
[:#&'*'\#&1 This is a capped fork #&'*'\ applied to the result of #&1 of the input. #&1 gives an array of x ones, and #&'*'\ shapes '*' to the prefixes of this array.
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 +----------+----------+ |* |* | |** |** | |*** |*** | |**** |**** | |***** |***** | |****** |****** | |******* |******* | |******** |******** | |********* |********* | |**********|**********| +----------+----------+ 
n copies of '*' for 8 bytes using ]\@#&'*' \$\endgroup\$ '*'"0\@i. \$\endgroup\$ O <esc>J:h r<cr>lyEZZ<C-v>{@" Huge credit to @Udioica for coming up with an awesome vim answer that I expanded on. This answer does not contain any asterisks, in hopes of winning the bounty.
Explanation:
Input is typed before the rest of the program. Udioica came up with this awesome trick. Typing <n>O <esc> will create a pyramid of spaces and one empty line, as long as you have :set autoindent enabled. This option comes on by default in vim 8 and neovim, though not older versions of vim. Since this also creates an extra line, we use J to join this line with the next one, which effectively just removes the line below us.
Now at this point, we need to replace all of these spaces with asterisks. If I was not worried about using asterisks in my code, I would just visually select the whole thing <C-v>{ and type r*, which replaces each character of the selection with an asterisk. But I can't do that.
So we open up the help pages to :h r. The interesting thing about this is that in the vim-window, this page is displayed as:
r r{char} Replace the character under the cursor with {char}. ... With the cursor on the first 'r'. However, the file itself actually contains this text:
*r* r{char} Replace the character under the cursor with {char}. ... Pretty convenient. So we move over one character with l, and yank the text r* with yE ([y]ank to the [E]nd of this word).
To close this buffer, we use the shortcut to save a file ZZ. Now, we visually select our spaces, and run the yanked text as if we had typed it by doing @". This works because "@" runs the following register as vim-keystrokes, and " is the default register for yanking.
Takes input from the command line
f(n){for(n&&f(n-1);~n;putchar(n--?42:10));} Basically if n is not 0 recurse on n-1. at the top of the recursion where n is 0 it just prints a newline, the for loop terminates when n is -1 or ~n is zero, otherwise it prints ASCII 42 which is '*'. Try it on ideone
#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 * ** *** 
&&: n?f(n-1):0 → n&&f(n-1). \$\endgroup\$ I had to use LaTeX instead of plain TeX for the \typein macro...
Here it is, as golfed as I could:
\documentclass{book}\begin{document}\typein[\n]{}\newcount\i\newcount\a\i=0\loop{\a=0\loop*\advance\a by1\ifnum\i>\a\repeat} \advance\i by1 \ifnum\n>\i\repeat\enddocument Explanation:
\documentclass{book}% Book because it is shorter than article ;) \begin{document}% Mandatory... \typein[\n]{}% User inputs \n \newcount\i% Create a line counter \newcount\a% And an asterisk counter \i=0% Initializes the line number to zero \loop{% Line number loop \a=0% Sets the number of asterisks to zero \loop% Asterisk loop *% Prints the asterisk \advance \a by 1% Adds one to \a \ifnum\i>\a% If the line number is smaller than the number of asterisks \repeat% Then repeat }% Otherwise prints a new line \advance\i by 1% And add 1 to the line counter \ifnum\n>\i% If input number is less than the number of lines then \repeat% Repeat \enddocument% And finish LaTeX 
0 INPUT"NUMBER OF *";A:ON-(A<1)GOTO1:J=1:FORI=1TOA:FORX=1TOJ:PRINT"*";:NEXTX:J=J+1:PRINT:NEXTI 1 : Technically line 1 isn't required, but I'm mis-using the ON...GOTO command as a conditional GOTO in line zero so I added in the shortest possible line 1 to end it gracefully.
You will need to use Commodore keyword abbreviations to fit line zero on a C64, see the screen shot below (Note that the C128 in 128 mode might have different keyword abbreviations, but then you can enter more characters so you probably won't need it):
Byte count assumes ISO 8859-1 encoding.
.+ $** . $`$&¶ .+ $** Turn the input N into N asterisks.
. $`$&¶ Replace each asterisk with everything up to and including that asterisk (this is the $`$&) and a linefeed (this the ¶).