text:
Alphabet Staircase
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, so the shortest answer in each language wins.

Output as list of lines?

Can we use the uppercase alphabet instead?

I was missing alphabet challenges! (but don't let Leaky Nun know)

I worked very hard checking if it was a dupe and apparently it isn't

related, related

Trailing/leading newlines or spaces allowed?

@totallyhuman that's up to you.

@Uriel, I don't see why not.

@Shaggy, go for it.

@SpookyGengar it's just not specified in the post; and people here tend to be strict about challenges specifications xD

Should "create a program" read "create a program or function"? (see this meta post).

@Uriel, I totally understand. If you look at my other posts you'll see that I am very lax with my rules lol.

@JonathanAllan - interesting. I updated the post.

related

05AB1E, 2 bytes
Aƶ

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.

Python 2, 36 bytes
i=1
exec'print chr(i+96)*i;i+=1;'*26

Try it online!

APL (Dyalog), 12 8 5 bytes SBCS
3 bytes saved thanks to @ngn
4 bytes saved thanks to @Adám
⍴⍨⌸⎕A

OP clarified uppercase letters are valid, as well as output as an array of strings.
Try it online!
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 indexes 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).

819⌶↑⎕A⍴¨⍨⍳26

@Adám thanks! I tried all variations of / and , completely ignored shape ⍨

You can remove the ↑ too.

@Adám but it would look uglier ⍨

Turn boxing on!

Uh, in this case you can substitute ⍴ with / for identical result.

But with ⍴ I can Sha⍴e (see what I did there?)

Ah, ⍴ ρeshapes.

Well, I take into account that most all people don't know the Greek alphabet.

Pollard rho algorithm. Anyone know that also knows that ⍴ is pronounced as "rho" (starts with r).

hey, this is just ⍴⍨⌸⎕A

@ngn thanks! should use SBCS for that, right?

@Uriel right, though I'm not sure what the rules are if it's published later than the challenge

@ngn newer-languages is a long gone standard. it's just not well known that it had gone.

Ruby, 32 30 bytes
-2 bytes thanks to @EricDuminil.
27.times{|n|puts (n+96).chr*n}

Try it online!

Excellent. According to a comment by OP, trailing/leading newlines are allowed. In that case 27.times{|n|puts (n+96).chr*n} would be correct with 30 bytes

Haskell, 27 bytes
[c<$['a'..c]|c<-['a'..'z']]

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"

*bows* Explanation for a noob? Does <$ repeat its first argument n times, where n is the length of its second argument?

@totallyhuman There you go. Feel free to ask in Of Monads and Men  if you have further questions.

There are some very interesting operators in Prelude... Thanks for the explanation!

brainfuck, 74 bytes
++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+<<[->>[->+<<.>]>[-<+>]<+<+<<.>]

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!

Befunge-98 (FBBI), 27 bytes
1+:0\::'`j'@+\k:$$>:#,_$a,

where  is a substitution character (ASCII 26)
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.

JavaScript (ES6), 54 bytes

f=(n=9)=>++n<36?n.toString(36).repeat(n-9)+`
`+f(n):''

O.innerText = f()

Excel VBA, 38 bytes
Using Immediate Window. :)
[A1:A26]="=REPT(CHAR(96+ROW()),ROW())"

Ah. My bad. I thought it's Excel because I used  Excel Functions using Immediate Window.

You can drop a byte by removing the terminal "

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.

This is only 48 bytes by my count.

You don’t need "\n" at all; puts does that for you (though for future reference $/ is 2 bytes shorter)—but you can get rid of puts entirely if you make this a lambda that just returns an array of lines. You can also change a=[*?a..?z];puts a.map to puts (a=*?a..?z).map and x*(a.index(x)+1) to x*-~a.index(x). All together that’s 38 bytes.

The 38-byte version works fine on TiO (see link in previous comment). Note that the (a=*?a..?z) is inside the block, not the arguments part of the lambda.

BASH, 59 54 40 bytes
for l in {a..z};{
a+=a
echo ${a//a/$l}
}

Try it online!
thx. 5 bytes to @Justin Mariner

The for loop can be golfed down using this tip for 54 bytes: Try it online!

Japt, 9 7 bytes
Outputs an array of lines
;C¬Ëp°E

Try it

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.

Exactly what I had, except I used ®p°Y

Python 3, 37 bytes
for k in range(27):print(chr(k+96)*k)

Prints a leading newline (which is allowed).
Try it online!

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

Welcome! Looks like you can shorten it a bit by removing the spaces around ind=1at the start, the semicolon after i<123 and the final semicolon. also, please make your header slightly more clear by stating language - bytecount, prefixed with a #.

You can save six bytes by dropping j altogether: for(i=1;i<27;){console.log(String.fromCharCode(i+96).repeat(i++))}

@steenbergh thank you once again, your how kind you are to help me.

MATL, 11 bytes
2Y2t!g*!YRc

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'

@StewieGriffin I was actually halfway commenting on your Octave answer on the coincidence of coming up with the same solution.

V, 9 bytes
¬az\ÓÎÛäl

Try it online!
Hexdump:
00000000: ac61 7a5c d3ce dbe4 6c                   .az\....l

MATL, 9 bytes
2Y2"@X@Y"

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

Do you know why & can't be used to duplicate and transpose 2Y2?

@StewieGriffin & doesn't actually duplicate and transpose, although it sometimes produces the same result as that. What it does is modify the number of inputs/outputs of the next function. For example, if you use &+, the + function now takes one input instead of two, and outputs the sum of the input with itself transposed. But that's only because that's how +  work with 1 input (same for =, > and some others)

Jelly,  5  4 bytes
sneaky Python implementation abuse
-1 byte thanks to Adám (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).
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)

Øa×J should be enough.

hmm, maybe - we may "output" a list of lines, but we must "create a program" - when running as a program the output of the four byter is smashed to have no indication of it's list nature.

program or function

Pip, 9 bytes
FczPcX++i

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

Acc!!, 66 bytes
Count i while 26-i {
Count j while i+1-j {
Write 97+i
}
Write 10
}

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
}

