[Question]
  [
**The Challenge**
Your task is to create a program or function that outputs the following with no input:
```
a
bb
ccc
dddd
eeeee
ffffff
ggggggg
hhhhhhhh
iiiiiiiii
jjjjjjjjjj
kkkkkkkkkkk
llllllllllll
mmmmmmmmmmmmm
nnnnnnnnnnnnnn
ooooooooooooooo
pppppppppppppppp
qqqqqqqqqqqqqqqqq
rrrrrrrrrrrrrrrrrr
sssssssssssssssssss
tttttttttttttttttttt
uuuuuuuuuuuuuuuuuuuuu
vvvvvvvvvvvvvvvvvvvvvv
wwwwwwwwwwwwwwwwwwwwwww
xxxxxxxxxxxxxxxxxxxxxxxx
yyyyyyyyyyyyyyyyyyyyyyyyy
zzzzzzzzzzzzzzzzzzzzzzzzzz
```
You may use the uppercase alphabet instead of lowercase if you prefer. Trailing/leading newlines or spaces are allowed.
**Scoring**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 36 bytes
```
i=1
exec'print chr(i+96)*i;i+=1;'*26
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWkCu1IjVZvaAoM69EITmjSCNT29JMUyvTOlPb1tBaXcvI7P9/AA "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Aƶ
```
**[Try it online!](https://tio.run/##MzBNTDJM/f/f8di2/4d2/wcA "05AB1E – Try It Online")**
Note that this outputs as a list of lines, as the OP explicitly allowed. The link uses a version with pretty-print (joined by newlines).
## How it works
* `A` yields the lowercase alphabet.
* `ƶ` lifts the alphabet (multiplies each element by its index).
* `»` joins by newlines.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~12~~ ~~8~~ 5 bytes [SBCS](https://github.com/abrudz/SBCS)
*3 bytes saved thanks to @ngn*
*4 bytes saved thanks to @Adám*
```
⍴⍨⌸⎕A
```
OP [clarified](https://codegolf.stackexchange.com/questions/147469/alphabet-staircase#comment360851_147469) uppercase letters are valid, as well as output as an array of strings.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtEx61TXzUu@VR74pHPTuAIo7//wMA)
**How?**
`⌸` gives us every letter in the **`⎕A`** lphabet with its indexes in it, handed into the function `⍴⍨` with the letter as left argument and the index~~es~~ as right argument.
`⍴⍨` resha **⍴** es its right argument to the length supplied by its left one. `⍨` switches the left and right (therefore the symbol of it, looking like the face of someone reading this explanation).
[Answer]
# [Haskell](https://www.haskell.org/), 27 bytes
```
[c<$['a'..c]|c<-['a'..'z']]
```
[Try it online!](https://tio.run/##y0gszk7NyflfbBvzPzrZRiVaPVFdTy85tibZRhfCVq9Sj439n5uYmadgq5CbWOCrUFBaElxS5JOnUPz/X3JaTmJ68X/d5IICAA "Haskell – Try It Online") Returns a list of lines. (Thanks to @totallyhuman for pointing out that this is now allowed)
**Explanation:**
```
             c<-['a'..'z']  -- for each character c from 'a' to 'z'
[           |c<-['a'..'z']] -- build the list of
[   ['a'..c]|c<-['a'..'z']] -- the lists from 'a' to c, e.g. "abcd" for c='d'
[c<$['a'..c]|c<-['a'..'z']] -- with each element replaced by c itself, e.g. "dddd"
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~32~~ 30 bytes
-2 bytes thanks to @EricDuminil.
```
27.times{|n|puts (n+96).chr*n}
```
[Try it online!](https://tio.run/##KypNqvz/38hcryQzN7W4uiavpqC0pFhBI0/b0kxTLzmjSCuv9v9/AA "Ruby – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 74 bytes
```
++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+<<[->>[->+<<.>]>[-<+>]<+<+<<.>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwqi7bTtgJSdNhKwsbHRjbUDC4JkbWyide3sgBjI0rOLBbJstO1ibbRtIPz//wE "brainfuck – Try It Online")
## Explanation
```
++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+
TAPE:
  000
  010   C_NEWLINE
  026   V_ITERCOUNT
  097   V_ALPHA
 >001<  V_PRINTCOUNT
  000   T_PRINTCOUNT
V_ITERCOUNT TIMES:      <<[-   
  V_PRINTCOUNT TIMES:     >>[-
    INC T_PRINTCOUNT        >+
    OUTPUT V_ALPHA          <<.
                          >]
  RESTORE V_PRINTCOUNT    >[-<+>]
  INC V_PRINTCOUNT        <+
  INC V_ALPHA             <+
  OUTPUT C_NEWLINE        <<.
                        >]
```
[Try it online!](https://tio.run/##jVBBCsIwELznFXsPlehBUZaFUgIGNC11q4dSRAVBBA@C76/ZWksrCs6hm84sM5Mc74fL7fw4XetatyhJUxike0DEqKKGFFVxnNmFAjDGyHdsACDZe7tbOW@FmUwDs907tnmSFp6Fm88aLl5ly1gBGTNG@c9y57lbMmLFfVL1bIDd2m4W0ACxjMJQaujS3yEqIyUH55OBK7QId5GRFpwV/C4HHRBHCn6CKsnO7YbT3A47iFpGqMPKK3z7JRx1J37kvsW2V/e0//Siqq6f "brainfuck – Try It Online")
[Answer]
# [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), 27 bytes
```
1+:0\::'`j'@+\k:$$>:#,_$a,
```
where `` is a substitution character (ASCII 26)
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/31DbyiDGykpdKiFL3UE7JttKRcXOSlknXiVR5/9/AA "Befunge-98 (FBBI) – Try It Online")
Uses uppercase letters, and has a trailing newline.
### Explanation
The code works by storing a counter (0 initially), and on every loop:
* `1+` - Increments it by 1
* `:0\::` - Pushes things so that the stack looks like this: `bottom [N, 0, N, N, N] top`
* `'`j'@` - Checks if the counter is greater than 26
	+ `j'@` - If it is, we jump over the `'` and exit using `@`
	+ `j'@` - If it isn't, we execute the `'`, which pushes the ASCII value of `@` to the stack
Now the stack looks like this: `bottom [N, 0, N, N, 64] top`
* `+\` - Adds, then switches the top 2: `bottom [N, 0, (N+64), N] top` The first time through, this is ASCII 65, or `A`
* `k:` - Duplicates the second from the top `(N+1)` times - now there are `(N+2)` values of `(N+64)` on the stack (plus the `N` and `0` from earlier)
* `$$` - Throw away the top 2 values - now there are only `N` values of `(N+64)`
* `>:#,_` - Prints each top value until it gets to a `0` - this means `N` copies of `(N+64)` get printed
* `$` - Throws away the `0` - Now the stack is just `N`
* `a,` - Prints an enter
And it repeats
---
I like how I used the `@` both for ending the program and for adding to the counter.
[Answer]
# JavaScript (ES6), 54 bytes
```
f=(n=9)=>++n<36?n.toString(36).repeat(n-9)+`
`+f(n):''
O.innerText = f()
```
```
<pre id=O></pre>
```
[Answer]
**Excel VBA, 38 bytes**
Using Immediate Window. :)
```
[A1:A26]="=REPT(CHAR(96+ROW()),ROW())"
```
[Answer]
## BASH, ~~59 54~~ 40 bytes
```
for l in {a..z};{
a+=a
echo ${a//a/$l}
}
```
[Try it online!](https://tio.run/##S0oszvj/Py2/SCFHITNPoTpRT6@q1rqaK1HbNpErNTkjX0GlOlFfP1FfJaeWq/b/fwA)
thx. 5 bytes to @Justin Mariner
[Answer]
# Ruby, 38 bytes
Returns an Array of strings
```
->{(a=*?a..?z).map{|x|x*-~a.index(x)}}
```
*-5 bytes thanks to totallyhuman*
\*-11 bytes thanks to some excellent golfing by Jordan.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 9 bytes
```
¬az\ÓÎÛäl
```
[Try it online!](https://tio.run/##K/v//9CaxKqYw5MP9x2efXhJzv//AA "V – Try It Online")
Hexdump:
```
00000000: ac61 7a5c d3ce dbe4 6c                   .az\....l
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 9 bytes
```
2Y2"@X@Y"
```
[**Try it online!**](https://tio.run/##y00syfn/3yjSSMkhwiFS6f9/AA "MATL – Try It Online")
### Explanation
```
2Y2     % Push string 'abc...z'
"       % For char in that string each
  @     %   Push current char
  X@    %   Push iteration index (1-based)
  Y"    %   Run-length decoding: repeat char that many times
        % Implicit end. Implicit display
```
[Answer]
# [Python 3](https://docs.python.org/3/), 37 bytes
```
for k in range(27):print(chr(k+96)*k)
```
Prints a leading newline (which is allowed).
[**Try it online!**](https://tio.run/##K6gsycjPM/7/Py2/SCFbITNPoSgxLz1Vw8hc06qgKDOvRCM5o0gjW9vSTFMrW/P/fwA "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 [bytes](https://github.com/DennisMitchell/jelly)
sneaky Python implementation abuse
-1 byte thanks to [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m) (outputting a list of lines has been allowed; as, now, has writing a function rather than a program)
```
Øa×J
```
A niladic link that returns a list of strings, the lines  
(to print it with the newlines as a full program [just add `Y` back in](https://tio.run/##y0rNyan8///wjMTD070i//8HAA "Jelly – Try It Online")).
**[Try it online!](https://tio.run/##ARYA6f9qZWxsef//w5hhw5dK/8KixZLhuZj/ "Jelly – Try It Online")** (the footer calls the link as a nilad (`¢`) and gets the Python representation of the result (`ŒṘ`) for clarity as the default full-program behaviour would smash the result together like `abbccc...`)
### How?
```
Øa×J - main link: no arguments
Øa   - yield the alphabet = ['a','b','c',...,'z']
   J - range of length    = [1,2,3,...,26]
  ×  - multiplication     = ["a","bb","ccc",...,"zzzzzzzzzzzzzzzzzzzzzzzzzz"]
     - (Python multiplication lengthens chars to strings - not usually a Jelly thing)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 11 bytes
```
2Y2t!g*!YRc
```
[Try it online!](https://tio.run/##y00syfn/3yjSqEQxXUsxMij5v6pjTnG@gqGhQlJlSWoxFxdQTrGkTlEbKAdm5xiZRShFBv0HAA "MATL – Try It Online")
Uses broadcast multiplication with ones to get a big square 26x26 matrix of the desired letters. Next, the lower triangular part is taken, and implicitly printed.
Also 11 bytes:
```
2Y2!t~!+YRc  % Using broadcast addition with zeroes
2Y2!l26X"YR  % Using 'repmat'
```
[Answer]
# Javascript, ~~87 bytes~~, 72 bytes (A lot of thank to @steenbergh)
My first answer too:
```
for(i=1,j=97;j<123;){console.log(String.fromCharCode(j++).repeat(i++))};
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), ~~9~~ 7 bytes
Outputs an array of lines
```
;C¬Ëp°E
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=O0Osy3CwRQ==&input=LVI=)
---
## Explanation
Split (`¬`) the lowercase alphabet (`;C`) to an array of characters, map over the array (`Ë`) and repeat (`p`) the current element by the current index (`E`) incremented (`°`) times.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 9 bytes
```
FczPcX++i
```
[Try it online!](https://tio.run/##K8gs@P/fLbkqIDlCWzvz/38A "Pip – Try It Online")
In pseudocode, this is
```
For-each c in z
    Print (c string-multiply ++i)
```
where `z` is preset to the lowercase alphabet and `i` is preset to 0.
---
Map-based solutions take one extra byte because they need the `-n` flag to display on multiple lines:
```
{aX++i}Mz
B X_+1MEz
```
[Answer]
# [*Acc!!*](https://github.com/dloscutoff/Esolangs/tree/master/Acc!!), 66 bytes
```
Count i while 26-i {
Count j while i+1-j {
Write 97+i
}
Write 10
}
```
[Try it online!](https://tio.run/##S0xOTkr6/985vzSvRCFToTwjMydVwchMN1OhmgsimAUVzNQ21M0CioYXZZakKliaa2dy1UI5hgZctf//AwA "Acc!! – Try It Online")
### With comments
```
# Loop i from 0 to 25
Count i while 26-i {
    # Loop j from 0 to i (inclusive)
    Count j while i+1-j {
        # Print a letter
        Write 97+i
    }
    # Print a newline
    Write 10
}
```
[Answer]
# [Haskell](https://www.haskell.org/), 31 bytes
*-12 bytes thanks to nimi.*
```
zipWith replicate[1..26]['a'..]
```
[Try it online!](https://tio.run/##BcExDoAgDADAr3QwYZJEBzde4eCgDg0BbaykkbL4eOvdifVKzJbDZi/JQnrCk4QpoqZ18H6c9tWh8363G6lAAGk66wMdtMJUUoVsX8yMR7U@ivw "Haskell – Try It Online")
This is not a snippet, it is a *nullary function* (one that takes no arguments) that outputs a list of lines which is allowed because of [this meta consensus](https://codegolf.meta.stackexchange.com/a/12945/68615).
[Answer]
# [R](https://www.r-project.org/), 38 bytes
A relatively uninteresting answer. Iterate for `i` from 1 to 26, print the `i`th letter of the alphabet `i` times (with an implicit line break).
```
for(i in 1:26)print(rep(letters[i],i))
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPwdDKyEyzoCgzr0SjKLVAIye1pCS1qDg6M1YnU1Pz/38A "R – Try It Online")
A more interesting approach might be to use something like the following:
```
cat(letters[(1:351*2)^.5+.5])
```
This gives us all the letters in the right amount, but no linebreaks. Perhaps someone smarter than me can figure out a way to use that to make a golfier answer.
[Answer]
# [Perl 5](https://www.perl.org/), 19 bytes
```
say$_ x++$"for a..z
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIlXqFCW1tFKS2/SCFRT6/q//9/@QUlmfl5xf91fU31DAwNAA "Perl 5 – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 82 bytes
```
||for i in 1..27u8{println!("{}",((i+96) as char).to_string().repeat(i as usize))}
```
I had hoped that it would've been a lot shorter, but explicitly converting/casting between types takes a lot of bytes :(
[Try it online!](https://tio.run/##Lc3LCsIwEEbhfZ/it6sZlIAuvFB8Fgkl1YGYlkmyMc2zxwquz4FPc0xtCnhbCcQoHeBdwujnmNXhjrau06wQSMDRmNMlX8uiEpIPO@pL7Q9Esr@dGTZifFllk@ZHTNvyJDbqFmcTya/mKB/HXBswbM7fIB662r4 "Rust – Try It Online")
[Answer]
# PHP, ~~47~~ 46 bytes
```
for($c=a;$i<26;)echo"
",str_pad($c,++$i,$c++);
```
or
```
for($c=a;$i<26;)echo str_pad("
",++$i+1,$c++);
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/31a9cb0fc1a67c88d9942b25365a5a78a9564535).
[Answer]
# [J](http://jsoftware.com/), 18 17 bytes
```
a.{~(#"0+&96)i.27
```
Explanation:
```
              i.27      - list of integers 0 - 26
     (   +&96)          - adds 96 to the above list (starting offset of 'a')
      #"0               - copies the right argument left argument times  
  {~                    - select items from a list (arguments reversed)
a.                      - the whole alphabet
#"0 +&96 is a hook, which means that at first +96 is applied to the list i.27,
resulting in a list 96, 97, 98... 122, then #"0 is applied to this result. 
So it is evaluated as ((i.27)#"0(96+i.27)){a:
```
[Try it online!](https://tio.run/##y/qfVqxga6VgoADE/xP1qus0lJUMtNUszTQz9YzM/2tyKekpqKfZWqkr6CjUWimkFXOlJmfkK6T9BwA "J – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), ~~24~~ 23 bytes
```
.say for 'a'..'z'Zx 1..*
```
[Try it](https://tio.run/##K0gtyjH7/1@vOLFSIS2/SEE9UV1PT71KPapCwVBPT@v/fwA "Perl 6 – Try It Online")
```
.say for 'a'..*Zx 1..26
```
[Try it](https://tio.run/##K0gtyjH7/1@vOLFSIS2/SEE9UV1PTyuqQsFQT88IKAEA "Perl 6 – Try It Online")
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~25~~ 24 bytes
```
['',tril((x=65:90)'+~x)]
```
[Try it online!](https://tio.run/##y08uSSxL/f8/Wl1dp6QoM0dDo8LWzNTK0kBTXbuuQjP2/38A "Octave – Try It Online")
Saved one byte thanks to Giuseppe who informed me that OP allows upper case letters.
### Explanation:
Create a vector `x` with the ASCII-values of the upper case alphabet, and transpose it. Add the negated `x` (thus 26 zeros, in a row vector, in order to create a grid with (the ASCII-values of):
```
AAAA
BBBB
CCCC
```
Take the lower triangular matrix and convert to characters by concatenating with the empty string.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~48 bytes~~ 50 bytes
Re-runnable version, as per cleblanc and Steadybox in the comments below.
```
s[9];main(i){for(;i<27;)puts(memset(s,i+95,i++));}
```
[Try it online!](https://tio.run/##S9ZNT07@/7842jLWOjcxM08jU7M6Lb9IwzrTxsjcWrOgtKRYIzc1tzi1RKNYJ1Pb0hRIaGtqWtf@/w8A "C (gcc) – Try It Online")
[Answer]
# Japt, ~~17~~ ~~16~~ 11 bytes
-5 bytes thanks to Oliver
In ISO-8859-1
```
;26ÆCgX pXÄ
```
Not the best score, but I'm still a novice. Any suggestions are very welcome.
Outputs list of lines, as OP allowed. Link contains 3 bytes more for newlines.
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=OzI2xkNnWCBwWMR9ILc=&input=)
```
;                      - Use string variables
 26                    - Literal 26
   Æ                   - For range 0..26
    C                  - Alphabet
     gX                -         . character at index X
        pXÄ            - Duplicate X+1 times
                       - End function (implicit)
```
]