Print a Tabula Recta!

Question 1

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

Question 2

Regarding rule 1: do we have to include each header for each function we use?

Question 3

I meant if we use printf, we need to include stdio.h, if isalpha is used, ctype.h is needed, etc. Is this correct?

Question 4

You should probably put "lowercase is allowed" in the challenge specification itself. Just so people are less likely to miss it if they don't see these comments.

Question 5

do i have to print it or can i return a string/char array

Question 6

Thanks for the question for making me stay awake all night. (+1)

Question 7

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

EDIT: lowercase is okay, so I can save two keys.

Question 8

That :h<_<cr>jjY is genius

Question 9

Wow, that's amazing! OP said lowercase was OK so you can remove V~

Question 10

@RobStarling see: meta.codegolf.stackexchange.com/q/8995/40695

Question 11

I dare someone to try this in emacs.

Question 12

@addison Emacs answer

Question 13

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

Question 14

What is the purpose of duplicating it?

Question 15

@Challenger5 The v command consumes a value, iterating over it. In this case, it consumes the alphabet, so it iterates 26 times. That's also the exact amount of times we need to iterate of the =À function. The = leaves the stack intact and the À only rotates the top of the stack element 1 to the left. Does this answer your question? :)

Question 16

@EsolangingFruit I know this was already answered six years ago, but the Dv could also have just been 2F (loop 26 times) for the same result: try it online. :) I'm not sure if 2 (26) was an existing constant in 05AB1E mid-2016, though.

Question 17

Python 2, (削除) 59 (削除ここまで) (削除) 57 (削除ここまで) 53 bytes

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

Thanks to @xsot for -4 bytes!

Question 18

I like this one. By the way, you can shorten the last line to print bytearray(a).

Question 19

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

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

Question 20

That... is... brilliant...

Question 21

@GeorgeGibson Thanks... I had to start over halfway through when I noticed a certain YX in the output. ;)

Question 22

My answer is gone, it was a dupe of this (bigger and later). +1 for that [incredible golfing]!

Question 23

Regarding complexity class, shouldn't the problem be undecidable since /// is Turing complete? The problem is "given a string, find the shortest /// program that outputs it". Except for small strings, there would exist /// programs that loop indefinitely (but cannot be proven to loop indefinitely) that cannot be shown to not produce the desired output without running them forever. Formal proof I'm myself not sure yet but intuitively isn't it possible?

Question 24

C, 47 bytes

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

Try it on Ideone

A single loop, printing the alphabet every 26 characters but with every 27th character replaced by a newline.

Question 25

Damn! I just wrote the exact same function! :-) You can save the first semicolon by using f(i) then just call f() without any arguments.

Question 26

@LevelRiverSt That would be relying on undefined behavior.

Question 27

It's ultimately up to you, but PPCG considers languages to be defined by their implementations, so as long as you mention in which compiler it works, relying on UB is not considered a problem.

Question 28

you can shave 1 byte by initializing i when first mentioned: i=702;f(){for(;i--;)//...

Question 29

@tucuxi No, because function answers have to be reusable.

Question 30

J, 15 bytes

u:65+26|+/~i.26

Online interpreter.

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

Question 31

Nice! Very clever arithmetic. The simplest approach that uses |. (Shift) is 8 bytes longer! (i.26)(|."0 _)u:65+i.26

Question 32

@dahnoak You can shorten it to 16 bytes u:65+1&|.^:]i.26 since the power adverbs tracks previous results if given a list.

Question 33

@miles Nice, my approach using |. is 17 bytes: u:65+|."0 1/~i.26 (still using /~)

Question 34

@LeakyNun Another 17 byte approach is u:65+(|./~,.)i.26. I got rid of the rank by using a hook and ,. to columnize the range but it ended up the same length.

Question 35

don't you know if I can find the source code of tryj.tk somewhere? I couldn't find any info neither about it neither about the author (f211)

Question 36

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

Inspired by Jakube's amazing answer 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.

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 As within the instructions from As 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.

Question 37

Nice one. Yesterday I experimented a little bit with a different idea. I wanted to substitute each character in each line. Something like A->B, B->C, ... But it didn't quite work. Removing the first char and appending it at the end is definitly a much better approach.

Question 38

@Jakube I tried that as well but wasn't getting anywhere. It's too hard to avoid messing up the subsequent instructions as well.

Question 39

124 bytes: goo.gl/efSLKQ This is just your solution, but I've managed add a few additional substitutions, so that you only need to write out the alphabet once. Used the same strategy on similar problem as well.

Question 40

122: goo.gl/zRsBbR

Question 41

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.

Question 42

Welcome to PPCG, nice answer! It's very rare to see a Emacs answer, I don't even know if a Emacs answer already have been posted.

Question 43

PowerShell, 37 bytes

25..0|%{-join('Z'..'A')[$_..($_-25)]}

Try it online!

Question 44

43 bytes: 25..0|%{-join[char[]](90..65)[$_..($_-25)]}

Question 45

@Dorian: Thanks; can also be combined with character ranges from later PowerShell versions (v6+, I think) to get rid of the [char[]].

Question 46

Jelly, 7 bytes

ØAṙJṢj7

Try it online!

How it works

ØAṙJṢj7 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.
 j7 Join, separating by linefeeds.

Question 47

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.

Question 48

Woah, well done. A very elegant solution. How does it work?

Question 49

@Polyducks Lots and lots of regexp magic. Naturally /./g matches each letter of the supplied alphabet string. In the replacement string, $& represents the match itself, $' the part of the string after the match and $` the part of the string before the match. $`$&$' would therefore represent the original string, but of course it's trivial to move the part after the match to the beginning, thus providing the rotation effect.

Question 50

Super smart! Well done @Neil!

Question 51

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.

Question 52

Piet, 247 bytes/190 codels

Tabula Recta in Piet

Try it Online!

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 and added IDE features 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.

Tabula Recta in Piet, large version

Tabula Recta run trace

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

Question 53

Mathematica (削除) 68 (削除ここまで) 61 bytes

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

Thanks to...

@MartinEnder (7 bytes)

Question 54

Also, Array might be shorter that mapping over a Range.

Question 55

I just checked and Array does indeed save a byte, but you can then save another by avoiding Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>"" (you'll just need to replace the \n with an actual linefeed).

Question 56

Wait no built-in? Impossible

Question 57

Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]

Question 58

Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]

