[Question]
  [
Given no input, output this interesting alphabet pattern in either case (the case has to be consistent) via an [accepted output method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods):
```
A
AB
ACBC
ADBDCD
AEBECEDE
AFBFCFDFEF
AGBGCGDGEGFG
AHBHCHDHEHFHGH
AIBICIDIEIFIGIHI
AJBJCJDJEJFJGJHJIJ
AKBKCKDKEKFKGKHKIKJK
ALBLCLDLELFLGLHLILJLKL
AMBMCMDMEMFMGMHMIMJMKMLM
ANBNCNDNENFNGNHNINJNKNLNMN
AOBOCODOEOFOGOHOIOJOKOLOMONO
APBPCPDPEPFPGPHPIPJPKPLPMPNPOP
AQBQCQDQEQFQGQHQIQJQKQLQMQNQOQPQ
ARBRCRDRERFRGRHRIRJRKRLRMRNRORPRQR
ASBSCSDSESFSGSHSISJSKSLSMSNSOSPSQSRS
ATBTCTDTETFTGTHTITJTKTLTMTNTOTPTQTRTST
AUBUCUDUEUFUGUHUIUJUKULUMUNUOUPUQURUSUTU
AVBVCVDVEVFVGVHVIVJVKVLVMVNVOVPVQVRVSVTVUV
AWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVW
AXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWX
AYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPYQYRYSYTYUYVYWYXY
AZBZCZDZEZFZGZHZIZJZKZLZMZNZOZPZQZRZSZTZUZVZWZXZYZ
```
Trailing spaces and newlines are acceptable, [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed, and this happens to be [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
ØAjṪ$Ƥż¹Y
```
[Try it online!](https://tio.run/##ARgA5/9qZWxsef//w5hBauG5qiTGpMW8wrlZ//8 "Jelly – Try It Online")
### How it works
```
ØAjṪ$Ƥż¹Y  Main link. No arguments.
ØA         Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
     Ƥ     Map the link to the left over all prefixes, i.e., ["A", "AB", ...].
    $        Combine the two links to the left into a chain.
   Ṫ           Tail; yield and remove the last letter of each prefix.
  j            Join the remainder, using that letter as separator.
      ż¹   Zip the resulting strings and the letters of the alphabet.
        Y  Separate the results by linefeeds.
```
[Answer]
# C, 82 bytes
```
f(i,j){for(i=!puts("A");++i<26;puts(""))for(j=0;j++<i*2;)putchar(65+(j&1?j/2:i));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1MnS7M6Lb9II9NWsaC0pFhDyVFJ01pbO9PGyMwaIqCkqQlSkGVrYJ2lrW2TqWVkrQmUSc5ILNIwM9XWyFIztM/SN7LK1NS0rv2fmVeikJuYmaehyVXNpQAEaRqa1ly1/wE)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
Ｅα⁺⪫…ακιι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUAjUUchIKe0WMMrPzNPw7kyOSfVOSMfLJytqaOQCcaamtb////XLcsBAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 α          Predefined uppercase alphabet
Ｅ           Map over each character
    …ακ     Get current prefix of alphabet
   ⪫   ι    Join with current character
  ⁺     ι   Append current character
            Implicitly print on separate lines
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 7 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｚ［Ｋ＊¹＋］
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNBJXVGRjNCJXVGRjJCJXVGRjBBJUI5JXVGRjBCJXVGRjNE,v=0,run)
Explanation:
```
Ｚ［     ］ for each prefix of the uppercase alphabet
    Ｋ        pop off the last letter
     ＊       and join the rest of the string with that character
      ¹＋     and append the current iterated character to it
```
[Answer]
# [R](https://www.r-project.org/), 50 bytes
```
l=LETTERS
for(i in 0:25)cat(l[0:i],"
",sep=l[i+1])
```
[Try it online!](https://tio.run/##K/r/P8fWxzUkxDUomCstv0gjUyEzT8HAyshUMzmxRCMn2sAqM1ZHiUtJpzi1wDYnOlPbMFbz/38A "R – Try It Online")
Perhaps the cleverest part here is using `letters[0]` for the empty string to get `cat(character(0),'\n',sep="A")` to print the first line.
[Answer]
# [Python 2](https://docs.python.org/2/), 56 bytes
```
n=65;s='';exec'c=chr(n);print c.join(s)+c;s+=c;n+=1;'*26
```
[Try it online!](https://tio.run/##BcExCsAgDADAr3SLNlBQqEvIa4KgHaIYh/b16d38dhua3ZXLTcYAVN8qICxtBY00V9d9yPWMrsEiChmykCIngjMX9x8 "Python 2 – Try It Online")
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) routine (C64), 39 bytes
```
A9 41 20 D2 FF AA A8 84 FB E4 FB B0 0B 8A 20 D2 FF 98 20 D2 FF E8 D0 F1 A9 0D
20 D2 FF A2 41 C0 5A F0 03 C8 D0 E1 60
```
Position-independet machine code subroutine, clobbers A, X and Y.
### [Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22calst.prg%22:%22data:;base64,AMCpQSDS/6qohPvk+7ALiiDS/5gg0v/o0PGpDSDS/6JBwFrwA8jQ4WA=%22%7D,%22vice%22:%7B%22-autostart%22:%22calst.prg%22%7D%7D)
The demo loads at `$C000`, so use `SYS49152` to call the routine.
---
### Commented disassembly:
```
A9 41       LDA #$41            ; 'A'
20 D2 FF    JSR $FFD2           ; Kernal CHROUT (output character)
AA          TAX                 ; copy to X (current pos)
A8          TAY                 ; copy to Y (current endpos)
  .outerloop:
84 FB       STY $FB             ; endpos to temporary
  .innerloop:
E4 FB       CPX $FB             ; compare pos with endpos
B0 0B       BCS .eol            ; reached -> do end of line
8A          TXA                 ; current pos to accu
20 D2 FF    JSR $FFD2           ; and output
98          TYA                 ; endpos to accu
20 D2 FF    JSR $FFD2           ; and output
E8          INX                 ; next character
D0 F1       BNE .innerloop      ; (repeat)
  .eol:
A9 0D       LDA #$0D            ; load newline
20 D2 FF    JSR $FFD2           ; and output
A2 41       LDX #$41            ; re-init current pos to 'A'
C0 5A       CPY #$5A            ; test endpos to 'Z'
F0 03       BEQ .done           ; done when 'Z' reached
C8          INY                 ; next endpos
D0 E1       BNE .outerloop      ; (repeat)
  .done:
60          RTS
```
[Answer]
# [Uiua](https://uiua.org) 0.1.0, 21 [bytes](https://codegolf.stackexchange.com/questions/247669/i-want-8-bits-for-every-character/265917#265917)
```
∵(&p+@A♭≐⊂⇡.)⇡26&pf@A
```
[See it in action](https://uiua.org/pad?src=4oi1KCZwK0BB4pmt4omQ4oqC4oehLinih6EyNiZwZkBBCg==)
[Answer]
# Java 8, ~~93~~ ~~91~~ 90 bytes
```
v->{String t="";for(char c=64;++c<91;t+=c)System.out.println(t.join(c+"",t.split(""))+c);}
```
-1 byte thanks to *@OlivierGrégoire* by printing directly instead of returning
**Explanation:**
[Try it online.](https://tio.run/##LY7BCsIwDIbvPkXoqaVaEESQOt9AL4IX8VDj1M6ajjUbiOzZZ3VCfkLCD99Xuc7NYl1SdXkMGFxKsHWe3hMAT1w2V4cl7L4nQBf9BVAevqtTNv/6nDyJHXuEHRAUMHSzzXvPjacbcCGEvcZG4t01gMVyYbXG9WpuWReo9q/E5dPElk2d@xxIsqmiJ4laiCmbVAfPUgilNCrbD3bk1e05ZN4f@9N6Zmk5Uo8np0ZhMiipDeHv2g8f)
```
v->{                     // Method with empty unused parameter and String return-type
  String t="";           //  Temp-String, starting empty
  for(char c=64;++c<91;  //  Loop over the letters of the alphabet:
      t+=c)              //    After every iteration: append the letter to the temp-String
    System.out.println(  //   Print with trailing new-line:
       r.join(c+"",t.split(""))
                         //    The temp-String with the current letter as delimiter
       +c);}             //    + the current letter as trailing character 
```
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~169~~ ~~143~~ ~~124~~ 123 bytes
```
	L =LEN(1)
	OUTPUT ='A'
I	&UCASE (ARB K L) . R L . S :F(END)
	O =K =
T	R K L . K :F(O)
	O =O K S :(T)
O 	OUTPUT =O :(I)
END
```
[Try it online!](https://tio.run/##K87LT8rPMfn/n9NHwdbH1U/DUJOL0z80JCA0RMFW3VGdy5NTLdTZMdhVQcMxyEnBW8FHU0FPIUjBB0gGK1i5abj6uYB0KNh6K9hyhXAGgZQA5bxBcv4QGX8gD6hWI0STy18Bbrg/UMRTkwuo//9/AA "SNOBOL4 (CSNOBOL4) – Try It Online")
Explanation for older version of the code:
```
i &ucase len(x) . r len(1) . s	;* set r to the first x characters and s to the x+1th.
 o =				;* set o,i to empty string
 i =
t r len(i) len(1) . k :f(o)	;* set k to the ith letter of r. on failure (no match), go to o.
 o =o s k			;* concatenate o,s,k
 i =i + 1 :(t)			;* increment i, goto t
o o s =				;* remove the first occurrence of s (the first character for x>1, and nothing otherwise)
 output =o s			;* output o concatenated with s
 x =lt(x,25) x + 1 :s(i)	;* increment x, goto i if x<25.
end
```
The problem here is the first line
using `o s k` will add an extra `s`eparator character at the beginning of each line and also not have an `s` at the end. This is OK because line `t` will jump over the following two lines when `x=0`. This means that `o` will still be blank. Hence, `o s =` will remove the first `s` character from `o`, and then we can simply print `o s` to have the appropriate last `s`.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 56 bytes
```
"A";65..89|%{([char[]](65..$_)-join[char]++$_)+[char]$_}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8lRydrMVE/PwrJGtVojOjkjsSg6NlYDJKQSr6mblZ@ZBxaM1dYG8rUhbJX42v//AQ "PowerShell – Try It Online")
Loops `65` to `89`, each iteration constructing a `char` array of `65` to the current number `$_`, then `-join`s that array together into a string with the next character, then tacks on that character at the end.
Change the `89` to some other ASCII number to see the behavior better.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~44~~ 34 bytes
```
"BA"oao"ZA"\=?;1+40.
o1+:{::o}=?\:
```
[Try it online!](https://tio.run/##S8sszvj/X8nJUSk/MV8pylEpxtbe2lDbxECPK99Q26rayiq/1tY@xur/fwA "><> – Try It Online")
# [><>](https://esolangs.org/wiki/Fish), 44 bytes
```
"A"o10ao\55*=?;1+40.
1+:{:}=?\:"A"+o{:}"A"+o
```
[Try it online!](https://tio.run/##S8sszvj/X8lRKd/QIDE/xtRUy9be2lDbxECPy1Dbqtqq1tY@xgoorZ0PZIPp//8B "><> – Try It Online")
As I use a different route to producing the output I've posted my own ><> answer; The other ><> answer can be found [here.](https://codegolf.stackexchange.com/a/153190/62009)
Big thanks to Jo king for spotting I didn't need to keep putting "A" onto the stack if I just compared against "Z" instead of 26. (-10 bytes)
### Explanation
The explanation will follow the flow of the code.
```
"BA"                 : Push "BA" onto the stack;
                       [] -> [66, 65]
    oao              : Print the stack top then print a new line;
                       [66, 65] -> [66]
       "ZA"\         : Push "ZA" onto the stack then move down to line 2;
                       [66, 90, 65]
o          \:        : Duplicate the stack top then print
 1+:                 : Add one to the stack top then duplicate;
                       [66, 90, 65, 65]
    {::              : Shift the stack right 1 place then duplicate the stack top twice;
                       [90, 65, 65, 66, 66]
       o}            : Print the stack top then shift the stack left 1 place;
                       [66, 90, 65, 65, 66]
         =?\         : Comparison for equality on the top 2 stack items then move to line 1 if equal otherwise continue on line 2;
                       [66, 90, 65]
           \=?;      : Comparison for equality on the top 2 stack items then quit if equal else continue on line 1;
                       [66]
               1+    : Add 1 to the stack top;
                       [67]
                 40. : Move the code pointer to column 4 row 0 of the code box and continue execution of code. 
```
[Answer]
## JavaScript (ES6), 81 bytes
```
f=
_=>[..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map((c,i,a)=>a.slice(0,i).join(c)+c).join`
`
;document.write('<pre>'+f());
```
Save 9 bytes if a string array return value is acceptable.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) (`-R` flag), ~~14~~ 12 bytes
*-2 bytes thanks to @Shaggy*
```
;B¬
ËiU¯E qD
```
[Test it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=O0KsCqNzMFkgcVggK1g=&input=LVI=)
[Answer]
# [Acc!!](https://github.com/dloscutoff/Esolangs/tree/master/Acc!!), 84 bytes
This is actually what inspired this challenge:
```
Write 65
Count i while i-26 {
Count b while b-i {
Write b+65
Write i+65
}
Write 10
}
```
[Try it online!](https://tio.run/##S0xOTkr6/z@8KLMkVcHMlMs5vzSvRCFToTwjMydVIVPXyEyhGiqYBBVM0s0EikF0JGkD9UCYmSBmLZRjaMBV@/8/AA "Acc!! – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~49~~ 48 bytes
```
'A':unlines[init['A'..x]>>=(:[x])|x<-['A'..'Z']]
```
[Try it online!](https://tio.run/##y0gszk7NyflfXFKUmZeuYKsQ81/dUd2qNC8nMy@1ODozL7MkGiigp1cRa2dnq2EVXRGrWVNhowsRVI9Sj439n5uYmQfUWVBaElxSpAAx6f@/5LScxPTi/7rJBQUA "Haskell – Try It Online")
*Edit: -1 byte thanks to totallyhuman!*
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform)
Port from Kevin Cruijssen's [answer](https://codegolf.stackexchange.com/a/153240/15214):
## ~~91~~ 90 bytes
```
_=>{var t="";for(char c='@';++c<91;t+=c)Console.WriteLine(string.Join(c+"",t.Skip(0))+c);}
```
[Try it online!](https://tio.run/##XY5BSwMxEIXv@RVhL02IhnqUGFH2UCgtCHvwHMapDq6JzUwLZdnfvgZBEY8Pvve@B3wNpeJyYsqveriw4EdQf5PvyzgiCJXMfoMZK8E/Ykf5GBSMiVk/TYolCYF@/O7oQRLVPjHqqBdj4/10TlVL7LpwKNXAW0sQVw@r4Bzc3d4EcRFs32xlRP9cSbDto2GpTem3hbIB13VX4od3@jRrax3YMC9B/ZjPhV70PjXQqkn9HjA2qFnNyxc "C# (.NET Core) – Try It Online")
## ~~132~~ ~~122~~ ~~110~~ ~~109~~ ~~104~~ 103 bytes
```
_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Select((c,i)=>string.Join(""+c,"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Take(i))+c)
```
[Try it online!](https://tio.run/##fY/PTgIxEMbvfYrJntqAfYGFTXQFBEHRRVFvdRx1Ymlj2yUxhGdfaozRePA4@f7M98N4hD5Q10Z2L9B8xESbUvy@dO2tJUzsXdQTchQY/zjm7N5LgdbECMudiMkkRhi3DgfTkWs3FMyjpUFMIYeqCppkONQmEgyhk2pYFccn9eloPDmbzs7ni4vL5dV1s7q5Xd/dPxS6oc/3UmKfs/WrRM88O1kUPez/m12ZN5KsVA9VV4rvZVvPT7AwuUGJnXjO/AZfQW5NAM48wO5nolQK6ozuLel1yHKGzZXZpkqxF/vuAA "C# (.NET Core) – Try It Online")
* Replace `()` with `_` to show that we declare an unused variable. Thank you Kevin Cruijssen.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 bytes
```
ØAż€Ð€`F€µJ’Ḥ»1ż@¹ḣ/€Y
```
[Try it online!](https://tio.run/##y0rNyan8///wDMejex41rTk8AUgkuAGJQ1u9HjXMfLhjyaHdhkf3OBza@XDHYn2geOT//wA "Jelly – Try It Online")
How it works:
```
                       take argument implicitly
ØA                     the uppercase alphabet
    Ð€`                for C in the alphabet
  ż€                     appends C to every letter in the alphabet
       F€              flatten every sublist
          J            get indices
           ’           subtract 1
            Ḥ          and double
             »1        take max([n, 1])
         µ     ż@¹     interleave alphabet list and indices
                  ḣ/€  reduce on head() for each element
                     Y join on newline
                       implicitly output
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~44~~ 34 bytes
```
?A.upto(?Z){|w|puts [*?A...w]*w+w}
```
[Try it online!](https://tio.run/##KypNqvz/395Rr7SgJF/DPkqzuqa8pqC0pFghWgsoqqdXHqtVrl1e@/8/AA "Ruby – Try It Online")
Thanks benj2240 for getting it down to 37 bytes. And of course crossed out 44 blah blah.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 29 bytes
```
'A,Au©.sRí¦®RSDgÝ×Rs)ø˜.Bíø»=
```
[Try it online!](https://tio.run/##ATIAzf8wNWFiMWX//ydBLEF1wqkuc1LDrcKmwq5SU0Rnw53Dl1JzKcO4y5wuQsOtw7jCuz3//w "05AB1E – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 96 bytes
```
+++++[->+++++>++>+++++++++++++>+++++++++++++<<<<]>>>.<.<[->>>+>+[-<<.+>.>>+<]>[-<+<<->>>]<<<<.<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwSide3AtB0YIQFUng0QxNrZ2enZ6NkAtdjZAeWjdW1s9LTt9IAcoByQB1QFkooFKdazif3/HwA "brainfuck – Try It Online")
**Tape Layout:**
*`[Init] [Line Count] [newline] [Growing Ascii] [Repeated Ascii] [Loop 1] [Loop 2]`*
**Explanation:**
```
+++++[->+++++>++                      Sets Line counter and newline cell
    >+++++++++++++>+++++++++++++<<<<] Sets Ascii cells to 65 ('A')
>>>.<.<                               Prints first "A" and moves to Line loop
  [->>>+>+                            Increment Repeated Ascii cell in outer loop
      [-<<.+>.>>+<]>                  Increment Growing Ascii cell in inner loop,
                                         Prints both Ascii cells and Sets Loop 2
      [-<+<<->>>]                     Resets Growing cell and Loop 1
  <<<<.<]                             Prints newline and moves to next Line
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 81 bytes
```
+++[[->++<<+>]>]<<,<[----<<+>>]<+<+.<+<--.>[>+>>+[-<.+<.>>>+<]>[-<+<->>]<<<<<.>-]
```
[Try it online!](https://tio.run/##FYpBCsRQDEIPZJMTiBcJWbSFQhmYRaHnT/0uxKcez37/r/f8zQCoCgEk1GpyY4W12AgibRGpkhtUMMGUI1smj@u4lIqe@QA "brainfuck – Try It Online")
Prints in lowercase
### Explanation:
```
+++[[->++<<+>]>]  Sets up the tape as 3*2^n (3,6,12,24,48,96,192,128)
<<,               Removes excess 128
<[----<<+>>]      Adds 196/4 to 48 resulting in 96
<+<+.             Add 1 to both 96s and print A
<+<--.            Add 1 to 25, subtract 2 from 12 to print a newline
                  Tape: 3 6 10 25 96 96 0 0
>[ Start loop
   >+>>+          Add one to the unchanging ASCII and the inner loop counter
   [-<.+<.>>>+<]  Print row while preserving counter
   >[-<+<->>]     Undo changes to changing ASCII and return inner loop counter to its cell
   <<<<<.>-       Print newline and decrement loop counter
]
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 88 bytes
```
++++++++[->+++>+>++++++++>++++++++<<<<]>+>++>+.<.<[->>+>>+[-<+.<.>>>+<]>[-<+<->>]<<<<.<]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwqide2ApJ22HUwAzrABgliwhJ22no2eDVAlkGcH1GED4tsBmUB5EM8GKBMLUq5nE/v/PwA "brainfuck – Try It Online")
should run on all brainfuck interpreters. No wrapping or negative values, no undefined input behaviour, values between 0 and 90.
**How it works**
```
Initialize tape: 25(row count) 10(lf) 64(row letter) 64(col letter) 0(col count) 0(temp)
++++++++[->+++>+>++++++++>++++++++<<<<]>+>++ 
>+.<.            print "A" and lf
<[               for each letter count
  -                decrement letter count
  >>+              increment row letter
  >>+              increment col count
  [                do col count times
    -                decrement col count
    <+.              increment and print col letter
    <.               print row letter
    >>>+             move col count to temp
    <                return to colcount
  ]
  >[-<+<->>]       move value from temp back to col count and set col letter back to "A" minus 1
  <<<<.            print lf
  <                return to row count
]
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~39~~ 38 bytes
*@DomHastings shaved off a byte*
```
say$.=A;say map$_.$.,A..$.++while$.!~Z
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJFz9bRGkgr5CYWqMTrqejpOOoBSW3t8ozMnFQVPcW6qP///@UXlGTm5xX/1/U11TMwNAAA "Perl 5 – Try It Online")
[Answer]
# Deadfish~, 4152 bytes
```
{i}cc{iiiii}iiiiic{ddddd}dddddc{iiiii}iiiiicic{ddddd}ddddddc{iiiii}iiiiiciicdcic{dddddd}iiic{iiiii}iiiiiciiicddciicdcic{dddddd}iic{iiiii}iiiiiciiiicdddciiicddciicdcic{dddddd}ic{iiiii}iiiiiciiiiicddddciiiicdddciiicddciicdcic{dddddd}c{iiiii}iiiiiciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}dc{iiiii}iiiiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}ddc{iiiii}iiiiic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}dddc{iiiii}iiiiic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}ddddc{iiiii}iiiiic{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}dddddc{iiiii}iiiiic{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{dddddd}ddddddc{iiiii}iiiiic{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}iiic{iiiii}iiiiic{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}iic{iiiii}iiiiic{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}ic{iiiii}iiiiic{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}c{iiiii}iiiiic{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}dc{iiiii}iiiiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}ddc{iiiii}iiiiic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}dddc{iiiii}iiiiic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}ddddc{iiiii}iiiiic{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}dddddc{iiiii}iiiiic{ii}ic{dd}c{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}iii}ddddddc{iiiii}iiiiic{ii}iic{dd}dc{ii}ic{dd}c{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}ii}iiic{iiiii}iiiiic{ii}iiic{dd}ddc{ii}iic{dd}dc{ii}ic{dd}c{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}ii}iic{iiiii}iiiiic{ii}iiiic{dd}dddc{ii}iiic{dd}ddc{ii}iic{dd}dc{ii}ic{dd}c{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}ii}ic{iiiii}iiiiic{ii}iiiiic{dd}ddddc{ii}iiiic{dd}dddc{ii}iiic{dd}ddc{ii}iic{dd}dc{ii}ic{dd}c{ii}c{dd}ic{ii}dc{dd}iic{ii}ddc{dd}iiic{ii}dddc{d}ddddddc{i}iiiiiic{d}dddddc{i}iiiiic{d}ddddc{i}iiiic{d}dddc{i}iiic{d}ddc{i}iic{d}dc{i}ic{d}c{i}c{d}ic{i}dc{d}iic{i}ddc{d}iiic{i}dddcddddddciiiiiicdddddciiiiicddddciiiicdddciiicddciicdcic{{d}ii}c
```
[Try it online!](https://tio.run/##7ZZLDoMwDERP1ENVmVbNusvIZ0@JkyDAg/pR@cOCBZ7YM08EgtsVd/98XGIMXpwLPl2idxeQLtF7v9KvDYveoVVAtFO/3ghgZUaVZBiTW7XK8W4hWZcX4osmg8QNuqRFp80PPVnTpip/nEBG5AnTTLPjdML0c@3gVJc5HRAL6gGzuclN7P4L5Vl55ZbzxWwVX1iNS2qyusRKXXPTrWtsJYfZRLlp6OyxzUaj2dI3RPYXlWUtUXcenCTPUQ8FgVDQ36UcFggjkpHg0HjYcaX6qmfkk1QhRUFVUjjJjZLj4FpyOFl@zNLF@AI "Deadfish~ – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ØA;\;€Ṫ$€YFḊ
```
**[Try it online!](https://tio.run/##y0rNyan8///wDEfrGOtHTWse7lylAqQi3R7u6Pr/HwA "Jelly – Try It Online")**
Bah just got `ØAjṪ$ƤżØAY` which is a step between this and the already posted solution of Dennis :/
[Answer]
# [Pyth](https://pyth.readthedocs.io), 13 bytes
```
+\ajmPjedd._G
```
[Try it here!](https://pyth.herokuapp.com/?code=%2B%5CajmPjedd._G&debug=0), [Alternative](https://pyth.herokuapp.com/?code=jm%2BjedPded._G&debug=0)
That leading `a` though...
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
ØA¹Ƥ+"¹Ṗ€Yṭ”A
```
[Try it online!](https://tio.run/##ASIA3f9qZWxsef//w5hBwrnGpCsiwrnhuZbigqxZ4bmt4oCdQf// "Jelly – Try It Online")
# Explanation
```
ØA¹Ƥ+"¹Ṗ€Yṭ”A  Main Link
ØA              Uppercase Alphabet
  ¹Ƥ            Prefixes
    +"¹         Doubly-vectorized addition to identity (uppercase alphabet) (gives lists of lists of strings)
       Ṗ€      a[:-1] of each (get rid of the double letters at the end)
         Y     Join on newlines
          ṭ”A  "A" + the result
```
partially abuses the way strings and character lists differ in Jelly
[Answer]
# [Python 2](https://docs.python.org/2/), ~~92~~ ~~86~~ ~~79~~ ~~75~~ 64 bytes
```
s=map(chr,range(65,91))
for d in s:print d.join(s[:ord(d)-65])+d
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9g2N7FAIzmjSKcoMS89VcPMVMfSUFOTKy2/SCFFITNPodiqoCgzr0QhRS8rPzNPozjaKr8oRSNFU9fMNFZTO@X/fwA "Python 2 – Try It Online")
11 bytes thx to Rod.
[Answer]
# APL+WIN, 51 bytes
```
⍎∊'a←⎕av[65+⍳26]⋄a[n←1]',25⍴⊂'⋄,⊃a[⍳n-1],¨a[n←n+1]'
```
Explanation:
```
a←⎕av[65+⍳26] create a vector of upper case letters
a[n←1] first A
25⍴⊂'⋄,⊃a[⍳n-1],¨a[n←n+1]' create an implicit loop to concatenate subsequent letters
```
]