text:
HexaRegex: A Tribute to Martin Ender
Martin Ender recently hit 100K, and has come up with some pretty awesome languages.  We're going to have a bit of fun with one of them, Hexagony (and a bit of regex for Retina)
As a brief overview, you need to write a program that inputs a Hexagony grid and determines if there is a path on that grid that matches a string of text
Generating
Hexagony generates hexagons from a string of text using the following steps:

Calculate the minimum hexagon size (take the length of the string and round up to the nearest hex number)
Wrapping the text into a hexagon of the above size
Filling the remaining locations with ..

For example, the string of text abcdefghijklm requires a hexagon of side-length 3, and therefore becomes:
   a b c
  d e f g
 h i j k l
  m . . .
   . . .

Now, notice that there are 6 possible directions you can travel in a hexagon.  For example, in the above hexagon, e is adjacent to abfjid.
Wrapping
Furthermore, in Hexagony, hexagons wrap:
   . . . .          . a . .          . . f .          . a . .
  a b c d e        . . b . .        . . g . .        . b . . f
 . . . . . .      g . . c . .      . . h . . a      . c . . g .
. . . . . . .    . h . . d . .    . . u . . b .    . d . . h . .
 f g h i j k      . i . . e .      . j . . c .      e . . i . .
  . . . . .        . j . . f        k . . d .        . . j . .
   . . . .          . k . .          . . e .          . k . .

If you look at the 2nd and 4th example, notice how a and k are in the same spots, despite the fact that you are wrapping in different directions.  Due to this fact, these spots are only adjacent to 5 other locations.
To make this clearer:
   a b c d
  e f g h i
 j k l m n o
p q r s t u v
 w x y z A B
  C D E F G
   H I J K

Edges wrap to their opposite neighbor (b->I and G->j).
Top/bottom corners wrap to the opposite center corner and up/down (d->K,p and H->a,v).
Center corners wrap to both the top and bottom corners (v->a,H)

Paths
A path to be a sequence of adjacent locations without returning to the same location.
   a b c
  d e f g
 h i f k l
  m . . .
   . . .

In the above hexagon, aefkgm is a valid path.  However, abfd is not a valid path (f and d aren't adjacent), and abea isn't valid (returns to the a location).
We can use these paths to match text (like regex).  An alpha-numeric character matches itself (and only itself), and a . matches any character.  For example, the path aej..lgm would match aej..lgm, aejAAlgm, aeja.lgm, or aej^%gm.
Input/Output
Your program should take two strings (in any order). The first string will be nonempty, and consist of only alphanumeric characters [a-zA-Z0-9]. This will represent the hexagon you are operating on.  The second string will consist of printable characters.
You need to return a truthy value iff there is a path in the hexagon that matches the string of text given, otherwise a falsy value.
Test cases
Truthy:
"a","a"
"ab","a"
"ab","b"
"ab","ba"
"ab","aba"
"ab","&"
"ab","#7.J!"
"ab","aaaaaa"
"ab","bgjneta"
"ab","cebtmaa"
"abcdefg","dfabcg"
"AbCDeFG","GCbAeFD"
"aaaabbb","aaababb"
"abcdefghijklmnopqrs","alq"
"abcdefghijklmnopqrs","aqnmiedh"
"abcdefghijklmnopqrs","adhcgkorbefjimnqlps"
"11122233344455","12341345123245"
"abcdefgh","h%a"
"abcdefghijklm","a)(@#.*b"
"abcdefghijklm","a)(@#.*i"
"abcdefghij","ja"
"abcdefghijklmno","kgfeia"
"abcdefghijklmno","mmmmmiea"
"abcdefghijklmno","mmmmmlae"
"abcdefghijklmno","ja"
"abcdefghijklmnopqrs","eijfbadhmnokgcsrql"

Falsy:
"a","b"
"a","%"
"a","."
"a","aa"
"a","a."
"ab","#7.J!*"
"ab","aaaaaaa"
"ab","aaaabaaa"
"ab","123456"
"abcdefg","bfgedac"
"abcdefg","gecafdb"
"abcdefg","GCbaeFD"
"aaaabbb","aaaaabb"
"abcdefghijklmnopqrs","aqrcgf"
"abcdefghijklmnopqrs","adhlcgknbeifjm"
"abcdefghijklmnopqrs","ja"
"abcdefghijklm","a)(@#.*&"
"abcdefghijklmno","a)(@bfeijk"
"abcdefghijklmno","kgfeic"
"abcdefghijklmno","mmmmmmiea"

This is a code-golf, so make your answers as short as possible in your favorite language.

Somebody should do this in Hexagony. :D

hexAGONY xD have fun

@DrGreenEggsandIronMan I was going to suggest Retina also, but that's probably pretty trivial. :P

Related: http://codegolf.stackexchange.com/q/66708/29750

I was initially very confused by the truthy examples until I realized that the hexagon is the source of the regex(es), so to speak, not the second string. Which is still mind-bending... :P

Apparently, I made this challenge too difficult, as I haven't gotten any answers yet (and to think that I was considering allowing any regex symbol in the hexagon)

@DrGreenEggsandIronMan I'll offer a 500-rep bounty if someone does do this in Hexagony.

('abcdefghijklm', 'h%a'):  h only connects to the bottom right corner, which doesn't connect to a.  ('abcdefghijklmno', 'ja') : j is completely entrapped.

As for kgfeia, I already had it in the truthy, but forgot to change it.  You were correct about side-to-side wrapping.  When I initially wrote the spec, I thought they wrapped.

You don't need to use h or j, there are .s at the bottom you can get to a from

oooh, I didn't think about that.  Good catch.

I guess you should also change your example to a hexagon that's completely filled in as well (it has dots that make the path valid)

@Blue An example of an unfilled hexagon is important.  More importantly, I've made the distinction between a "path" and a "regex".

Retina, 744 bytes
Sorry folks, no Hexagony this time...
Byte count assumes ISO 8859-1 encoding.
.+¶
$.'$*_¶$&
^_¶
¶
((^_|\2_)*)_\1{5}_+
$2_
^_*
$.&$*×_$&$&$.&$*×
M!&m`(?<=(?=×*(_)+)\A.*)(?<-1>.)+(?(1)!)|^.*$
O$`(_)|.(?=.*$)
$1
G-2`
T`d`À-É
m`\A(\D*)(?(_)\D*¶.|(.)\D*¶\2)((.)(?<=(?<4>_)\D+)?((?<=(?<1>\1.)\4\D*)|(?<=(?<1>\D*)\4(?<=\1)\D*)|(?<=\1(.(.)*¶\D*))((?<=(?<1>\D*)\4(?>(?<-7>.)*)¶.*\6)|(?<=(?<1>\D*)(?=\4)(?>(?<-7>.)+)¶.*\6))|(?<=(×)*¶.*)((?<=(?<1>\1.(?>(?<-9>¶.*)*))^\4\D*)|(?<=(?<1>\D*)\4(?>(?<-9>¶.*)*)(?<=\1)^\D*)|(?<=(?<1>\1\b.*(?(9)!)(?<-9>¶.*)*)\4×*¶\D*)|(?<=(?<1>\D*\b)\4.*(?(9)!)(?<-9>¶.*)*(?<=\1.)\b\D*))|(?<=(?<1>\1.(?>(?<-11>.)*)¶.*)\4(.)*¶\D*)|(?<=(?<1>\1(?>(?<-12>.)*)¶.*)\4(.)*¶\D*)|(?<=(?<1>\1.(?>(?<-13>.)*¶\D*))\4(\w)*\W+.+)|(?<=(?<1>.*)\4(?>(?<-14>.)*¶\D*)(?<=\1.)(\w)*\W+.+))(?<=\1(\D*).+)(?<!\1\15.*(?<-1>.)+))*\Z

Expects the target string on the first line and the hexagon on the second line of the input. Prints 0 or 1 accordingly.
Try it online! (The first line enables a test suite, where each line is a test case, using ¦ for separation instead of a linefeed.)
The proper way to solve this challenge is with a regex of course. ;) And if it wasn't for the fact that this challenge also involves the unfolding procedure of the hexagon, this answer would actually consist of nothing but a single ~600-byte long regex.
This isn't quite optimally golfed yet, but I'm quite happy with the result (my first working version, after removing named groups and other stuff required for sanity, was around 1000 bytes). I think I could save about 10 bytes by swapping the order of the string and the hexagon but it would require a complete rewrite of the regex at the end, which I'm not feeling up to right now. There's also a 2-byte saving by omitting the G stage, but it slows down the solution considerably, so I'll wait with making that change until I'm sure I've golfed this as well as I can.
Explanation
The main part of this solution makes extensive use of balancing groups, so I recommend reading up on them, if you want to understand how this works in detail (I won't blame you if you don't...).
The first part of the solution (i.e. everything except the last two lines) is a modified version of my answer to Unfolding the Hexagony source code. It constructs the hexagon, while leaving the target string untouched (and it actually constructs the hexagon before the target string). I've made some changes to the previous code to save bytes:

The background character is × instead of a space so that it doesn't conflict with potential spaces in the input.
The no-op/wildcard character is _ instead ., so that grid cells can be reliably identified as word characters.
I don't insert any spaces or indentation after the hexagon is first constructed. That gives me a slanted hexagon, but that is actually much more convenient to work with and the adjacency rules are fairly simple.

Here is an example. For the following test case:
ja
abcdefghij

We get:
××abc
×defg
hij__
____×
___××
ja

Compare this with the usual layout of the hexagon:
  a b c
 d e f g
h i j _ _
 _ _ _ _
  _ _ _

We can see that the neighbours are now all of the usual 8 Moore-neighbours, except the north-west and south-east neighbours. So we need to check horizontal, vertical and south-west/north-east adjacency (well and then there are the wrapping edges). Using this more compact layout also has the bonus that we'll be able to use those ×× at the end to determine the size of the hexagon on the fly when we need it.
After this form has been constructed, we make one more change to the entire string:
T`d`À-É

This replaces the digits with the extended ASCII letters
ÀÁÂÃÄÅÆÇÈÉ