Java (OpenJDK 8), 74 bytes
n->{for(int i=1,j=0;i<27;)System.out.printf("%c",j++{                      // Lambda, unused parameter
 for(int i=1,j=0;i<27;)   // Loop from 1 to 26 included
  System.out.printf("%c", // Print a character
   j++{String s="";for(char i=96;++i<123;System.out.println(s.replace(' ',i)))s+=" ";}

Also, kinda cheating imo due to two leading new-lines, but n->{String s="\n",r=s;for(char i=96;++i<123;r+=s.replace(' ',i))s+=" ";return r;} (81 bytes) would also be possible. OP said in the comments trailing/leading spaces/new-lines are allowed, but I'm not sure if more than 1 is allowed.

Sorry for all the comments, but this time without leading new-lines and shorter (and uppercase): n->{String r="";for(char c=64,i;++c<91;r+="\n")for(i=64;i++<c;r+=c);return r;} (78 bytes) Got inspired by an old answer of mine. :)

@KevinCruijssen It's only fair to have provided many answers: I reckon I often do it as well ;-) Thanks for this golf!

@Oliver I worked on trying to make it shorter for quite some time and was unable to. However I thought you might find this interesting. Incrementing starting at 97 (ASCII for 'a') does not shorten the byte count :( I could only get it down to 79 on my best attempt:
a->{for(int i=97,j=96;i<123;)System.out.printf("%c",j++<i?i:106-(j=j-++i+96));}

@DevelopingDeveloper Yep, golfing is hard. ;)

-6 https://codegolf.stackexchange.com/a/235727/106557

R, 38 bytes
A relatively uninteresting answer. Iterate for i from 1 to 26, print the ith letter of the alphabet i times (with an implicit line break).
for(i in 1:26)print(rep(letters[i],i))

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.

I'm not sure how to use your second approach, either, but I know that rep(letters, 1:26) is much shorter...

@Giuseppe Hah! Like I said, "someone smarter than me" is definitely needed.

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.

Perl 5, 19 bytes
say$_ x++$"for a..z

Try it online!

J, 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!

Rust, 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!

I got 76 bytes: Try it online!

Octave, 25 24 bytes
['',tril((x=65:90)'+~x)]

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.

C (gcc), 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!

Nice answer.  I think your function will fail the next time it's called and according to this link it should be re-useable;
https://codegolf.meta.stackexchange.com/questions/4939/do-function-submissions-have-to-be-reusable

Here's a fixed version in 50 bytes: s[9];main(i){for(;i<27;)puts(memset(s,i+95,i++));} Still beats my answer by a few bytes :)

49 bytes: s[9];main(i){for(;puts(memset(s,i+95,i++))-27;);}

Perl 6,  24  23 bytes
.say for 'a'..'z'Zx 1..*

Try it
.say for 'a'..*Zx 1..26

Try it

Haskell, 31 bytes
-12 bytes thanks to nimi.
zipWith replicate[1..26]['a'..]

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.

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!
;                      - 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)

Nice! 1oBÊÄ can be replaced by 26õ. You can save a couple more bytes by doing something like ;26ÆCgX pXÄ

@Oliver How the heck I didn't see that 26 is shorter than alphabet length?! Thanks. Also, my bad I didn't found that o takes the f argument...

Brain-Flak, 107 bytes
((((()()()){}){}()){}){(({})){({}<(({})<({}((((()()()()){}){}){}){})>)>[()])}{}({}<((()()()()()){})>[()])}

Try it online!
This is 106 bytes of code, and +1 byte for the -A flag, which enables ASCII output.
Explanation:
#Push 26
((((()()()){}){}()){})

#While True...
{

    #Duplicate A
    (({}))

    #While True...
    {
        #Grab the value of A...
        ({}<

            #Make a duplicate of B (on the first loop, B == A)
            (({})<

                #Push B +
                ({}

                #64 (ASCII 'A' - 1)
                ((((()()()()){}){}){}){})

            #Then push B on top of all of that
            >)

        #Push A - 1 on top of all of that
        >[()])

    #Endwhile, pop the loop counter
    }{}

    #Underneath A,
    ({}<

        #Push 10
        ((()()()()()){})

    # Then Push A - 1
    >[()])

#Endwhile
}

Brainfuck, 107 104 94 Bytes
>>>>++[<<<+++++++++++++>>++++[<++++++++>-]>>+++++<-]<<+>+[<]>[>>[<.>>+<-]>>.<<<+>+>[<+>-]<<<-]

How it works:
>>>>++[<<<+++++++++++++>>++++[<++++++++>-]>>+++++<-]<<+>+

Stores 26 on the second cell, 65 on the third cell, 10 on the sixth cell, and 1 on the fourth, leaving the pointer on the fourth (Saved 3 13 bytes by making 26, 10, and 97 65 at the same time).
[<]>

Moves the pointer back to the start.
Now we're ready to get started!
[                       | While the first cell is non-zero (so 26 times)
>>                      | Move to cell 3
    [                   | While cell 3 is non-zero
        <.>>+<-         | Print cell 2, increment cell 4, and decrement cell 3
    ]                   |
    >>.<<               | Move to cell 5 and print it (new line), then return
    <+>+>               | Increment cells 2 and 3, and move to 4
    [<+>-]              | Add the value at 4 to 3
<<<-                    | Decrement cell 1
]                       |

The important part is that cell 3 stores the number of times to print a letter. Each time a letter is printed, the value at 3 is moved to 4 and increased by 1, so that the next number is printed one more time than the last.
Side Note:
I'm completely new to brainfuck, so I wouldn't be surprised if this could be improved. However, I was also surprised by how fun brainfuck is to write, as well as by how easy it was to write, when compared with what I had imagined.
I would definitely recommend learning brainfuck to any bored programmers out there ;)

If you’re fine with negative cells, you can save 4 bytes at the beginning

VBA, 33 Bytes
Anonymous VBE immediate window function that outputs to the VBE immediate window
For i=1To 26:?String(i,96+i):Next

Hey, cool to see you can skip chr$() in the call to String().

C# (.NET Core), 78 bytes
n=>{var s="";for(int i=1;i<27;)s+=new string((char)(i+96),i++)+'\n';return s;}

Try it online!

Mathematica, 33 bytes
Alphabet[][[#]]~Table~#&~Array~26

Try it online!

Stacked, 14 bytes
[26~>:96+chr*]

Try it online!
Pushes a list of lines to the stack.
Explanation
[26~>:96+chr*]
[            ]  anonymous function, takes no arguments
 26~>           range from 1 to 26
     :96+       push range from 97 to 122 (97..122')
         chr    convert each of these to a char ('a'..'z')
            *   repeat each char by the former amount ('a' 'bb' 'ccc' ...)

C (gcc), 53 bytes
i,j;f(){i=i-putchar(j++-i?96+i:(j=!++i)+10)-16&&f();}

Prints a leading newline. Has undefined behaviour, but works with gcc...
Try it online!
C, 54 bytes
j;main(i){for(;i<27;)putchar(j++-i?96+i:(j=!++i)+10);}

Try it online!
C, 54 bytes
i,j;f(){putchar(j++-i?96+i:(j=!++i)+10);(i%=27)&&f();}

Prints a leading newline.
Try it online!
C, 56 bytes
main(i,j){for(;i<27;)for(j=++i;j--;)putchar(j?95+i:10);}

Try it online!

j;main(i){for(;i<28;putchar(j?95+i:10))j=j?j-1:i++;} (52 bytes) almost works.

Charcoal, 6 bytes
Ｅβ×ι⊕κ

Try it online! Link is to verbose version of code. Explanation:
     κ  Index
    ⊕   Incremented
   ι    Character
  ×     Repeated
 β      Lowercase letters
Ｅ       Map over each character
        Implicitly print each result on its own line

Japt, 9 bytes
;C£RiXpYÄ

Try it online!

Retina, 20 bytes
:`
a
{2`
$`
T:`_l`l_

Try it online!
Prints a couple of trailing linefeeds.
Explanation
:`
a

Initialise the string to a and print it.
{2`
$`

The { tells Retina to loop the remainder of the program until it fails to change the string. The stage itself duplicates the first character.
T:`_l`l_

This increments all letters using transliteration and prints the result.

Brachylog, 7 bytes
Ại₁j₎ẉ⊥

Try it online!
Explanation
Ạ         The alphabet string "abcdefghijklmnopqrstuvwxyz"
 i₁       A couple: [a letter of the alphabet, its index (1-indexed) in it]
   j₎     Juxtapose that letter as many times as its index
     ẉ    Write followed by a linebreak
      ⊥   False: try another couple of [letter, index]

Elixir, 47 bytes
for x<-?a..?z,do: IO.puts List.duplicate x,x-96

Try it

Pyke, 5 bytes
G Foh*

Try it here!
       - o=0
G      -  alphabet
  F    - for i in ^:
     * -  ^ * v
   oh  -   (o++)+1

Is there supposed to be a space between G and F?

That's just in the readable version, in the link, that's changed into a single byte and that's just the 2 byte representation I've used

Jelly, 7 6 5 bytes
Øax"J

Try it online!
-1 byte thanks to dylnan
Returns a list of lines
How it works
Øax"J - Main link. No arguments
Øa    - Lower case alphabet
  x"  - each character repeated...
    J - range(len) times (vectorises)

An alternative (which I prefer, but is longer):
ØaḊLÐ¡UZYṚ

Try it online!

5 bytes

Befunge, 37 35 bytes
:"a"+:>,#:\:#->#1_55+,$"`"-:55*`#@_

Try it online!
Explanation
The program starts with an implicit zero on the stack, representing the repeat count (off by 1).
:"a"+                                Duplicate the count and convert it to a character.
     :                               Duplicate the character prior to writing it out.

      >                              Start the output loop.
       ,                             Write the duped character to stdout.
          \                          Swap the count to the top of the stack.
           :  >  _                   Duplicate it and check if zero, returning left if not.
             -  1                    Decrement the count.
          \                          Swap the character back to the top.
         :                           Duplicate it prior to writing it out again.
      >                              Repeat the loop.

                 _                   If the count reached zero, we continue right.
                  55+,               Output a linefeed.
                      $              Drop the zero count.
                       "`"-          Convert the character to a numeric count and increment.
                           :55*`     Check if greater than 25.
                                #@_  If so, then terminate, else wrap back to the start.

I feel like this could almost be golfed further by combining the \ before the loop with the \ inside the loop, but it screws too much up

Whoops! Yeah, I meant the \\s. Apparently I have to escape them. EDIT: I have no clue how code snippets in comments work

@MistahFiggins Did a bit of fiddling to try and combine the swaps, and while that didn't help with the size of the inner loop, it did enable me to get rid of the 2+ increment at the start, saving a couple of bytes. So thanks for pushing me to look at it again.

C# (.NET Core), 57 bytes
57 bytes with a a trailling line
()=>new int[27].Select((_,i)=>new string((char)(i+96),i))

59 bytes without a trailling line
()=>new int[26].Select((_,i)=>new string((char)(i+++97),i))

Try it online!
I am using using System.Linq;

The int[x].Select() can be found here.

Nicely done. I'm going to have to learn this Select trick. (I would have thought it would need to be wrapped in string.Join("\n",...) though.)

OP allows list :)

That simplifies things, and shows me for not reading the question comments.

CJam, 13 bytes
26{)_96+c*N}%

Explanation:
26             e# push 26
  {        }%  e# for n in 0 .. 25:
   )           e#   increment
     96+       e#   add 96
        c      e#   convert to character
    _    *     e#   repeat that character n+1 times
          N    e#   add a newline

Underload, 62 bytes
()(::(.)~^(.):*:*:*:*:*::***( )*~^S(
)S(:)~*(*)*):*::*:*::***^

Try it online!
This is really stretching the limits of what's allowed.
It outputs a list of lines represented by strings (allowed by the OP), where the strings are lists of bytes (allowed by meta consensus), where the bytes are given in unary (also allowed by meta consensus).
The result is... well, see for yourself.

JavaScript, 65 bytes
for(x=0;x<26;)console.log(String.fromCharCode(x+97).repeat(++x));

old:
for(x=0;x<26;x++)console.log((function p(a,b){return b==0?a:a+p(a,--b);})(String.fromCharCode(97+x),x));

Common Lisp, 65 bytes
(dotimes(a 26)(format t"~v@{~a~:*~}~%"(1+ a)(code-char(+ a 97))))

Try it online!

C# (.NET Core), 84 bytes
()=>{return A(1);string A(int n)=>new string((char)(n+96),n)+(n<26?"\n"+A(++n):"");}

Try it online!
A recursive approach using a local function (given no inputs were allowed).
UnGolfed
()=>{
    return A(1);
    string A(int n) => new string((char)(n+96), n) +
                       (n < 26? "\n" + A(++n) : "");
}

Nice one. Recursion is hard in C#. I just found a solution in 57 bytes :p

Kotlin, 56 bytes
for(c in 'a'..'z'){for(j in 0..c-'a')print(c);println()}

Try it online!

I don't understand. Isn't this a valid full Kotlin program? Just drop it on a .kts file and it will run as is.

48 bytes as a function.

@Steadybox are you are aware that Kotlin can run in script mode, in which case it doesn't need to declare the main function?

@ovs Nice! Your solution is much better than mine. I'll vote yours.

@alves No, I wasn't. Sorry for the confusion.

Befunge 2x24 = 48 Bytes
I know the other befunge answer has me solidly beat, but I thought I'd post my solution anyway, as it's interesting, since it's partially self-modifying.
"z`"-:!_> 10g\v v!:_0# p
g01+55$_^#!:-1<@_,1^01-1

Try It Online
How it works
"?`"-:!

Gets how many times to iterate. (The question mark represents the current letter)
        _> 10g\v
        _^#!:-1<

Adds the iteration size*char into the stack.
                   _0# p
g01+55$_           ^01-1

Pops the excess character and adds a newline. Gets the current character from 1,0 and decrements it, putting back at 1,0
"?`"-:!_           _0# p

Now the ? inside the quotes has been decremented. Once it has run through all the letters it runs backwards from the underscore, which was the tricky part. ! inverts the excess 0 to a 1, which is duplicated and subtracted from itself, turning it back to a 0. The 0 is put at (97,97) thanks to the backticks inside the quotes and the put command. This leaves just the original iteration size, which is 0, when it hits the underscore, pushing the pointer left.
                v!:_
               @_,1^

Prints out the whole stack, which at this point is a newline separated alphabet staircase.

Kotlin, 37 bytes
{(1..26).map{"${'`'+it}".repeat(it)}}

Try it online!
Returns a List of Strings

This is a nice solution but is it ok to just return a list of Strings, without printing them? I'm still new to the code golf rules...

@alves The OP verified this in a comment. Usually these rules should be in the post itself, but it is always useful to look in the comments.

brainfuck, 70 59 bytes
-<--[[<+>->----<]++>]<-<-<<[>>>[-<.>>+<]>[-<+>]<[+<]>->.->]

Try it online!
-<--[[<+>->----<]++>]<-<-<<
Sets the tape up as:
     254
     9    Newline (10-1)
     230' Loop counter (-26)
     114
     65   Character (A)
     1    Repeat counter
[ Loop 26 times
   >>>[-<.>>+<]   Print the character repeat counter times while preserving the counter
   >[-<+>]        Restore counter
   <[+<]          Increment everything
   >->.->         Print a newline
]

Java (JDK), 68 bytes
n->{for(var i='`';i++<'z';)System.out.println((i+"").repeat(i-96));}

Try it online!

Congrats on using newer API to beat my score! :-)

Oh I didn't realize String::repeat was new in the API. Sorry then. Your solution was a lot more creative and harder though ;)

It's fine! String::repeat comes from Java 11 which is from September 2018, 1 year before my answer, and it's always OK to take the full tools at your disposal to golf, that's what I always advocate, so your answer is perfect in that regards, don't be sorry :D

Vyxal j, 6 bytes
ka¨2›*

Try it Online!
How?
ka¨2›*
ka     # Push the lowercase alphabet
  ¨2   # Map with indices (pushes letter and index)
    ›  # Increment the index to make it one-indexed
     * # Repeat the letter that many times

Also 6 bytes:
kaf:ż*

Try it Online!
How?
kaf:ż*
ka     # Push the lowercase alphabet
  f    # Convert to list of characters
   :   # Duplicate it
    ż  # Push length range [0, length)
     * # Repeat each letter that many times

JavaScript, 113 bytes

(function(){var i=0,j=0,s;while(++i<=26){s="";j=0;while(++j<=i)s+=String.fromCharCode(96+i);console.log(s);}})();

Tcl, 80 bytes
set a 97;time {time {puts -nonewline [format %c $a]} [incr i];puts "";incr a} 26

Try it online!

Funky, 42 bytes
fori=1i<27i++print("a".char(96+i)::rep(i))

Try it online!

C++, 56 bytes
for(char a='a';a<='z';++a)cout<<string(a-'a'+1,a)<<endl;

Try it online

C/C++ submissions need to be full programs or functions, not just snippets.

@MDXF All submissions need to be. :P

@MDXF Let see https://codegolf.stackexchange.com/a/147497/68468 - Java code needs at least public class Main {   public static void main(String[] args) { .... - is that answer correct?

@Harry Full programs or functions. That's an anonymous function or lambda. It's correct. Either way, regardless of the validity of another's submission, please delete yours, as it is invalid.

[](){for(char a='a';a<='z';++a)cout<<string(a-'a'+1,a)<<endl;}() - is this lambda OK?

The lambda is almost valid, but you need to include the #include<iostream> and the using namespace std; in the bytecount because the code doesn't work without them. Also, you don't need to call the lambda, just define it. Change the trailing () to ;. Try it online! 73 bytes + 19 for the #include = 92 bytes

Actually, the ; isn't counted either, since it's not part of the lambda expression.

QBIC, 23 bytes
[26|[a|?chr$(a+96)';`]?

Explanation
[26|   FOR a = 1 TO 26
[a|      FOR b = 1 TO a
?chr$(     PRINT the character
a+96)         a, or b, or c depending on outer loop
';`           and suppress new-lines, tabs etc
]          NEXT, for this character (a, bb, ccc)
?          PRINT a newline between a, bb, ccc....
       NEXT on outer loop added implicitly

K (oK), 16 bytes
Solution:
`c$t#'96+t:1_!27

Returns a list of lists. TIO prints to stdout:
Try it online!
Explanation:
`c$t#'96+t:1_!27 / the solution
             !27 / til 27, creates range of 0..26
           1_    / drop first element, 1..26 (could have done 1+!26 but 1_!26 is faster ;))
         t:      / store in variable v
      96+        / add 96 to each (97=a)
   t#'           / t take each, 1#97 = 97, 2#98 = 98 98, 3#99 = 99 99 99 etc
`c$              / cast to characters

PowerShell, 30 bytes
1..26|%{"$([char]($_+96))"*$_}

Try it online!
Also 30 bytes --

1..26|%{(""+[char]($_+96))*$_}

Try it online!
In either case, we're just looping 26 times, each iteration constructing a string of the appropriate character, then string-multiplying it out to the appropriate length. Ho-hum.

T-SQL, 68 bytes
Using a variable and loop:
DECLARE @ INT=1;a:PRINT REPLICATE(CHAR(@+96),@)SET @+=1IF @<27GOTO a

Longer (94 bytes), but feels much more SQL-like, using a recursive CTE to generate a number table:
WITH t AS(SELECT 1n UNION ALL SELECT n+1FROM t WHERE n<26)
SELECT REPLICATE(CHAR(n+96),n)FROM t

Pyth, 7 bytes
.e*hkbG

Try it online!
Outputs a list of lines. If that's not allowed, add a j to the start and let me know to add one byte to the count!

.e*hkbG  Full program - outputs to stdout
.e       map over
      G  the alphabet,
  *  b   repeating each letter
   hk    according to its index+1

Check, 26 bytes
 >#v
#d##)::>96+]*o<:>26-?

Try it online!
Explanation:
Check's gimmick is that it can switch between 2D semantics (for control flow) and 1D semantics (for stack manipulation). The program starts out at the beginning of the program in 1D semantics.
> pushes 0 to the stack. # switches to 2D semantics and v directs the IP downwards. It then hits #, switching back to 1D semantics for the main loop.
#d##)::>96+]*o<:>26-?

The commands before the ? go like this:
#    1D mode:                   0
)    increment:                 1
:    duplicate:                 1, 1
:    duplicate:                 1, 1, 1
>96  push 96:                   1, 1, 1, 96
+    add:                       1, 1, 97
]    wrap:                      1, 1, [97]
*    repeat:                    1, [97]
o    output char codes ("a"):   1
<    output newline ("\n"):     1
:    duplicate:                 1, 1
>26  push 26:                   1, 1, 26
-    subtract:                  1, -25

The ? is Check's only branching operator. It switches to 2D semantics if the TOS is nonzero, and stays in 1D semantics otherwise. In this case, if the top stack value is 0, then the program ends, and if it is negative, then it goes around to the beginning. # switches back to 1D semantics, d deletes the top stack element (since ? does not pop it). ## switches to 2D and then back again, and then the loop restarts.

Ruby, 28 31 35 bytes
Edit: saved 3 bytes by using a number range instead of letters. Try it online!
(0..26).map{|l|(l+96).chr*l}

Edit: saved 4 bytes by using the character number instead of looping with index. Try it online!
('`'..'z').map{|l|l*(l.ord-96)}

Edit: saved 6 bytes by outputting a list. Try it online!
('`'..'z').map.with_index{|l,i|l*i}

Original:
('`'..'z').each_with_index{|l,i|puts l*i}

Vim, 33 Keystrokes
:h<_␍jjYZZiyl0pr␛pqq{<C-a>YG@"q25@q{D

Explanation
:h<_␍jjYZZ                             " get a-z
          iyl0pr                       " Put yl0pr as macro line
                ␛p                     " Back to normal mode and paste
                  qq                   " Record macro
                    {                  " Go to macro line
                     <C-a>             " Increment counter
                          Y            " Yank the macro
                           G           " Go to last line
                            @"         " Run the macro (also adds \r)
                              q        " Stop recording @q
                               25@q    " Run @q 25 times
                                   {D  " go to top and clear the line

Had experimented with this which inspired the above Macro line:
:h<_␍jjYZZP:exe ":norm yl".line('.')."ps^M"␍25@:

Thought about putting a-z on separate lines and global replace with repeat, but can't make :%s/./\=repeat(\0,line('.'))/g work -- and that's long.

SNOBOL4 (CSNOBOL4), 74 bytes
O	&LCASE POS(I) LEN(1) . X
	I =I + 1
	OUTPUT =LE(I,26) DUPL(X,I) :S(O)
END

Try it online!
O	&LCASE POS(I) LEN(1) . X		;* set X to I'th 0-indexed character of lowercase letters
	I =I + 1				;* increment I
	OUTPUT =LE(I,26) DUPL(X,I) :S(O)	;* if I<=26, output X DUPLicated I times and goto O otherwise goto END
END

R, 33 bytes
cat(strrep(letters,1:26),sep="
")

Try it online!
This challenge got bumped to main; I tried a strrep approach which was happily shorter than the other existing R answer.

Or as a list of lines for the same count ? TIO

@JayCe Or just with letters instead of utf8 which is shorter...

Of course why am I over-complicating things?

Scala (39 bytes)
('a'to'z')map(n=>println(s"$n"*(n-96)))

Try it online

Ahead, 28 bytes
Featuring trailing newline!
'a'zEr~@~kdW<
~:\N\0<~'a-k:l

Try it online!

Pyth, 9 8 bytes
m*dhxGdG

Try it online!
m*dhxGdG
m      G  Map through the alphabet, with current letter as variable 'd'
   hxGd   Index of d in alphabet, + 1
 *d       Repeat current letter ↑ that many times.

VUG*hN@GN
In English; utilizing G as a auto-initialised variable of the alphabet:
Loop through list of 0-25:
print (i++ * letter at index i)

Labyrinth, 25 bytes
\#"_2@
;  -6
("##
. _
+59

Try it online!
Prints with one leading and one trailing newline.
      Start at the top left, going East
\     Print a newline
#"    Push stack height (" is no-op)
_26-  Subtract 26; if negative, turn left (South); if zero, turn backwards (East)
62@   Zero case (after 26 loops): halt after a few dummy instructions
##    Negative case (after n loops): push stack height twice
      (n -- inner loop counter k, then n+1)
_95+  Add 95
.     Print as char
(     Decrement k; if positive, turn right (East); if zero, go straight (North)
"#_   Positive case: repeat inner loop
;     Zero case: remove k and repeat outer loop

Factor + spelling, 44 bytes
[ ALPHABET [ 1 + swap <string> ] map-index ]

Only works in recent-ish builds of Factor, so have a screenshot instead of a TIO link.

APOL, 14 bytes
ⅎ(ⓛ p(*(∋ ∈)))
Explanation:
ⅎ(        1-indexed for (f is 0-indexed)
  ⓛ      The built-in lowercase ascii letters constant
  p(      Print
    *(    Multiply
      ∋   Current item in the for loop
      ∈   For loop counter
    )
  )
)

tinylisp, 63 62 bytes
(load library
(map string(map* repeat-val(range 97 123)(1to 26

Try it online!
Output as a list of lines.

Pyramid Scheme, 965 bytes
    ^
   / \
  /do \
 ^-----^
/!\    -^
---^    -^
  /=\    -^
 ^---^    -^
/a\ / \    -^
---/26 \   /[\
   -----  ^---^
         ^-  /[\
        ^-  ^---^
       ^-  / \  -^
      ^-  /set\  -^
     ^-  ^-----^  -^
    / \ /b\   /a\  -^
   /set\---   ---  /[\
  ^-----^         ^---^
 /a\   /+\       / \  -^
 ---  ^---^     /do \  -^
     /a\ /1\   ^-----^  -^
     --- ---  /b\   /[\  -^
              ---  ^---^  -^
                  / \  -^  -^
                 /set\  -^  -^
                ^-----^  -^  -^
               /b\   /-\  -^  -^
               ---  ^---^  -^  -^
                   /b\ /1\ / \  -^
                   --- ---/out\ / \
                         ^-----/out\
                        / \   ^-----
                       /chr\ / \
                      ^-----/chr\
                     /+\    -----^
                    ^---^       / \
                   /a\ / \     /10 \
                   ---/96 \    -----
                      -----

Try it online!
Wow this thing is huge. Nested loops result in a very big program.

K (ngn/k), 21 bytes
{{x#(`c$96+x)}'1+!26}

Try it online!
Explanation:
{{x#(`c$96+x)}'1+!26}      Main program
              '1+!26       For each number in range [1..26] (x) (inclusive)
 {           }             Execute a function that
    (`c$96+x)              Display the character with the ASCII code 96 + x
  x#                       x amount of times

I think it'd be fair to drop the outer pair of {}'s, as the desired result will still be returned without them. Things can be shuffled around a bit too, to get to 16 bytes with ``c$96+{x}#'1+!26`

Zsh (+ coreutils), 30 bytes
eval ';s+=_&&tr<<<$s _ '{a..z}
Attempt This Online!
Pure Zsh, 31 bytes
eval '<<<${(l:++i::'{a..z}:')}'
Attempt This Online!

Lua, 48 bytes
for i=1,26 do print(string.char(i+96):rep(i))end

Try it online!
Explanation:

for i=1,26 do ... end — try all numbers between 1 and 26.
print(...) — prints, of couse.
string.char(i+96) — get alphabet char number i.
:rep(i) — repeat char i times.

You can replace string with ("") to save 2 bytes.

Acc!!, 74 bytes
97
Count i while i-27 {
 	Count t while t-i {
 		Write _+i-1
	}
Write 10
}

Try it online!

Wolfram Language (Mathematica), 43 bytes
This submission creates the specified output string exactly - in other words, it's NOT an array of string-enclosed characters.
#~Table~#2<>"\n"&~MapIndexed~Alphabet[]<>""

Try it online!

I guess my answer needs 44 bytes to do this... ""<>Array[Alphabet[][[#]]~Table~#<>"\n"&,26]

x86-64 machine code function, 19 bytes
18 bytes for x86-32 with a non-standard calling convention, inc eax is only 1B vs. 2B.
Callable from C (with the x86-64 System V calling convention) as:
void alphabet_staircase(char output[377]);

// or
struct string_result { char buf[377]; }  \
  alphabet_staircase(void);   // return-value pointer passed as implicit first arg

i.e. it stores a flat string (including '\n' newlines) into a buffer pointed to by rdi.
0000000000400080 <alphabet_staircase>:
  400080:       6a 61           push   0x61
  400082:       58              pop    rax      ; eax = 'a'

0000000000400083 <alphabet_staircase.loop>:
                                 ;;; do {
  400083:       8d 48 a1        lea    ecx,[rax-0x5f]      ; rax-'a'+1 + 1
  400086:       f3 aa           rep stos BYTE PTR es:[rdi],al
  400088:       c6 47 ff 0a     mov    BYTE PTR [rdi-0x1],0xa
  40008c:       ff c0           inc    eax
  40008e:       3c 7a           cmp    al,0x7a
  400090:       76 f1           jbe    400083 <alphabet_staircase.loop>
                                 ;;; } while(al <= 'z')
  400092:       c3              ret

  400093  end of function.  0x93 - 0x80 = 0x13 = 19 bytes

Try it online!  (including a _start caller that prints the result with sys_write())
In each loop iteration, we store one extra copy of current letter, then overwrite it with a newline.  rep stosb = memset(rdi, al, rcx).  It advances rdi to point one-past-the-end of the bytes it stored.
eax holds the current letter, and we use it as the loop counter.  do {} while(eax <= 'z');.  Setting rcx from it with LEA requires that the upper bytes of eax be zeroed, otherwise we could use 2-byte mov al, 'a' to start.
The x86-64 SysV ABI requires that DF is cleared on function entry/exit, so we don't need cld.  If we wanted to use std to store backwards, it wouldn't solve the problem of needing an offset of one in an addressing mode to store the newline (or needing a separate inc/dec, or swapping eax with a reg holding 0x10 and using stosb to store a newline); stosb always overwrites the memory rdi is pointing to.

F# (.NET Core), 58 bytes
58 bytes
[1..26]|>Seq.map(fun i->new System.String((char)(i+96),i))

Try it online!
A basic port of my C# answer.
59 bytes
[1..26]|>Seq.map(fun i->[1..i]|>Seq.map(fun _->i+96|>char))

Try it online!
Same answer as above but without `System.String.

Pushy, 8 bytes
Z26:q&Kh

Try it online!
Z          \ Push 0 to the stack
 26:       \ 26 times do:
    q      \    Print stack, with each number as its letter in the 0-indexed lower alphabet
     &     \    Make a copy of the last number
      Kh   \    Increment all numbers

Kotlin, 76 bytes
for(i in 0..25){var j=0;while(j<=i){print((i+97).toChar());j++};print("\n")}

Try it online!

C (gcc), 68 64 bytes
I know there's another C answer but this is a different approach
n=65;main(i){for(i=n;i-->64;putchar(n));++n>90||main(puts(""));}

Try it online!

Javascript (ES6) 61 bytes
_=>[...Array(26)].map((_,i)=>(10+i).toString(36).repeat(i+1))

Javascript (ES6) 62 bytes
_=>[..."abcdefghijklmnopqrstuvwxyz"].map((v,i)=>v.repeat(i+1))

I'm aware there's a better answer already for js, still wanted to post these, feel free to suggest any improvement as long as it keeps the "methodology" intact. (for readability im using underscores for unused variables)

JsFuck, 7929c
[][(![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]([!![]]+[][[]]+[][[]]+!![])[(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((![]+[])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[+!![]]]+(+!![])+(+[])+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+[][[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[+!![]]]+([]+[])[(![]+[])[!![]+!![]+!![]]+([][[]]+[])[+[]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]]()[+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(+[]+[![]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[!![]+!![]+[+[]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(![]+[])[+[]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(![]+[])[+[]]+(+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(+!![])+(+[])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())

From
[].slice.call('trueundefinedundefinedtrue').filter([].filter.constructor('f=10\nreturn undefined=>console.log(f.toString(36).repeat(++f-10))')())

JsFuck, 7961c
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]])()(((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+![]+(!![]+!![])+(+[])+(![]+[])[+[]]+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+[])[+[]]+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+(+!![])+(+[])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+([][[]]+[])[!![]+!![]]+![]+(!![]+!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+([][[]]+[])[!![]+!![]]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+(![]+[])[+[]]+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(![]+[])[+[]]+![]+(!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![])+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+[])+(!![]+[])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(!![]+[])[+[]]+![]+(!![]+!![])+([][[]]+[])[!![]+!![]]+(+!![])+(+[])+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+[])+![]+(+[])+(![]+[])[+!![]]+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+[])+(+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[]))+[])[!![]+!![]]+(![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+[])[+[]]+![]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![])+(![]+[])[+!![]]+![]+(!![]+!![])+(!![]+!![])+![]+(!![]+!![])+(!![]+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])[([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[])+(![]+[])[!![]+!![]])[!![]+!![]])))

From
[].filter.constructor(unescape('returnfalse20ffalse3dfalse28tfalse3d10false29false3dfalse3etfalse2d36false3ftfalse2etfalse6ffalse53trinfalse67false2836false29false2erefalse70eatfalse28++tfalse2d10false29+false60false0afalse60+ffalse28tfalse29false3afalse22false22'.split(false).join('%')))

Both work on Firefox, because I only have it

uBASIC, 57 bytes
Anonymous function that takes no input and outputs to the console.
0ForI=1To26:ForJ=1ToI:?Left$(Chr$(I+64),1);:NextJ:?:NextI

Try it online!

MY-BASIC, 59 bytes
Anonymous Function that takes no input and outputs to the console.
For I=1 To 26
For J=1 To I
Print Chr(I+64)
Next
Print;
Next

Try it online!

Yabasic, 49 bytes

A BASIC answer that takes no input and outputs to the console.
For I=1To 26
For J=1To I
?Chr$(I+64);
Next
?
Next

Try it online!

Visual Basic .NET (Mono), 120 bytes
Another BASIC answer
Module M
Sub Main
Dim S,I,J
For I=1To 26
S=""
For J=1To I
S+=Chr(I+64)
Next
Console.WriteLine(S)
Next
End Sub
End Module

Try it online!

Pepe, 49 bytes
rEeEEeeeeEREeEEEEeEEREEreeereeErEEEeErEEEEEeeERee

Try it online!
Explanation:
rEeEEeeeeE # Push A (r)
REeEEEEeEE # Push 91 (Z + 1) (R)
REE        # Start loop labeled 91
           # | All the following commands below operate on r
reee       # | Output whole stack of r
reeE       # | Output newline "\n"
rEEEeE     # | Duplicate char to end
rEEEEEeeE  # | Increment whole stack
Ree        # If r != 91, repeat loop

sed, 82 bytes
s:^:a:
:A
p
y:abcdefghijklmnopqrstuvwxy:bcdefghijklmnopqrstuvwxyz:
s:.:&&:
/z/q
bA

Try it online!
Loop from a to z. The last line is printed implicitly, preceding lines are printed with a p.

MBASIC, 42 bytes
1 FOR I=1 TO 26:PRINT STRING$(I,96+I):NEXT

Whitespace, 127 bytes
Because the syntax is entirely in whitespace characters, each character is prefixed with S, T, or L (for Space, Tab, and Linefeed, respectively).
S S S T	L
L
S S L
S L
S S L
S S S S T	T	S S S S S L
T	S S S L
S S T	L
S L
S T	L
S S S L
T	S S S T	L
T	S S T	S L
S L
T	S T	S L
S L
T	L
S L
T	L
L
S S T	S L
S L
L
S L
L
S S S T	S T	S L
T	L
S S S S S T	L
T	S S S S L
S S S S T	T	S T	T	L
T	S S T	L
T	T	L
L
L
L

Try the whitespace-only version online!

Julia, 42 36 bytes
[println(l^(l-'`')) for l∈'a':'z']

K4, 13 bytes
(1+!26)#'.Q.a

Output:
q)k)(1+!26)#'.Q.a
,"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"

Dart, 81 bytes
List.generate(26,(i)=>''.padRight(i+1,String.fromCharCode(i+97))).forEach(print);

Try it online!

Rockstar, 51 bytes
X's0
while X-26
build X up
cast X+96 into C
say C*X

Try it here (Code will need to be pasted in)

Forth (gforth), 49 bytes
: f 26. do i dup for dup 97 + emit next cr loop ;

Try it online!

Python 2, 57 bytes
for a in "abcdefghijklmnosqrstuvwxyz":print a*(ord(a)-96)

Try it online!

BQN, 11 bytes
⥊¨⟜'`'⊸+↕27

Run it online!
Outputs a list of lines, including an empty line at the beginning. If that's bending the rules too much, here's a 17-byte version that outputs a string (with two leading newlines).
Explanation
⥊¨⟜'`'⊸+↕27
         ↕27  Range(27)
    '`'⊸+     Add the ` character to each (0 -> `, 1 -> a, ..., 26 -> z)
⥊¨⟜          Reshape each: Nth character -> string N characters long

Fig, \$7\log_{256}(96)\approx\$ 5.762 bytes
*fcaa26

Try it online!
-2 chars thanks to my clone
*fcaa26 # Returns a list of lines, as allowed in the comments
 fca    # Split the letters of the alphabet
*       # Multiply
    a26 # By the range [1, 26]

You can remove the z@ at the beginning.

@Sʨɠɠan hmm, i forgot that vectorised. thanks

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Pyramid Scheme Negation
In my language Pyramid Scheme, there is a slightly funny construct: the empty triangle:
^
-

When given no arguments, it returns 0. To generate 1 using this construct, we could use this:
   ^
  /!\
 ^---
 -

This simply passes 0 to the negation function. We can continue negating this result:
 ^
/!\
---^
  /!\
 ^---
 -

To get 0. One more negation gives:
   ^
  /!\
 ^---
/!\
---^
  /!\
 ^---
 -

Challenge
Given an integer n ≥ 1, output the empty pyramid being negated n times in the described fashion.
Test cases
input
output

1
   ^
  /!\
 ^---
 -

2
 ^
/!\
---^
  /!\
 ^---
 -

3
   ^
  /!\
 ^---
/!\
---^
  /!\
 ^---
 -

6
 ^
/!\
---^
  /!\
 ^---
/!\
---^
  /!\
 ^---
/!\
---^
  /!\
 ^---
 -

By negation here I suppose you means bitwise complement (~)?

@user202729 No, I mean regular negation.

So it's C/C++ ! (not).

@user202729 Yes. Though what it means is tangential to the problem

I had to stare at the examples in the Pyramid Scheme README for a solid 10 minutes before I figured out how it works. Cool stuff.

/!\ Warning! /!\ I see warning triangles everywhere!

Charcoal, 17 bytes
ＦＮ«↙^→/!\¶³‖Ｔ»↓^-

Try it online! Link is to verbose version of code. Explanation:
ＦＮ«

Loop for the appropriate number of negations.
↙^→/!\¶³

Print a negation function. (The ³ expands to ---.)
‖Ｔ

Reflect the canvas.
»↓^-

At the end of the loop, print the empty triangle.

Just fyi, the empty triangle uses - instead of _

@ConorO'Brien Thanks for pointing that out! I did think it didn't quite look right, but couldn't place my finger on it...

Pyramid Scheme, 31655 bytes, non-competing (obviously...)  16989 12901 8465 bytes, somewhat-competing
So, I thought this would be a funny thing to try.
Edits:

-14666 bytes by finally getting around to adding some compiler optimisation to psll
-4088 bytes by using different optimisation technique
-4436 bytes by implementing automatic variable name shortening into psll (I really wanted the Explanation psll code to compile into the answer without any modifications)

      ^    ^  ^          ^             ^  ^        ^          ^        ^      ^  ^          ^          ^                ^       ^                 ^          ^
     ^-   / \ -^        / \           ^- / \       -^        / \      ^-     / \ -^        / \        / \              ^-      / \               / \        / \
    ^-   /set\ -^      /set\         ^- /set\       -^      /set\    ^-     /set\ -^      /set\      /set\            / \     /set\             /   \      /out\
   ^-   ^-----^ -^    ^-----^       ^- ^-----^       -^    ^-----^   -^    ^-----^ -^    ^-----^    ^-----^          ^---^   ^-----^           /     \    ^-----^
  ^-   /f\   / \ -^  /t\   /f\     ^- /r\   /+\       -^  /r\   /+\   -^  /r\   /+\ -^  /r\   /+\  /r\   /+\        ^-  / \ /l\   /0\         / loop  \  /s\   /d\
  -^   ---  /chr\ -^ ---   ---    ^-  ---  ^---^       -^ ---  ^---^   -^ ---  ^---^ -^ ---  ^---^ ---  ^---^      ^-  /   \---   ---        ^---------^ ---   ---
   -^      ^----- / \            / \      /r\ /e\       -^    /r\ /f\   -^    /r\ /c\ -^    /r\ /d\    /r\ /e\    ^-  /     \               /!\       / \
    -^    / \    ^---^          ^---^     --- ---       / \   --- ---    -^   --- --- / \   --- ---    --- ---   ^-  /       \             ^---      /   \
     -^  /47 \  / \  -^        / \  -^                 /   \              -^         /   \                      ^-  /         \           /!\       /     \
      -^ ----- /set\  -^      /set\  -^               /     \              -^       /     \                    ^-  /           \         ^---      /       \
       -^     ^-----^  -^    ^-----^  -^             /       \              -^     /       \                  ^-  /      ?      \       / \       ^---------^
        -^   /a\   / \  -^  /t\   /+\  -^           /         \              -^   /         \                ^-  ^---------------^     /<=>\     / \       / \
         -^  ---  /chr\  -^ ---  ^---^  -^         ^-----------^             ^-  ^-----------^              ^-  /!\             / \   ^-----^   /   \     /set\
         / \     ^-----  / \    /t\ /a\  -^       / \         / \           ^-  / \         / \            ^-  ^---            /   \ /l\   /n\ /     \   ^-----^
        /   \   / \     /   \   --- ---   -^     /set\       /set\         ^-  /set\       /set\          ^-  /?\             /     \---   ---/       \ /l\   /+\
       /     \ /33 \   /     \             -^   ^-----^     ^-----^       ^-  ^-----^     ^-----^        ^-  ^---^           /       \       /         \---  ^---^
      /       \-----  /       \             -^ /r\   /+\   /r\   /+\     ^-  /r\   /+\   /r\   /+\      ^-  /m\ / \         ^---------^     /           \   /l\ /1\
     /         \     ^---------^            / \---  ^---^  ---  ^---^   ^-   ---  ^---^  ---  ^---^    ^-   ---/   \       / \       / \   /             \  --- ---
    ^-----------^   / \       / \          /   \   /r\ /s\     /r\ /s\ ^-        /r\ /d\     /r\ /d\  ^-      /     \     /out\     /out\ /               \
   / \         ^-  /set\     /set\        /     \  --- ---     --- ---/ \        --- ---     --- --- ^-      /       \   ^-----^   ^-----/                 \
  /set\       ^-  ^-----^   ^-----^      ^-------^                   /   \                          ^-      ^---------^ /s\   /c\ /e\   /                   \
 ^-----^     ^-  /b\   / \ /d\   / \    ^-      ^-                  /     \                        ^-      / \       / \---   --- ---  /                     \
/n\   /#\   ^-   ---  /chr\---  /chr\  ^-      ^-                  /       \                      / \     /out\     /out\             /                       \
---  ^---  ^-        ^-----    ^----- ^-      / \                 /         \                    /   \   ^-----^   ^-----            /                         \
    /l\   / \       / \       / \    ^-      /   \               ^-----------^                  /     \ /s\   /s\ /s\               /                           \
   /ine\ /   \     /92 \     /45 \  ^-      /     \              -^         / \                /       \---   --- ---              /                             \
   -----/     \    -----     ----- ^-      /       \              -^       /set\              /         \                         /                               \
       /       \                  ^-      /         \              -^     ^-----^            ^-----------^                       /                                 \
      /         \                ^-      ^-----------^              -^   /r\   /+\          / \         / \                     /                                   \
     ^-----------^              ^-       -^         / \              -^  ---  ^---^        /set\       /   \                   ^-------------------------------------^
    / \         ^-             / \        -^       /set\              -^     /r\ /s\      ^-----^     /     \                 / \                                   / \
   /set\       ^-             /   \        -^     ^-----^             / \    --- ---     /m\   /n\   / loop  \               /   \                                 /   \
  ^-----^     ^-             /     \        -^   /r\   /c\           ^---^               ---   ---  ^---------^             /     \                               /     \
 /s\   / \   ^-             /       \        -^  ---   ---          / \  -^                        / \       / \           /       \                             /   ?   \
 ---  /chr\ ^-             /         \        -^                   /set\  -^                      /   \     /set\         /         \                           ^---------^
     ^-----/ \            ^-----------^        -^                 ^-----^  -^                    / <=> \   ^-----^       ^-----------^                         /!\       ^-
    / \   /   \           -^         / \        -^               /r\   /+\  -^                  ^-------^ /m\   /-\     / \         / \                       ^---      / \
   /32 \ /     \           -^       /set\        -^              ---  ^---^  -^                / \     / \---  ^---^   /set\       /   \                     / \       /out\
   -----/       \           -^     ^-----^       / \                 /r\ /a\  -^              /<=>\   /-1 \   /m\ /2\ ^-----^     /     \                   /   \     ^-----
       ^---------^           -^   /t\   /+\     /   \                --- ---  / \            ^-----^  -----   --- ---/k\   /l\   / loop  \                 /  ?  \   /t\
      / \       / \           -^  ---  ^---^   /     \                       /   \          /m\   /2\                ---   ---  ^---------^               ^-------^  ---
     /set\     /set\           -^     /t\ /d\ /       \                     /     \         ---   ---                          / \       / \             /!\     ^-
    ^-----^   ^-----^          / \    --- ---/         \                   /       \                                          /   \     /set\           ^---    / \
   /e\   / \ /c\   / \        /   \         ^-----------^                 /         \                                        / <=> \   ^-----^         / \     /out\
   ---  /chr\---  /chr\      /     \       / \         / \               ^-----------^                                      ^-------^ /k\   /-\       /<=>\   ^-----
       ^-----    ^-----     /       \     /set\       /set\             / \         / \                                    / \     / \---  ^---^     ^-----^ /r\
      / \       / \        /         \   ^-----^     ^-----^           /set\       /set\                                  /<=>\   /-1 \   /k\ /2\   /+\   /1\---
     /10 \     /94 \      ^-----------^ /t\   /+\   /t\   /+\         ^-----^     ^-----^                                ^-----^  -----   --- ---  ^---^  ---
     -----     -----     / \         / \---  ^---^  ---  ^---^       /r\   /+\   /r\   /+\                              /k\   /2\                 /k\ /m\
                        /set\       /set\   /t\ /d\     /t\ /d\      ---  ^---^  ---  ^---^                             ---   ---                 --- ---
                       ^-----^     ^-----^  --- ---     --- ---          /r\ /b\     /r\ /e\
                      /t\   /+\   /t\   /+\                              --- ---     --- ---
                      ---  ^---^  ---  ^---^
                          /t\ /b\     /t\ /e\
                          --- ---     --- ---

Try it online!
Explanation
(set n (# line)) // Set n to line input

(set space (chr 32))
(set newline (chr 10))
(set caret (chr 94))
(set fslash (chr 47))
(set bang (chr 33))
(set bslash (chr 92))
(set dash (chr 45))

// Left triangle
(set lt fslash)
(set lt (+ lt bang)) (set lt (+ lt bslash)) (set lt (+ lt newline))
(set lt (+ lt dash)) (set lt (+ lt dash)) (set lt (+ lt dash))

// Right triangle
(set rt caret) (set rt (+ rt newline))
(set rt (+ rt space)) (set rt (+ rt space))
(set rt (+ rt fslash)) (set rt (+ rt bang)) (set rt (+ rt bslash))
(set rt (+ rt newline))
(set rt (+ rt space)) (set rt (+ rt caret))
(set rt (+ rt dash)) (set rt (+ rt dash)) (set rt (+ rt dash))
(set rt (+ rt newline))

// n = mod(m,2)
((set m n) (loop (<=> (<=> m 2) -1) (set m (- m 2))))

// Print the top and the first triangle
(? (! (? m ( // If m
    (out space space) (out space)
))) ( // Else
    (out space caret) (out newline)
))

(set l 0)
(loop (! (! (<=> l n))) ( // While l < n
    ((set k l) (loop (<=> (<=> k 2) -1) (set k (- k 2)))) // k = mod(l,2)
    (? (! (? (! (<=> (+ k m) 1)) ( // If xor(k,m)
        (out rt)
    ))) ( // Else
        (out lt)
    ))
(set l (+ l 1))
))
(out space dash) // Final triangle

I applaud your determination. This may not be the shortest answer, but it seems like you worked really hard on this. +1

Why is this non-competing?

@pppery, Is this better?  The answer was non-competing because I didn't feel like it was actually code golf. I wrote it because I wanted to write a meta-language for Pyramid Scheme (and because I thought the idea of answering a question about Pyramid Scheme in Pyramid Scheme was hilarious). I've now actually gotten to the point to where I've implemented some (rudimentary) compiler optimisations and therefore can generate much smaller code. It's not done by any stretch of the imagination though. Hence only 'somewhat-competing'.

Yes. The reason I was asking is that the term "non-competing" is often used to mean "Uses a language released after the challenge" (which no longer requires any annotation), "doesn't meat the spec in some way", or "not a serious contender" (both of which should be handled by deleting the answer). Since I don't know the language well enough to know what the situation is, I asked.

non-competing does not mean "not really golfed". Such answers are usually called "baseline" not "non-competing". "non-competing" indicates your answer have to break one of the rules for some reason.

@pppery and HighlyRadioactive, Thank you very much for clarifying. I think the only one this answer used to fall under was the "serious contender" clause. As far as I'm concerned, however, I have actually (and will continue to) put a lot of effort into making the code shorter.

Python 2, 94 bytes
i=input();print i%2*2*" "+" ^"
while i:print['/!\\\n---^','  /!\\\n ^---'][i%2];i-=1
print" -"

Try it online!
Trying to golf this... 3 print statements seem awfully redundant.

Proton, 101 bytes
a=>{k=" ^---"for i:0..a print(["   ^",k,"---^"][i?~i%2+1:i]+"\n"+" "*(~i%2)*2+"/!\\")print(k+"\n -")}

Try it online!
also too long lol

Perl 5, 77+1 (-p) bytes
$\=' ^
 _';map$_%2?$\=~s,\^,  ^
  /!\\
 ^---,:$\=~s,  \^,^
/!\\
---^,,1..$_}{

try it online

Funky, 95 bytes
n=>{print((n%2)?" ^":"   ^")fori=n i>0i--print({"  /!\\\n ^---","/!\\\n---^"}[i%2])print"   -"}

Try it online!

JavaScript (ES6), 77 74 bytes
n=>(s=`^
  /!\\
 ^---`,n%2?`   `+s:` ^`)+`
/!\\
---${s}`.repeat(n/2)+`
 -`

Try it:

f=

n=>(s=`^
  /!\\
 ^---`,n%2?`   `+s:` ^`)+`
/!\\
---${s}`.repeat(n/2)+`
 -`
<input oninput=o.innerHTML=f(value)>
<pre id=o>

Retina, 70 68 60 bytes
thanks to @MartinEnder for -8 bytes
.+
$*
r`11
21
1
¶  /!\¶ ^---
2
¶/!\¶---^
^¶( *)
$1 ^$&
$
¶ -

Try it online!

Java 8, 104 bytes
n->{String r=n%2>0?"   ^\n":" ^\n";for(;n-->0;r+=n%2<1?"  /!\\\n ^---\n":"/!\\\n---^\n");return r+" -";}

Explanation:
Try it here.
n->{                       // Method with integer parameter and String return-type
  String r=                //  Result-String, starting at:
           n%2>0?          //  If the input is odd:
            "   ^\n"       //   Start the result at "   ^" + new-line
           :               //  Else (the input is even):
            " ^\n";        //   Start the result at " ^" + new-line
  for(;n-->0;              //  Loop the input amount of times
    r+=n%2<1?              //   If the current row is even:
        "  /!\\\n ^---\n"  //    Append the result-String with "  /!\" + new-line
                           //                                  " ^---" + new-line
       :                   //   Else (the current row is odd):
        "/!\\\n---^\n"     //    Append the result-String with "/!\" + new-line
                           //                                  "---^" + new-line
  );                       //  End of loop
  return r                 //  Return the result-String
          +" -";           //   + " -"
}                          // End of method

Python 2, 73 bytes
lambda n:n%2*'  '+' ^%s\n -'%(-~n/2*r"""
/!\
---^
  /!\
 ^---""")[n%2*9:]

Try it online!
Golfing TFeld's solution.

Python 3, 167 bytes
def f(n):
	g=[[" "]*5for _ in'  '*-~n];a=["^","/!\\","---"]
	for i in range(n):
		for r,R in zip(a,g[i*2:]):R[(i-n)%2*2+(r>"]"):]=r
	g[-2][1]="^";g[-1][1]="-";return g

Try it online!
-4 bytes thanks to Mr. Xcoder
-1 byte thanks to Jonathan Frech

' '*2*n can be '  '*n (two spaces there, but eugh... SE markdown), and then '  '*n+'  ' can be replaced by '  '*-~n for 168 bytes.

@Mr.Xcoder Oh cool, thanks!

I think r=="^" can be r>"]".

@JonathanFrech Appears to be so, thanks!

Python 2, 100 bytes
lambda n:n%2*'  '+' ^\n'+'\n'.join(['/!\\\n---^','  /!\\\n ^---'][i%2]for i in range(n,0,-1))+'\n -'

Try it online!

SOGL V0.12, 25 bytes
 ^¶ -”.∫2%«I"X¬ΒNN┘y7¹‘∆ž

Try it Here!

C (gcc), 87 bytes
f(n){for(puts(n%2?"   ^":" ^");n;)puts(n--%2?"  /!\\\n ^---":"/!\\\n---^");puts(" -");}

Try it online!

Suggest "   ^"-~n%2*2 instead of n%2?"   ^":" ^"

Python 2, 82 bytes
def f(n):x=n%2;print' '*x*2,'^'+(-~n/2*"\n/!\\\n---^\n  /!\\\n ^---")[x*9:]+'\n -'

Try it online!

Ruby, 97 94 bytes
puts "  "*(a%2)+" ^";f=->n{puts""+["/!\\\n---^","  /!\\\n ^---"][n%2];(n>1)?f[n-1]:puts(" -")}

Try It Online!
I was unable to find a way to fit the entire thing in one function, so f is set to the lambda.
Based on TotallyHuman's Python answer.

05AB1E, 42 bytes
É·>'^ú¶•2ÂŸ§'vôÅ•"-
 ^\!/"ÅвJ12ôIL<Rè`„ -J

Try it online or verify some more test cases.
Minor 42 bytes alternative:
É·ðú„^
•e
QΣœKΔ•"- ^
\!/"ÅвJ8₂‚£ILRè»…
 -J

Try it online or verify some more test cases.
Explanation:
É              # Check if the (implicit) input-integer is odd (1 if odd; 0 if even)
 ·             # Double that (2 if odd; 0 if even)
  >            # Increase it by 1 (3 if odd; 1 if even)
   '^         '# Push string "^"
     ú         # Pad it with the input%2*2+1 amount of leading spaces
¶              # Push a newline character "\n"
•2ÂŸ§'vôÅ•    '# Push compressed integer 193455283599881836
 "-\n ^\!/"Åв  # Convert it to custom base-"-\n ^\!/"
               # (which converts it to base-length and indices it into the string)
  J            # Join this list of characters together to a single string:
               #  "  /!\\n ^---\n/!\\n---^\n"
   12ô         # Split it into parts of size 12: ["  /!\\n ^---\n","/!\\n---^\n"]
      IL       # Push a list in the range [1, input]
        <      # Decrease each by 1 to make the range [0, input)
         R     # Reverse it to range (input, 0]
          è    # Index each into the pair of strings (0-based and modulair)
           `   # Pop and push all strings separated to the stack
„ -            # Push string " -"
J              # Join all strings on the stack together
               # (and output the result implicitly)

É·             # Same as above
  ðú           # Pad a space character with that many spaces
    „^\n       # Push string "^\n"
•e\nQΣœKΔ•     # Push integer 11080812880919929
"- ^\n\!/"ÅвJ  # Same as above: "/!\\n---^  /!\\n ^---"
8₂‚            # Push 8 and 26 paired together: [8,26]
   £           # Split the string into parts of that size: ["/!\\n---^","  /!\\n ^---"]
    IL         # Push a list in the range [1, input]
      R        # Reverse it to range [input, 1]
       è       # Index each into the pair of strings (0-based and modulair)
        »      # Join this list with newline delimiter
…\n -          # Push string "\n -"
J              # Join all strings on the stack together
               # (and output the result implicitly)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •2ÂŸ§'vôÅ• is 193455283599881836 and •e\nQΣœKΔ• is 11080812880919929.
The compressed ASCII-string was generation with this 05AB1E tip.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes