[Question]
  [
# Task
Your task is to print this exact text:
```
A
BCD
EFGHI
JKLMNOP
QRSTUVWXY
ZABCDEFGHIJ
KLMNOPQRSTUVW
XYZABCDEFGHIJKL
MNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLM
NOPQRSTUVWXYZABCDEFGHIJKLMN
OPQRSTUVWXYZABCDEFGHIJKLMNOPQ
RSTUVWXYZABCDEFGHIJKLMNOPQRSTUV
WXYZABCDEFGHIJKLMNOPQRSTUVWXYZABC
DEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL
MNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW
XYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJ
KLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXY
ZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOP
QRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHI
JKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCD
EFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZA
BCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ
```
# Specs
* You may do it in all-lowercase instead of all-uppercase.
* Trailing newlines at the end of the triangle is allowed.
* Trailing spaces after each line is allowed.
* You must print to STDOUT instead of outputting an array of strings.
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Program with lowest byte-count wins.
  
[Answer]
# Vim, 29 bytes
```
:h<_↵↵↵y$ZZ26P0qqa↵♥βjllq25@q
```
Where `↵` represents the Return key, `♥` the Escape key, and `β` the Backspace key.
[![enter image description here](https://i.stack.imgur.com/am59T.gif)](https://i.stack.imgur.com/am59T.gif)
[Answer]
# Python 2, 65 bytes
```
i=1
a=bytearray(range(65,91))*26
while a:print a[:i];a=a[i:];i+=2
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
26RḤ’RØAṁY
```
[Try it online!](http://jelly.tryitonline.net/#code=MjZS4bik4oCZUsOYQeG5gVk&input=)
### How it works
```
26RḤ’RØAṁY  Main link. No Arguments.
26          Set the return value to 26.
  R         Range; yield [1, 2, ..., 25, 26].
   Ḥ        Unhalve; yield [2, 4, ..., 50, 52].
    ’       Decrement; yield [1, 3, ..., 49, 51].
     R      Range; yield [[1], [1, 2, 3], ..., [1, ..., 49], [1, ..., 51]].
      ØA    Yield the uppercase alphabet.
        ṁ   Mold the alphabet as the array of ranges. This repeats the uppercase
            letters over an over again, until all integers in the range arrays
            have been replaced with letters.
         Y  Join, separating by linefeeds.
```
[Answer]
## VBA Excel (80 bytes, 1742 bytes)
---
# Excel, 1742 bytes
Inspired by [the ugoren's creative answer](https://codegolf.stackexchange.com/a/87079/58742), I managed to find an Excel formula to create the pattern as shown in the OP.
```
=MID(REPT("ABCDEFGHIJKLMNOPQRSTUVWXYZ",26),(ROW()-1)^2+1,2*ROW()-1)
```
Paste this formula in cell A1, then drag all over range A1:A26.
The length of the formula is 67 bytes but you have to replicate it 26 times, so it's equal to 67\*26=1742 bytes. Here is the output:
[![enter image description here](https://i.stack.imgur.com/jClc9.png)](https://i.stack.imgur.com/jClc9.png)
---
# Excel VBA, 80 bytes
Now it's possible we integrate Excel with VBA to automate the process and to save many bytes since VBA is built into most Microsoft Office applications, including Excel. Write and run the following code in the Immediate Window (use combination keys `CTRL`+`G` to display it in Visual Basic Editor):
```
[A1:A26]="=MID(REPT(""ABCDEFGHIJKLMNOPQRSTUVWXYZ"",26),(ROW()-1)^2+1,2*ROW()-1)"
```
The program works by printing the Excel formula above to the range A1:A26. Unfortunately, both Excel and VBA have no built-in alphabet.
[Answer]
## Haskell, 67 bytes
```
_#53=[]
s#i=take i s:drop i s#(i+2)
mapM putStrLn$cycle['A'..'Z']#1
```
A simple recursion over the length `i` of the line. In each step the next `i` chars are taken from an infinite repetition of the alphabet.
[Answer]
# Mathematica, 90 bytes
```
StringRiffle[Flatten[Alphabet[]&~Array~26]~Internal`PartitionRagged~Range[1,51,2],"
",""]&
```
Anonymous function. Takes no input and returns a string as output. Golfing suggestions welcome. An example of what `Internal`PartitionRagged` does:
```
In[1]:= Internal`PartitionRagged[{2, 3, 5, 7, 11, 13}, {2, 3, 1}]               
Out[1]= {{2, 3}, {5, 7, 11}, {13}}
```
[Answer]
# C, 79 bytes
```
main(i,j){for(i=0,j=1;i<676;i++){putchar(i%26+65);if(j*j==i+1){puts("");j++;}}}
```
My first answer in C \o/
Golfing suggestions are more than welcome.
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 37 bytes
```
26~l<:1aLc~j[@A:I],L~@nw
=:2%1,.#@l?,
```
[Try it online!](http://brachylog.tryitonline.net/#code=MjZ-bDw6MWFMY35qW0BBOkldLEx-QG53Cj06MiUxLC4jQGw_LA&input=)
### Explanation
* Main predicate:
```
26~l         Let there be a list of 26 elements
<            This list is an ascending list of integers
:1aL         Apply predicate 1 to that list ; the resulting list of strings is L
c            Concatenate the list of strings into one big string
~j[@A:I],    That big string is the result of juxataposing the alphabet I times to itself
L~@n         Create a string which when splitted on line breaks results in L
w            Write that string to STDOUT
```
* Predicate 1: used to generate variable strings of odd lengths.
```
=            Assign a value to the Input
:2%1,        That value must be odd
.#@l?,       Output is a string of length Input
```
[Answer]
# Perl, ~~42~~ ~~41~~ 39 bytes
```
perl -E '@b=(A..Z)x26;say splice@b,0,$#a+=2for@b'
```
Just the code:
```
@b=(A..Z)x26;say splice@b,0,$#a+=2for@b
```
An obvious shorter version unfortunately triggers an internal perl problem (Use of freed value in iteration): 
```
say splice@b,0,$#a+=2for@b=(A..Z)x26
```
[Answer]
# [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/Pyramid-Scheme), 1492 bytes
```
    ^         ^
   / \       / \
  /set\     /do \
 ^-----^   ^-----^
/a\   ^-  /!\   /[\
---  ^-  ^---  ^---^
    ^-  /=\   ^-  / \
   ^-  ^---^  -^ /out\
  ^-  ^-  /a\ ^- -----^
 ^-  / \  ---/[\     / \
 -^ /51 \   ^---^   /chr\
 ^- -----  ^-  / \  -----^
 -^       ^-  /do \     / \
 ^-      ^-  ^-----^   /10 \
 -^     /[\  -^   ^-   -----
 ^-    ^---^  -^  -^ 
 -^   / \  -^ /c\ ^-  
 ^-  /set\ /[\--- -^    
^-  ^-----^---^   ^-
-^ /a\   /+\  -^  -^
^- ---  ^---^  -^  -^
-^     /a\ /2\ / \  -^
 -^    --- ---/set\  -^
  -^         ^-----^ ^-
   -^       /c\   /a\-^
    -^      ---   --- -^
     -^               /[\
      -^             ^---^
       -^           ^-   -^
       /]\         / \    -^
      ^---^       /set\    -^ 
     ^-   -^     ^-----^    -^
    / \   ^-    /c\   /-\    -^
   /set\ ^-     ---  ^---^    -^
  ^-----^-          /c\ /1\    -^
 /b\   / \          --- ---    /]\
 ---  / -1\                   ^---^
      -----                  ^-  / \
                            / \ /out\
                           /set\-----^
                          ^-----^    -^
                         /b\   /?\    -^
                         ---  ^---^   / \
                             /!\  -^ /chr\
                            ^---  /+\-----^
                           /=\   ^---^   /+\
                          ^---^ /b\ /1\ ^---^
                         /b\ / \--- ---/ \ /b\
                         ---/25 \     /65 \---
                            -----     -----
```
[Try it online!](https://tio.run/##hVRJbsMwDLzrFew5MFgHSG9FH1JWQDYgPQQpkvTQ17tcJTmLLcCJLJJDzlD0z995ffzedZftYX/cDwPwyhArJ/5BIH/lHR/gZX@1E9yd5CR3siTKdwnXpG/s8iI7/KTEBjvKvhNHCLf3EqA5iiOj8oOn36scZ4cQfP73bBEHcsCpaq0SuuqBoIABbg9nrdmiYRSsaF3wV4tQrIByBE15jtm/ejYwsgAuBzhsRFZK8niIZedSt8oKnJDKzGBSpUGnJm1RPEmk6o0LCuhk/G4SpqiQ3XFJkTgq10SsoPVXu9M1d8HpckZoDFK0Ino3w6DZDdIMLRaEUAkemerduLWZosWGX1TRrE/FGAqpLa6sit4AjZjVaIS4joVg16AbnN@FVmZ3iBY1VBkE@wKBGxoNVhXfWSXbI3Q9wf1qBfJrfO9SZunpkgJitJ47CdmYjafrXsPHYEb8g@YcR6rO8bCvjE6QDjdM16mTMsuofJO8hgXN0M/KTrqcp6HVDSjGTZqwoUkpcLmKr9DbSiMnSdYrobth@Ac "Pyramid Scheme – Try It Online")
Why? Why not?
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 12 bytes
```
jtc*G26*Rd26
```
[Try it online!](http://pyth.herokuapp.com/?code=jtc%2aG26%2aRd26&debug=0)
[Answer]
# JavaScript (ES6), 77 ~~82 88~~
EcmaScript 6 required just to save 1 byte using a template string literal for newline.
```
for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)
```
*Less golfed*
```
for(i = r = l = o = '';
    l + 52;
    r++ || (r = l -= 2, o += `\n`))
  o += (i++ % 26 + 10).toString(36);
alert(o);
```
**Test**
```
for(i=r=l=o='';l+52;r++||(r=l-=2,o+=`
`))o+=(i++%26+10).toString(36);alert(o)
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
Cİ1ṠṁK…"AZ
```
[Try it online!](https://tio.run/##yygtzv7/3/nIBsOHOxc83Nno/ahhmZJj1P//AA "Husk – Try It Online")
### Explanation
```
Cİ1ṠṁK…"AZ
      …"AZ    Get the alphabet
   ṠṁK        Replace each letter with the whole alphabet
C             Cut the resulting string into lines with lengths
 İ1            equal to the list of odd numbers
```
[Answer]
# JavaScript, 129 bytes
```
z=1,i=0,g=a=>{b=0,c="";while(a+a-1>b){c+='ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split``[i>26?i=0:i++];b++}console.log(c)};while(z<26)g(z++)
```
[Answer]
## Pyke, 14 bytes
```
G26*WDoh<
Ko>D
```
[Try it here!](http://pyke.catbus.co.uk/?code=G26%2aWDoh%3C%0AKo%3ED&warnings=0)
[Answer]
# Go, 133 bytes
```
package main
import S "strings"
func main(){s:=S.Repeat("ABCDEFGHIJKLMNOPQRSTUVXXYZ",26)
for i:=1;s!="";i+=2{println(s[:i]);s=s[i:]}}
```
[Answer]
# MATLAB, ~~112 109 95 79~~ 77 bytes
This will also work with **Octave**, you can try [online here](http://octave-online.net).
```
a=['' 65:90 65:90]';j=0;for i=1:2:52;b=circshift(a,j);j=j-i;disp(b(1:i)');end
```
So after some major changes, I've saved a further ~~14~~ 32 bytes. This one is getting to be much more like the length I would have expected from MATLAB. I've left the old version below as it is substantially different.
```
a=['' 65:90 65:90]';        %Create 2 copies of the upper case alphabet
j=0;                        %Initialise cumulative sum
for i=1:2:52;               %For each line length
    b=circshift(a,j);       %Rotate the alphabet string by the cumulative offset
    j=j-i;                  %Update cumulative negative sum of offsets.
    disp(
         b(1:i)'            %Extract first 'line length' characters from rotated alphabet.
               );           %Display next line (disp adds newline automatically)
end
```
---
**Original version:**
```
a=['' repmat(65:90,1,26)];c=cumsum(1:2:51);disp(cell2mat(arrayfun(@(s,f)[a(s:f) 10],[1,c(1:25)+1],c,'Un',0)))
```
Wow that one ended up being longer than I thought it would. I'll see if I can't knock a few bytes off it.
An ungolfed version to explain:
```
a=['' repmat(65:90,1,26)]; %Create 26 copies of the upper case alphabet
c=cumsum(1:2:51);          %Calculate the end index of each row in the above array, by cumulatively summing the length of each line
disp(
     cell2mat(
              arrayfun(@(s,f)
                             [a(s:f) 10], %Extract the part of the alphabet and insert a new line.
                                         [1,c(1:25)+1],c, %start index is the previous end of line plus 1. End index is as calculated by cumsum.
                       'Un',0 %The returned values are not all the same length
                       )   %Do this for each line
              )            %Convert back to a matrix now new lines inserted
     )                     %And display it
```
---
**Acknowledgements**
* 3 bytes saved - thanks @LuisMendo
[Answer]
## XPath 3.0 (and XQuery 3.0), 84 bytes
```
codepoints-to-string((0 to 25)!(subsequence(((1 to 26)!(65 to 90)),.*.+1,2*.+1),10))
```
Explanation:
`(1 to 26)!(65 to 90)` is the alphabet 26 times
`(0 to 25)!(subsequence(XX, start, len),10)` takes 26 subsequences of this, each followed by newline
`subsequence(X, .*.+1, 2*.+1)` takes successive subsequences with start position and length: (1, 1), (2, 3), (5, 5), (10, 9) etc.
`codepoints-to-string()` turns Unicode codepoints into characters
[Answer]
# Ruby, 46 bytes
```
26.times{|i|puts ([*?A..?Z]*26)[i*i,i*2+1]*""}
```
See it on ideone: <http://ideone.com/3hGLB0>
[Answer]
# 05AB1E (alternate) 15 bytes
```
A2×52µ¼D¾£,¾¼FÀ
```
[Try it online!](http://05ab1e.tryitonline.net/#code=QTLDlzUywrXCvETCvsKjLMK-wrxGw4A&input=)
Explanation:
```
A2×              # push a string containing a-za-z
   52µ           # Loop the rest of the program until counter = 52
      ¼          # increment counter (it's 0 initially)
       D         # Duplicate the alpha string on the stack
        ¾£       # Replace alpha with alpha[0..counter]
          ,      # Pop the substring and print it
           ¾¼FÀ  # rotate the alpha string left counter++ times.
```
[Answer]
# R, ~~120~~ ~~115~~ 111 bytes
```
v=c();for(i in 1:26){v=c(v,c(rep(LETTERS,26)[(sum((b=seq(1,51,2))[1:i-1])+1):sum(b[1:i])],"\n"))};cat(v,sep="")
```
**Ungolfed :**
```
a=rep(LETTERS,26)
b=seq(1,51,2)
v=vector()
for(i in 1:26)
    {
    v=c(v,c(a[(sum(b[1:i-1])+1):sum(b[1:i])],"\n"))
    }
cat(v,sep="")
```
Basically, `b` is the vector of the odd numbers between `1` and `51`, thus giving the length of each line. Obviously, the `sum` function *sums* the numbers of this vector, and gives the starting and ending indexes.
*-5 bytes* thanks to @plannapus !  
*-4 bytes* thanks to @plannapus !
[Answer]
# R, 81 73 65 63 bytes
A simple `for` loop approach. Repeat the alphabet 26 times and loop through a sliding index range that is calculated using `(i^2-2*i+2):i^2`.
```
for(i in 1:26)cat(rep(LETTERS,26)[(i^2-2*i+2):i^2],"\n",sep="")
```
[Answer]
## Batch, 123 bytes
```
@set s=
@for /l %%i in (1,2,51)do @call set s=%%s%%ABCDEFGHIJKLMNOPQRSTUVWXYZ&call echo %%s:~0,%%i%%&call set s=%%s:~%%i%%
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~18~~ 17 bytes
```
26FA26×N>n£NnF¦},
```
**Explanation**
```
26F                 # for N in range(0, 26) do
   A26×             # the alphabet repeated 26 times
       N>n£         # take (N+1)^2 letters
           NnF¦}    # throw away the first N^2 letters
                ,   # print with newline
```
[Try it online!](http://05ab1e.tryitonline.net/#code=MjZGQTI2w5dOPm7Co05uRsKmfSw&input=)
[Answer]
# Rexx, ~~74~~ 72 bytes
```
i=1;m=1;do 26;say substr(copies(xrange('A','Z'),26),i,m);i=i+m;m=m+2;end
```
Ungolfed:
```
i=1
m=1
do 26
  say substr(copies(xrange('A','Z'),26),i,m)
  i=i+m
  m=m+2
end
```
[Answer]
# TSQL, 129 bytes
USE MASTER in the beginning of the script is to ensure that the query is run in the master database which is default for many users(not counting bytes for that).
**Golfed:**
```
USE MASTER
SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)FROM spt_values WHERE number<26and'P'=type
```
**Ungolfed:**
```
USE MASTER
SELECT SUBSTRING(REPLICATE('ABCDEFGHIJKLMNOPQRSTUVWXYZ',26),number*number+1,number*2+1)
FROM spt_values
WHERE number<26and'P'=type
```
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/527267/alphabet-triangle-strikes-again)**
**[Fiddle for older version using xml path](https://data.stackexchange.com/stackoverflow/query/527174/alphabet-triangle-strikes-again)**
[Answer]
# PowerShell, 68 bytes
```
$a=-join(65..90|%{[char]$_})*26;26..1|%{$a=$a.Insert($_*$_,"`n")};$a
```
The section before the first semicolon produces a string containing 26 copies of the uppercase alphabet. The next section injects linebreaks at the index of each square number (working backward so I don't have to account for the shifting). Finally, the `$a` at the end just shoves that string variable onto PowerShell's equivalent of `STDOUT`.
[Answer]
# Dyalog APL, 18 [bytes](http://meta.codegolf.stackexchange.com/questions/9428/when-can-apl-characters-be-counted-as-1-byte-each/)
[`↑2{⍺↓⍵⍴⎕a}/×⍨0,⍳26`](http://tryapl.org/?a=%u21912%7B%u237A%u2193%u2375%u2374%u2395a%7D/%D7%u23680%2C%u237326&run)
[Answer]
# C, 60 bytes
```
i;main(j){for(;j<27;j*j^++i||puts("",j++))putchar(i%26+65);}
```
[Answer]
# C++, 111 bytes
```
void a(){int c=65,i,j;for(i=0;i<26;i++){for(j=0;j<=2*i;j++){std::cout<<(char)c;c++;if(c==91)c=65;}std::cout<<'\n';}}
```
First try at one of these.
Uses an int "c" to record which letter it needs to print at any given time. Once "c" passes 90 ('Z') it gets reset to 65 ('A'). Prints the pyramid using for loops.
]