Since they are replaced both in the hexagon and in the target string this won't affect whether the string is matched or not. Also, since they are letters \w and \b still identify them as hexagon cells. The benefit of doing this substitution is that we can now use \D in the upcoming regex to match any character (specifically, linefeeds as well as non-linefeed characters). We can't use the s option to accomplish that, because we'll need . to match non-linefeed characters in several places.
Now the last bit: determining whether any path matches our given string. This is done with a single monstrous regex. You might ask yourself why?!?! Well, this is fundamentally a backtracking problem: you start somewhere and attempt a path as long as it matches the string, and once it doesn't you backtrack and try a different neighbour from the last character that worked. The one thing that you get for free when working with regex is backtracking. That's literally the only thing the regex engine does. So if we just find a way to describe a valid path (which is tricky enough for this kind of problem, but definitely possible with balancing groups), then the regex engine will sort out finding that path among all possible ones for us. It would certainly be possible to implement the search manually with multiple stages (and I've done so in the past), but I doubt it would be shorter in this particular case.
One issue with implementing this with a regex is that we can't arbitrarily weave the regex engine's cursor back and forth through the string during backtracking (which we'd need since the path might go up or down). So instead, we keep track of our own "cursor" in a capturing group and update that at every step (we can move to the position of the cursor temporarily with a lookaround). This also enables us to store all past positions which we'll use to check that we haven't visited the current position before.
So let's get to it. Here is a slightly saner version of the regex, with named groups, indentation, less random order of neighbours and some comments:
\A
# Store initial cursor position in <pos>
(?<pos>\D*)
(?(_)
  # If we start on a wildcard, just skip to the first character of the target.
  \D*¶.
|
  # Otherwise, make sure that the target starts with this character.
  (?<first>.)\D*¶\k<first>
)
(?:
  # Match 0 or more subsequent characters by moving the cursor along the path.
  # First, we store the character to be matched in <next>.
  (?<next>.)
  # Now we optionally push an underscore on top (if one exists in the string).
  # Depending on whether this done or not (both of which are attempted by
  # the engine's backtracking), either the exact character, or an underscore
  # will respond to the match. So when we now use the backreference \k<next>
  # further down, it will automatically handle wildcards correctly.
  (?<=(?<next>_)\D+)?
  # This alternation now simply covers all 6 possible neighbours as well as
  # all 6 possible wrapped edges.
  # Each option needs to go into a separate lookbehind, because otherwise
  # the engine would not backtrack through all possible neighbours once it
  # has found a valid one (lookarounds are atomic).
  # In any case, if the new character is found in the given direction, <pos>
  # will have been updated with the new cursor position.
  (?:
    # Try moving east.
    (?<=(?<pos>\k<pos>.)\k<next>\D*)
  |
    # Try moving west.
    (?<=(?<pos>\D*)\k<next>(?<=\k<pos>)\D*)
  |
    # Store the horizontal position of the cursor in <x> and remember where
    # it is (because we'll need this for the next two options).
    (?<=\k<pos>(?<skip>.(?<x>.)*¶\D*))
    (?:
      # Try moving north.
      (?<=(?<pos>\D*)\k<next>(?>(?<-x>.)*)¶.*\k<skip>)
    |
      # Try moving north-east.
      (?<=(?<pos>\D*)(?=\k<next>)(?>(?<-x>.)+)¶.*\k<skip>)
    )
  |
    # Try moving south.
    (?<=(?<pos>\k<pos>.(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)
  |
    # Try moving south-east.
    (?<=(?<pos>\k<pos>(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)
  |
    # Store the number of '×' at the end in <w>, which is one less than the
    # the side-length of the hexagon. This happens to be the number of lines
    # we need to skip when wrapping around certain edges.
    (?<=(?<w>×)*¶.*)
    (?:
      # Try wrapping around the east edge.
      (?<=(?<pos>\k<pos>.(?>(?<-w>¶.*)*))^\k<next>\D*)
    |
      # Try wrapping around the west edge.
      (?<=(?<pos>\D*)\k<next>(?>(?<-w>¶.*)*)(?<=\k<pos>)^\D*)
    |
      # Try wrapping around the south-east edge.
      (?<=(?<pos>\k<pos>\b.*(?(w)!)(?<-w>¶.*)*)\k<next>×*¶\D*)
    |
      # Try wrapping around the north-west edge.
      (?<=(?<pos>\D*\b)\k<next>.*(?(w)!)(?<-w>¶.*)*(?<=\k<pos>.)\b\D*)
    )
  |
    # Try wrapping around the south edge.
    (?<=(?<pos>\k<pos>.(?>(?<-x>.)*¶\D*))\k<next>(?<x>\w)*\W+.+)
  |
    # Try wrapping around the north edge.
    (?<=(?<pos>.*)\k<next>(?>(?<-x>.)*¶\D*)(?<=\k<pos>.)(?<x>\w)*\W+.+)
  )
  # Copy the current cursor position into <current>.
  (?<=\k<pos>(?<current>\D*).+)
  # Make sure that no matter how many strings we pop from our stack of previous
  # cursor positions, none are equal to the current one (to ensure that we use
  # each cell at most once).
  (?<!\k<pos>\k<current>.*(?<-pos>.)+)
)*
# Finally make sure that we've reached the end of the string, so that we've
# successfully matched all characters in the target string.
\Z

I hope that the general idea is roughly clear from this. As an example for how one of those movements along the path works, let's look at the bit that moves the cursor south:
(?<=(?<pos>\k<pos>.(?>(?<-x>.)*)¶.*)\k<next>(?<x>.)*¶\D*)

Remember that lookbehinds should be read from right to left (or bottom to top), because that's the order they are executed in:
(?<=
  (?<pos>
    \k<pos>       # Check that this is the old cursor position.
    .             # Match the character directly on top of the new one.
    (?>(?<-x>.)*) # Match the same amount of characters as before.
    ¶.*           # Skip to the next line (the line, the old cursor is on).
  )               # We will store everything left of here as the new
                  # cursor position.
  \k<next>        # ...up to a match of our current target character.
  (?<x>.)*        # Count how many characters there are...
  ¶\D*            # Skip to the end of some line (this will be the line below
                  # the current cursor, which the regex engine's backtracking
                  # will determine for us).
)

Note that it's not necessary to put an anchor in front of the \k<pos> to ensure that this actually reaches the beginning of the string. <pos> always starts with an amount of × that can't be found anywhere else, so this acts as an implicit anchor already.
I don't want to bloat this post more than necessary, so I won't go into the other 11 cases in detail, but in principle they all work similarly. We check that <next> can be found in some specific (admissible) direction from the old cursor position with the help of balancing groups, and then we store the string up to that match as the new cursor position in <pos>.

Python 3, 990 943 770 709 bytes
First answer, yay!
EDIT: Golfed adjacency list making. I now use a slightly different formula
EDIT 2: Removed unnecessary fluff, golfed a lot more.
EDIT 3: Shortened the code for conversion from index in list to coordinates, golfed a few more things.
The majority of the bytes relates to making the adjacency list (it has the most potential to be golfed). From then, it's a simple matter of brute-forcing the solution (which I might be able to do in less bytes).
Golfed:
from math import*
b=abs
c=max
e=range
f=len
A=input()
B=input()
C=ceil(sqrt((f(A)-.25)/3)+.5)
D=3*C*~-C+1
E=2*C-1
F=C-1
A+='.'*(D-f(A))
G=[set()for x in e(D)]
I=lambda H:sum(E+.5-b(t-F+.5)for t in e(int(H+F)))
for x in e(D):
 r=sum([[J-F]*(E-b(J-F))for J in e(E)],[])[x];q=x-I(r);s=-q-r;a=lambda q,r:G[x].add(int(q+I(r)));m=c(map(b,[q,r,s]))
 if m==F:
  if q in(m,-m):a(-q,-s)
  if r in(m,-m):a(-s,-r)
  if s in(m,-m):a(-r,-q)
 for K,L in zip([1,0,-1,-1,0,1],[0,1,1,0,-1,-1]):
  M,H=q+K,r+L
  if c(map(b,[M,H,-M-H]))<C:a(M,H)
def N(i,O,P):
 Q=O and O[0]==A[i]or'.'==A[i];R=0
 if(2>f(O))*Q:R=1
 elif Q:R=c([(x not in P)*N(x,O[1:],P+[i])for x in G[i]]+[0])
 return R
print(c([N(x,B,[])for x in e(D)])*(f(B)<=D))

Ungolfed w/ explanation:
from math import*

#Rundown of the formula:
# * Get data about the size of the hexagon
# * Create lookup tables for index <-> coordinate conversion
#   * q=0, r=0 is the center of the hexagon
#   * I chose to measure in a mix of cubic and axial coordinates,
#     as that allows for easy oob checks and easy retrevial
# * Create the adjacency list using the lookup tables, while
#   checking for wrapping
# * Brute-force check if a path in the hexagon matches the
#   expression

# shorten functions used a lot
b=abs
c=max
e=range

# Get input

prog=input()
expr=input()

# sdln = Side length
# hxln = Closest hexagonal number
# nmrw = Number of rows in the hexagon
# usdl = one less than the side length. I use it a lot later

sdln=ceil(sqrt((len(prog)-.25)/3)+.5)
hxln=3*sdln*~-sdln+1
nmrw=2*sdln-1
usdl=sdln-1

# Pad prog with dots

prog+='.'*(hxln-len(prog))

# nmbf = Number of elements before in each row
# in2q = index to collum
# in2r = index to row

nmbf=[0]*nmrw
in2q=[0]*hxln
in2r=[0]*hxln

#  4    5
#   \  /
# 3 -- -- 0
#   /  \
#  2    1

# dirs contains the q,r and s values needed to move a point
# in the direction refrenced by the index

qdir=[1,0,-1,-1,0,1]
rdir=[0,1,1,0,-1,-1]

# generate nmbf using a summation formula I made

for r in e(nmrw-1):
    nmbf[r+1]=int(nmbf[r]+nmrw+.5-b(r-sdln+1.5))

# generate in2q and in2r using more formulas
# cntr = running counter

cntr=0
for r in e(nmrw):
    bgnq=c(-r,1-sdln)
    for q in e(nmrw-b(r-sdln+1)):
        in2q[cntr]=bgnq+q
        in2r[cntr]=r-usdl
        cntr+=1

# adjn = Adjacency sets

adjn=[set()for x in e(hxln)]

# Generate adjacency sets

for x in e(hxln):
    #Get the q,r,s coords
    q,r=in2q[x],in2r[x]
    s=-q-r
    # a = function to add q,r to the adjacency list
    a=lambda q,r:adjn[x].add(q+nmbf[r+usdl])
    # m = absolute value distance away from the center
    m=c(map(b,[q,r,s]))
    # if we are on the edge (includes corners)...
    if m==usdl:
        # add the only other point it wraps to
        if q in(m,-m):
            a(-q,-s)
        if r in(m,-m):
            a(-s,-r)
        if s in(m,-m):
            a(-r,-q)
    # for all the directions...
    for d in e(6):
        # tmp{q,r,s} = moving in direction d from q,r,s
        tmpq,tmpr=q+qdir[d],r+rdir[d]
        # if the point we moved to is in bounds...
        if c(map(b,[tmpq,tmpr,-tmpq-tmpr]))<sdln:
            # add it
            a(tmpq,tmpr)

# Recursive path checking function
def mtch(i,mtst,past):
    # dmch = Does the place we are on in the hexagon match
    #        the place we are in the expression?
    # out = the value to return
    dmch=mtst and mtst[0]==prog[i]or'.'==prog[i]
    out=0
    # if we are at the end, and it matches...
    if(2>len(mtst))*dmch:
        out=1
    # otherwise...
    elif dmch:
        # Recur in all directions that we haven't visited yet
        # replace '*' with 'and' to speed up the recursion
        out=c([(x not in past)*mtch(x,mtst[1:],past+[i])for x in adjn[i]]+[0])
    return out

# Start function at all the locations in the hexagon
# Automatically return false if the expression is longer
# than the entire hexagon
print(c([mtch(x,expr,[])for x in e(hxln)])*(len(expr)<=hxln))

So close to Retina! :( Yay, beat Retina!

Javascript (ES6), 511 500 496 bytes
(H,N)=>{C=(x,y)=>(c[x]=c[x]||[])[y]=y;S=d=>(C(x,y=x+d),C(y,x),C(s-x,s-y),C(s-y,s-x));r=(x,p,v)=>{p<N.length?(v[x]=1,c[x].map(n=>!v[n]&&(H[n]==N[p]||H[n]=='.')&&r(n,p+1,v.slice()))):K=1};for(e=x=K=0;(s=3*e*++e)<(l=H.length)-1;);H+='.'.repeat(s+1-l);for(a=[],b=[],c=[[]],w=e;w<e*2;){a[w-e]=x;b[e*2-w-1]=s-x;for(p=w;p--;x++){w-e||S(s-e+1);w<e*2-1&&(S(w),S(w+1));p&&S(1)}a[w]=x-1;b[e*3-++w]=s-x+1}a.map((v,i)=>S(b[i]-(x=v)));[N[0],'.'].map(y=>{for(x=-1;(x=H.indexOf(y,x+1))>-1;r(x,1,[]));});return K}

Ungolfed and commented
// Entry point
//   H = haystack (the string the hexagon is filled with)
//   N = needle (the substring we're looking for)
(H, N) => {
  // C(x, y) - Helper function to save a connection between two locations.
  //   x = source location
  //   y = target location
  C = (x, y) => (c[x] = c[x] || [])[y] = y;

  // S(d) - Helper function to save reciprocal connections between two locations
  //        and their symmetric counterparts.
  //   d = distance between source location (x) and target location
  S = d => (C(x, y = x + d), C(y, x), C(s - x, s - y), C(s - y, s - x));

  // r(x, p, v) - Recursive path search.
  //   x = current location in hexagon
  //   p = current position in needle
  //   v = array of visited locations
  r = (x, p, v) => {
    p < N.length ?
      (v[x] = 1, c[x].map(n => !v[n] && (H[n] == N[p] || H[n] == '.') &&
      r(n, p + 1, v.slice())))
    :
      K = 1
  };

  // Compute e = the minimum required edge width of the hexagon to store the haystack.
  // Also initialize:
  //   x = current location in hexagon
  //   l = length of haystack
  //   s = size of hexagon (number of locations - 1)
  //   K = fail/success flag
  for(e = x = K = 0; (s = 3 * e * ++e) < (l = H.length) - 1;);

  // Pad haystack with '.'
  H += '.'.repeat(s + 1 - l);

  // Build connections c[] between locations, using:
  //   x = current location
  //   w = width of current row
  //   p = position in current row
  // Also initialize:
  //   a[] = list of locations on top left and top right edges
  //   b[] = list of locations on bottom left and bottom right edges
  for(a = [], b = [], c = [[]], w = e; w < e * 2;) {
    a[w - e] = x;
    b[e * 2 - w - 1] = s - x;

    for(p = w; p--; x++) {
      // connection between top and bottom edges
      w - e || S(s - e + 1);
      // connections between current location and locations below it
      w < e * 2 - 1 && (S(w), S(w + 1));
      // connection between current location and next location
      p && S(1)
    }
    a[w] = x - 1;
    b[e * 3 - ++w] = s - x + 1
  }

  // Save connections between top left/right edges and bottom left/right edges.
  a.map((v, i) => S(b[i] - (x = v)));

  // Look for either the first character of the needle or a '.' in the haystack,
  // and use it as the starting point for the recursive search. All candidate
  // locations are tried out.
  [N[0], '.'].map(y => {
    for(x = -1; (x = H.indexOf(y, x + 1)) > -1; r(x, 1, []));
  });

  // Return fail/success flag.
  return K
}

Test cases
The snippet below will walk through all truthy and falsy test cases.

let f =
(H,N)=>{C=(x,y)=>(c[x]=c[x]||[])[y]=y;S=d=>(C(x,y=x+d),C(y,x),C(s-x,s-y),C(s-y,s-x));r=(x,p,v)=>{p<N.length?(v[x]=1,c[x].map(n=>!v[n]&&(H[n]==N[p]||H[n]=='.')&&r(n,p+1,v.slice()))):K=1};for(e=x=K=0;(s=3*e*++e)<(l=H.length)-1;);H+='.'.repeat(s+1-l);for(a=[],b=[],c=[[]],w=e;w<e*2;){a[w-e]=x;b[e*2-w-1]=s-x;for(p=w;p--;x++){w-e||S(s-e+1);w<e*2-1&&(S(w),S(w+1));p&&S(1)}a[w]=x-1;b[e*3-++w]=s-x+1}a.map((v,i)=>S(b[i]-(x=v)));[N[0],'.'].map(y=>{for(x=-1;(x=H.indexOf(y,x+1))>-1;r(x,1,[]));});return K}

let truthy = [
  ["a","a"],
  ["ab","a"],
  ["ab","b"],
  ["ab","ba"],
  ["ab","aba"],
  ["ab","&"],
  ["ab","#7.J!"],
  ["ab","aaaaaa"],
  ["ab","bgjneta"],
  ["ab","cebtmaa"],
  ["abcdefg","dfabcg"],
  ["AbCDeFG","GCbAeFD"],
  ["aaaabbb","aaababb"],
  ["abcdefghijklmnopqrs","alq"],
  ["abcdefghijklmnopqrs","aqnmiedh"],
  ["abcdefghijklmnopqrs","adhcgkorbefjimnqlps"],
  ["11122233344455","12341345123245"],
  ["abcdefgh","h%a"],
  ["abcdefghijklm","a)(@#.*b"],
  ["abcdefghijklm","a)(@#.*i"],
  ["abcdefghij","ja"],
  ["abcdefghijklmno","kgfeia"],
  ["abcdefghijklmno","mmmmmiea"],
  ["abcdefghijklmno","mmmmmlae"],
  ["abcdefghijklmno","ja"],
  ["abcdefghijklmnopqrs","eijfbadhmnokgcsrql"]
];

let falsy = [
  ["a","b"],
  ["a","%"],
  ["a","."],
  ["a","aa"],
  ["a","a."],
  ["ab","#7.J!*"],
  ["ab","aaaaaaa"],
  ["ab","aaaabaaa"],
  ["ab","123456"],
  ["abcdefg","bfgedac"],
  ["abcdefg","gecafdb"],
  ["abcdefg","GCbaeFD"],
  ["aaaabbb","aaaaabb"],
  ["abcdefghijklmnopqrs","aqrcgf"],
  ["abcdefghijklmnopqrs","adhlcgknbeifjm"],
  ["abcdefghijklmnopqrs","ja"],
  ["abcdefghijklm","a)(@#.*&"],
  ["abcdefghijklmno","a)(@bfeijk"],
  ["abcdefghijklmno","kgfeic"],
  ["abcdefghijklmno","mmmmmmiea"]
];

console.log(
  'Testing truthy test cases:',
  truthy.every(v => f(v[0], v[1])) ? 'passed' : 'failed'
);
console.log(
  'Testing falsy test cases:',
  falsy.every(v => !f(v[0], v[1])) ? 'passed' : 'failed'
);


text:
Alphabet triangle
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.

So many alphabets recently

My synesthesia is going hog wild, @downrep_nation

"Since a triangle has 3 sides and 3 is a small number, so your code should be small in terms of byte count." seems legitimate

Squares of numbers composed only of 1 seems related: 11 = 1 ~= A , 1111 = 121 ~= ABA , 111*111 = 12321 ~= ABCBA ...

"Since a triangle has 3 sides and..." Illuminati Confirmed.

Vim, 37 bytes
:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ

Legend
↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape

That's a really cool GIF.

I will never cease to be amazed by Vim answers.

Care to explain how this works for those not fluent in Vim?

@R.Kap I recommend you download Vim and try the solution out yourself — you can watch the solution unfold stroke by stroke! Essentially, I steal the alphabet from a help file (:h<_↵↵↵YZZP), then record a macro (qq…q) that repeatedly chops a letter off the top line, makes two copies of it to grow the triangle vertically, then appends the chopped-off letter to all lines to grow it horizontally. I repeat this macro 24 more times to draw the full triangle.

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 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.

Out of the box. Nicely done.

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

Jelly, 16 13 bytes
Ṗ;Ṛ
ØAḣJÇ€Çj⁷

Thanks to @LeakyNun for golfing off 3 bytes!
Try it online!
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.

3 bytes off

I'd be curious to know how in the world this works...

maybe if use the link duplicator u can save one byte

@SocraticPhoenix I've added an explanation.

@LeakyNun Unfortunately, combining Ṗ;Ṛ requires two bytes. ØAḣJµṖ;Ṛµ⁺€j⁷ is just as long.

In which encoding does this code take 13 bytes?

@MathieuRodic Jelly uses a custom code page that encodes all 256 characters it understands as a single byte each. The bytes link in the header points to it.

Is something like ØA;\ŒBŒḄY possible or does it use commands that postdate the challenge :p?

@Adnan Unfortunately, everything after the first four bytes postdates the challenge...

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)]

You can save 2 bytes if you offset the variables, i.e. f(x=66,s='A'). This allows you to update s in the function call instead of the function body.

I think your Python 3 version, like its Python 2 relative, needs a value of 90 instead of 89 in order to have the longest row that goes all the way to Z and back.

@Tebbe Thanks, fixed them.

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!
Explanation
Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines

Very nice! You can change Œ26£ to .p, which is the prefix command. Also, you can change D, to =, which prints without popping.

Wow, clever trick with the gF,!

@Adnan: Thanks! I knew there was a prefix command in there somewhere :) I seldom check the extended ones though.

That bifurcate command Â is very nice and a really neat feature.

@carusocomputing: unfortunately û is newer than the challenge and would make this answer non-competing.

A.p€û}û» - 8 bytes, ahh... Yeah, just realized that as well.

@carusocomputing: It would have been amazing to have that command when this challenge was made :)

Aη€ûû» :P, since it's been rebumped hehe

brainfuck, 1733 121 119 bytes
----[---->+<]>++.<++++++++++.<+++++[<+++++>-]<+>>>.<[>>[>.]<[>+>+<<-]>+.>[<<+> >-]<[<.]<-]>>[>[>]<[-]<[<]>>[.>]<<[.<]>]

Slightly more readable version:
----[---->+<]>++.<
++++++++++.<
+++++[<+++++>-]<+
>>
>.<
[
  >>[>.]<
  [>+>+<<-]
  >+.>
  [<<+>>-]
  <[<.]<
  -
]
>>
[
  >[>]<
  [-]
  <[<]>
  >[.>]<<[.<]>
]

Explanation possibly to come.

Try using a loop instead of building each character manually.

@LeakyNun I have no idea how to go about that. Any suggestions?

Refer to this.

Basically, to do a loop of n iterations, set up n on a cell and then start a while loop [ on it. On each iteration, return to that cell and minus one.

@LeakyNun But then how will I return to the cell I was on after decrementing?

Can we discuss this in chat?

@LeakyNun Actually, I just realised how to do it. I'll work on it tomorrow.

@LeakyNun I did it!

Nice, so you only slept for 4 hours.

@LeakyNun I suppose so. That may not have been a good idea.

An alternative starting point, perhaps: ->+>++++++[++[>++++++++<-]++<]. It initializes the tape as [2, 10, 26, 64].

Congratulations on getting the program smaller than the output!

How does one golf off 1612 bytes?

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!

You can also do '\n'.join(a+a[-2::-1])

96 bytes!

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

f=:,1}.|. try this

@LeakyNun Thanks I don't know why I thought they were different.

Ruby, 71 bytes
Try it on repl.it
s=*?A..?Y
s+=[?Z]+s.reverse
puts s.map{|e|k=[*?A...e]*'';k+e+k.reverse}

This solution builds on yours, using absolute value arithmetic to save 3 bytes.

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

Ahhh, I just wanted to add a C answer as well... Whatever, I'll just help you then ;) First, this is code golf, you do not need to write perfect code. Compiler warnings are completely fine. That's why you can remove main()'s return type and even the #include <stdio.h>. GCC (and also sites like Ideone) are OK with that. Next, you can 'outsource' variable definitions to the parameter list of a function. Let for(int i=65;... become for(i=65... and change main() to main(i). Do the same for every other int variable as well (GCC defaults missing types to int).

@sigalor Thanks for the tips! :) Just one question: why do I need to change main() to main(i)?

@sigalor Actually, now I'm getting a bunch of compilation errors.

When you do not declare your i variable in the for loop's initialization, you need to declare it somewhere else. And because (at least in C) the parameters of a function can be used like normal variables, there should be no problem. Btw, which compiler are you using?

@sigalor Currently C in Ideone. I'm getting several <variable> undeclared errors.

I see your problem. First, you can (of course) ignore all lines of the compilation info that contain warning. Next, you need to add the names of all variables you removed the type from (and that were int's previously) to main's parameter list like this: main(i,w,g,x,q,b). The compiler will implicitly convert this function head to int main(int i, int w, int g, int x, int q, int b) (remember, missing types are defaulted to int).

@sigalor Oh wow. It worked! Thanks! :)

Let us continue this discussion in chat.

@R.Kap - 117 bytes: main(q,i,e,x){for(q=0;q<51;q++){i=q>25?50-q:q;for(e=65;e<66+i;)putchar(e++);for(x=64+i;x>64;)putchar(x--);puts("");}}.

I think your provided code requires 138, not 137 bytes. Anyway, 131 bytes.

You can use putchar(e); instead of printf("%c", e);, saving 4 bytes.

Mathematica 59 bytes
Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]

