TXR Lisp, 77 59 56 bytes

(op map(op pprinl`@{""@2}@{(repeat @1 @3)}`)"A"..@1 0 1)

Run:

This is the TXR Lisp interactive listener of TXR 299.
Quit with :quit or Ctrl-D on an empty line. Ctrl-X ? for cheatsheet.
TXR causes vomiting if accidentally ingested; no need to induce such.
1> (op map(op pprinl`@{""@2}@{(repeat @1 @3)}`)"A"..@1 0 1)
#<interpreted fun: lambda (#:arg-1-0022 . #:arg-rest-0021)>
2> [*1"F"]
A
 B B
  C C C
   D D D D
    E E E E E
     F F F F F F
("A" " B B" "  C C C" "   D D D D" "    E E E E E" "     F F F F F F")

The list is the result value, not part of the output.

Raku (Perl 6) (rakudo), 42 bytes

{say " "x($/=.ord-64)~"$_ "x$/for 'A'..@_}

Attempt This Online!

{say         # craft and print string:
" "x         # multiply number of spaces
($/=         # (set variable $/)
.ord-64)     # by ascii code -64
~            # append
"$_ "        # current letter and a space
x$/          # times $/ from above.
for 'A'..@_} # loop from A to ending letter

AWK, 85 bytes

@load"ordchr";{for(i=64;i++<ord($1);printf"\n"(z=" "z))for(j=64;j++<i;)printf"%c ",i}

Attempt This Online!

@load"ordchr";  # lib for ascii
{for(i=64;      # alpha starts at 65
i++<ord($1);    # while less than input
printf"\n"      # print a return
(z=" "z))       # along with a concatenating string of spaces
for(j=64;       # ascii alpha
j++<i;)         # number of chars equal to it's place in alpha
printf"%c ",i}  # print char and a space

Very naïve approach.

Tcl, 94 bytes

time {puts [format %[incr i]s ""][lrepeat $i [format %c [expr $i+64]]]} [expr [scan $c %c]-64]

Try it online!

time {puts [format %[incr i]s \ ][string repe [format %c\  [expr $i+64]] $i]} [expr [scan $c %c]-64]

set i 0;while \$i<[scan $c %c]-64 {puts [format %$i.s \ ][string repe [format %2c [expr $i+65]] [incr i]]}

set i 0;while \$i<[scan $c %c]-64 {puts [format %$i.s \ ][string repe [format %c [expr $i+65]]\  [incr i]]}

set i 0;time {puts [format %$i.s \ ][string repe [format %c [expr $i+65]]\  [incr i]]} [expr [scan $c %c]-64]

set i 0;time {puts [string repe \  $i][string repe [format %c [expr $i+65]]\  [incr i]]} [expr [scan $c %c]-64]

Vyxal, 20 bytes

C65-›ɾ(nIn‹kAin*Ṅ+,)

Try it Online!

Explanation:

C65-›ɾ  # range from 1 to 0-25 depending on which letter is inputted
 (  # begin loop
  nI  # push n (current loop variable) spaces to the stack
   n‹kAin*Ṅ+  # which letter of the alphabet is n and push n letters 
    separated by spaces
     ,  # output

Ruby, 43 bytes

->c{i=0
(?A..c).map{" "*(i+=1)+[_1]*i*" "}}

Attempt This Online!

Python 2, 101 99 bytes

-2 because I forgot I could remove the parentheses in print

def f(l,a="abcdefghijklmnopqrstuvwxyz",s=0):
 for c in a[:a.index(l)+1]:print" "*s+(c+" ")*-~s;s+=1

Try it online!

Vyxal rMj, ¹⁶ 13 bytes

Thanks to @Lyxal for -3 bytes by using Map Lambda instead of a for loop.

kAḟƛ›nkAi*Ṅn꘍

Try it Online!

Explanation:

               # Implicit input
kA             # Constant 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  ḟ            # Index of input in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ’
   ƛ           # Map over range [0,index)
     nkAi      # Index of n in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    ›    *     # Multiply by n+1
          Ṅ    # Join with spaces
           n꘍  # Prepend n spaces
               # 'j' flag - Join top of stack with newlines and print

Vim, 45 bytes

D:h<_
jjYZZPJ/<C-r>-
lDqqha
<esc>:,$s/\S/ & &
{$@qq@q

Uses lowercase. Try it online!

Explanation

D

Delete the input letter (we'll use it later).

:h<_<cr>jjYZZ

Yank the lowercase alphabet from an article in the help file (see this tip).

PJ

Paste the alphabet and turn the blank line (where the input used to be) into a trailing space.

/<C-r>-<cr>

Find the input letter (pasting it into the find command from the "small deletion" register -).

lD

Move one character to the right and delete everything till the end of the line. We now have one line containing letters a through the input letter, with the cursor on the last character of the line.

qqh

Begin recording macro q. Try going left one character. If this fails, we've gotten all the way to a and we're done; the macro exits. Otherwise, the cursor is now on the second-last character of the top line.

a<cr><esc>

Insert a newline after the cursor, moving the final character of the top line to its own line.

:,$s/\S/ & &<cr>

On every line from this second line till the end of the file, substitute the first non-space character for space, itself, space, and itself again. This turns a line like c into c c, d d into d d d, etc.

{$@q

Go back to the first line, then go to the end of the line and run the macro recursively.

q@q

Stop recording, and call the macro.

Pip, 22 21 bytes

FxzIxLEaPsXi.YxX++iJs

Uses lowercase and takes input from the command line. Try it online!

Explanation

Implicit: a is 1st cmdline arg; z is lowercase alphabet; i is 0; s is space.

Fxz                      For each letter x in lowercase alphabet:
   IxLEa                  If x is less than or equal to a:
        P                  Print
         sXi               i spaces
            .Y             to which concatenate (the Y enforces precedence)
              xX++i        x repeated i times, after incrementing i
                   Js      joined on spaces

Excel

=LET(x,SEQUENCE(CODE(A1)-64),REPT(" ",x-1)&REPT(CHAR(64+x),x))

Link to Spreadsheet

SmileBASIC, 58 57 bytes

INPUT E$WHILE L$<E$L=L+1L$=CHR$(L+#X)+" "?" "*L;L$*L
WEND

Common Lisp, 89 bytes

(dotimes(m(-(char-code(read))63))(format t"~va~v@{~c ~:*~}~%"m #\  m(code-char(+ m 64))))

Try it online!

Kotlin, 57 bytes

{('A'..it).map{" ".repeat(it-'A')+"$it ".repeat(it-'@')}}

Try it online!

Burlesque - 39 bytes

-]'Ajr@id?i?*m{' []}zim{p^' j?*j_+}unsh

This is not fully golfed yet and (trivially at least the sh can be replaced with Q) but it's a first start. m{}un can probably be replaced by a version of map that unlines and zim[ is a good candidate for a shortcut in the near future. The two maps can also probably be merged together into a single map.

Japt -R, 24 23 17 15 bytes

Outputs an array, includes a leading newline and a leading & trailing space on each line.

IòUc ÏçSiXd¹iYç

Test it

• 1 byte saved with help from Oliver and a further 6 thanks to him pointing out a better way to generate the initial array.

Julia 0.6, 40 bytes

c->[" "^i*"$('A'+i) "^-~i for i=0:c-'A']

Try it online!

Returns an array of strings containing the output. (Pretty printed on TIO using just map (println, f(c)).)

^ applied to strings repeats the string that many times. $() executes its content and pastes the result into the string (here, the correct letter for the line). Finally, the space repetition and the letter repetition are concatenated with *.

QBasic, 79 74 72 bytes

Thanks to Taylor Scott for byte savings (twice!)

FOR i=1TO ASC(INPUT$(1))-64
?TAB(i)
FOR j=1TO i
?CHR$(64+i)" ";
NEXT j,i

Uses uppercase. The input is by keypress and is not echoed to the screen.

Explanation

We loop i from 1 up to the limiting letter's position in the alphabet (1-based). For each i, we move to column i of the screen using TAB; then, i times, we print the ith letter of the alphabet followed by a space.

Excel VBA, ₇₈ 71 Bytes

Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window

For i=1To[Code(A1)-64]:?:?Spc(i-1);:For j=1To i:?Chr(i+64)" ";:Next j,i

-1 Byte for switching to leading newline over trailing, and condensing Next statements

-6 bytes for using Spc() over String()

APL (Dyalog Unicode), 22 bytes^SBCS

⍕⍪⊢∘⊂\2,.↑⍉⍴⍨⌸⎕a↑⍨⎕a⍳⍞

Try it online!

Uses ⎕io←1. Prints a leading space, which is allowed.

Julia 0.4, 48 bytes

It should work the same in more recent versions of Julia as well.

x->[" "^i*"$c "^i for (i,c) in enumerate('A':x)]

Try it online!

Swift, 133 bytes

func f(c:String){for i in 9..<Int(c,radix:36)!{var s=""
for _ in 9..<i{s+=" "}
for _ in 9...i{s+=String(i+1,radix:36)+" "}
print(s)}}

Try it online!

SNOBOL4 (CSNOBOL4), 115 bytes

	U =&UCASE
	U INPUT @L
N	U POS(X) LEN(1) . R
	OUTPUT =DUPL(' ',X) DUPL(R ' ',X + 1)
	X =LT(X,L - 1) X + 1	:S(N)
END

Try it online!

Ruby, 62 Bytes

Assumes input as a string (e.g., 'A'). Wasn't clear from the rules whether this was allowed. Will update if not.

Lots of room for improvement, I'm sure.

->n{a=[*'A'..n];a.map{|x|' '*a.index(x)+(x+' ')*-~a.index(x)}}

C (gcc), 76 bytes

i,j;f(c){for(i=0;i++<c-64;puts(""))for(j=0;j<i;)printf("%*c",j++?2:i,i+64);}

Try it online!

SOGL V0.12, 15 14 12 bytes

ZZ,Wm{ē@Ο}¹¾

Try it Here!

K (oK), 35 bytes

Solution:

`c${,/(x#32),(x+1)#,65+x,-33}'!-64+

Returns list of strings. prepend `0: to write to stdout instead.

Try it online!

Example:

`c${,/(x#32),(x+1)#,65+x,-33}'!-64+"F"
("A "
 " B B "
 "  C C C "
 "   D D D D "
 "    E E E E E "
 "     F F F F F F ")

Explanation:

Struggled to golf this down any further... K is interpretted right-to-left:

`c${,/(x#32),(x+1)#,65+x,-33}'!-64+ / the solution
                               -64+ / subtract 64 from input, "F"=>6 (implicit ascii)
                              !     / til, !6 => 0 1 2 3 4 5
   {                        }'      / lambda function with each input
                         -33        / negative 33
                       x,           / x concatenated, e.g. 0 -33
                    65+             / add 65, 0 -33 => 65 32 (aka "A ")
                   ,                / enlist, wraps "A " into a list ("A ")
             (x+1)#                 / take (#) x+1 instances of this list
            ,                       / concatenate with
      (x#32)                        / x instances of the number 32 (aka " ")
    ,/                              / raze, flattens this list down
`c$                                 / cast to characters

Recursiva, 28 bytes

{B-Oa64"P+*' '~}J' '*}C+64}"

Try it online!

PHP, 69+1 bytes

A<?for($c=A;$c<$argn;)echo($p=str_pad)($p("
",++$i+1),$i*3,++$c." ");

Run as pipe with -nF or try it online.

The Z case cost 4 bytes. for($c=A;$c<=$argn;)echo($p=str_pad)($p(" ",++$i),$i*3,$c++." "); (with -nR) works for A to Y.

Printing a list of underscore-separated lines would save two bytes, but that´d feel like cheating.

Pyth, 18 17 bytes

-1 thanks to @TheIOSCoder because you are apparently allowed to surround the input in quotes

j.b+*dYjd*NhYGhxG

Try it online!

Explanation

j.b+*dYjd*NhYGhxG    accepts a token as input, must be lowercase and in quotes

j                    joins on new line
 .b   Y   N Y        maps A (lambdas NY) over B and C in parallel
   +                 joins two strings on same line
    *    *           repeats A B times
     d  d            " " or space
       j             joins B on A
           h  h      A + 1
             G  G    lowercase alphabet
               x     returns position of B in A
                     implicit input

Haskell, 52 44 bytes

f k=[[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]

Returns a list of lines.

Try it online!

f k=                  -- main function is f, input parameter k
  [   |s<-['A'..k]]   -- for each s from ['A'..k]
     >>=              -- map (and collect the results in a single string) the function: 
         (['A'..s]>>) --  replace each element in ['A'..s] with
    [  ,  ]           --  over the list, containing
     " "              --   a single space to get the indent
        s:" "         --   s followed by space to get the letter sequence

Edit: @jferard: saved three bytes. Thanks!

PowerShell, 45 42 bytes

65..$args[0]|%{" "*$i+++"$([char]$_) "*$i}

Try it online!

Takes input as a literal char, then loops up through the capitals to that point, each iteration prepending the appropriate number of spaces and then the char\space hybrid.

Saved 3 bytes thanks to TessellatingHeckler.

Alice, 31 bytes

/A''*?h~w0O~
\I"AxrS&..r!y"kx@/

Try it online!

Explanation

Linearized and with relevant spaces included, the program is as follows:

I'A*rh&w.O!" x A"'x?S~.0r~yk@

I                                   take input
 'A*                                append the letter A
    r                               expand to range (e.g., if input was D, string is now DCBA)
     h&w                            split string into characters, and repeat the main loop that number of times
        .O                          output copy of top string on stack with newline
          !                         move top string (last printed row) to tape
           " x A"                   push " x A"
                 'x S               replace the occurrence of "x" with
                   ?                  the string on the tape
                     ~              swap to get next letter
                      .             copy this letter
                       0r           get entire range from that letter down to "0"
                         ~          swap again to put letter on top of stack
                          y         replace all characters in this range (effectively, all non-space characters) with the next letter
                           k        repeat (end of main loop)
                            @       exit

Python 2, 63 61 59 bytes

-2 bytes thanks to Rod. -2 bytes thanks to Felipe Nardi Batista.

i=1
exec"print' '*i+'%c '%(i+64)*i;i+=1;"*(ord(input())-64)

Try it online!

Pyth, 26 bytes

Should meet OPs specs.

VhxrG1w++*dNr@GN1*+dr@GN1N

Try it online!

R, 94 88 bytes

-6 bytes thanks to Giuseppe

function(x,l=LETTERS)for(i in 1:match(x,l))cat(rep(' ',i-1),rep(paste(l[i],' '),i),'\n')}

Ungolfed:

f=function(x,l=letters){
  for(i in 1:which(l==x)){
    A=paste(l[i],' ')
    cat(rep(' ',i-1),rep(A,i),'\n')
  }
}

C (gcc), 77 bytes

i,j;f(c){for(j=64;i||j++<c&&printf("\n%*c ",i=j-64,j);--i&&printf("%c ",j));}

Try it online!

Contains unsequenced access to possibly incremented j, so very likely to break with a different compiler :)

fixed with identical byte count

Shnap, 97 96 bytes

-1 byte because I remembered that the parser reads strings through newlines, so a literal newline is shorter than \n

$c{n=65s=""for k:range(n,c+1){for range(n,k)s+=" "for range(n,k+1)s+=char(k)+" "s+="
"}return:s}

This is an anonymous function (actually, all functions in Shnap are anonymous...).

Try it online!

Alternative version that uses the fact that blocks return the last instruction's value

Ungolfed/explanation:

$ (c) {                  //Function with 1 parameter
    n=65                    //Value of 'A'
    s=""                    //The result
    for k:range(n,c+1) {    //Inclusive range from n to c, range(n,c,1,1) also works, as third arg is step and fourth is inclusive (bool).
                            //For loop variable is k
        for range(n,k)      //Exclusive range from n to k
            s+=" "          //Add a space
        for range(n,k+1)    //Inclusive range from n to k
            s+=char(k)+" "  //Add k and a space
        s+="\n"             //Add a newline

    }
    return:s                //Return the result
}

I really should implement string multiplication and eval...

Java, 363 bytes

public class MyClass {
    public static void main(String args[]) {
        char x='A';
        int count=0;
      for(x='A';x<='Z';x++){
        for(int x1=count;x1>0;x1--) {
            System.out.print(" ");
        }
        for(int y=count;y>=1;y--) {
            System.out.print(x);
        }
        System.out.print(x+"\n");
       count++;
    }
    }
}

05AB1E, 10 bytes

A¹¡н«ðâƶāú

Try it online!

-2 thanks to Adnan.

Append » to make it print in separate lines.

C++ (gcc), 179 bytes

Well, someone ought to post the most un-original method, I might as well be that someone.

#include <iostream>
using namespace std;
int main(){char n;cin>>n;for(char i='A';i<=n;i++){for(char k='A';k<i;k++){cout<<" ";}for(int j=0;j<=i-'A';j++){cout<<i<<" ";}cout<<endl;}}

An easier-to-read version of the code:

#include <iostream>
using namespace std;
int main()
{
    char n;
    cin>>n;
    for (char i='A';i<=n;i++)
    {
        for (int k=0;k<n-i;k++)
        {
            cout<<" ";
        }
        for (int j=0; j<n-'A'+1;j++)
        {
            cout<<i<<" ";
        }
        cout<<endl;
    }
}

Try it online!

C (GCC), 115 109 Bytes

f(a,n,k,s,i){if(k){for(;i<s;i++)printf(" ");for(i=0;i<s+1;i++)printf("%c ",a);puts();f(++a,++n,--k,++s,0);}}

Usage

f(65,5,5,0,0)

Where the two 5's are the given K value, the rest are constants used later for recursive calls.

Ungolfed

f(a,n,k,s,i){
    if(k){
        for (; i<s; i++) printf(" ");
        for (i=0; i<s+1; i++) printf("%c ",a);
        puts();
        f(++a,++n,--k,++s,0);
    }
}

Output

Bash, 93 90 bytes

for c in {A..Z}
{
printf "%$[i++*3+2]s\n" "$(echo `yes $c|head -$i`)"
[ $c = $1 ]&&break
}

Try it online!

Takes input as, and outputs as, uppercase letters.

Still getting the hang of golfing in Bash, so I'm open to tips.

Java (OpenJDK 8), 81 bytes

c->{String s="";for(int d=64;d++<c;)System.out.printf((s=" "+s+"%1$c ")+"%n",d);}

Try it online!

Brain-Flak, 179 bytes

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

This is 178 bytes of code, and +1 for the -c flag.

Try it online!

(Semi-)Readable version:

({}[((((()()()()){}){}){}){}])

{

    ((({}[()])()))

    {
        ({}<

            (({})<>((((()()()()){}){}){}){})
            ((((()()()()){}){}){})<>

        >[()])
    }{}

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

    <>{}

    ((()()()()()){})

    <>

}

Fun fact: This will work with arbitrary characters above Z! Try it online!

><>, 85 Bytes

i1-&0\1o*84\      \o*84o:$\
@)?;&>:> :?/~1+:88*+$:@>:?/~ao&:
     /-/          /$1- /

Try it online

brainfuck, 111 bytes

>+[+[<]>>+<+],>>++++++++++>++++[>++++++++<-]----[<<<->>>----]<<<-[<[-<+>>>>>.<<<<]+<[->+>>.>>.<<<<<]>>>.+>.<<-]

Try it online!

Surprising how the Turing Tarpit itself can out-golf some other languages.

The breakdown:

Section A

>+[+[<]>>+<+]                                                       create character 'A'
             ,                                                      take input
              >>++++++++++                                          create '\n' character
                          >++++[>++++++++<-]                        create ' ' character
                                            ----[<<<->>>----]<<<-   map input to (1->26)

Section B

[<[-<+>>>>>.<<<<]+                                 print N spaces, then increment N
                  <[->+>>.>>.<<<<<]                print (N-1) of the Nth letter and spaces
                                   >>>.+>.<<-]     print additional letter, and newline

C++ (gcc), 164 bytes

#include<iostream>
#define f for(int i=0;i<o-'`';i++)
using namespace std;int main(){char c;cin>>c;for(char o='a';o<=c;o++){f cout<<' ';f cout<<o<<' ';cout<<'\n';}}

My first attempt after a long time lurking!

Ungolfed code below:

#include <iostream>

using namespace std;
#define f for (auto i = 0; i < output - '`'; i++)

int main()
{
  char input;

  cin >> input;

  for (char output = 'a'; output <= input; output++)
  {
    f cout << ' ';

    f cout << output << ' ';

    cout << endl;
  }
}

Try it online!

05AB1E, 15 14 13 bytes

Saved 1 byte thanks to Adnan

A¹¡н«ƶ€S»¶¡āú»

Try it online! or the Ascii art version

Explanation

A                # push lowercase alphabet
 ¹¡              # split at input
   н             # get the first part
    «            # append the input
     ƶ           # repeat each a number of times corresponding to its 1-based index
      €S         # split each to a list of chars
        »        # join on spaces and newlines
         ¶¡      # split on newlines
           āú    # prepend spaces to each corresponding to its 1-based index
             »   # join on newlines

Husk, 13 bytes

z+ḣ∞øzRNC1…'A

Takes a character in single quotes as command line argument, prints result to STDOUT. Try it online!

Explanation

I'm exploiting the way Husk prints lists of lists of strings: join inner lists with spaces and outer lists with newlines.

z+ḣ∞øzRNC1…'A  Implicit input, say 'C'
          …'A  Range from A: "ABC"
        C1     Cut into strings of length 1: ["A","B","C"]
     z N       Zip with positive integers
      R        using repetition: x = [["A"],["B","B"],["C","C","C"]]
   ∞ø          The empty string repeated infinitely: ["","","",...
  ḣ            Prefixes: [[],[""],["",""],["","",""],...
z+             Zip with x using concatenation: [["A"],["","B","B"],["","","C","C","C"]]
               Implicitly join each inner list with spaces, join the resulting strings with newlines and print.

Pyth, 17 bytes

.e+*kd*+bdhk<GhxG

Try it here (pretty print version).

How does this work?

• hxG - Takes the index of the input in the lowercase alphabet.

• <G - Trims every character after the input from the alphabet.

• .e - Enumerated Map. Maps over the trimmed alphabet with the indexes as k and the letters as b.

• *kd - Append k spaces.

• +bd - b + a space (the current letter + space).

• *...hk - Repeat k+1 times.

• +(...)(...) - Concatenate.

Jelly, 19 bytes

ḢØAḣi¥p⁶ẋ"J$µLḶ⁶ẋ;"

Try it online!

Function that returns a list. Append ⁸Y to print in separate lines. Erase the footer to show actual output instead of string representation.

Excel VBA, 72 Bytes

Anonymous VBE immediate window function that takes input from cell A1 and outputs to the VBE immediate window

For i=1To Asc([A1])-64:[B1]=i:?Space(i-1)[REPT(CHAR(B1+64)&" ",B1)]:Next

CJam, 22 21 20 bytes

This is the "list of lines" version. Just add an "N" before the close bracket to make it look nice. (Thanks to @Erik)

rc'@-{)_S*\_'@+*S*}%

Try it Online (nice version).

Mathematica, 70 bytes

(T=Table)[""<>{" "~T~i,T[Alphabet[][[i]]<>" ",i]},{i,LetterNumber@#}]&

lowercase

outputs a list

thanx @ngenisis for corrections

For ascii-art version place Column@ at the beginning

Charcoal, 15 bytes

Ｆ…·AＳ«Ｐ⪫Ｅ…@ιι ↘

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

 …·AＳ           Inclusive character range from A to the input
Ｆ    «          Loop over each character
         …@ι    Exclusive range from @ to the current character
        Ｅ   ι   Replace each element with the current character
       ⪫        Join with spaces
      Ｐ         Print without moving the cursor.
              ↘ Move the cursor down and right.

If extra padding was legal, this would work for 14 bytes:

Ｅ…·?θ⁺× κ⪫× κι

Try it online! Link is to verbose version of code.

J, 39 bytes

[:(#\([' '&,1j1##)"0])i.@>:&.(65-~3&u:)

Try it online!

V, 28, 26, 25, 23 bytes (Competing)

¬A[/a
lDÓ./& ò
ò-Ûä$Û>

Try it online!

Note that although I have been planning on adding certain features for a long time, this challenge was what convinced me to finally do it.

The output contains one leading space on each line and one trailing newline.

Hexdump:

00000000: ac41 5b2f 1261 0a6c 44d3 2e2f 2620 f20a  .A[/.a.lD../& ..
00000010: f22d dbe4 24db 3e                        .-..$.>

Explanation:

¬A[         " Insert 'ABCDEFGHIJKLMNOPQRSTUVWXYZ['
   /        " Search for...
    <C-r>a  "   The input
l           " Move one character to the right
 D          " And delete every character after the cursor
  Ó         " Search for...
   .        "   Any character
    /       " And replace it with...
     & ò    "   That character followed by a space and a newline
ò           " Recursively...
 -          "   Move to the beginning of the next line up
  Ûä$       "   Make *line number* copies of the current line
     Û>     "   And indent this line by *line number* spaces

APL (Dyalog Classic), 26 bytes

{↑{(≠\⍵<⍳3×⍵)\⍵⊃⎕A}¨⍳⎕A⍳⍵}

Try it online!

Explanation

                      ⍳⎕A⍳⍵  generate indexes up to position of right arg ⍵
{                   }¨       on each index apply function
   (≠\⍵<⍳3×⍵)                generate boolean mask for expansion (each line has a length 3 times its index ⍵, starting with ⍵ blanks and then alternating letter blank)
             \⍵⊃⎕A          expand character in position ⍵
 ↑                            mix result into text matrix

JavaScript (ES8), 92 bytes

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

Uses lowercase letters. Lines have one leading and one trailing space. Returns an array of lines.

Test Snippet

let f=

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

;O.innerText=f("k").join`\n`

<pre id=O></pre>

APL (Dyalog), 26 bytes

Prompts for scalar character. Prints list of lines.

(∊⍴∘'',' ',¨⍨⊢⍴⊃∘⎕A)¨⍳⎕A⍳⎕

Try it online! (has ASCII art version at one additional byte)

⎕ prompt for input

⎕A⍳ find ɩndex in Alphabet

⍳ first that many ɩntegers

(…)¨ apply the following tacit function to each :

 ⊃∘⎕A pick the argument'th letter letter from the Alphabet

 ⊢⍴ cyclically reshape it to the argument length

 ' ',¨⍨ append a space to each

 ⍴∘'', prepend a string of argument length (padded with spaces)

 ∊ ϵnlist (flatten)

The ASCII art version just has a ↑ on the very left; mix list of strings into table of characters.

Haskell, 57 bytes

x!'@'=x
x!e=([e]:[' ':r++' ':[last r]|r<-x])!pred e
([]!)

Try it online!

Retina, 51 bytes

^.
$&$&
}T`L`_L`^.
.
$.`$* $&$.`$* ¶
+`(\w) \B
$&$1

Try it online! Explanation:

^.
$&$&

Duplicate the (first) letter.

}T`L`_L`^.

Rotate it back 1 in the alphabet, or delete it if it's a duplicate A. Keep duplicating and rotating until we duplicate A, at which point the deletion undoes the duplication and the loop completes.

.
$.`$* $&$.`$* ¶

Replace each letter with a line with the letter padded on both sides.

+`(\w) \B
$&$1

Insert duplicate letters between all pairs of padding spaces to the right of existing letters.

JavaScript, 102 94 bytes

2 bytes saved thanks to Neil

f=
a=>[...Array(parseInt(a,36)-9)].map((a,b)=>''.padEnd(b).padEnd(b*3+1,(b+10).toString(36)+' '))

console.log(f('k').join`\n`)

JavaScript (ES6), 85 bytes

Works in lower case for both input and output. Outputs a leading space and a trailing space on each line.

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

Demo

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

O.innerText = f('m')

<pre id=O>

Proton, 47 bytes

c=>[' '*i+-~i*('%c '%(i+65))for i:0..ord(c)-64]

Not unlike the Python answers.

Try it online!

C# (.NET Core), 103 bytes

n=>{var i='`';var l="";for(;i<n;l+='\n'){l+="".PadLeft(i++-96);for(int s=96;s++<i;)l+=i+" ";}return l;}

Try it online!

Charcoal, 19 bytes

Ｆ⁻℅Ｓ⁶³«×⁺℅⁺ι⁶⁴ ιＪιι

Try it online! Link is to verbose version.

A bit of a different approach from the other answer, let's see if it's golfable...

Perl 5, 31 bytes

30 bytes code + 1 for -l.

print$"x$-,"$_ "x++$-for A..<>

Try it online!

Dyalog APL, 38 bytes

{↑{(y/' '),(2×y←⎕A⍳⍵)⍴⍵,' '}¨⎕A↑⍨⎕A⍳⍵}

Try it online!

How?

⎕A↑⍨ - take the alphabet until

⎕A⍳⍵ - the input character

¨ - for each char

    ⍵,' ' - take the char and a space

    (...)⍴ - reshape to

    2×y←⎕A⍳⍵ - twice the index of the char in the alphabet

    (y/' ') - and prepend index-of-char spaces

↑ - then flatten

C, 89 bytes

i,j;f(l){for(i=64;i++<l&&printf("%*c ",i-64,i);puts(""))for(j=i-65;j--;)printf("%c ",i);}

Try it online!

Python 3, 59 bytes

lambda l:[' '*i+'%c '%(i+65)*-~i for i in range(ord(l)-64)]

Try it online!

Python 3, 61 bytes

lambda l:[' '*i+-~i*(chr(i+65)+' ')for i in range(ord(l)-64)]

Try it online! (link to pretty-print version)

Braingolf, 65 bytes

a#a-# 7-,-~vc<!?>[$_]:$_|&,(.#a-!?.>[# M]1+>[.M# M]:$_!@|v#
&@R);

Try it online!

Lowercase.

Contains 1 trailing space on each line, and a trailing newline at the end of output.

Charcoal, 18 bytes

Ｆ⁺⌕αθ¹«Ｐ×⁺§αι ⁺ι¹↘

Try it online!

Röda, 53 bytes

f L{seq 0,ord(L)-65|[" "*_..`${chr(_1+65)} `*(_1+1)]}

Try it online!