Question 59

MATL, 8 bytes

With thanks to @Dennis, who suggested that MATL should incorporate modular indexing, and to @Suever, who had the idea of automatic pairwise operations.

1Y2t&+Q)

Try it online!

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

Question 60

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!

Question 61

Apparently a="ABCDEFGHIJKLMNOPQRSTUVWXYZ" is shorter.

Question 62

You can do a[1:] instead of a[1:26].

Question 63

Your loop can be done as for x in s:print s;s=s[1:]+x.

Question 64

You can do one byte shorter than hardcoding the alphabet: s='%c'*26%tuple(range(65,91)).

lynn 69.7k11 gold badges137 silver badges285 bronze badges · Accepted Answer · 2016-07-30 18:10:44Z

115

\$\begingroup\$

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

EDIT: lowercase is okay, so I can save two keys.

Share

Improve this answer

edited Jul 31, 2016 at 16:16

answered Jul 30, 2016 at 18:10

lynn's user avatar

lynn

69.7k11 gold badges137 silver badges285 bronze badges

\$\endgroup\$

10

27

\$\begingroup\$ That :h<_<cr>jjY is genius \$\endgroup\$

Downgoat
– Downgoat

2016年07月30日 18:18:37 +00:00
Commented Jul 30, 2016 at 18:18
3

\$\begingroup\$ Wow, that's amazing! OP said lowercase was OK so you can remove V~ \$\endgroup\$

DJMcMayhem
– DJMcMayhem

2016年07月30日 18:22:25 +00:00
Commented Jul 30, 2016 at 18:22
4

\$\begingroup\$ @RobStarling see: meta.codegolf.stackexchange.com/q/8995/40695 \$\endgroup\$

Downgoat
– Downgoat

2016年07月30日 22:57:22 +00:00
Commented Jul 30, 2016 at 22:57
5

\$\begingroup\$ I dare someone to try this in emacs. \$\endgroup\$

addison
– addison

2016年07月31日 03:49:39 +00:00
Commented Jul 31, 2016 at 3:49
2

\$\begingroup\$ @addison Emacs answer \$\endgroup\$

TuxCrafting
– TuxCrafting

2016年08月03日 13:09:01 +00:00
Commented Aug 3, 2016 at 13:09

| Show 5 more comments

Print a Tabula Recta!

Rules/Requirements

Scoring

Submissions

Leaderboard

173 Answers 173

Vim, (削除) 25 (削除ここまで) 23 bytes

05AB1E, (削除) 6 (削除ここまで) 5 bytes

Python 2, (削除) 59 (削除ここまで) (削除) 57 (削除ここまで) 53 bytes

///, 220 bytes

C, 47 bytes

J, 15 bytes

///, 128 bytes

Explanation

Emacs, 47 bytes

PowerShell, 37 bytes

Jelly, 7 bytes

How it works

JavaScript (ES6), 56 bytes

C, (削除) 88 (削除ここまで) 64 bytes

Piet, 247 bytes/190 codels

Mathematica (削除) 68 (削除ここまで) 61 bytes

MATL, 8 bytes

Python 2, (削除) 75 (削除ここまで) (削除) 65 (削除ここまで) (削除) 61 (削除ここまで) 58 bytes

R, (削除) 47 (削除ここまで) (削除) 42 (削除ここまで) 41 bytes

Javascript, (削除) 113 (削除ここまで) (削除) 96 (削除ここまで) (削除) 91 (削除ここまで) 76 bytes

Javascript/HTML, (削除) 140 (削除ここまで) (削除) 123 (削除ここまで) (削除) 118 (削除ここまで) 105 bytes

Retina, (削除) 36 (削除ここまで) 31 bytes

Sesos, (削除) 27 (削除ここまで) 25 bytes

Sesos assembly

How it works

Haskell, (削除) 56 (削除ここまで) (削除) 53 (削除ここまで) 52 Bytes

R, 53 bytes

V, (削除) 36 (削除ここまで), 10 bytes

Dyalog APL, (削除) 10 (削除ここまで) 11 bytes

Brain-Flak, 222 bytes

C#, 98 bytes

Octave, 27 bytes

q, 20 bytes

Java, (削除) 190 (削除ここまで) (削除) 176 (削除ここまで) (削除) 172 (削除ここまで) 163 bytes

Bash, 66 bytes

Your Answer

Sign up or log in

Post as a guest

Post as a guest

Linked

Related

Hot Network Questions