I think that removing the //Column from the end and prefixing your code with Column@ works.

You seem to have counted 〚 and 〛 as single bytes. I doubt that there's a single-byte code page that has them and is also supported by Mathematica out of the box. They'd by three bytes in UTF-8, so they don't really save anything over plain [[...]]. I'm also not sure how legitimate Column is since it only displays like a list of lines in a Mathematica notebook. Running this code from a script file wouldn't display anything. However, Print/@ is the same number of bytes and works in either case.

If you want to make a link to a page with a long address, you can do the following: [what you see](actual link). Ex. [Example Link](https://www.example.com), which shows as Example Link

><>, 60 bytes
1"AA"1[v
?v:1-:}>:5d*=
o>l  ?!v
{$-}:1[\ao]{:}+::"@Z"@=?;=2*

Try it online!

JavaScript (ES6), 81 bytes
[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)

Dyalog APL, 18 bytes
↑(⊣,⌽)(⊣,1↓⌽)¨,\⎕a

Your longest line is duplicated. Fix that and save two bytes.

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

You can use a literal newline instead of \n

(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:

Welcome to Code Golf! Nice first 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

Don't you need to include bytes that you need to import the library?

Idk, Ive posted over 20 answers using a library and you would be the first to say that to me. I dont think anybody really cares because my answers never win anyway

@applejacks01 Pretty sure if you don't import it, then you have to say something like "JS + Enumerable" at the top. Similar to "Bash + Coreutils"

@mbomb007 Hahahah, I did!! Dr Green Eggs and Iron Man edited that out of my answer lmao

It's commonplace to count the import. Python + SymPy answers still have import sympy or from sympy import* at the top. The Bash + x answers are different because you only have to install x, not enable it somehow.

Lol, why cant anybody agree? Ive heard conflicting rules on this, unless people have just remained silent or didn't really scrutinize my code. OR...nobody really cared about my answer and thus never said anything

So, can I just put  at the top or something?

That would make it a HTML + JavaScript + Enumerable answer, and you'd need to wrap your code in a <script> tag as well. Non-browser interpreters (Node, etc.) should have a saner way to import libraries, but I don't really know JS.

Ok, I'll do some research to find a way to make it Node compatible I guess if I want to use a lib. Or, could I just mark my answer as non-competing, since I'm also just doing these to test my skills?

@Dennis does this mean libraries like lodash are allowed if I specify them in the title and include the amount of bytes to import them? This is the first I'm hearing of this...

@PatrickRoberts As long as the library existed before the challenge was posted, yes. Python answers make use of sympy, numpy, scipy, etc. all the time.

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)

I used some similar logic in one of my Iceland flag submissions.  Couldn't you golf this further by running it entirely in the immediate window and skipping the function declaration, or does that break some rule I'm not familiar with?

@GuitarPicker ; not sure whether running in immediate window counts as a complete program, but if so then 8 bytes less, effectively; instead of starting with Function T: , end with :?T (although it would only work once, because after that you'd need to reset T to "" - but who needs more than one of these triangles?)

You don't even need T if you ? as you go with ;.

I was able to shave it down to 71 using that method. Hint: you won't need vbCrLf either.

yeah, I got the same; note that return is required.

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]

Can't Range[65,64+k] just be 65~Range~64+k?

That doesn't work.  I think the +k somehow is left out.

~Table~ and Column@ should work though. And since you seem to use r only in conjunction with Most you might as well define it as Reverse@*Most.

Table and Column now have infix notation.  r=Reverse@Most appears not to work.

It should be Reverse@*Most (the asterisk wasn't a typo ;)). I'm also not sure how legitimate Column actually is since it only displays like a list of lines in a Mathematica notebook. Running this code from a script file wouldn't display anything. However, Print/@ is the same number of bytes and works in either case.

Nice. But I am puzzled by *. What does it do here?

@* is Composition. Also, I'm not getting notifications for your comments if you don't @mention me. ;)

@MartinEnder, Composition?  Very useful!

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

I tried to do it but end up with 250+ bytes so never posted that. You, indeed, have a better solution then mine. Once again :)

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"))

