[Question]
  [
# Description
Output the rhyme scheme for a very long Terza Rima.
# Input
None.
# Output
```
ABA
BCB
CDC
DED
EFE
FGF
GHG
HIH
IJI
JKJ
KLK
LML
MNM
NON
OPO
PQP
QRQ
RSR
STS
TUT
UVU
VWV
WXW
XYX
YZY
```
# Rules
You can pick between separating stanzas with whitespace or newlines, so either:
```
ABA BCB...
```
OR
```
ABA
BCB
...
```
A single trailing whitespace allowed per line and one trailing newline allowed.
Output can be either uppercase or lowercase.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes for each language wins.
  
[Answer]
# JavaScript (ES6), ~~51~~ ~~50~~ 49 bytes
*Saved 1 byte thanks to @l4m2*
```
f=(n=45358)=>n%63?f(n-1333)+n.toString(36)+' ':''
```
[Try it online!](https://tio.run/##BcH/CkAwEADgV/GPdpcoHZIaD@EJxKb5cadtKU8/33cs7xJW755Yhsdtxt/Cp/lSshpYNy21PeqR844mC1zWRIQFV1Hm6B3vQB0WKlODUmkVDnKZ6pIdLCCmHw "JavaScript (SpiderMonkey) – Try It Online")
### How?
We start with **n = 45358** (**yzy** in base-36). We subtract **1333** from **n** at each iteration (**111** in base-36). We stop as soon as **n MOD 63 = 0**, because **12033** (**9a9** in base-36) is the first value for which this condition is fulfilled, and **63** is the smallest modulo with such a property.
```
Decimal | Base-36 | MOD 63
--------+---------+-------
  45358 |   yzy   |   61
  44025 |   xyx   |   51
  42692 |   wxw   |   41
  41359 |   vwv   |   31
  40026 |   uvu   |   21
  38693 |   tut   |   11
  37360 |   sts   |    1
  36027 |   rsr   |   54
  34694 |   qrq   |   44
  33361 |   pqp   |   34
  32028 |   opo   |   24
  30695 |   non   |   14
  29362 |   mnm   |    4
  28029 |   lml   |   57
  26696 |   klk   |   47
  25363 |   jkj   |   37
  24030 |   iji   |   27
  22697 |   hih   |   17
  21364 |   ghg   |    7
  20031 |   fgf   |   60
  18698 |   efe   |   50
  17365 |   ded   |   40
  16032 |   cdc   |   30
  14699 |   bcb   |   20
  13366 |   aba   |   10
  12033 |   9a9   |    0
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 41 bytes
```
f(i){for(i='ABA';i%29;i+=65793)puts(&i);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOi2/SCPTVt3RyVHdOlPVyNI6U9vWzNTc0lizoLSkWEMtU9O69n9mXolCbmJmnoZmNRdnmoamNRdnUWpJaVGegoE1V@1/AA "C (gcc) – Try It Online")
Fixed and -9 thanks to [user202729](https://codegolf.stackexchange.com/users/69850/user202729). -1 thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis) and -2 thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld) too.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
ØAṡ2ŒBY
```
[Try it online!](https://tio.run/##y0rNyan8///wDMeHOxcaHZ3kFPn/PwA "Jelly – Try It Online")
-1 byte thanks to Dennis
```
ØAṡ2ŒBY  Main Link
ØA       Alphabet
  ṡ2     Slice into overlapping slices of length 2
    ŒB   Palindromize (bounce) each
      Y  Join by newlines
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~51~~ 48 bytes
*Saved 3 bytes thanks to @ovs.*
```
++++++++[>+>+++>++++++++<<<-]>++>+[->+.+.-.<<.>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwqi7bTtgJQdjG9jY6MbawcSsNO2ida109PW09UDiurZxf7/DwA "brainfuck – Try It Online")
## Explanation
```
INITIALIZE TAPE:
0000:           (none)
0001: C_NEWLINE (10)
0002: V_COUNT   (25)
0003: V_ALPHA   (64)
++++++++[>+>+++>++++++++<<<-]>++>+
V_COUNT TIMES:              [-
    INCREMENT V_ALPHA         >+
    PRINT V_ALPHA             .
    PRINT V_ALPHA PLUS ONE    +.
    PRINT V_ALPHA             -.
    PRINT C_NEWLINE           <<.
END LOOP                    >]
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~51~~ 49 bytes
```
+++++[>+++++>+++++++++++++>++<<<-]>[>.+.-.+>.<<-]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGwSi7cAUhIQBIM/GxkY31i7aTk9bT1dP204PxP3/HwA "brainfuck – Try It Online")
An attempt at an explanation...
```
+++++                     #Put 5 in cell 0 because that is the highest common denominator of 10, 65 and 25
[                         #Start loop
>+++++                    #Counter in cell 1 is 25 (How many lines we must print)
>+++++++++++++            #Counter in cell 2 is 65 (ASCII A)  
>++                       #Counter in cell 3 is 10 (Newline)
<<<-]                     #Decrement the outer counter until the cells have the right values (muliples of 5).
>                         #Move to the counter that says how many lines we must print.
[>.                       #Print the character in cell 2
+.                        #Add one to the character in cell 2 and print it
-.                        #Subtract one from the character in cell 2 and print it
+                         #Add one to the character in cell 2 for the next loop
>.                        #Print a new line
<<-]                      #Decrement cell 1 and run again until cell 1 is 0
```
-2 with thanks to @ovs
My first attempt at brainfuck so any hints gratefully received. If I was more experienced with it then I am sure I could shave a few more bytes off but I only got into it yesterday.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
Aü«€û
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f8fCeQ6sfNa05vPv/fwA "05AB1E – Try It Online")
-1 byte thanks to Emigna  
-1 byte thanks to rule change; thanks to kalsowerus for pointing that out
Hehe, currently beats Pyth. \o/
# Explanation
```
Aü«€û   Full Program
A       Lowercase Alphabet
 ü«     Pairwise with merge-list
   €û   For each, palindromize
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~42~~ 41 bytes
-1 byte thanks to Halvard Hummel
```
i=65;exec"print'%c'*3%(i,i+1,i);i+=1;"*25
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWzNQ6tSI1WamgKDOvRF01WV3LWFUjUydT21AnU9M6U9vW0FpJy8j0/38A "Python 2 – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 14 bytes
```
25↑0 1 0⊖3/⍪⎕A
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE4xMH7VNNFAwVDB41DXNWP9R7yqguOP//wA "APL (Dyalog Unicode) – Try It Online")
Please note that the added `⎕←` is for TIO to output the text and is not normally required.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
Ｅ²⁵✂αι⁺²ι‖Ｏ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUDDyFRHITgnMzlVI1FHIVNHISCntFjDCMjUBAJrrqDUtJzU5BL/stSiHKBqTev////rluUAAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 ²⁵         Literal 25
Ｅ           Map over implicit range
    α       Predefined uppercase letters
   ✂ ι⁺²ι   Slice 2 characters
            Implicitly print result on separate lines
         ‖Ｏ Reflect with overlap
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 90 bytes
```
((((()()()){}){}){}()){(({})<((({}((((()()()()){}){}){}){})())[()])((()()()()()){})>[()])}
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwMENEFQs7oWgkBMDQ0g00YDRCFUIKkBISA3WkMzVhMhDVFgBxat/f//v64jAA "Brain-Flak – Try It Online")
One reason this is shorter than the other brain-flak answer is because it uses uppercase instead of lowercase characters, which have smaller ASCII values, and are therefore easier to push.
Explanation:
```
#Push 25
((((()()()){}){}){}())
#While true
{
    #Keep track of the number on top of the stack...
    # We'll call it 'a'
    (({})
        #Push A +...
        <((({}
        # 64 (push)
        ((((()()()()){}){}){}){})
        # + 1 (push)
        ())
        # - 1 (push)
        [()])
        # Push 10
        ((()()()()()){})>
    # Now that's all pushed, we push a - 1 to decrement the loop counter
    [()])
# Endwhile
}
```
[Answer]
# R, ~~51~~ 47 bytes
```
L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))
```
Output:
```
> L=LETTERS;cat(sprintf("%s%s%1$s",L[-26],L[-1]))
ABA BCB CDC DED EFE FGF GHG HIH IJI JKJ KLK LML MNM NON OPO PQP QRQ RSR STS TUT UVU VWV WXW XYX YZY
```
[Answer]
# [Java 8](http://www.oracle.com/technetwork/java/javase/overview/java8-2100321.html), ~~132~~ ~~85~~ ~~62~~ 60 Bytes
* 47 bytes thanks to Neil
* 26 bytes thanks to Oliver
* 3 bytes and much better formatting thanks to Kevin
* Error fixed by Oliver
# Golfed
```
a->{for(char i=64;++i<90;)System.out.println(""+i+++i--+i);}
```
# Ungolfed
```
public class TerzaRima {
    interface A{
        void a(String a);
    }
    static A a = a -> {
        for (char i = 64; ++i < 90; ) System.out.println("" + i++ + i-- + i);
    };
    public static void main(String[] args){
        a.a(null);
    }
}
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~25~~ ~~24~~ ~~23~~ 22 bytes
Saved 2 bytes thanks to *Jo King*
```
"!;::o1+:o$oao:'Y')0.A
```
[Try it online!](https://tio.run/##S8sszvj/X0nR2soq31DbKl8lPzHfSj1SXdNAz/H/fwA "><> – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~45~~ 37 bytes
```
+[[<+>>++<-]>]<<---[-----<+.+.-.<.>>]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fOzraRtvOTlvbRjfWLtbGRldXN1oXBGy09bT1dPVs9OzsYv//BwA)
Prints in uppercase, separated by spaces with a trailing space.
### How it Works:
```
+[[<+>>++<-]>] Intialises the tape with the format n^2
               1 2 4 8 16 32 64 128 0 0'
<<---          Navigates to the desired section and tweaks the counter
               1 2 4 8 16 32 64 125<
[-----<+.+.-.<.>>] Prints the Terza Rima, using:
                 125 as the loop counter (decremented by 5 each loop)
                 64 as the current alphabetic character (incremented and printed each loop)
                 32 as the space character
```
[Answer]
# [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), ~~27~~ ~~23~~ 21 bytes
-4 bytes thanks to [James Holderness](https://codegolf.stackexchange.com/users/62101/james-holderness)
```
j'@1+3k:,1+,,a,'Y/!1+
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/P0vdwVDbONtKx1BbRydRRz1SX9FQ@/9/AA "Befunge-98 (FBBI) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal/tree/version-2) `j`, 3 bytes
```
nzʁ
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyJqIiwiIiwibnrKgSIsIiIsIiJd)
```
n   # Lowercase alphabet
 z  # Overlapping pairs of elements
  ʁ # Mirror each
    # (j flag joins list of lines by newlines)
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
ẊS:`e…"AZ
```
[Try it online!](https://tio.run/##yygtzv7//@GurmCrhNRHDcuUHKP@/wcA "Husk – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 41 bytes
```
-[[<+>--->++>>>+<<<<]>+]>>>[<<.+.-.+>.>-]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fNzraRttOV1fXTlvbzs5O2wYIYu20Y4HsaBsbPW09XT1tOz073dj//wE "brainfuck – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
jC[GtGG
```
**[Try it here!](https://pyth.herokuapp.com/?code=jC%5BGtGG&debug=0)**
~~Hehe, currently beats Jelly. \o/~~
Easily translates to the follwong 05ab1e program:
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
AA¦A)ø»
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f0fHQMkfNwzsO7f7/HwA "05AB1E – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 15 bytes
```
u:2$~&3\65+i.26
```
[Try it online!](https://tio.run/##y/r/PzU5I1@h1MpIpU7NOMbMVDtTz8js/38A "J – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~34~~ ~~32~~ 31 bytes
Based on [totallyhuman's](https://codegolf.stackexchange.com/users/68615/totallyhuman) answer. **-1** byte thanks to [H.PWiz](https://codegolf.stackexchange.com/users/71256/h-pwiz)
```
do x<-['A'..'Y'];x:succ x:x:" "
```
[Try it online!](https://tio.run/##y0gszk7NyfmfmFdcnlpkG/M/JV@hwkY3Wt1RXU9PPVI91rrCqrg0OVmhwqrCSklB6X9uYmaegq1CQWlJcEmRAkTb/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 180 bytes
```
(()()())(({}){})(({}){})(({}){})(({}){})(({}){}())<>(()()()()())(({}){})(({}){})(()()()()(){}){({}[()])<>(({}))(({}()))(({}[()]))({}()<(()()()()()()()()()())>)<>}<>{}{}{({}<>)<>}<>
```
[Try it online!](https://tio.run/##hY65asNAEIb7eQqXUmHQypcEQqD78CFbtxJSOEUgJKRIa/Tsyv6riXETwor9vpmdX8zr9/X9a/n2ef2YJk3TcXRNu426/P6hnHRczvyRu7@hIbvPmv6iQrJWYzKlqB501XAeYg8/d2VudNzbKI@cc7iePN9b2LuFbcmb/MBXZsubgjCACcOQoDAKlQpDgBTFEbsJUpzEvw5SkiZcr1SdZin7GqQsz9g3IOX7nH0L0v6wZ9@BdDge2C2QjqcjO1a06FScZhfY0abiXMwuBEjny5ndBOlSXthXIJVVyb4Gqaor9g1IdVOzb0Fq2oZ9B1LbtewWSF3fsWMni/qhn93ETjYNT8PspgCnaen9AA "Brain-Flak – Try It Online")
Thanks to DJ for getting this working
[Answer]
# [Haskell](https://www.haskell.org/), 28 bytes
```
[[x,succ x,x]|x<-['A'..'Y']]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfYxvzPzq6Qqe4NDlZoUKnIramwkY3Wt1RXU9PPVI9NvZ/bmJmnoKtQkFpSXBJkYKKQmleTmZearFCzv9/yWk5ienF/3WTCwoA "Haskell – Try It Online")
`succ` is such an unfortunate naming choice...
## Explanation
```
[[x,succ x,x]|x<-['A'..'Y']]
[            |x<-          ]  -- for x in...
                 ['A'..'Y']   -- the alphabet sans Z
 [x,succ x,x]                 -- construct a string of x, the successor of x and x
```
[Answer]
# [R](https://www.r-project.org/), 40 bytes
```
cat(intToUtf8(rbind(x<-65:89,x+1,x,10)))
```
[Try it online!](https://tio.run/##K/r/PzmxRCMzryQkP7QkzUKjKCkzL0WjwkbXzNTKwlKnQttQp0LH0EBTU/P/fwA "R – Try It Online")
One more alternative in R to [Plannapus](https://codegolf.stackexchange.com/a/151050/67312) and [Giuseppe's](https://codegolf.stackexchange.com/a/151190/72975) answers. Posted following their request. This solution uses ASCII code to UTF8 coding. 
PS if TABs were allowed, one could replace the newline (ASCII code 10) with a tabulation (ASCII code 9), and the solution could shrink to 39 bytes:
`cat(intToUtf8(rbind(x<-65:89,x+1,x,9)))`
[Answer]
# [R](https://www.r-project.org/), ~~40~~ 36 bytes
```
cat(paste0(L<-LETTERS,L[-1],L)[-26])
```
[Try it online!](https://tio.run/##K/r/PzmxRKMgsbgk1UDDx0bXxzUkxDUoWMcnWtcwVsdHM1rXyCxW8/9/AA "R – Try It Online")
An alternative to [plannapus' answer](https://codegolf.stackexchange.com/a/151050/67312); this turns out to be a bit golfier; I've posted it per his request.
See also [this 40 byte answer](https://codegolf.stackexchange.com/a/151208/67312) by NofP which is quite nice.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~39~~ 37 bytes
```
65..89|%{-join[char[]]($_,++$_,--$_)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38xUT8/Cska1WjcrPzMvOjkjsSg6NlZDJV5HWxtI6OqqxGvW/v8PAA "PowerShell – Try It Online")
Loops from `65` to `89`. Each iteration, we're constructing an integer array of (the current, one more, and the current) of the current digit, using pre-increment and pre-decrement. That's then re-cast as a `char`-array, and `-join`ed together into a single string. Each string is left on the pipeline and an implicit `Write-Output` at program completion gives us a newline between each element for free.
---
Alternatively, same byte count
```
65..89|%{-join[char[]]($_,($_+1),$_)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38xUT8/Cska1WjcrPzMvOjkjsSg6NlZDJV4HiLUNNXVU4jVr//8HAA "PowerShell – Try It Online")
[Answer]
# Pepe, ~~59~~ 56 bytes
-3 bytes thanks to u\_ndefined
```
REeEeEEeEerEeEeeeeeERrEEEEErEEEeeREEreeerEEEEEeeEreeERee
```
[Try it online!](https://soaku.github.io/Pepe/#!bp!aa--i-cFGS2I/)
Explanation:
```
# Prepare stacks
  # prepare stack R [Z]
  REeEeEEeEe  # push Z
  # prepare stack r [A,B,A]
  rEeEeeeeeE  # push A
  RrEEEEE     # copy and increment A (getting B)
  rEEEee      # duplicate A to end
# Start loop
REE           # create label Z
  reee        # output stack r contents
  rEEEEEeeE   # increment all
  reeE        # end line
Ree           # loop while r[p] != Z
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 8 bytes
```
PZ_.BMPz
```
[Try it online!](https://tio.run/##K8gs@P8/ICpez8k3oOr///@6eQA "Pip – Try It Online")
[Answer]
# [vJASS](https://wc3modding.info/pages/vjass-documentation/) (Warcraft 3), ~~203~~ ~~189~~ ~~182~~ ~~177~~ 156 bytes
Using `//! import zinc "<code_path>"` command to exclude `//! zinc` and `//! endzinc`.
---
```
library q{integer w,e;string r="ABCDEFGHIJKLMNOPQRSTUVWXYZ",t;function onInit(){for(0<=w<25){e=w+1;t=SubString(r,w,e);BJDebugMsg(t+SubString(r,e,e+1)+t);}}}
```
---
**Readable Version:**
```
library q{
    integer Index, Increment;
    string Alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ", Letter;
    function onInit(){
        /*
        *   Index from 0 to 24
        */
        for (0 <= Index < 25){
            Increment = Index + 1;
            // Slice
            Letter = SubString(Alphabets, Index, Increment);
            // Output
            BJDebugMsg(Letter + SubString(Alphabets, Increment, Increment + 1) + Letter);
        }
    }
}
```
[![Warcraft 3](https://i.stack.imgur.com/h8kFH.jpg)](https://i.stack.imgur.com/h8kFH.jpg)
  
---
  
**Verification purposes only:**  
The in-game text screen has limited space. Using `Preload()`, we may able to see the full output.
```
//! zinc
library q{
    integer Index, Increment;
    string Alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ", Letter;
    function onInit(){
        // Create an empty text file (Preload file).
        PreloadGenClear();
        PreloadGenStart();
        /*
        *   Index from 0 to 24
        */
        for (0 <= Index < 25){
            Increment = Index + 1;
            // Slice
            Letter = SubString(Alphabets, Index, Increment);
            // Output
            Preload(Letter + SubString(Alphabets, Increment, Increment + 1) + Letter);
        }
        // Save .txt
        PreloadGenEnd("CodeGolf\\testOutput.txt");
    }
}
//! endzinc
```
[![Preload File as an output](https://i.stack.imgur.com/MCqET.png)](https://i.stack.imgur.com/MCqET.png)
[Answer]
# [J](http://jsoftware.com/), 18 16 bytes
```
2(,{.)\u:65+i.26
```
Changed `a.{~` to `u:` after Conor O'Brien's and FrownyFrog's solutions
[Try it online!](https://tio.run/##y/qfZmulYKAAxP@NNHSq9TRjSq3MTLUz9YzM/mtyKekpqKfbWqkr6CjUWimkcaUmZ@QrpP8HAA "J – Try It Online")
]