[Question]
  [
Inspired by [George Gibson's Print a Tabula Recta](https://codegolf.stackexchange.com/q/86986/48934).
You are to print/output this exact text:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
```
(Yes, I typed that by hand)
You are allowed to use all lowercase instead of all uppercase.
However, your choice of case must be consistent throughout the whole text.
### Rules/Requirements
* Each submission should be either a full program or function. If it is a function, it must be runnable by only needing to add the function call to the bottom of the program. Anything else (e.g. headers in C), must be included.
* If it is possible, provide a link to a site where your program can be tested.
* Your program must not write anything to `STDERR`.
* [Standard Loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* Your program can output in any case, but it must be printed (not an array or similar).
### Scoring
Programs are scored according to bytes, in UTF-8 by default or a different character set of your choice.
Eventually, the answer with the least bytes will win.
## Submissions
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
## Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
```
/* Configuration */
var QUESTION_ID = 87064; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 48934; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# Excel, 19,604 bytes
```
=CHAR(64+MAX(COLUMN(),ROW()))
```
Paste this formula in `A1`, then drag all over `A1:Z26`.
Byte count:
1. The formula is 27 bytes.
2. You need to copy it 26^2 times. 27\*26\*26=19604.
3. I and others thought the score should be lower because you don't really need to type the formula again and again. I now think it's irrelevant - we count the size of the program, not the work spent writing it.
4. For comparison - see [this 28,187 chars JS answer](https://codegolf.stackexchange.com/a/22547/3544) - obviously, someone generated it rather than typing all this, but it doesn't change its size.
[Answer]
# Vim, 43 bytes
```
:h<_‚ÜµjjYZZPqqlmaYp`ajyl:norm v0r‚ô•"‚Üµ`ajq25@q
```
Here `‚Üµ` represents Return (`0x0a`) and `‚ô•` represents Ctrl-R (`0x12`).
Not quite as short as my Tabula Recta answer, but‚Ä¶
[![enter image description here](https://i.stack.imgur.com/Awe6f.gif)](https://i.stack.imgur.com/Awe6f.gif)
[Answer]
# Jelly, 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code%20page)
```
√òA¬ª'j‚Å∑
```
[Try it here.](http://jelly.tryitonline.net/#code=w5hBwrsnauKBtw&input=) If only I hadn‚Äôt been lazy yesterday and implemented that one-byte alternative to `j‚Å∑` (join by newlines)‚Ä¶
```
√òA      The uppercase alphabet.
  ¬ª'    Table of max(x, y).
    j‚Å∑  Join by newlines.
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 11 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319)
```
‚éïA[‚àò.‚åà‚ç®‚ç≥26]
```
`A[`...`]` pick elements from the uppercase alphabet according to  
¬†¬†¬†¬†`‚àò.‚åà‚ç®` the maximum table of  
¬†¬†¬†¬†`‚ç≥26` the first 26 integers  
[TryAPL online!](http://tryapl.org/?a=%u2395A%5B%u2218.%u2308%u2368%u237326%5D&run)
[Answer]
# brainfuck, ~~103~~ ~~96~~ ~~95~~ ~~91~~ 87 bytes
```
+++++[>+++++>++<<-]>+[[<<<+>>>-]----[<+>----]<+<<[>+>+>+<<<-]>-]>>[[<.>-]>[.>>]<<[<]>>]
```
This uses Esolangs' brainfuck constant for [64](https://esolangs.org/wiki/Brainfuck_constants#64). [Try it online!](http://brainfuck.tryitonline.net/#code=KysrKytbPisrKysrPisrPDwtXT4rW1s8PDwrPj4-LV0tLS0tWzwrPi0tLS1dPCs8PFs-Kz4rPis8PDwtXT4tXT4-W1s8Lj4tXT5bLj4-XTw8WzxdPj5d&input=)
[Answer]
# [///](http://esolangs.org/wiki////), ~~141~~ ~~94~~ ~~92~~ 82 bytes
```
/:/\\\\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#
\/a\///A/#
```
Try it online: [Demonstration](https://tio.run/##FcunAYAwAAVRzxoZ4Ptz2QNDCYReQl8@wInnLvRZ8C7EKJR@WcmInIISR0WNp6Glo2dgZGJmYSWwsXNwcnHzoP9XZpKPVJKVifEF)
Quite a fun language. 
### Explanation:
Shortend code to only print a 4x4 square: 
```
/:/\\\\A//#/:b:c:d://:/\/a#
\/a\///A/#
```
The first replacement `/:/\\\\A/` replaces `:` with `\\A`. This gives:
```
/#/\\Ab\\Ac\\Ad\\A//\\A/\/a#
\/a\///A/#
```
Then `/#/\\Ab\\Ac\\Ad\\A//\\A/` replaces `#` with `\Ab\Ac\Ad\A`: 
```
/\\A/\/a\Ab\Ac\Ad\A
\/a\///A/\Ab\Ac\Ad\A
```
Now `/\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//` replaces each `\A` in the subsequent code by `/aAbAcAdA<newline>/a/`, so this results in:
```
/A//aAbAcAdA
/a/b/aAbAcAdA
/a/c/aAbAcAdA
/a/d/aAbAcAdA
/a/
```
Now the first part `/A//` removes all `A`s. 
```
abcd
/a/b/abcd
/a/c/abcd
/a/d/abcd
/a/
```
The first five characters `abcd<newline>` get printed. The next command `/a/b/` replaces `a` by `b`, resulting in:
```
bbcd
/b/c/bbcd
/b/d/bbcd
/b/
```
Again the first five characters `bbcd<newline>` get printed. The next command `/b/c/` replaces `b` by `c`:
```
cccd
/c/d/cccd
/c/
```
Again the first five characters `cccd<newline>` get printed. The next command `/c/d/` replaces `c` by `d`:
```
dddd
/d/
```
The first five characters `dddd<newline>` get printed. And the next command `/d/` is incomplete and therefore does nothing.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~69~~ ~~65~~ ~~57~~ 44 bytes
*Saved 8 bytes thanks to [Martin Ender](https://codegolf.stackexchange.com/users/8478).  
Saved 13 bytes thanks to [att](https://codegolf.stackexchange.com/users/81203).*
```
Print@@@Array[Alphabet[][[Max@##]]&,{26,26}]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/z@gKDOvxMHBwbGoKLEy2jGnICMxKbUkOjY62jexwkFZOTZWTafayEzHyKw29v9/AA "Wolfram Language (Mathematica) ‚Äì Try It Online") Full program which prints to standard output.
[Answer]
## [Retina](https://github.com/m-ender/retina), 41 bytes
Byte count assumes ISO 8859-1 encoding. The leading linefeed is significant.
```
26$*Z
{`^[^A].+
$&¬∂$&
}T0-2`L`_L`^(.)\1+
```
### Explanation
```
26$*Z
```
Set the string to 26 copies of `Z`. Then the `{...}` instruct Retina to perform the remaining two instructions in a loop until the string stops changing.
```
{`^[^A].+
$&¬∂$&
```
Duplicate the first line if it doesn't start with an `A`.
```
}T0-2`L`_L`^(.)\1+
```
This is a transliteration stage. It is only applied if the string starts with at least two copies of the same character. If so, all but the last of those characters are decremented. The decrementing happens by mapping `L` (upper case alphabet) to `_L` (blank followed by upper case alphabet). The "all but the last" is indicated by the limit `-2` which tells Retina only to transliterate all characters up to the second-to-last in the match.
[Try it online!](http://retina.tryitonline.net/#code=CjI2JCpaCntgXlteQV0uKwokJsK2JCYKfVQwLTJgTGBfTGBeKC4pXDEr&input=)
[Answer]
## [///](http://esolangs.org/wiki////), 348 bytes
```
/|/\/\///v/NNN|u/MMM|t/LLL|s/WXYZ|r/OOO|q/KLMa|p/RRRR|o/QQQQ|n/PPPP|m/SSS|l/EFGc|k/RSTb|j/UUUU|i/TTTT|h/WWW|g/VVV|f/XXXX|e/ZZZZZ|d/YYYYY|c/HIJq|b/UVs
|a/NOPQk/ABCDlBBCDlCCCDlDDDDlEEEElFFFFFFGcGGGGGGGcHHHHHHHcIIIIIIIIIJqJJJJJJJJJJqKKKKKKKKKKqttttMauuuuMavvvvNarrrrrPQknnnnQkooooQkppppRkmmmmmmSTbiiiiibjjjjjbgggggggVs
hhhhhhhWs
ffffffYZ
dddddZ
eeeeeZ
```
[Try it online!](http://slashes.tryitonline.net/#code=L3wvXC9cLy8vdi9OTk58dS9NTU18dC9MTEx8cy9XWFlafHIvT09PfHEvS0xNYXxwL1JSUlJ8by9RUVFRfG4vUFBQUHxtL1NTU3xsL0VGR2N8ay9SU1RifGovVVVVVXxpL1RUVFR8aC9XV1d8Zy9WVlZ8Zi9YWFhYfGUvWlpaWlp8ZC9ZWVlZWXxjL0hJSnF8Yi9VVnMKfGEvTk9QUWsvQUJDRGxCQkNEbENDQ0RsRERERGxFRUVFbEZGRkZGRkdjR0dHR0dHR2NISEhISEhIY0lJSUlJSUlJSUpxSkpKSkpKSkpKSnFLS0tLS0tLS0tLcXR0dHRNYXV1dXVNYXZ2dnZOYXJycnJyUFFrbm5ublFrb29vb1FrcHBwcFJrbW1tbW1tU1RiaWlpaWliampqampiZ2dnZ2dnZ1ZzCmhoaGhoaGhXcwpmZmZmZmZZWgpkZGRkZFoKZWVlZWVa&input=)
I've used the same technique to build this [as for my /// answer to the challenge this was based on](https://codegolf.stackexchange.com/a/87056/8478). However, I had to fix [the CJam script](http://cjam.tryitonline.net/#code=MjYsMj5xOlhmZXc6fl8me1tfXywoWEAvLCgoKjUtXF19JSRXJVNmKk4q&input=QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVoKQkJDREVGR0hJSktMTU5PUFFSU1RVVldYWVoKQ0NDREVGR0hJSktMTU5PUFFSU1RVVldYWVoKREREREVGR0hJSktMTU5PUFFSU1RVVldYWVoKRUVFRUVGR0hJSktMTU5PUFFSU1RVVldYWVoKRkZGRkZGR0hJSktMTU5PUFFSU1RVVldYWVoKR0dHR0dHR0hJSktMTU5PUFFSU1RVVldYWVoKSEhISEhISEhJSktMTU5PUFFSU1RVVldYWVoKSUlJSUlJSUlJSktMTU5PUFFSU1RVVldYWVoKSkpKSkpKSkpKSktMTU5PUFFSU1RVVldYWVoKS0tLS0tLS0tLS0tMTU5PUFFSU1RVVldYWVoKTExMTExMTExMTExMTU5PUFFSU1RVVldYWVoKTU1NTU1NTU1NTU1NTU5PUFFSU1RVVldYWVoKTk5OTk5OTk5OTk5OTk5PUFFSU1RVVldYWVoKT09PT09PT09PT09PT09PUFFSU1RVVldYWVoKUFBQUFBQUFBQUFBQUFBQUFFSU1RVVldYWVoKUVFRUVFRUVFRUVFRUVFRUVFSU1RVVldYWVoKUlJSUlJSUlJSUlJSUlJSUlJSU1RVVldYWVoKU1NTU1NTU1NTU1NTU1NTU1NTU1RVVldYWVoKVFRUVFRUVFRUVFRUVFRUVFRUVFRVVldYWVoKVVVVVVVVVVVVVVVVVVVVVVVVVVVVVldYWVoKVlZWVlZWVlZWVlZWVlZWVlZWVlZWVldYWVoKV1dXV1dXV1dXV1dXV1dXV1dXV1dXV1dYWVoKWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWVoKWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVlZWVoKWlpaWlpaWlpaWlpaWlpaWlpaWlpaWlpaWlo) because it didn't correctly handle substrings that can overlap themselves.
[Answer]
# Haskell, 35 bytes
```
a=['A'..'Z']
unlines$(<$>a).max<$>a
```
[Answer]
# Python 2, 59 bytes
```
n=0;exec'print bytearray([n+65]*n+range(n+65,91));n+=1;'*26
```
Test it on [Ideone](http://ideone.com/Trw1SP).
[Answer]
# R, 58 bytes
```
l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
```
Thanks to operator precedence, `2:i-1` is equivalent to `1:(i-1)`. Uses the built-in constant `LETTERS` that contains the alphabet in upper case. Everything else is rather self-explanatory.  
Usage:
```
> l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
```
[Answer]
# [Sesos](https://github.com/DennisMitchell/sesos), 25 bytes
```
0000000: 2829c0 756fc6 aecae2 aecd9c 39e09e 099c63 7d8e3d  ().uo.......9....c}.=
0000015: 65a7c0 39                                         e..9
```
[Try it online!](http://sesos.tryitonline.net/#code=YWRkIDI2CmptcAogICAgam1wCiAgICAgICAgcndkIDEsIGFkZCAxLCByd2QgMSwgYWRkIDEsIGZ3ZCAyLCBzdWIgMQogICAgam56CiAgICByd2QgMiwgYWRkIDY0CiAgICBqbXAKICAgICAgICBmd2QgMiwgYWRkIDEsIHJ3ZCAyLCBzdWIgMQogICAgam56CiAgICBmd2QgMSwgc3ViIDEKam56CmZ3ZCAxCmptcAogICAgam1wCiAgICAgICAgcndkIDEsIGFkZCAxLCBmd2QgMSwgc3ViIDEKICAgIGpuegogICAgcndkIDEKICAgIGptcAogICAgICAgIHJ3ZCAxCiAgICBqbnoKICAgIGZ3ZCAxCiAgICBqbXAKICAgICAgICBwdXQsIGFkZCAxLCBmd2QgMQogICAgam56CiAgICBmd2QgMQogICAgam1wCiAgICAgICAgcHV0LCBmd2QgMQogICAgam56CiAgICBhZGQgMTAsIHB1dCwgZ2V0LCByd2QgMQogICAgam1wCiAgICAgICAgcndkIDEKICAgIGpuegogICAgZndkIDEKOyBqbnogKGltcGxpY2l0KQ&input=) Check *Debug* to see the generated SBIN code.
### Sesos assembly
The binary file above has been generated by assembling the following SASM code.
```
add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    nop
        rwd 1
    jnz
    fwd 1
    jmp
        put, add 1, fwd 1
    jnz
    fwd 1
    jmp
        put, fwd 1
    jnz
    add 10, put, get
    nop
        rwd 1
    jnz
    fwd 1
; jnz (implicit)
```
### How it works
We start by initializing the tape to `ABCDEFGHIJKLMNOPQRSTUVWXYZ`. This is as follows.
Write **26** to a cell, leaving the tape in the following state.
```
                                                       v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0
```
As long as the cell under the data head is non-zero, we do the following.
Copy the number to the two cells to the left and add **64** to the leftmost copy.
```
                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0
```
Move the leftmost copy to the original location, then subtract **1** from the rightmost copy.
```
                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0
```
The process stops after **26** iterations, since the rightmost copy is **0** by then. We move a cell to the right, so the final state of the tape after the initialization is the following.
```
     v
0 0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
Now we're ready to generate the output, by repeating the following process until the cell under the data head is zero.
First, we move the content of the cell under the data head one unit to the left, then move left until the last cell with a non-zero content.
```
   v
0 65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
Now, we print all cells, starting with the one under the data head and moving right until we find a **0** cell, incrementing each printed cell after printing it. After printing `A`, the tape looks as follows.
```
     v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
Now we move right, again printing all cells until a **0** cell in encountered. After printing `BCDEFGHIJKLMNOPQRSTUVWXYZ`, the tape looks as follows.
```
                                                                                  v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
Now, we write **10** to the current cell, print the corresponding character (linefeed) and zero the cell with a call to `get` on empty input, leaving the tape unchanged.
Finally, we move to the last non-zero to the left, preparing the tape for the next iteration.
```
        v
0 66 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
The next iteration is similar. We first move **66** one cell to the left, print both **66** cells (`BB`) and increment them to **67**, then print the remaining non-zero cells to the right (`CDEFGHIJKLMNOPQRSTUVWXYZ`), and finally place the data head on **67**, leaving the tape as follows.
```
           v
0 66 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0
```
After **24** more iterations and after printing `ZZZZZZZZZZZZZZZZZZZZZZZZZZ` and a linefeed, the tapes is left in the following state.
```
                                                                                  v
0 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 0 0
```
Moving the data head to the left to the next non-zero cell will leave it in its current position, so the cell under it is **0** and the loop terminates.
[Answer]
## C#, 147 bytes
```
void e(){for(int i=0,j=97;i<26;i++,j++)Console.WriteLine(new string((char)j,i)+new string(Enumerable.Range(j,26-i).Select(n=>(char)n).ToArray()));}
```
*sometimes i wonder why im even trying*
*edit:* fixed it
[Try it online](http://rextester.com/EBCH52681)
[Answer]
# J, 13 bytes
```
u:65+>./~i.26
```
[Online interpreter](https://tio.run/##y/r/PzU5I1@h1MrMVNtOT78uU8/I7P9/AA).
### Explanation
```
u:65+>./~i.26
         i.26  generate [0 1 ... 25]
       /~      build a table...
     >.        ...of maximum
  65+          add 65 to each element
u:             convert to unicode
```
[Answer]
# Matlab / Octave, ~~43~~ 39 bytes
*1 byte removed thanks to [@beaker's](https://codegolf.stackexchange.com/a/87080/36398) idea of using `[...,'']` to convert to char.*
```
@()[91-rot90(gallery('minij',26),2),'']
```
This is an anonymous function that returns a 2D char array.
[**Try it on Ideone**](http://ideone.com/yFwVQc).
### Explanation
`gallery('minij',...)` gives a matrix in which each entry equals the minimum of its row and column indices:
```
 1     1     1     1  ...
 1     2     2     2
 1     2     3     3
 1     2     3     4
 ...
```
This is rotated 180 degrees with `rot90(...,2)`:
```
26    25    24    23  ...
25    25    24    23
24    24    24    23
23    23    23    23
...  
```
The `91-...` operation gives the ASCII codes of uppercase letters:
```
65    66    67    68
66    66    67    68
67    67    67    68
68    68    69    68 ...
...
```
Finally `[...,'']` concatenates horizontally with an empty string. This has the effect of converting to char.
[Answer]
# Python 2, ~~76~~ ~~70~~ 68 bytes
```
a=range(65,91)
i=0
for c in a:a[:i]=[c]*i;i+=1;print'%c'*26%tuple(a)
```
Very similar to [my answer to the linked question](https://codegolf.stackexchange.com/a/87001/56755).
*Saved 2 bytes thanks to @xnor (again)!*
[Answer]
## PowerShell v2+, ~~76~~ ~~52~~ 40 bytes
```
65..90|%{-join[char[]](,$_*$i+++$_..90)}
```
Loops from `65` to `89`. Each iteration, we're constructing an array using the comma-operator that consists of the current number `$_` multiplied by post-incremented helper variable `$i++`, concatenated with an array of the current number `$_` to `90`. That's encapsulated in a char-array cast, and `-join`ed together into a string. For example, for the first iteration, this array would be equivalent to `65..90`, or the whole alphabet. The second iteration would be `66+66..90`, or the whole alphabet with `B` repeated and no `A`.
Those are all left on the pipeline at program end (as an array), and printing to the console is implicit (the default `.ToString()` for an array is separated via newline, so we get that for free).
```
PS C:\Tools\Scripts\golfing> .\print-the-l-phabet.ps1
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
```
[Answer]
# [R](https://www.r-project.org/), ~~42~~ 41 bytes
```
write(outer(L<-LETTERS,L,pmax),'',26,,'')
```
[Try it online!](https://tio.run/##K/r/v7wosyRVI7@0JLVIw8dG18c1JMQ1KFjHR6cgN7FCU0ddXcfITAdIaf7/DwA "R ‚Äì Try It Online")
The [next shortest R answer](https://codegolf.stackexchange.com/a/99532/67312) is still a bit too long since it prints out line by line. I was thinking about another question earlier today and realized a much shorter approach was possible for this one: I generate the matrix all at once using `outer` and `pmax` (parallel maximum) and then print it(\*) in one step with `write`.
(\*) technically, its transpose, but it's fortunately symmetric across its diagonal.
[Answer]
# MATL, 10 bytes
```
lY2t!2$X>c
```
[**Online demo**](https://matl.suever.net/?code=lY2t%212%24X%3Ec&inputs=&version=18.6.0) (If you have issues with this interpreter, ping me in the [MATL chat](https://chat.stackexchange.com/rooms/39466/matl-chatl). Also, [here](http://matl.tryitonline.net/#code=bFkydCEyJFg-Yw&input=) is the TIO link in case you have issues)
**Explanation**
```
lY2     % Push an array of characters to the stack: 'AB...Z'
t!      % Duplicate and transpose
2$X>    % Take the element-wise maximum between these two (with expansion)
c       % Explicitly convert back to characters
        % Implicitly display the result.
```
[Answer]
# Octave, 26 bytes
```
disp([max(L=65:90,L'),''])
```
Sample run on [ideone](http://ideone.com/18fUKi).
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 9 bytes
Code:
```
AAv¬¨N√ó?=¬¶
```
Explanation:
```
AA         # Push the alphabet twice.
  v        # For each in the alphabet.
   ¬¨       # Get the first character and
    N√ó     # multiply by the iteration variable.
      ?    # Pop and print.
       =   # Print the initial alphabet without popping.
        ¬¶  # Remove the first character of the initial alphabet and repeat.
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=QUF2wqxOw5c_PcKm&input=).
[Answer]
# Javascript ES6, 81 bytes
```
x=>[...a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map((x,y)=>x.repeat(y)+a.slice(y)).join`
`
```
Self-explanatory.
[Answer]
# R, 56 bytes
Don't have the rep to comment, but @plannapus [answer](https://codegolf.stackexchange.com/a/87224/61633) can be golfed-down a bit to:
```
for(i in 1:26)cat({L=LETTERS;L[1:i]=L[i];L},"\n",sep="")
```
resulting in the same output:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
```
Though, if answer as a matrix is allowed ([i.e. like here](https://codegolf.stackexchange.com/a/87302/61633)), we could do 49 bytes:
```
sapply(1:26,function(l){L=LETTERS;L[1:l]=L[l];L})
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
¬¥·π™Y‚Ä¶"AZ
```
[Try it online!](https://tio.run/##yygtzv7//9CWhztXRT5qWKbkGPX/PwA "Husk ‚Äì Try It Online") I'm rather surprised there isn't a Husk answer for this already. In any case, all this does is create a table (`·π™`) of the maximum (`Y`) of each pair of letters A to Z.
[Answer]
## Haskell, ~~53~~ 46 bytes
```
unlines[(i<$['B'..i])++[i..'Z']|i<-['A'..'Z']]
```
Returns a single string with the L-phabet.
go through the chars `i` from `A` to `Z` and make a list of `(length ['B'..i])` copies of `i` followed by `[i..'Z']`. Join elements with newlines in-between.
[Answer]
# Python 3, ~~71~~ 65 bytes
*Thanks to @LeakyNun for -6 bytes*
```
r=range(26)
for i in r:print(''.join(chr(max(i,x)+65)for x in r))
```
A full program that prints to STDOUT.
**How it works**
We assign character codes to the letters of the alphabet, from `0` for `A` to `25` for `Z`. The program loops over the interval `[0, 25]` with a line counter `i`, which determines the current character to be repeated and the length of the repeated section, and a character index `x`. By calling `max(i,x)`, all characters below the repeated character are clamped to the character code of the same. Adding `65` and calling `chr` converts the resultant character codes to their ASCII equivalents; `''.join` concatenates the characters, and each line is printed to STDOUT.
[Try it on Ideone](https://ideone.com/5L08ro)
[Answer]
# ùîºùïäùïÑùïöùïü, 12 chars / 15 bytes
```
·∂ê‚ì¢‚í®ƒä_+·∂êƒç_)√º‚¨¨
```
`[Try it here (Chrome Canary only).](http://molarmanful.github.io/ESMin/interpreter3.html?eval=false&input=&code=%E1%B6%90%E2%93%A2%E2%92%A8%C4%8A_%2B%E1%B6%90%C4%8D_)%C3%BC%E2%AC%AC)`
Basically a port of my ES6 answer.
[Answer]
# R, 54 bytes
`v=L=LETTERS;for(i in 2:26){L[1:i]=L[i];v=cbind(v,L)};v`
This solution uses the **R** built-in constant `LETTERS`, that... well... lists the uppercase letters. There is also the constant `letters` for lowercase letters.
[Answer]
# Cheddar, 90 bytes
```
(|>26).map(i->String.letters.chars.map((j,k,l)->k<i?l[i]:j).fuse).vfuse.slice(1)
```
That `String.letters` is too long :/
Had to add a `.slice(1)` because leading newline is disallowed
## Explanation
```
(|>26)       // Range from [0, 26)
.map(i->     // Loop through that range
 String.letters.chars // Alphabet array
  .map(               // Loop through alphabet
  (j,k,l) ->          // j = letter, j = index, l = alphabet
    k<i?l[i]:j        // Basically `l[max(k,i)]` 
  ).fuse     // Collapse the array
).vfuse      // Join on newlines
```
# Cheddar, 65 bytes (non-competing)
```
(|>26).map(i->String.letters.map((j,k,l)->k<i?l[i]:j).fuse).vfuse
```
Works with the [nightly branch](https://github.com/cheddar-lang/Cheddar/tree/develop). Non-competing... sad part is that I already had the changes... just never commited ;\_;
]