112 bytes

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.

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.

Hey, that's good, thanks! I had plugged in 65..90..65 on a whim earlier with no success. Guess I forgot I could just add the ranges together.

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

What a clever method, pushing t through to the next loop. There's an extra leading newline though; x=66,s='A'' gets rid of it. The base case can be shortened to x/92*t or .

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
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.

You can remove both instances of 0

Good catch! Thanks, updated @LeakyNun

Huh? len(s)/2? Why not 26?

Good catch! @manatwork

See and apply marcog's tip from Tips for golfing in Python: print[s[:-i-1]+s[-i-3::-1],s[:i]+s[i::-1]][26>i].

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 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.

@"(1|>26) can be 1@"26

String.letters can be (65@"91)

String.letters.slice(0,i) could maybe be 65@"(66+i)

Aha, I see you've been grating your bytecount.

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 and Kevin Cruijssen

Welcome to PPCG. Please read the “How should I answer a code golf? Any hints?” section in the [tag:code-golf] tag's info page. Answers to this kind of challenges are expected to present efforts to reduce the code size. In this you may find help in Tips for golfing in Java and Tips for golfing in .

There you use 4 ternary operators and all conditions are enclosed in parenthesis. You can remove those to save 8 characters.

d and k can not go below -1, right? Then you can replace d!=-1 with d>-1, same for k. (BTW, you forgot to fix the golfed version.)

Moved statements from loop body to increment statement section to save 3 bytes..

you could also use bitwise operator & instead logical &&, which gives you another 2 bytes

you could remove int ,  if you declare c inside your outer for loop

I can use bitwise operator.. Thanks.. But changing c incide will not save any charectors..

Hi, I know it's been quite a while, but you can golf two things: i+=k==1?1:-1 can be i+=k and System.out.print((char)c+(c+d<65?"\n":"")),c+=d==1?1:-1); can be System.out.print((char)c+((c+=d)<65?"\n":"")));. So in total it becomes (131 bytes): 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":"")));

HTML + CSS, 884 characters
(763 characters HTML + 121 characters CSS)
Just expanding Leaky Nun's comment on MonkeyZeus's answer. (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

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

You can replace ,A in Predicate 1 with h, saving one byte.

You can also save two bytes by replacing :1:2yt. with :2&. and adding a ! (cut choice points) at the end of predicate 2.

33 bytes using [char:char]y to generate the sustrings abcd… instead of ~c[A:B]

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

Formatted:
+<++<<
--------[>+++++>>[+++<+<]>]
<+
[
  [>+>+.<<-]
  >-[<+> >-.<-]
  >->.>[->]
  <<<[<<++>]
  <
]

Try it online

Sesos, 27 bytes
0000000: a85ab9 ac5daa f8b1c7 785f9b b961f7 665c1b 73ccfc  .Z..]....x_..a.f\.s..
0000015: c01ecb 987303                                     ....s.

Try it online! Check Debug to see the generated SBIN code.
Sesos assembly
The binary file above has been generated by assembling the following SASM code.
add 65, rwd 1, add 10, rwd 2, add 25
jmp
    fwd 3
    jmp
        put, fwd 1
    jnz
    rwd 1
    jmp
        fwd 1, add 1, fwd 1, add 1, rwd 2, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    rwd 1, add 1, rwd 2
    jmp
        put, rwd 1
    jnz
    rwd 1, sub 1
jnz
fwd 3
jmp
    jmp
        put, fwd 1
    jnz
    rwd 1, get, rwd 1
    jmp
        put, rwd 1
    jnz
    fwd 2
; jnz (implicit)

bash, 80 bytes
printf -v a %s {A..Z};for i in {1..26} {25..1};{ echo ${a::i}`rev<<<${a::i-1}`;}

///, 208 bytes
/'/\/\///+/BA
AB'-/DC+CD'&/FE-EF')/HG&GH'=/JI)IJ'|/LK=KL'7/NM|MN'1/PO7OP'q/RQ1QR'p/TSqST'6/VUpUV'[/XW6WX/A
A+C+C-E-E&G&G)I)I=K=K|M|M7O7O1Q1QqSqSpUpU6W6W[Y[YZY[Y[W6W6UpUpSqSqQ1Q1O7O7M|M|K=K=I)I)G&G&E-E-C+C+A
A

Not winning of course, but here it is, predating Martin Ender...

Perl 5 with -M5.010, 54 bytes
for$@(A..Z){@;=($_.$/,@;);s/$*/$*$@$*/;say;$*=$@}say@;

Try it online!
Saved bytes thanks to @Xcali!

Found a method which takes 56 bytes

Thanks @Xcali! With you suggestion managed to get it down to 54. And some added obfuscation for entertainment...

C#, 289 215 206 190 179 171 159 157 156 153 147 bytes
(n,i,s)=>{s=new string[51];for(i=0;i<26;){for(n=65;n-65<i;)s[i]+=(char)n++;for(;n>64;)s[i]+=(char)n--;s[50-i]=s[i++];}return string.Join("\n",s);};

Saved 3 bytes thanks to VisualMelon
Saved 6 bytes thanks to mdfst13
Formatted version:
(n,i,s)=>
{
    s=new string[51];

    for(i=0;i<26;)
    {
        for(n=65;n-65<i;)
            s[i]+=(char)n++;

        for(;n>64;)
            s[i] += (char)n--;

        s[50-i]=s[i++];
    }

    return string.Join("\n",s);
};

156 byte version (when the irrelevant whitespace is removed) of counting backwards, uses a similar concept to the above method but does so in reverse.
(n, i, s) =>
{
    s = new string[i = 51];
    for (; --i > 24;)
    {
        for (n = 65; i + n < 116;)
            s[i] += (char)n++;

        for (n = 50 - i + 64; n > 64;)
            s[i] += (char)n--;

        s[50 - i] = s[i];
    }

    return string.Join("\n", s);
};

Feel free to share any improvements to my code if you find any

An explanation would be nice! You can use a for loop instead of a while, saving you the ; on the statement prior. The last statement in the outer loop can be put inside the last inner for loop (s[...]=s[i]+=) (need to juggle the i++ a bit, can certainly be done with only one extra byte). You've also got 51-i-1 in there, which can be reduced ;) I would be looking into reducing the two inner loops into one, and counting i backwards (so you assign it to 51 inside the array constructor).

@VisualMelon I've been looking at it for ages and I never saw the 51 - I - 1 haha, and I can't put the last statement in the last inner loop as it doesn't get called on the first pass but didn't know I could chain the assignment like that so that's cool! And I've been looking into combining the loops, getting there

@VisualMelon I reversed the outer loop and ended up adding 3 bytes when I got it working, will see if I can golf it down though

Julia 0.4, 84 bytes
!()=(- =join;a=-char(65:90);b=[a[1:x+1]*a[x:~0:1]for x=0:25];vcat(b,b[25:~0:1])-"
")

Try it online!

Javascript (ES5), 105 bytes
Beating all other ES6 answers using some good ol' vanilla JS looping!
for(a="",n=g=1;n++<52;n<27?g++:g--){for(z=x=0;z++<g*2-1;z<g?x++:x--)a+=String.fromCharCode(65+x);a+="\n"}a

I could save 1 byte by using ES6 and changing
a+="\n"

to
a+=`
`

but nah.

Since you don't have console.log anywhere I imagine this is supposed to be the contents of a function. If you wrapped it in the ()=>{} that you need to actually execute your code and tried it, it would return undefined. It needs to be return a. If you had done everything so that it can actually be run (including the ()=>{} and return ) it would be 119 bytes. tl;dr this code doesn't work.

Nice. Also (10+x).toString(36) is shorter than String.fromCharCode(65+x) and like @Pandacoder said, you should put something like alert(a) at the end to make it valid.

JavaScript (ES6), 89 bytes
R=(n,s=10,c=s.toString(36))=>n?c+R(n-1,s+1)+c:c
C=(n=0,r=R(n))=>n<25?r+`
`+C(n+1)+`
`+r:r

Not the shortest, but I wanted to try my hand at recursion. Call with C().

Pepe, 94 bytes
rEeEeEEeEeREeEeeeeeEREEEEEEerEEReeeReeEREEEeEREEEeEREEeeREEEEEreererEEReeeReeEReReREEeEreeReee

Try it online!

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

Try it online!
; Initialize memory as: 0 (25) 0 "\n" "A" 0
+++++[->+++++>>++>+++++++++++++<<<<]>

[-                          ; Repeat 25 times
    >>>[.>]                 ; print all the characters on the band
    <[->+>+<<]>+>[-<<+>>]   ; copy the last character and increment
    <<<[.<]                 ; print all but the last two characters backwards
<]
>>>
[                           ; while there is still characters left
    [.>]                    ; print all the characters
    <[-]                    ; remove last character
    <[.<]                   ; print all characters backwards
>>]

Vyxal j, 8 bytes
kA¦ømƛøm

Try it Online!
Explanation:
kA        # Uppercase ALPHABET
  ¦       # Prefixes (A, AB, ABC, ...)
   øm     # Mirror without duplicating middle
     ƛ    # For each:
      øm  #   Mirror without duplicating middle

Batch, 226 224 bytes
@set z=ABCDEFGHIJKLMNOPQRSTUVWXYZ
@set a=YXWVUTSRQPONMLKJIHGFEDCBA
@for /l %%i in (0,1,25)do @call echo %%z:~0,%%i%%%%z:~%%i,1%%%%a:~-%%i,%%i%%
@for /l %%i in (24,-1,0)do @call echo %%z:~0,%%i%%%%z:~%%i,1%%%%a:~-%%i,%%i%%

Edit: Saved 2 bytes thanks to @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

I think you can do )do, but not any other space (except in(), maybe...

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Oddly enough I have done this before, just the once: http://codegolf.stackexchange.com/a/68936/17602

JavaScript (ES6), 141

for(a=65,q=[],z=[];a<91;z.push(a++))q.push(String.fromCharCode(...z,a,...[...z].reverse()))
a=q.pop(),alert([...q,a,...q.reverse()].join`\n`)

QBasic, 151 122 bytes
Really just for fun (via QB64) - it doesn't golf well
Taking some ABS() inspiration from Joffan's VBA answer but applying it differently:
FOR i=-25 TO 25
FOR n=0 TO 25-abs(i)
s$=s$+chr$(n+65)
IF n THEN t$=t$+chr$(90-abs(i)-abs(n))
NEXT
? s$+t$
s$=""
t$=""
NEXT

Previously:
FOR i=0 TO 25
p(i)
NEXT
FOR i=0 to 25
p(25-i)
NEXT
SUB p(i)
FOR n=0 TO i
s$=s$+chr$(n+65)
IF n THEN t$=t$+chr$(65+i-n)
NEXT
? s$+t$
s$=""
t$=""
END SUB

Retina, 90 88 86 76 bytes
I'm sure it can be made shorter, maybe by using non-verbose replacements and simply outputting at the end. (I tried. I don't think I can do it shorter that way.)
:`
A
A
ABA
{:`

(.)([^Z]\1)
$1$2$2
}T1`__L`L`(?<=(.)[^Z])\1
+:`(.).\1|^A$
$1

Try it online
Thanks to LeakyNun for 14 bytes off

@LeakyNun Thanks, idk why I thought I needed that part...

Match the second stage with ^ and insert only AB.

Swift 2.2, 157 142 Bytes
let t={(l:Int)in[Int](1..<l)+[Int](l.stride(to:0,by:-1))}
for x in(t(n).map{t($0).map{"\(UnicodeScalar($0+64))"}.reduce(""){$0+$1}}){print(x)}

ungolfed:
let makeTriangleArray = {(limit: Int) -> [Int] in
    return [Int](1 ..< limit) + [Int](limit.stride(to: 0, by: -1))
}

let n = 26
let lines = makeTriangleArray(n).map{
    makeTriangleArray($0).map{String(UnicodeScalar($0 + 64))}
                         .reduce(""){ $0 + $1}
}

for line in lines {
    print(line)
}

157 bytes:
let t={(l:Int)in[Int](1..<l)+[Int](l.stride(to:0,by:-1))}
print(t(n).map{t($0).map{"\(UnicodeScalar($0+64))"}.joinWithSeparator("")}.joinWithSeparator("\n"))

ungolfed:
let makeTriangleArray = {(limit: Int) -> [Int] in // "called t" above
    return [Int](1 ..< limit) + [Int](limit.stride(to: 0, by: -1))
}

let n = 26
let s = makeTriangleArray(n).map{
    makeTriangleArray($0).map{String(UnicodeScalar($0 + 64))}
                         .joinWithSeparator("")
}.joinWithSeparator("\n")
print(s)

Jelly, 16 bytes
ŒRAạ
25ÇÇ€‘ịØAj⁷

This uses the same method in my Python answer.
Try it online.
Explanation
ŒRAạ  Define a helper link. Input: n
ŒR    Create the range [-abs(n), , ..., 0, ..., abs(n)]
  A   Take the absolute value of each
   ạ  Return the absolute difference between each value and n

25ÇÇ€‘ịØAj⁷  Main link. No arguments
25           The constant 25
  Ç          Call the helper link on 25 to get [0, 1, ..., 25, ..., 1, 0]
   Ç€        Call the helper link on each value in the previous
     ‘       Increment every value
       ØA    The alphabet (the string 'A..Z')
      ị      Select the char at each index in the alphabet
         j⁷  Join them using newlines and return

This is extremely close to this answer

@LeakyNun It generates the indices into the alphabet using a different method. Since there is only one output the intermediate values only finally become identical after the increment.

PHP, 80 83 bytes
Making half of the triangle then print it in reverse did the trick.
for($a="A";$a<"Z";$b.=$a++)$c.=$b.$a.strrev($b)."
";echo"$c{$b}Z".strrev($c.$b);

Kotlin,  99 93 88 bytes
(('A'..'Y')+'Z'.downTo('A')).map{println((('A'..it-1)+it.downTo('A')).joinToString(""))}

That's still longer than I expected but I doubt I'll be able to golf it further.
Factorisation doesn't save the day, best I could do is 93 bytes :
fun r(a:Char,b:Char)=(a..b-1)+b.downTo(a)
r('A','Z').map{println(r('A',it).joinToString(""))}

C#, 162 bytes
void p(){for(int i=1;i<54;i++){var a=Enumerable.Range(65,i>27?54-i:i).Select(n=>(char)n);Console.WriteLine(new string(a.Concat(a.Reverse().Skip(1)).ToArray()));}}

Try it online!

I was wondering what the linq version would look like, you need System.Console.. though right? and shouldn't you also include using System.Linq in the byte count although I'm unsure about that

Change your for loop to for(int i=0;++i<54;) to save some bytes

HTML, 1412 bytes

<pre>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</pre>

Please – – – – –

Actually, with native HTML it's impossible to do better than this

@LeakyNun You must be on a whole 'nother level. What is – – – – – – and how do I make it work?

A possible interpretation of @LeakyNun's comment: http://codegolf.stackexchange.com/a/88984

R, 95 bytes
L=LETTERS;cat("A\n");for(i in 2:50)cat(L[1:(26-abs(i-26))],L[(25-abs(i-26)):1],'\n');cat("A\n")

Ungolfed:
L=LETTERS; #Took idea from @Frederic, I apologize if I shouldn't (first time posting)
cat("A\n")
for(i in 2:50)
{
    cat(L[1:(26-abs(i-26))],L[(25-abs(i-26)):1],'\n')
}
cat("A\n")

Basically, the formula in the cat function in the for loop is a transformation on the absolute value function, mapping n -> n for Letters 2 through 26 and then mapping Letters 27 -> 25, 28 -> 24, ..., 50 -> 2. I don't think it would work if I included the 'A' in this formula, which is why I printed it out separately.

100 bytes and actually valid.

MATLAB, 53 Bytes
MATLAB is not made for strings, so this needs some looping. I haven't found a faster way to create a list 1 2 3 4 3 2 1, than [1:4,3:-1:1], which seems really verbose.
Anyway, it's only beaten by 11/55 other submissions, and most of those are golfing languages.
for i=[1:26,25:-1:1]
disp(['',64+[1:i,i-1:-1:1]])
end

Just spent an entertaining fifteen minutes proving you right that this is indeed the shortest - even inline definition of an anonymous function (Octave-only) is still longer.

R, 71 69 bytes
L=LETTERS;for(i in c(1:26,25:1))cat(c(L[1:i],L[i:1][-1]),"\n",sep="")

See here on an online interpreter.
Edit: moved LETTERS outside the loop in order to avoid the curly brackets.

59 bytes

oh I didn't notice that my suggestion was identical to this one.

Javascript (ES6), 113 bytes
i=>{for(i=0;i<51;i++,console.log(L))for(j=s=i<26?i:50-i,L="";j>=0;)k=String.fromCharCode(65+j),L=k+(j---s?L+k:L)}

Thanks to manatwork for pointing me to a tip written by William Barbosa to reduce by a byte.

As William Barbosa wrote in his tip, is shorter to declare an unused dummy parameter.

PHP, 78 Bytes
foreach(range(A,Z)as$r)$o.="\n$t".strrev($t.=$r);echo$o.substr(strrev($o),51);

Rust, 120 bytes
fn main(){for j in -25i8..26{let k=25-j.abs();for i in -k..k+1{print!("{}",(65+k-i.abs())as u8 as char);}println!("");}}

My first attempt at codegolfing in Rust... codegolfing in anything, really. A straightforward attempt, just using for loops and abs().
fn main() {
    for j in -25i8..26 {
        let k=25-j.abs();
        for i in -k..k+1{
            print!("{}",(65+k-i.abs())as u8 as char);
        }
        println!("");
    }
}

Python, 156 bytes
Not impressive, but I'm proud of myself because I'm a noob:
def p(k):
    x=k-1
    while x>-k:
        print(chr(64+(k-abs(x))),end="")
        x-=1
q=25
while q>-27:
    p(26-abs(q))
    print()
    q-=1

Welcome to PPCG! You can save a bunch of bytes by making your indentation single spaces. You can also use tricks like print();q-=1.

SOGL V0.12, 10 bytes
øZ{⁴Κ}¹╬,k

Try it Here!
Explanation:
ø           push an empty string
 Z{  }      for each character in the alphabet do
   ⁴          duplicate the item before the top item
    Κ         reverse add to that
              or simpler - on each iteration creates a duplicate of ToS but with the current character appended.
      ¹     wrap the stack in an array
       ╬,   quad-palindromize without spacing to a square
         k  remove the 1st line

The last k could be removed if the question allowed leading newlines.

Your interpreter site runs fine half of the time and half of the time, the run button seems to do nothing!

@officialaimm ..huh. It's probably that Processing.js hasn't yet downloaded/transpiled the source. When I get the time I'll make the run button blank out while its loading

ah, makes sense.

Canvas, 6 bytes
Ｚ［│］──

Try it here!
Explanation:
Z       push the alphabet
 [ ]    map over the prefixes
  │     palindromize horizontally
    ──  palindromize vertically without mirroring characters

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

Try it online!
Explanation
+++++[<+++++>-] 26 times
<+[
  >>[>[.>]]     print every letter up to new char position
  >++++++++++<<[>>.<]  if any letter exists print lf
  >[<]>         resync pointer position
  --[<++++++++>-] set new char to A minus 1
  <[+.<]        increment each letter and print it
  <-            decrement counter
]
>>,             delete last letter
>[.>]           print rest of middle line
+++++ +++++.    print lf
[               while chars exist
  <[.<]         print all
  >,            delete last
  >[.>]<        print second half (including lf)
]

Alternative
If a leading newline would be alowed, this could also be done with 97 bytes.
+++++[<+++++>-]<+[>>[>[.>]]>++++++++++.--[<++++++++>-]<[+.<]<-]>>,>[.>]++++++++++.[<[.<]>,>[.>]<]

Try it online!
Explanation
+++++[<+++++>-]     26 times
<+[
  >>[>[.>]]           print every letter up to new char position
  >++++++++++.        print lf
  --[<++++++++>-]     set new char to A minus 1
  <[+.<]              increment each letter and print it
  <-                  decrement counter
]
>>,                 delete last letter
>[.>]               print rest of middle line
+++++ +++++.        print lf
[                   while chars exist
  <[.<]               print all
  >,                  delete last
  >[.>]<              print second half (including lf)
]

Both codes need interpreters that use "end of input = 0".

MATL, 12 bytes
26Zv"1Y2@Zv)

Try it on MATL Online
Pretty straightforward in MATL, thanks to the Zv symmetric range function.
26Zv - Make the symmetric range around 26 i.e. [1:26 25:-1:1]
" - Iterate through that
1Y2 - Push the literal 'A':'Z' on the stack
@ - Push the current loop index on the stack
Zv - Make the symmetric range around the index
) - Index into the alphabets using this symmetric range

