[Question]
  [
You are to print this exact text:
```
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A
```
# Specs
* Extra trailing newlines are allowed at the end of the output.
* Extra trailing spaces (U+0020) are allowed at the end of each line, including the extra trailing newlines.
* You can use all lowercase instead of all uppercase, but you cannot print partially lowercase partially uppercase.
* You can return the text as a function output instead of printing it in a full program.
# Scoring
Since this is a triangle, and a triangle has 3 sides, and 3 is a small number, your code should be small in terms of byte-count.
  
[Answer]
# Vim, 37 bytes
```
:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ
```
[![enter image description here](https://i.stack.imgur.com/pM4Ku.gif)](https://i.stack.imgur.com/pM4Ku.gif)
## Legend
```
↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape
```
[Answer]
# Logo, ~~232 207 196~~ 190 bytes
## Did somebody say triangles?
Get out your compass and protractor, and let's do this the graphical way. The geometry uses an equilateral triangle to align the results. I previously had an isosceles triangle, but it involved too many decimal places. This change also compacted the output, reducing the amount of screen prep and font changing I had to do.
I used the [Calormen online interpreter](http://www.calormen.com/jslogo/#) to flesh this one out. If you don't have enough screen real estate, it's going to wrap, but you can also fiddle with some numbers to take care of that. I used the "F11" full-screen mode on my browser.
```
ht
pu
to r:n:b:l repeat:n[rt:b label char 90-:n lt:b fd:l] end
to t:s
fd 12 rt 120 bk 6
repeat 2[r:s 90 12]
repeat 2[rt 120 r:s 90-heading 24]
end
rt 90 label "Z lt 210
repeat 25[t repcount]
```
The `r` procedure draws a line of `n` characters. The character is determined automatically depending on how many segments it is told to use. The `b` parameter tells it how much to temporarily rotate so that the letters are pointing in the right direction. The `l` parameter determines the linear distance between letters.
The `t` procedure steps to the next position and calls the `r` function a four times to create a triangle, rotating when appropriate. I called it twice for the vertical side because that took fewer bytes than calling it once with special handling. The end of the procedure positions the turtle for start of the next triangle, one step above.
`Z` is a special case, so we just print it directly and rotate as if we had just finished a triangle. Finally, `t` is called 25 times.
[![In progress annotated picture](https://i.stack.imgur.com/xvU9F.png)](https://i.stack.imgur.com/xvU9F.png)[![Finished result](https://i.stack.imgur.com/gBWWD.png)](https://i.stack.imgur.com/gBWWD.png)
[Answer]
## Haskell, 58 bytes
```
f x=init x++reverse x
t=unlines$f[f['A'..c]|c<-['A'..'Z']]
```
Defines a function `t` that returns the output as a string.
```
f x=               define a helper function
init x             take the argument minus its last element
++                 and concatenate it with
reverse x          the argument reversed, producing ex. [a,b,c,b,a] from [a,b,c]
t=                                    define the main function
           [         |c<-['A'..'Z']]  for every char c from 'A' to 'Z'...
             ['A'..c]                 generate the range from 'A' to c
            f                         call the helper function to "reflect" it
          f                           call the helper function on the entire list
  unlines$                            join on newlines
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~16~~ 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ṗ;Ṛ
ØAḣJÇ€Çj⁷
```
*Thanks to @LeakyNun for golfing off 3 bytes!*
[Try it online!](http://jelly.tryitonline.net/#code=4bmWO-G5mgrDmEHhuKNKw4figqzDh2rigbc&input=)
### How it works
```
Ṗ;Ṛ        Helper link. Argument: A (array)
Ṗ          Pop; yield A without its last element.
  Ṛ        Reversed; yield A with inverted order.
 ;         Concatenate the results to both sides.
ØAḣJÇ€Çj⁷  Main link. No arguments.
ØA         Alphabet; set link argument and return value to "A...Z".
   J       Indices; yield [1, ..., 26].
  ḣ        Head; take the first, the first two, etc. elements of the alphabet.
           This yields ["A", AB", ..., "A...Z"].
    Ç€     Apply the helper link to each string.
      Ç    Apply the helper link to the array itself.
       j⁷  Join, separating by linefeeds.
```
[Answer]
## Python, 74 bytes
```
def f(x=66,s='A'):
 t=s+s[-2::-1];print t
 if x<91:f(x+1,s+chr(x));print t
```
A Python 2 function that prints and takes no arguments. The key idea is to generate the triangular there-and-back pattern with recursion. First consider this simpler function that prints the letters 'A' up to 'Z' and down back to 'A':
```
def f(x=65):
 t=chr(x);print t
 if x<90:f(x+1);print t 
```
The function first prints "A" (char-code 65), then recurses to print "B" (66) and so on to "Z" (90). From there, it stops recursing. On the way popping back down the recursive stack, it prints whatever character `t` it printed at the same layer, from "Y" back to "A".
The main code does the same, except it accumulates into `s` the string of letters so far, and prints the up-and-down string `s+s[-2::-1]`.
Thanks to xsot for 2 bytes.
In Python 3, the same thing is a byte shorter (73 bytes) by putting everything on one line.
```
def f(x=66,s='A'):t=s+s[-2::-1];print(t);x>90or[f(x+1,s+chr(x)),print(t)]
```
[Answer]
# brainfuck, ~~1733~~ ~~121~~ 119 bytes
```
----[---->+<]>++.<++++++++++.<+++++[<+++++>-]<+>>>.<[>>[>.]<[>+>+<<-]>+.>[<<+> >-]<[<.]<-]>>[>[>]<[-]<[<]>>[.>]<<[.<]>]
```
Slightly more readable version:
```
----[---->+<]>++.<
++++++++++.<
+++++[<+++++>-]<+
>>
>.<
[
  >>[>.]<
  [>+>+<<-]
  >+.>
  [<<+>>-]
  <[<.]<
  -
]
>>
[
  >[>]<
  [-]
  <[<]>
  >[.>]<<[.<]>
]
```
Explanation possibly to come.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~20 13 12~~ 6 bytes
Saved 2 bytes thanks to Adnan.  
Saved 6 bytes thanks to *Magic Octopus Urn* and some new language functionality.
```
Aη€ûû»
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f8dz2R01rDu8@vPvQ7v//AQ "05AB1E – Try It Online")
**Explanation**
```
Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines
```
[Answer]
# Python 3, 97 bytes
```
s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
a=[s[:x]+s[x::-1]for x in range(26)]
print('\n'.join(a+a[24::-1]))
```
[Ideone it!](http://ideone.com/D2L9xU)
[Answer]
# J, ~~26~~ ~~23~~ 22 bytes
```
f(f=:,1}.|.)\u:65+i.26
```
## Explanation
```
,1}.|.  Monad f: Input: A
    |.  Reverse the items in A
 1}.    Drop the first item in the reversed A
,       Join A and the previous
f(f=:,1}.|.)\u:65+i.26
                  i.26  Create the range [0, 1, ..., 25]
               65+      Add 65 to each
             u:         Convert to characters to get 'A..Z'
  f=:,1}.|.             Define a verb f
 (         )\           Call f monadically on each prefix of 'A..Z'
f                       Call f again on that result
```
[Answer]
# Ruby, 71 bytes
[Try it on repl.it](https://repl.it/Civw)
```
s=*?A..?Y
s+=[?Z]+s.reverse
puts s.map{|e|k=[*?A...e]*'';k+e+k.reverse}
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 60 bytes
```
1"AA"1[v
?v:1-:}>:5d*=
o>l  ?!v
{$-}:1[\ao]{:}+::"@Z"@=?;=2*
```
[Try it online!](http://fish.tryitonline.net/#code=MSJBQSIxW3YKP3Y6MS06fT46NWQqPQpvPmwgID8hdgp7JC19OjFbXGFvXXs6fSs6OiJAWiJAPT87PTIq&input=)
[Answer]
# C, ~~272~~ ~~247~~ ~~234~~ ~~230~~ ~~144~~ 137 bytes:
(*Saved many bytes (`272 -> 230`) in my previous method thanks to great golfing tips & tricks from [sigalor](https://codegolf.stackexchange.com/users/41463/sigalor)!*)
(*Saved nearly 100 bytes (`230 -> 144`) by switching to a better method.*)
```
main(q,i,e,x){for(q=0;q<51;q++){i=q>25 ? 25-(q-25):q;for(e=65;e<66+i;e++)printf("%c",e);for(x=64+i;x>64;x--)printf("%c",x);printf("\n");}}
```
My first answer ever in `C`. I just started self-learning it recently, so let's see how it goes.
[C it in Action! (Ideone)](https://ideone.com/9mlbQk)
[Answer]
# JavaScript (ES6), 81 bytes
```
[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)
```
[Answer]
# Mathematica 59 bytes
```
Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]
```
[Answer]
## Dyalog APL, 18 bytes
```
↑(⊣,⌽)(⊣,1↓⌽)¨,\⎕a
```
[Answer]
# R, ~~63 61~~ 59 bytes
```
for(i in c(1:26,25:1))cat(LETTERS[c(1:i,i:1-1)],"
",sep="")
```
Helpfully `LETTTERS[0]` doesn't return any characters.
Edit: lost one thanks to @leakynun
Edit: two more thanks to @plannapus
[Answer]
# (plain) TeX, 209 bytes
```
\newcount~~65\newcount\j\j64\tt\def\a#1{{\loop\advance\j1\char\j\ifnum\j<#1\repeat\loop\advance\j-1\char\j\ifnum\j>65\repeat}\par}\def\c#1#2#3.{\loop\advance~#11\a~\ifnum~#2#3\repeat}A\par\c{}<90.\c->66.A\bye
```
Output:
[![](https://i.stack.imgur.com/il32X.png)](https://i.stack.imgur.com/il32X.png)
[Answer]
# TSQL, 159 bytes
```
DECLARE @ varchar(52)='ABCDEFGHIJKLMNOPQRSTUVWXY',@o varchar(max)SELECT @+='Z'+REVERSE(@)+'
',@o=@
WHILE''<@
SELECT @=STUFF(@,LEN(@)/2,2,''),@o=@+@o+@
PRINT @o
```
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/520605/alphabet-triangle)**
[Answer]
# Javascript(using external library-Enumerable), 135 bytes
```
_.Range(1,51).WriteLine(x=>(g=_.Range(65,x>25?52-x:x)).Write("",y=>(w=String.fromCharCode)(y))+(g.Reverse().Skip(1).Write("",y=>w(y))))
```
Link to the library: <https://github.com/mvegh1/Enumerable>
Code explanation: Create a range of ints starting at 1, for a count of 51. For each, write a line according to complex pred. Do some JS wizardry with global variables and caching...and voila. For each int in WriteLine, we are creating the left hand range of ints and storing into global "g", and String Joining (Write) with `""` delimiter and mapping each int to the String mapping to the int char code. Then, we concat the right hand side by taking the reversal of that sequence (and skipping the first element because that will match the last element of the original order...), writing with the same logic. EDIT: Updated the internals of Write in the library. An empty sequence will write an empty string instead of null now. This also shaved 15 bytes off the answer
[![enter image description here](https://i.stack.imgur.com/YTF0i.png)](https://i.stack.imgur.com/YTF0i.png)
[Answer]
# Powershell, 61 52 bytes
Thanks to TimmyD for saving 9 bytes!
```
65..90+89..65|%{-join[char[]]((65..$_-ne$_)+$_..65)}
```
Loops through ASCII values for capital letters forwards, then backwards.
For each number, this creates an array of the first X numbers, removes the X-1st number, then adds the reverse of the first X numbers, which is all then cast to chars and joined into a string.
[Answer]
# Python 2, 117 111 105 100 bytes
```
s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"*2
for i in range(51):print(s[:-i-1]+s[-i-3::-1],s[:i]+s[i::-1])[26>i]
```
[Run it](https://ideone.com/QiWRUJ)
Thanks to @**LeakyNun** and @**manatwork** for pointing out a few byte saves.
**Non-Golfed:**
```
import string
def print_alphatriangle(n):
    offset = 1
    tail_offset = 3
    alpha = string.ascii_uppercase * n
    for i in range(len(alpha) - offset):
        if len(alpha) / 2 > i:
            print alpha[:i] + alpha[i::-offset]
            continue
        print alpha[:-i-offset] + alpha[-i-tail_offset::-offset]
```
This method works simply by string splicing an *alphabet* string that is concatenated together. Depending on whether `i` has reached a mid-way point of the string, it then starts to print out decreasing strings.
[Answer]
# [Cheddar](https://github.com/cheddar-lang/Cheddar), ~~102~~ ~~96~~ ~~79~~ ~~69~~ 67 bytes
**17 bytes thanks to Downgoat, and inspiration for 10 more.**
```
"A"+(2@"27+@"(25|>1)).bytes.map(i->65@"(64+i)+@"((64+i)|>65)).vfuse
```
The fact that strings can concatenate but not arrays means that I would have to convert the two ranges to strings, concatenate, and then convert back to arrays.
Also, the fact that `vfuse` produces a leading newliens means that I would need to generate the first line manually and then concat to the rest.
`@"` as a dyad (two-argument function) can convert to string directly, but does not work for reversed range (if first argument is bigger than the second).
Range was half-inclusive. After the bug-fix it became inclusive.
## Usage
```
cheddar> "A"+(2@"27+@"(25|>1)).bytes.map(i->(65@"(64+i)+@"((64+i)|>65))).vfuse
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A"
```
### Cheddar, 55 bytes (non-competing)
In [the latest version](https://github.com/cheddar-lang/Cheddar/releases/tag/v1.0.0-beta.29) with all the fixes, the answer is:
```
(|>25+24|>0).map(i->65@"(65+i)+(i?(64+i)@"65:"")).vfuse
```
but it was made after the challenge.
[Answer]
# C, 93 bytes
Call `f()` without arguments.
```
g(l,n){putchar(l);n?g(l+1,--n),putchar(l):0;}f(n){for(n=-26;++n<26;puts(""))g(65,25-abs(n));}
```
[Try it on ideone](http://ideone.com/xGbRYw).
[Answer]
# Mathematica ~~98 96~~ 92 bytes
There has to be a shorter way, even in Mathematica.
6 bytes saved thanks to Martin Ender.
```
r=Reverse@*Most; Print/@FromCharacterCode@Join[t=Join[s=Range[65,64+k],r@s]~Table~{k,26},r@t]
```
[Answer]
## VBA, 94 bytes
```
Function T:For j=-25To 25:k=25-Abs(j):For i=-k To k:T=T &Chr(65+k-Abs(i)):Next:T=T &vbLf:Next
```
Call in Immediate window with ?T
Just to explain what's going on: I use Abs function twice, to reflect both the alphabet traverse and the line length. It's well suited to the task because of the single extreme value in both cases, which corresponds to the zero crossing of the pre-Abs variable.
As a simple set of commands in VBA Immediate window, rather than a program or function, the following would need 72 bytes:
```
For j=-25To 25:k=25-Abs(j):For i=-k To k:?Chr(65+k-Abs(i));:Next:?:Next
```
*(with thanks to @GuitarPicker)*
[Answer]
## Python, ~~73~~ 71 bytes
*Thanks to @xnor for the recursion*
```
f=lambda x=66,s='A',t='':x/92*t or t+f(x+1,s+chr(x),s+s[-2::-1]+"\n")+t
```
---
### Explanation
* **Parameters**:
	+ `x` is the ascii value of the next letter in the alphabet
	+ `s` is an accumulator for the alphabet
	+ `t` is a line in the triangle (ie `s` + `s backwards`)
* **Return**: `t` if the alphabet is done (ie we're at the center)
* **Else**: `t+f(...)+t` with:
	+ `x` incremented
	+ `s` appended with the next letter
	+ `t` reset to `s` + `s backwards` + `\n`
---
**Update**
* **-2** [16-08-05] Remove leading `\n` (+1) and shortened conditional (-3) all thanks to *@xnor*
[Answer]
# HTML + CSS, 884 characters
(763 characters HTML + 121 characters CSS)
Just expanding [Leaky Nun](https://codegolf.stackexchange.com/users/48934/leaky-nun)'s [comment](https://codegolf.stackexchange.com/questions/87496/alphabet-triangle/88834?noredirect=1#comment216336_88735) on [MonkeyZeus](https://codegolf.stackexchange.com/users/32018/monkeyzeus)'s [answer](https://codegolf.stackexchange.com/a/88735). (Though I might misread the comment…)
```
p{margin:0}p:before{content:"ABCDEFGH"}p:after{content:"HGFEDCBA"}a:before{content:"IJKLMNOP"}a:after{content:"PONMLKJI"}
```
```
<pre>A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
<p>I</p><p>IJI</p><p>IJKJI</p><p>IJKLKJI</p><p>IJKLMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNOPONMLKJI</p><p><a>Q</p><p><a>QRQ</p><p><a>QRSRQ</p><p><a>QRSTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXYZYXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTSRQ</p><p><a>QRSRQ</p><p><a>QRQ</p><p><a>Q</a></p><p>IJKLMNOPONMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMLKJI</p><p>IJKLKJI</p><p>IJKJI</p><p>IJI</p><p>I</p>ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~37~~ 29 bytes
**Credits to Fatalize for his assistance throughout.**
**4 bytes thanks to Fatalize, and inspiration for another 4 bytes.**
```
@A:1&e:"a"yr:1&cw@Nw\
:Lc.r.!
```
[Try it online!](http://brachylog.tryitonline.net/#code=QEE6MSZlOiJhInlyOjEmY3dATndcCjpMYy5yLiE&input=)
### Predicate 0 (Main predicate)
```
@A:1&e:"a"yr:1&cw@Nw\
@A:1&                  Apply predicate 1 to @A, which is
                       basically "abcdefghijklmnopqrstuvwxyz"
     e                 Choose one element from the result (choice point)
      :"a"yr               generate substring from element to "a"
            :1&            apply predicate 1
               c           concatenate
                w          write to STDOUT
                 @Nw       write "\n" to STDOUT
                    \  Backtrack to last choice point to choose
                       another element until there is no more
                       choice left, then halt.
```
### Predicate 1 (Auxiliary predicate)
This basically builds a palindrome from the given string.
```
:Lc.r.!
:Lc.     output is [input:L]
   .r.   output reversed is still output
      !  stop searching after the first output
```
[Answer]
# R, ~~127~~ 125 bytes
```
k=cat;L=LETTERS;for(i in 1:26)k(c(L[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))
```
Not completely satisfied with this solution, especially the two `for` loops, but couldn't come with something better !  
`LETTERS` contains the uppercase letters.
**Ungolfed :**
```
for(i in 1:26){
  cat(c(LETTERS[1:i],LETTERS[(i-1):0],"\n"))
               }
for(i in 1:26){
  cat(c(LETTERS[0:(26-i)],LETTERS[ifelse((25-i)>=0,25-i,0):0],"\n"))
               }
```
`ifelse` is a shorter way for unsing `if... else...` and works this way : `ifelse(condition,action if TRUE, action if FALSE)`
An other 125 bytes' solution :
```
for(i in 1:26)(k=cat)(c((L=LETTERS)[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))
```
[Answer]
## Java 131 bytes
**Without using String (131 bytes)**
```
public static void main(String[] args) {
    for(int i = 0 ,k=1; i>-1; i+=k){
        for(int c= 65, d = 1; c>64;){
            d = d>-1 & c < 65+i?1:-1;
            System.out.print((char)c+((c+=d)<65?"\n":""));
        }
        k = k>-1 & i < 25?1:-1;
    }
}
```
**Codegolfed**
```
for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));
```
---
**With String(173 bytes)**
```
String a="abcdefghijklmnopqrstuvwxyz";
for(int i = 1 ,k=1; i>0; i+=k==1?1:-1){
    System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i));
    k = k>-1 & i < 26?1:-1;
}
```
**Codegolfed**
```
String a="abcdefghijklmnopqrstuvwxyz";for(int i=1,k=1;i>0;k=k>-1&i<26?1:-1,System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i)),i+=k==1?1:-1);
```
---
**Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) and [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)**
]