[Question]
  [
The Tabula Recta (sometimes called a 'Vigenere Table'), was created by Johannes Trithemius, and has been used in several ciphers, including all variants of Bellaso's Vigenere cipher and the Trithemius cipher. It looks like this:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY
```
I frequently need this, but can't find it anywhere on the internet to copy and paste from. Because the square table is so long, and takes frigging *ages* to type, your code must be as short as possible.
### 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 = 86986; // 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 = 53406; // 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]
# Vim, ~~25~~ 23 bytes
```
:h<_↵jjYZZP25@='Ypx$p'↵
```
Where `↵` is the Return key.
```
:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.
```
[![GIF of solution](https://i.stack.imgur.com/RuYkf.gif)](https://i.stack.imgur.com/RuYkf.gif)
**EDIT**: lowercase is okay, so I can save two keys.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~6~~ 5 bytes
Thanks to **Downgoat** for saving 1 byte. Code:
```
ADv=À
```
Explanation:
```
A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=QUR2PcOA&input=).
[Answer]
# Python 2, ~~59~~ ~~57~~ 53 bytes
```
a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)
```
*Thanks to @xsot for -4 bytes!*
[Answer]
## [///](http://esolangs.org/wiki////), 220 bytes
```
/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn
```
[Try it online!](http://slashes.tryitonline.net/#code=L3wvXC9cLy8vbi9XWFl8bS9KS0x8bC9QUVJTfGsvQ0RFRnxqL1phTmZWfGkvTWJBZUl8aC9UVWNPfGcvR0hkQnxmL09sVFV8ZS9Ca0dIfGQvSW1NYkF8Yy9WblphTnxiL05mVm5afGEvQWVJbU0vYWIKZWQKa2cKREVGZ0MKRUZnQ0QKRmdDREUKZ2sKSGRCa0cKZGUKbWkKS0xpSgpMaUpLCmltCmJhCmZjCmxoClFSU2hQClJTaFBRClNoUFFSCmhsClVjT2xUCmNmCm5qClhZalcKWWpXWApqbg&input=)
This was surprisingly non-trivial and I have no clue whether it's optimal.
~~The only way to golf a problem like this in /// is by extracting common substrings.~~ ([Turns out I was wrong.](https://codegolf.stackexchange.com/a/87384/8478)) However, due to the nature of the output it's not at all clear which substrings should best be extracted since you can't actually extract the entire alphabet due to the linebreaks. So you'll need to extract some substrings of the wrapped alphabet, but then there are trade-offs in terms of how long you make the substrings and which ones you choose.
So here's what I did. [This is a CJam script](http://cjam.tryitonline.net/#code=MjYsMj5xZmV3On4kZWB7fl8sKEAoKjUtW1xdfSUkVyVTZipOKg&input=QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVoKQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWkEKQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaQUIKREVGR0hJSktMTU5PUFFSU1RVVldYWVpBQkMKRUZHSElKS0xNTk9QUVJTVFVWV1hZWkFCQ0QKRkdISUpLTE1OT1BRUlNUVVZXWFlaQUJDREUKR0hJSktMTU5PUFFSU1RVVldYWVpBQkNERUYKSElKS0xNTk9QUVJTVFVWV1hZWkFCQ0RFRkcKSUpLTE1OT1BRUlNUVVZXWFlaQUJDREVGR0gKSktMTU5PUFFSU1RVVldYWVpBQkNERUZHSEkKS0xNTk9QUVJTVFVWV1hZWkFCQ0RFRkdISUoKTE1OT1BRUlNUVVZXWFlaQUJDREVGR0hJSksKTU5PUFFSU1RVVldYWVpBQkNERUZHSElKS0wKTk9QUVJTVFVWV1hZWkFCQ0RFRkdISUpLTE0KT1BRUlNUVVZXWFlaQUJDREVGR0hJSktMTU4KUFFSU1RVVldYWVpBQkNERUZHSElKS0xNTk8KUVJTVFVWV1hZWkFCQ0RFRkdISUpLTE1OT1AKUlNUVVZXWFlaQUJDREVGR0hJSktMTU5PUFEKU1RVVldYWVpBQkNERUZHSElKS0xNTk9QUVIKVFVWV1hZWkFCQ0RFRkdISUpLTE1OT1BRUlMKVVZXWFlaQUJDREVGR0hJSktMTU5PUFFSU1QKVldYWVpBQkNERUZHSElKS0xNTk9QUVJTVFUKV1hZWkFCQ0RFRkdISUpLTE1OT1BRUlNUVVYKWFlaQUJDREVGR0hJSktMTU5PUFFSU1RVVlcKWVpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1gKWkFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFk) which finds all substrings up to length 25 in the given string and for each of them computes how many bytes its extracting would save. Basically if there are `N` copies of a length-`M` substring, you'd save `(N-1)*(M-1) - 5` substrings, these substrings don't contain slashes. Also, technically, when you've already extract 8 substrings or so, the constant offset at the end reduces to `-4`, but the script doesn't consider that.
Anyway, here's what I did with the script:
* Run the script against the current code (which is initially just the output).
* Out of the substrings that yield the largest improvement, pick the shortest one. If there are several, pick the lexicographically smallest (from what I can tell, for the given input this reduces overlaps between substrings).
* Replace all occurrences of the chosen substring in the code with an unused lower case letter.
* Prepend `/x/ABC/` to the code where `x` is the chosen letter and `ABC` is the substring.
* Repeat until there are no substrings left that would save anything.
At the end, we save a few more bytes by replacing the resulting `//` with `|` and prepending `/|/\/\//` (this is why extracting substrings only costs 4 instead of 5 bytes after the 8th substring or so).
Like I said, I have no clue whether this is optimal and I find the rather irregular-looking result quite interesting. It might be possible to get to a shorter solution by chosing non-optimal (but more) substrings somewhere down the line. I wonder what the complexity class of this problem is...
[Answer]
# C, 47 bytes
```
i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}
```
[Try it on Ideone](http://ideone.com/uTof3S)
A single loop, printing the alphabet every 26 characters but with every 27th character replaced by a newline.
[Answer]
# J, 15 bytes
```
u:65+26|+/~i.26
```
[Online interpreter](http://tryj.tk/).
```
u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character
```
[Answer]
## [///](http://esolangs.org/wiki////), 128 bytes
```
/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\: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:
```
[Try it online!](http://slashes.tryitonline.net/#code=LzovZkFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaCmZiZmJBZnhmCnhiQV94Zl94CnhmYmJiQWZiYi8veC9iZmYvL2YvXC8vL2IvXFw6QjpDOkQ6RTpGOkc6SDpJOko6SzpMOk06TjpPOlA6UTpSOlM6VDpVOlY6VzpYOlk6Wjo&input=)
Inspired by [Jakube's amazing answer](https://codegolf.stackexchange.com/a/87245/8478) to the L-phabet challenge, I thought I'd try my hand as well at actual *programming* in /// as opposed to just using it for compression. This was pretty tricky and I needed four attempts, but in the end it came out much shorter than my [compression-based solution](https://codegolf.stackexchange.com/a/87056/8478).
### Explanation
A quick primer on ///: basically the interpreter just reads the code character by character and does the following:
* If it's neither a `\` nor a `/`, print it.
* If it's a `\`, print the next character.
* If it's a `/`, parse a `/x/y/` instruction (with the same escaping rules) and repeatedly substitute all `x` in the remaining code with `y`.
Taking some more inspiration from Jakube, for simplicity I'll just explain a 4x4 version of this:
```
/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:
```
We start by replacing those `:` with the stuff between the second and third `/`. This will end up being the code the rotates the subsequent rows. We get this:
```
/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb
```
The `f`, `b` and `x` are just shorthands for common strings, which we'll expand now. The `f` is for slashes, the `b` is for backslashes and the `x` is for `\//` which happens to come up quite a lot. The reason I'm using aliases for the single-character substrings `/` and `\` is that they'd have to be escaped in the first substitution instruction, so I'm actually saving quite a lot of bytes by not needing all those backslashes. Here's what we get after `x`, `f` and `b` have been filled in:
```
ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\
```
Very readable.
So the first line is just printed verbatim. Then we get to the funky part that rotates all further rows. It actually consists of four different instructions. One thing to notice is that I've escaped all occurrences of `A` within these instructions. The reason for this is that it allows me to distinguish `A`s within the instructions from `A`s in the remaining rows, which need to be processed differently.
```
/\/\A/\//
```
This matches `/A` and replaces it with `/`, removing the `A`. Note that this substring only appears at the front of each `ABCD`, so this drops the first character of all subsequent lines:
```
/
\//\A_\//
```
This matches a linefeed followed by a slash and replaces it with `A_/`. So this inserts an `A` at the end of each line, completing the rotation and also turns the linefeed into an underscore.
```
/_\//
\//
```
This matches `_/` and replaces it with a linefeed followed by a slash. The reason I need to make this detour via the underscore is the fact that /// applies each instruction repeatedly until the string no longer matches. That means you can never use an instruction of the form `/x/axb/` where `x`, `a` and `b` are arbitrary strings, because after the substitution `x` will always still match. In particular, this means we can't just insert something in front of a linefeed. We need to replace the linefeed in the process and the undo this replacement.
```
/\\\A/\\B/
```
This matches `\A` and replaces it with `\B`, so that the instructions after the remaining rows process the next character. After all four instructions have been processed the remaining string looks like this:
```
BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\
```
So now the first rotated row gets printed, and then the next set of instructions rotates the remaining rows by another cell and so on. After the last rotation, we have a few more instructions that we can ignore and then we end with the incomplete instruction:
```
/\\\B/\\
```
Incomplete instructions at the end are simply ignored and the program terminates.
[Answer]
# Emacs, 47 bytes
```
abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4
```
Where `^P` means "Control P", etc. That's 47 bytes, since the F3 and F4 keys require two ASCII bytes.
After entering the starting input, it defines a keyboard macro to duplicate the line and move the first character to the end. It then runs the macro a further 24 times.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 37 bytes
```
25..0|%{-join('Z'..'A')[$_..($_-25)]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38hUT8@gRrVaNys/M09DPUpdT0/dUV0zWiVeT09DJV7XyFQztvb/fwA "PowerShell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ØAṙJṢj⁷
```
[Try it online!](http://jelly.tryitonline.net/#code=w5hB4bmZSuG5omrigbc&input=)
### How it works
```
ØAṙJṢj⁷  Main link. No arguments.
ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.
```
[Answer]
## JavaScript (ES6), 56 bytes
```
_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")
```
Yes, that's right, half my code is the alphabet string literal. Best I could do without the literal is 81 bytes:
```
_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`
```
If you want a program rather than a function, then remove the `_=>` and wrap in `console.log()` for a cost of 10 bytes.
[Answer]
# C, ~~88~~ 64 bytes
Call `f()` without arguments.
```
f(i,j){for(i=j=0;i<26;putchar(j==26?j=0,i++,10:65+(i+j++)%26));}
```
[Try it on ideone](http://ideone.com/hWifIZ).
[Answer]
# [Piet](http://www.dangermouse.net/esoteric/piet.html), 247 bytes/190 codels
[![Tabula Recta in Piet](https://i.stack.imgur.com/PNk35.png)](https://i.stack.imgur.com/PNk35.png)
[Try it Online!](https://tio.run/#%23fZRLbxQxEITv/IoSSChC0LI9tsfmgJIoUTYIhRASRBCHeF6wJxKF/79U27t5XLBmLO/I/rqqu7236/nvZmPaeI@UEQz8DN/DTDAFtuhszO6Z4DN8gvcIDpDzsxPZjtPV0cWLCrJEPRxx8cnxAJNg3OOXEhEZKxMl8loexi9pKEdUtE8IHfoO3qmM4CutPtOA2cIvmA1QlHB/eHpZUZ@3qO6pKkbsjRoJWYHbjwPs87WqktvV9f1OV0N5RVVVuSCPsOmRzC@aIg9vVaFLsAEhNFRL1NHB5Z5cNVQgarRIVnM7dugqpC2WCf2CHNDNmDqkEcVrBirK1Ec@PKqKRAWWzCnKOSSn686qQZY1e3QOQ4exGh9H1YkfIi9F7P25OJGVnDZUT9TA2o1afTfpKa7ToHbGSc/SPg36ukG7wlLVW3nHd4@CDj7xbahElKUpr0oC0ztjyJiobVZJMWDK2hi0xrJGA6sosV9rrma@hzdbg1mbIcJXL4zLsyxfTEgGKcIZxAVd1kTZWPM/Ass@Kde/RfAnU9TPhipETdyQkCN6qwWaipJTj5g1b4k2I/KC4hQYtUW/y92V7Mu61XHdUANRLLp2MnuScYuqSiRnvSNERadRqJb8YDUcDa6/fbwWuZBB5v0vdw01agU97FiDOj3OnxqdCezh2BVxm0y6awtol19cyo28ivS3a4aJKCbcFd2Z68ySFZ7yGJntUEtZ9Kb7oFeSEWHfHCiBY09OjneoWSvoMXEb79eidrqgbbA4JTDzz26oqX2lkCHoXG/jtq8WohhO/2E8yrytOJ3@bxyfHWkPbDb/AA)
So, this took far longer than I had anticipated, and I have a few ideas on some other more efficient (more stack-friendly) approaches, but I finally got the dang thing working (and [fixed an interpreter bug](https://github.com/cincodenada/bertnase_npiet/commits/bugfix/pointer) and [added IDE features](https://github.com/cincodenada/PietCreator/commits/master) along the way), so here it is. Hardly the most byte-efficient language, but a hell of a lot of fun. Here's a larger view, and a trace showing the path taken. History up on my [GitHub](https://github.com/cincodenada/piet_projects).
[![Tabula Recta in Piet, large version](https://i.stack.imgur.com/BLKPF.png)](https://i.stack.imgur.com/BLKPF.png)
[![Tabula Recta run trace](https://i.stack.imgur.com/mEcOt.png)](https://i.stack.imgur.com/mEcOt.png)
As a stack-based language, it's far too convoluted to explain briefly, but here's a basic overview of what the various sections/loops do. All variable and function names are just for explanation, as there are no variables or functions in Piet.
* Initialization (upper-left): starts `line_counter` at 27, loads '@' as `cur_letter`, sets `letter_count` to 27
* Main loop (starting at dark purple, center top)
	+ Decrements `letter_counter`
	+ Branches to `reset_line` if zero (light cyan 2-block)
	+ Rolls `cur_letter` to the top of the stack
	+ Branches to `check_done` if `cur_letter > 'X'` (teal/red block, right side)
	+ Increments `cur_letter` and outputs it (lower-right corner)
	+ Branches to `reset_letter` if `cur_letter > 'Y'` (light green block, left)
	+ Rolls `letter\_counter\_ back to top of stack, back to top of loop
* `reset_line` branch (big pink square):
	+ Outputs newline character
	+ Resets `letter_count` to 27
	+ Continues back to top of main loop
* `check_done` branch (right half inside)
	+ Rolls `line_counter` to top
	+ Branches to end if zero
	+ Decrements `line_counter` and rolls back to bottom of stack
	+ Resumes where it left off, printing letter
* `reset_line` branch (left side, green block):
	+ Resets `cur_letter` to '@'
	+ Resumes where it left off, rolling/returning to top of loop
[Answer]
# Mathematica ~~68~~ 61 bytes
```
Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]
```
Thanks to...
@MartinEnder (7 bytes)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
*With thanks to [@Dennis](https://codegolf.stackexchange.com/users/12012/dennis), who [suggested](https://codegolf.stackexchange.com/questions/75841/parity-of-a-permutation/75853#comment184427_75853) that MATL should incorporate modular indexing, and to [@Suever](https://codegolf.stackexchange.com/users/51939/suever), who had the [idea](https://codegolf.stackexchange.com/questions/82981/leyland-numbers/82995#comment202388_82995) of automatic pairwise operations.*
```
1Y2t&+Q)
```
[**Try it online!**](http://matl.tryitonline.net/#code=MVkydCYrUSk&input=)
```
1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display
```
[Answer]
# Python 2, ~~75~~ ~~65~~ ~~61~~ 58 bytes
```
a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x
```
Gets the alphabet with `map(chr,range(65,91))`, then manually applies the string shift operation.
*Thanks to @LeakyNun and @TheBikingViking for -4 bytes!*
*Thanks to @xnor for -3 bytes!*
[Answer]
# R, ~~47~~ ~~42~~ 41 bytes
```
write(rep(LETTERS,27)[-27*1:26],1,26,,'') 
```
[Try it online!](https://tio.run/##K/r/v7wosyRVoyi1QMPHNSTENShYx8hcM1rXyFzL0MrILFbHUMfITEdHXV3z////AA "R – Try It Online")
Generates 27 alphabetes, removes 27-th letters and prints in 26 columns.
*Improvement inspired by* [@Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe)'s [solution](https://codegolf.stackexchange.com/a/154518/65510).
[Answer]
# Javascript, ~~113~~ ~~96~~ ~~91~~ 76 bytes
A super-short version for running in the console:
```
l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));
```
# Javascript/HTML, ~~140~~ ~~123~~ ~~118~~ 105 bytes
A prettier version, with an HTML output that makes it easier for OP to copy and paste:
```
<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>
```
**(EDIT: I should've just used the string A-Z instead of generating it)**
**(EDIT 2: Thanks to @Neil and @DanTheMan for their input (see comments))**
[Answer]
# Retina, ~~36~~ 31 bytes
**5 bytes thanks to Martin Ender.**
```
Z
{2`
$`
}T01`L`_L
\`.
$&$'$`¶
```
Leading linefeed is significant.
[Try it online!](http://retina.tryitonline.net/#code=CloKezJgCiRgCn1UMDFgTGBfTApcYC4KJCYkJyRgwrY&input=)
[Credits](https://codegolf.stackexchange.com/a/85123/48934).
[Answer]
# [Sesos](https://github.com/DennisMitchell/sesos), ~~27~~ 25 bytes
```
0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07
```
[Try it online!](http://sesos.tryitonline.net/#code=YWRkIDI2CmptcAogICAgam1wCiAgICAgICAgcndkIDEsIGFkZCAxLCByd2QgMSwgYWRkIDEsIGZ3ZCAyLCBzdWIgMQogICAgam56CiAgICByd2QgMiwgYWRkIDY0CiAgICBqbXAKICAgICAgICBmd2QgMiwgYWRkIDEsIHJ3ZCAyLCBzdWIgMQogICAgam56CiAgICBmd2QgMSwgc3ViIDEKam56CmZ3ZCAxCmptcAogICAgam1wCiAgICAgICAgcHV0LCBmd2QgMQogICAgam56CiAgICByd2QgMjcKICAgIGptcAogICAgICAgIHB1dCwgZndkIDEKICAgIGpuegogICAgYWRkIDEwLCBwdXQsIGdldCwgZndkIDEKICAgIGptcAogICAgICAgIHJ3ZCAxLCBhZGQgMSwgZndkIDEsIHN1YiAxCiAgICBqbnoKICAgIGZ3ZCAxCjsgam56IChpbXBsaWNpdCk&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
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 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 print the character under the data head and move to the right, repeating this step until a cell with value **0** is found. After printing `ABCDEFGHIJKLMNOPQRSTUVWXYZ`, the tape looks as follows.
```
                                                                                v
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 move the data head **27** units to the left (back to the leading **0**) and repeat the print-move combination until a cell with value **0** is found. This prints nothing and leaves the tape as follows.
```
v
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 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.
Afterwards, we move the content of the cell to the right to the current cell, then move the data head to units to the right.
```
      v
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
```
The next iteration is slightly different. The first printing step prints `BCDEFGHIJKLMNOPQRSTUVWXYZ`, leaving the tape as follows.
```
                                                                                v
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 move the data head **27** units to the left.
```
 v
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
```
The subsequent printing loop prints `A` and leaves the tape as follows.
```
   v
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
```
Once again, we print a linefeed, move the content of the cell to the right to the current cell, then move the data head to units to the right.
```
         v
65 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, the final step of moving the data head to the right leaves the tape in the following state.
```
                                                                                v
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 0
```
The cell under the data head is now **0** and the program terminates.
---
† TIO uses a newer version of Sesos, which is backwards-compatible for SASM, but generates shorter SBIN code.
[Answer]
# Haskell, ~~56~~ ~~53~~ 52 Bytes
```
mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']
```
same length: (using a suggestion by @AndersKaseorg)
```
a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]
```
to do modular stuff you have to import Data.Char to get the chr function, ~~74~~ ~~59~~ 58 Bytes was the best I could get with that: (thanks to @nimi for suggesting the toEnum function)
```
a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a
```
This could probably be much shorter, but I don't know any Haskell golfing tricks.
*used mapM instead of mapM\_ (see @Lynn's comment)*
[Answer]
# R, 53 bytes
```
for(i in 1:26)cat(LETTERS[c(i:26,1:i-1)],"\n",sep="")
```
Here it is on an [online interpreter](http://www.r-fiddle.org/#/fiddle?id=OI53e9Np).
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~36~~, 10 bytes
```
¬AZ25ñÙx$p
```
[Try it online!](https://tio.run/##K/v//9Aaxygj08MbD8@sUCn4/x8A "V – Try It Online")
This uses the "Latin1" encoding. 
Explanation:
```
¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), ~~10~~ 11 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
(↑⍳∘⍴⌽¨⊂)⎕A
```
[TryAPL online!](http://tryapl.org/?a=%u2395IO%u21900%20%u22C4%20%28%u2191%u2373%u2218%u2374%u233D%A8%u2282%29%u2395A&run)
Requires `⎕IO←0` which is standard on many systems.
The generalized 7-char function is just `↑⍳∘⍴⌽¨⊂`:
`↑` make the following list of strings into a character table:  
    `⍳`the indices  
    `∘` of   
    `⍴` the length of the argument, i.e [1, 2, 3, ..., 26]  
`⌽¨` each rotate  
    `⊂` the entire argument
With the argument of `⎕A` (uppercase alphabet) we get the desired result, but any argument can be fed to get the corresponding cipher:
```
      f←↑⍳∘⍴⌽¨⊂
      f'o+×'
o+×
+×o
×o+
```
In fact, even strings and numbers are allowed:
```
      f'Alpha' 'Bravo' 'Charlie' 'Delta'
┌───────┬───────┬───────┬───────┐
│Alpha  │Bravo  │Charlie│Delta  │
├───────┼───────┼───────┼───────┤
│Bravo  │Charlie│Delta  │Alpha  │
├───────┼───────┼───────┼───────┤
│Charlie│Delta  │Alpha  │Bravo  │
├───────┼───────┼───────┼───────┤
│Delta  │Alpha  │Bravo  │Charlie│
└───────┴───────┴───────┴───────┘
      f⍳8
0 1 2 3 4 5 6 7
1 2 3 4 5 6 7 0
2 3 4 5 6 7 0 1
3 4 5 6 7 0 1 2
4 5 6 7 0 1 2 3
5 6 7 0 1 2 3 4
6 7 0 1 2 3 4 5
7 0 1 2 3 4 5 6
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 222 bytes
```
(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}
```
[Try it online!](https://tio.run/##VU47CsAgDL2Ob@gNROg5xMEOhdLSoWvI2dM8pWJVNHk/sz31uJf9qqdZ8IW@IYrI3t9xEoiEnEtpQJchJhZ@i8bknbCg02GkHFCgpEJmWnGB0tPlaL5JNGBRacgcR11swPfdyHd@TN8H@5GiZrasLw "Brain-Flak – Try It Online")
I'm new to Brain-Flak, so maybe this can be golfed a lot, but at least it's a first try. It stores 27 full alphabets on the left stack, then moves the alphabets to the right and replaces every 27th letter by a newline.
My sourcecode is a bit confusing, but i will add it nevertheless.
```
(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf
```
[Answer]
# C#, 98 bytes
I have tried to see if I can generate the letters shorter than just initializing them as a string, but it's not really possible. The letters are 26 bytes and this snippet alone
```
for(char a='A';a<'[';a++)
```
is 25 bytes. I think initializing them and then appending them with a+=a is a good solution, but with C# you are limited by the bytecount of functions like `Substring()` and `Console.WriteLine()`.
My attempt at 98 bytes:
```
var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));
```
[Answer]
# Octave, 27 bytes
We're adding a row and a column vector, and Octave nicely expands the sigleton dimensions, no need for `bsxfun` (as you would need in Matlab).
```
[mod((v=0:25)+v',26)+65,'']
```
[Answer]
# q, 20 bytes
```
(til 26)rotate\:.Q.A
```
[Answer]
# Java, ~~190~~ ~~176~~ ~~172~~ 163 bytes
```
class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}
```
[Answer]
# Bash, 66 bytes
```
A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done
```
I create a full alphabet in `A`, then print 26 rotated versions of it by taking the characters beginning at `n` and appending those preceding position `n`.
]