Common Lisp, 170 bytes
(let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))(loop for i from 1 to 51 do(let ((l (subseq r 0 (- i (* 2 (- i 26) (floor i 26))))))(format t "~a~a~%" l (subseq (reverse l) 1)))))

Run it: TIO here.
Formatted:
(let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
  (loop for i from 1 to 51
    do(let ((l (subseq r 0 (- i (* 2 (- i 26) (floor i 26))))))
      (format t "~a~a~%" l (subseq (reverse l) 1)))))

Breakdown:

(let ((r "ABCDEFGHIJKLMNOPQRSTUVWXYZ")) - variable r holds string range of all characters
variable l holds a substring from the r of length based on the line number, where l = r[0:i - (2 * (i - 26) * i % 26)] ...  (2 * (i - 26) * i % 26) this part ensures the i to be this sequence 0...26...0
format prints the l string and its reversed counter part with skipped first letter (to avoid ABBA, ABCCBA , etc.)

Welcome! Consider adding a detailed explanation. We also like to use online interpreters to allow easy testing of code. I like to use TIO. Here is its Common Lisp interpreter. It also has a permalink tool that can automatically generate markup for an answer post.

@mbomb007 Thank you for the suggestions, will add the notes. The REPL code is in the title "Common Lisp" ... the TIO looks better, good to know.

Ah, I didn't notice. Most answers with linked language names are links to the language's home page or documentation.

@mbomb007 updated with with the link to TIO and with the breakdown. ... Common Lisp is just my newest guilty pleasure, so there is definitely a better approach, just this is my current best try. Looking forward for any suggestions.

See if this helps: Tips for golfing is Lisp

Python 2, 70 bytes
x=25
exec'b=bytearray(range(65,91-abs(x)));print b+b[-2::-1];x-=1;'*51

Try it online!

Zsh, 100 96 92 80 57 bytes
Try it online!
-23!! thanks to @pxeger
eval Z+={A..Z}';<<<$Z`rev<<<$Z[1,-2]`;'>f
{<f;tac f}|uniq

We build the string $Z by iterating over A..Z, concat $Z with its reverse, and add the resulting string to file f. Then we print f forwards and backwards.
100 bytes   96 bytes   92 bytes   80 bytes

57 Try it online!

Elixir, 107 bytes
import Enum
a=reduce ?A..?Z,[],&(&2++[(at(&2,-1)||[])++[&1]])
map a++tl(reverse a),&IO.puts&1++tl reverse&1

Try it online!

Julia 1.0, 39 bytes
~c=['A':c;c-1:-1:'A']
!()=join.(.~~'Z')

Try it online!
output is a list of strings

Python 2, 86 85 bytes
n=0;exec'x=25-abs(n-25);print bytearray(65+x-abs(y-x)for y in range(2*x+1));n+=1;'*51

Try it at Ideone.
This follows a simple process. First, create the range [0, 1, ..., 24, 25, 24, ..., 1, 0]. Then, for each value x in that range, create another range [0, 1, ..., x, ..., 1, 0] and map each of those values to a character in 'A..Z'. Finally, print each string of characters.

JavaScript (ES6), 122 bytes
_=>(s='',r=x=>[...x].reverse().join``,t=[...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map(c=>s+c+r(s,s+=c)).join`
`)+r(t.slice(0,650))

As an anonymous function. (4 more bytes if you want to alert it)
Test

document.write('<pre>'+(

_=>(
  s='',
  r=x=>[...x].reverse().join``,
  t=
    [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
    .map(c=>
      s+c+r(s,s+=c)
    ).join`\n`
)+r(t.slice(0,650))

)());

Pyke, 19 16 bytes
27Gm<m[D_t+)RK[X

Try it here!

Python 2.7, 136 bytes
x=[chr(y) for y in range(65,91)]
for y in range(25):print ''.join(x[:y]+x[y::-1])
for y in range(25,-1,-1):print ''.join(x[:y]+x[y::-1])

for y in list(range(25)+list(range(24))[::-1]:print ''.join(x[:y]+x[y::-1])

Java 169 156bytes
String a="abcdefghijklmnopqrstuvwxyz";
public void alphabetTriangle(){
  for(int i=0;++i<27;){
    System.out.println(a.substring(0,a)+new StringBuilder(a).reverse().substring(1,-i+1));
  }
}

Golfed
String a="abcdefghijklmnopqrstuvwxyz";void l(){for(int i=0;++i<27;){System.out.println(a.substring(0,a)+new StringBuilder(a).reverse().substring(1,-i+1));}}

It is actually same as the batch solution with some shortcuts
Thanks to @Value Ink for saving 15 bytes by shortening the method name.

Trim your function name to one letter. This is code-golf, you don't need verbose function names!

I allways miss that. Thanks ;)

I'm sorry, but its not working.. "System.out.println(a.substring(0,a)+new StringBuilder(a).reverse.substring(1,-i+1));" has some errors

reverse is a function I suppose and substring does not take string as argument(a.substring(0,a)??)

see mine, http://codegolf.stackexchange.com/a/88646/52212

Python 2, 98 bytes
This is what I think is a unique approach in that it recursively builds up half a line at a time and calls the alphabet-building function twice to build a full line. Golfing suggestions welcome.
f=lambda a:a and f(a-1)+chr(64+a)or""
for i in range(-26,27):print f(26-abs(i))+f(27-abs(i))[::-1]

Convex, 21 bytes
U{[),U&)\¿@\N]}%)\¿@\

Try it online!

Pyth, 13 bytes
L+bt_bjyyM._G

Demonstration
L+bt_b Concatenates a thing with its reverse without the first element. Define as y.
._G: Form all prefixes of the alphabet
yM: Apply y to each element.
y: Apply y to the list as a whole.
j: Join on newlines.

Racket, 147 bytes
At least it beats QBasic.
((λ(x)(display(string-join(x(build-list 26(λ(n)(list->string(map integer->char(x(range 65(+ 66 n))))))))"\n")))(λ(m)(append m(cdr(reverse m)))))

Python, 109 bytes
z="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def a(x):v=z[:x]+z[x-26::-1]+"\n";return v+a(x+1)+v if x<25 else v
print a(0)

Build up a string with a recursive call in the middle to build the triangle out.
Might come back to try and get it <100.

Python 3, 123 101 98 bytes
for i in range(1,52):r=[chr(j+65)for j in range(abs(26*(i//26)-i%26))];print(''.join(r+r[-2::-1]))

lol I am really bad at this
thanks @Leaky Nun for the r[-1::-1] == r[:-1][::-1] tip (:
Alternative solution, with help from @Leaky Nun (8885 bytes)
for i in range(1,52):r=[*map(chr,range(65,91-abs(i-26)))];print(''.join(r+r[-2::-1]))

Why do you need lambda :?

was originally this def A(l):r=[chr(i + ord('A'))for i in range(l)];return ''.join(r+r[:-1][::-1])

for i in range(1,52):print((lambda r:''.join(r+r[:-1][::-1]))([chr(j+65)for j in range(abs(26*(i//26)-i%26))]))

Also, r[:-1][::-1] can be written as r[-1::-1]

You can shift the whole range instead of shifting j, and then you can use map

I don't get it lol

r=map(chr,range(65,65+abs(26*(i//26)-i%26)))

OOOOOOOOOOOOOOOOOOH

abs(26*(i//26)-i%26) is really i>26 and 52-i or i

lol, i was struggling to get that written in and and or operator, but gave up lol

65+abs(26*(i//26)-i%26) would become i>26and 117-i or 65+i

Which should become 91-abs(i-26)

lol thumb up #salute

lol, apparently 'abc'[-1::-1] is actually 'cba' instead of 'ba'

Then just do 'abc'[-2::-1] (Don't you test your answers before updating?)

somehow missed that one :P

Guile, 188 bytes
(define(t d e)(if(= e 27)(apply string-append(map list->string(append(reverse(cdr d))d)))(t(cons(let((a(map integer->char(iota e #x41))))(append a(cdr(reverse a))'(#\newline)))d)(1+ e))))

Or in a readable form:
(define (triangle done depth)
  (if (= depth 27)
    (apply string-append
     (map list->string
      (append (reverse (cdr done))
              done)))
    (triangle
     (cons (let ((alphabet (map integer->char (iota depth #x41))))
            (append alphabet (cdr (reverse alphabet)) '(#\newline)))
      done)
    (1+ depth))))

Call the program with (triangle '() 1) or (t '() 1), note that srfi-1 needs to be loaded.
The program creates a list of the chars in the alphabet, from a to the last letter in the current line. It then takes that lists, reverses it and removes the original last character, appends the two lists and adds a newline character at the end. It then does that 26 times, from A to Z. It then converts the lists to strings and concats them.
The program returns a string, which then should be passed to display, but this wasn't needed in the challenge.

Which version? I get “Wrong number of arguments to #<procedure iota (n)>” with GNU Guile 2.0.11.

Tested with Guile 2.0.12, but that sounds more like srfi-1 isn't loaded. Load it with guile --use-srfi=1 when starting, or as a module with (use-modules (srfi srfi-1)).

Sorry, that srfi-1 related note said nothing to me. Indeed, this way works fine. BTW, if the code needs module/package/library/unit/whatever loaded or requires command line option to turn on non-default processing mode, those should be included in the code length. Can't tell for sure whether it includes this srfi-1 case, but probably yes.

JavaScript (177 175 chars)
This is my best attempt at golfing this problem. I cannot find a way to do this with fewer characters

o='';

for(i=1;i<=26;i++){
 l='';
  for(j=1;j<=i;j++){
   l+=String.fromCharCode(j+64);
  }
 o+=l+l.slice(0,l.indexOf(l.slice(-1))).split('').reverse().join('')+"\n";
}

console.log(o);

Clojure, 182 bytes
(let[d dec w str c char n \u000A](defn p[x s](if(= x 65)s(p(d x)(w(c(d x))s(c(d x))))))(println(#(if(= % 65)%2(recur(d %)(w(p(d %)(c(d %)))n %2(p(d %)(c(d %)))n)))90(w(p 90 "Z")n))))
My first codegolf :). There is probably a much easier way to do it, but I am very new to clojure.
Ideone

Racket 327 bytes
(define(sr s)(list->string(reverse(string->list s))))(let loop((n 0)(s"A")(ol'("A")))(let*((st string)(mr(floor(/(string-length s)2)))
(mc(string-ref s mr))(ss(substring s 0 mr))(ns(string-append ss(st mc)(st(integer->char(+ 65(add1 n))))(st mc)(sr ss))))(if(< n 25)
(loop(add1 n)ns(cons ns ol))(append(reverse ol)(rest ol)))))

Ungolfed:
(define (f)

  (define (sr s)                     ; sub-fn to reverse a string;
    (list->string
     (reverse
      (string->list s))))

  (let loop ((n 0)
             (s "A")
             (ol '("A")))
    (let* ((st string)
           (mr (floor(/(string-length s)2)))
           (mc (string-ref s mr))
           (ss (substring s 0 mr))
           (ns (string-append
                ss
                (st mc)
                (st (integer->char (+ 65(add1 n))))
                (st mc)
                (sr ss))))
      (if (< n 25)
          (loop (add1 n)
                ns
                (cons ns ol))
          (append(reverse ol)(rest ol))
          ))))

Testing:
(f)

Output:
'("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")

You can shorten your names (i.e. (define (a s) rather than (define (sr s), (let l rather than (let loop). In addition, it was required to output that exact text, so you'd have to join with newlines.

Clojure, 111 bytes
#(let[f(fn[i](concat(range i)(range i -1 -1)))](doseq[i(f 25)](println(apply str(for[j(f i)](char(+ j 65)))))))

A function which prints the result. f is an utility function which creates the sequence from 0 to i and back to 0.

CJam, 29 bytes
'[,65>:A,{)A<_W%(;+}%_W%(;+N*

Pretty simple.
Explanation:
'[,65>:A e# Get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ" and store in A
,{       e# For i in range(26), collecting j:
  )      e#   j += i + 1
  A<     e#   j = a[:i]
  _W%    e#   k = reverse(j)
  (;     e#   k.pop()
  +      e#   j += k
}%       e# End
_W%      e# Duplicate and reverse
(;       e# Pop()
+        e# Append
N*       e# Join with newlines

VBA, 91 Bytes
Anonymous VBE immediate window function that takes no input and outputs the alphabet triangle to the VBE immediate window
For i=-25To 25:For j=0To-Abs(i)+25:s=s+Chr(65+j):Next:?s;StrReverse(Left(s,j-1)):s="":Next

-1 byte for use of ; over  & in ? statement

Common Lisp, 175 bytes
(let*((a"abcdefghijklmnopqrstuvwxyz")(f"~a~a~%")(b(reverse a)))(#1=dotimes(i 26)(#2=format t f(#3=subseq a 0 i)(#3#b(- 25 i))))(#1#(i 25)(#2#t f(#3#a 0(- 24 i))(#3#b(1+ i)))))

Try it online!
Ungolfed version:
(let* ((a "abcdefghijklmnopqrstuvwxyz")          ; define the alphabet
       (b (reverse a)))                          ; and reverse it
  (dotimes (i 26)                                ; print first half, 26 lines
    (format t "~a~a~%" (subseq a 0 i) (subseq b (- 25 i))))
  (dotimes (i 25)                                ; print second half
    (format t "~a~a~%" (subseq a 0 (- 24 i)) (subseq b (1+ i)))))

Japt -R, 14 9 bytes
;Bå+ mê ê

Test it

Explanation
;B            :Uppercase alphabet
  å+          :Cumulatively reduce by addition
     m        :Map
      ê       :  Mirror
        ê     :Mirror
              :Implicitly join with newlines and output

Recursiva, 12 bytes
{pB26'PpZ0(}

Try it online!
Explanation:
{pB26'PpZ0(}
{                   - For each
 p                  - Palindromize [1,2..26,25,24...1]
  B26               - Range 26 [1,2....26]
     '              - iteration command begin
      P             - Print
       p            - palindromize 'ABCDEDCBA'
        Z0(}        - Slice upper-case alphabet "(" from 0 to current count "}"
                      for example if }=5 'ABCDE'

K4, 28 bytes
Solution:
-1 .Q.A@f'(f:{t,x,|t:!x})25;

Explanation:
Define a function to create a palindrome range, create a palindrome range of 0..25..0, and then apply it to each in the list:
-1 .Q.A@f'(f:{t,x,|t:!x})25; / the solution
-1                         ; / print to stdout and swallow return value (-1)
          (             )    / do together
           f:{         }     / define function f as...
                     !x      / range 0..x-1
                   t:        / save as variable t
                  |          / reverse it
                x,           / join with x
              t,             / join with t
                         25  / perform f[25] => 0 1 2.. 25 24.. 1 0
        f'                   / apply f to each of these
   .Q.A@                     / apply (@) these indices to the alphabet A..Z

K4 isn't on TIO, but there's oK which is similar... Try it online!

Small Basic, 146 bytes
A Script that takes no input and outputs to the TextWindow Object
For i=-25To 25
For j=0To-Math.Abs(i)+25
c=Text.GetCharacter(65+j)
s=s+c
t=c+t
EndFor
TextWindow.WriteLine(s+Text.GetSubText(t,2,j))
s="
t="
EndFor

Try it at SmallBasic.com! Requires IE/Silverlight

JavaScript - 97 bytes
f=(i,l,q,t,r,a="ABCDEFGHIJKLMNOPQRSTUVWXYZ")=>(r="\n"+q+(c=a[i])+l+t)+(i<25?f(i+1,c,q+c,l+t)+r:"")

Which is called as:
f(0,"","","")

Should the function call factor into the byte count?

Stax, 8 bytes
çtò-+è╥â

Run and debug it
Palindromize the palindromizations of the prefixes of the alphabet.  Not very interesting program, but the challenge is back on the front page.

Pip, 15 bytes
PZ(PZz@<_M\,27)

Try it online!

Vyxal 3, 10 bytes
₂ɾṅ(nkaΘṅ,

Try it Online!

Jelly, 9 bytes
ØAḣJŒBŒḄY

Try it online!

https://codegolf.stackexchange.com/questions/87496/alphabet-triangle?page=1&tab=votes#comment237069_87498

@LeakyNun Thanks, although I'll keep it here, since that was a comment.

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


text:
Count the Unique Rectangles!
In my last challenge, you were asked to find all rectangles given a m x n grid of them. However, it turned out to be very trivial as there actually was a mathematical formula I did not even know about to solve the problem! So now, for a little bit more of a challenge, how about calculating the number of unique rectangles, i.e. find the number rectangles that are all of different dimensions?
For example, consider 4 horizontal, or y lines at [-250,-50,50,250] and 4 vertical, or x lines at [-250,-70,70,250]. Graphing these on a coordinate plane with infinite dimensions results in the following 500 x 500 pixel closed grid, in which the length of each segment in pixels and the lines corresponding to their respected values from the arrays are shown:

which contains the 16 unique rectangles shown in this animated GIF:

However, if the topmost line (y = 250) were to be removed, there would only be 12 unique rectangles, as the top 3 rectangles would be factored out since they each won't be fully closed without the y = 250 line.
Task
So, as shown above, the task is counting the number of rectangles rectangles with different dimensions. In other words, given an input of 2 arrays, with the first one containing all equations of all x lines, and the latter containing those of all y lines, output the total number of rectangles of different dimensions created when the lines corresponding to those equations are graphed on a coordinate plane.
Rules

The use of any built-ins that directly solve this problem is explicitly disallowed.
If either of the arrays have less than 2 elements, the output should be 0, since if there are less than 4 lines on the plane, there are no closed, 4 sided figures.
The input arrays are not guaranteed to be sorted.
You can assume that there are not any repeated values in either of the the input arrays.
A n x m rectangle is the same as a m x n rectangle. For example, a 300 x 200 rectangle is the same as a 200 x 300 one.
Standard loopholes are prohibited.

Test Cases
Given in the format Comma Separated Arrays Input -> Integer output:
[],[] -> 0
[-250,-50,50,250],[-250,-70,70,250] -> 16 (Visualized above)
[-250,-50,50,250],[-250,-70,70] -> 12
[-40, 40],[-80, 50] -> 1
[10],[10] -> 0
[60, -210, -60, 180, 400, -400], [250, -150] -> 12
[0,300,500],[0,300,500] -> 6
[0,81,90],[0,90,100] -> 9

Remember, this is code-golf, so shortest code wins!

[[0,300,500],[0,300,500]] should probably be a test case

@Sp3000 All right. I'll add that one as soon as possible.

@Sp3000 It's added.

@PeterTaylor Yeah, you're right. There are 6. I forgot to count the entire square itself! It's updated now.

@PeterTaylor Okay. Added.

JavaScript (ES6), 99
(X,Y,Z=new Set)=>X.map(v=>X.map(t=>t>v&&Y.map(w=>Y.map(u=>u>w&&Z.add([u-w,t-v].sort()+0)))))|Z.size

Note: sort is not numeric but lexicographic, but in this specific case I don't care
Less golfed
(X, Y, Z = new Set) =>
  X.map(
    v => X.map(
      t => t>v && Y.map(
        w => Y.map(
          u => u>w && Z.add([u-w, t-v].sort() + 0)
        )
      )
    )
  ) | Z.size

Test

F=(X,Y,Z=new Set)=>X.map(v=>X.map(t=>t>v&&Y.map(w=>Y.map(u=>u>w&&Z.add([u-w,t-v].sort()+0)))))|Z.size

;[
 [[],[], 0]
,[[-250,-50,50,250],[-250,-70,70,250], 16]
,[[-250,-50,50,250],[-250,-70,70], 12]
,[[-40, 40],[-80, 50], 1]
,[[10],[10], 0]
,[[60, -210, -60, 180, 400, -400], [250, -150], 12]
,[[0,300,500],[0,300,500], 6]
].forEach(t=>{
  var a=t[0],b=t[1],k=t[2],r=F(a,b)

  console.log(r==k?'OK':'KO','['+a+']','['+b+']',r)
})

Jelly, 13 bytes
ṢIẆS€µ€ŒpṢ€QL

Try it online!
A rectangle is uniquely defined by its height and its width.
ṢIẆS€µ€ŒpṢ€QL   Main chain, argument: z

     µ€         For each subarray:
Ṣ                   sort
 I                  compute consecutive increments
  Ẇ                 yield all substrings
   S€               compute sum of each substring
       Œp       Cartesian product
         Ṣ€     Sort each
           Q    Remove duplicates
            L   Length

Great job! +1 from me! :)

@PeterTaylor But it does work for that input...

@R.Kap, was this just because the test case was wrong?

Actually, it wasn't producing any output when I entered that test case at the time, but that was because I entered it in the wrong format. My bad. It works really well for that test case. Good job.

CJam (22 bytes)
q~{2m*::-:z0-}/m*:$_&,

Takes input as an array of arrays. Online demo, test suite
Dissection
q~     e# Parse input
{      e# For each of the two elements in the top-level array
  2m*  e#   Take its Cartesian self-product
  ::-  e#   Map fold subtraction, giving the separations between lines
  :z   e#   Map absolute value
  0-   e#   Remove 0, since trivial rectangles don't count
}/
m*     e# Cartesian product of the two sets of separations
:$     e# Sort so that mxn === nxm
_&     e# Deduplicate
,      e# Count

MATL, 22 bytes
"@gd&Xfo!s|]Z*!S!Xuz2/

Try it online! Or verify all test cases.
Explanation
"        % Implicitly input cell array of two numerical arrays. For each cell
  @g     %   Push cell contents
  d      %   Difference of its two entries
  &Xf    %   Cell array of all substrings
  o      %   Convert to numerical array, padding with zeros
  !s     %   Sum of each row. Gives a row vector
  |      %   Absolute value of each entry
]        % End for
Z*       % Cartesian product
!S!      % Sort each row
Xu       % Unique rows
z2/      % Number of unique rows excluding zeros. Implicitly display

Python, 208 bytes
import itertools as i
def h(x,y):
    s=[]
    k=[p for p in i.product(x,y)]
    for j,(v,w) in enumerate(k):
        for a,b in k[j+1:]:
            q=sorted([abs(a-v),abs(b-w)])
            if 0not in q and q not in s:s+=[q]
    return len(s)

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