打印Tabula Recta！

Tabula Recta（有时称为“ Vigenere表”）是由Johannes Trithemius创建的，并已用于多种密码中，包括Bellaso Vigenere密码和Trithemius密码的所有变体。看起来像这样：

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

我经常需要它，但是在Internet上任何地方都找不到它可以复制和粘贴。因为方桌是那么的漫长，并采取该死的年龄打字，你的代码必须尽可能短。

规则/要求

• 每个提交应该是完整的程序或功能。如果它是一个函数，则只需将函数调用添加到程序底部即可使其可运行。其他任何内容（例如C中的标头）都必须包括在内。
• 如果可能，请提供指向可以测试您的程序的站点的链接。
• 您的程序不得向写入任何内容STDERR。
• 禁止使用标准漏洞。
• 您的程序在任何情况下都可以输出，但是必须将其打印出来（而不是数组或类似的东西）。

计分

程序根据字节评分，默认情况下为UTF-8或您选择的其他字符集。

最终，字节数最少的答案将获胜。

意见书

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

# Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

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

05AB1E，6 5字节

感谢Downgoat节省了1个字节。码：

ADv=À

说明：

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.

使用CP-1252编码。在线尝试！。

Vim，25 23字节

:h<_↵jjYZZP25@='Ypx$p'↵

↵返回键在哪里。

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

编辑：小写是可以的，所以我可以保存两个键。

Python 2，59 57 53字节

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

感谢@xsot -4个字节！

///，220字节

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

在线尝试！

令人惊讶的是，这并不平凡，我不知道它是否是最佳的。

///中打高尔夫球这样的问题的唯一方法是提取公共子字符串。（事实证明我错了。）但是，由于输出的性质，完全不清楚应该最佳地提取哪个子字符串，因为由于换行符而导致您实际上无法提取整个字母。因此，您需要提取包装后的字母的一些子字符串，但是在制作子字符串的时间以及选择哪些子字符串方面需要权衡。

这就是我所做的。这是一个CJam脚本，它在给定的字符串中查找长度不超过25的所有子字符串，并为每个子字符串计算其提取将节省多少字节。基本上，如果存在Nlength- M子字符串的副本，则将保存(N-1)*(M-1) - 5子字符串，这些子字符串不包含斜杠。同样，从技术上讲，当您已经提取了大约8个子字符串时，最后的常量偏移量将减少为-4，但是脚本不会考虑这一点。

无论如何，这是我对脚本所做的操作：

• 针对当前代码运行脚本（最初只是输出）。
• 在产生最大改进的子字符串中，选择最短的子字符串。如果有多个，则选择字典上最小的（据我所知，对于给定的输入，这会减少子字符串之间的重叠）。
• 用未使用的小写字母替换代码中所有出现的所选子字符串。
• 前面/x/ABC/的代码x是所选字母和ABC子字符串。
• 重复直到没有剩余的子字符串可以保存任何内容。

最后，我们通过将结果替换为//并|加上前缀来节省更多的字节/|/\/\//（这就是为什么提取子字符串仅花费4个字节而不是第8个子字符串之后的5个字节）的原因。

就像我说的那样，我不知道这是否是最佳选择，而且我发现看上去很不规则的结果非常有趣。通过在行中的某处选择非最佳（但更多）的子字符串，可以获得更短的解决方案。我想知道这个问题的复杂度等级是多少...

C，47个字节

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

在Ideone上尝试

一个循环，每26个字符打印一次字母，但每27个字符用换行符替换。

J，15个字节

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

在线口译员。

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

///，128字节

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

在线尝试！

受到Jakube对L-phabet挑战的惊人回答的启发，我认为我会尽力在/// 进行实际编程，而不是仅仅将其用于压缩。这非常棘手，我需要进行四次尝试，但最终比我基于压缩的解决方案要短得多。

说明

快速入门///：基本上，解释器只逐字符读取代码，然后执行以下操作：

• 如果既不是\也不是/，请打印出来。
• 如果是\，请打印下一个字符。
• 如果是a /，则解析一条/x/y/指令（具有相同的转义规则），然后用重复替换x其余代码中的所有代码y。

从Jakube那里获得更多启发，为简单起见，我将解释一个4x4版本：

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

我们首先用:第二和第三之间的东西替换那些东西/。这最终将成为旋转后续行的代码。我们得到这个：

/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

的f，b并且x是常见字符串，我们将扩大，现在只是速记。该f是一个斜杠，b是反斜线和x是\//恰好拿出了不少。究其原因我使用单字符子的别名/和\是他们不得不在第一次换人指令进行转义，所以我实际上不需要所有这些反斜线节省相当多的字节。这是我们得到的x，f并b已填写：

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

可读性强。

因此，第一行只是逐字打印。然后，我们进入旋转所有其他行的时髦部分。它实际上由四个不同的指令组成。需要注意的一件事是，我已经避免了A这些说明中所有的出现。这样做的原因是，它使我可以将A指令中的As与其余行中的s 区分开来，需要对它们进行不同的处理。

/\/\A/\//

匹配/A并替换为/，删除A。请注意，此子字符串仅出现在each的前面ABCD，因此这会删除所有后续行的第一个字符：

/
\//\A_\//

这与换行符后跟斜杠匹配，并用代替A_/。因此，这会A在每行的末尾插入一个，以完成旋转，并将换行符变成下划线。

/_\//
\//

它将匹配_/并替换为换行符，后跟斜杠。我需要通过下划线进行绕行的原因是这样的事实，即///反复应用每条指令，直到字符串不再匹配为止。这意味着你可以永远使用形式的指令/x/axb/，其中x，a并且b是任意的字符串，因为毕竟替代x将永远仍然匹配。特别是，这意味着我们不能只在换行符前面插入内容。我们需要在此过程中替换换行符，然后撤消该替换。

/\\\A/\\B/

它将匹配\A并替换为\B，以便其余行之后的指令处理下一个字符。处理完所有四条指令后，剩余的字符串如下所示：

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

因此，现在打印第一个旋转的行，然后下一组指令将另一个单元旋转其余的行，依此类推。在最后一次轮换之后，我们还有更多可以忽略的指令，然后以不完整的指令结尾：

/\\\B/\\

最后，不完整的指令将被忽略，程序将终止。

果冻，7 个字节

ØAṙJṢj⁷

在线尝试！

这个怎么运作

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

Emacs，47个字节

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

哪里 ^P表示“控件P”，以此类推。这是47个字节，因为F3和F4键需要两个ASCII字节。

输入开始输入后，它定义一个键盘宏以复制该行并将第一个字符移到末尾。然后，它将再次运行宏24次。

JavaScript（ES6），56个字节

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

是的，没错，我的一半代码是字母字符串文字。没有字面值，我能做的最好是81个字节：

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

如果要使用程序而不是函数，请删除_=>并包装，console.log()费用为10个字节。

Mathematica 68 61字节

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

谢谢...

@MartinEnder（7个字节）

Python 2，75 65 61 58字节

a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x

获取与字母map(chr,range(65,91))，然后手动应用串移位操作。

感谢@LeakyNun和@TheBikingViking -4个字节！

感谢@xnor -3个字节！

C，88 64字节

调用时f()不带参数。

f(i,j){for(i=j=0;i<26;putchar(j==26?j=0,i++,10:65+(i+j++)%26));}

在ideone上尝试一下。

Piet，247字节/ 190个编码

在线尝试！

所以，这花了更长的时间比我预想的，我有一些其他的更有效（更堆型）接近一些想法，但我终于得到了党的事情工作（和固定的翻译错误，并添加IDE功能沿方式），所以就在这里。几乎不是字节效率最高的语言，但它带来了很多乐趣。这是一个较大的视图，并显示了所走路径的轨迹。历史记录在我的GitHub上。

作为一种基于堆栈的语言，它太费时费力以致无法简要说明，但是这里是各个节/循环的基本概述。所有变量和函数名称仅用于解释，因为Piet中没有变量或函数。

• 初始化（左上）：从line_counter27 开始，将加载为@ cur_letter，设置letter_count为27
• 主循环（从深紫色开始，中间居中）
  • 减量 letter_counter
  • 分支到reset_line是否为零（浅青色2块）
  • 卷cur_letter到栈顶
  • 分支到check_doneif cur_letter > 'X'（teal /红色块，右侧）
  • 递增cur_letter并输出（右下角）
  • 分支到reset_letterif cur_letter > 'Y'（浅绿色块，左）
  • 将`letter_counter_回滚到堆栈顶部，回滚到循环顶部
• reset_line 分支（粉色大方块）：
  • 输出换行符
  • 重置letter_count为27
  • 继续回到主循环的顶部
• check_done 分支（右半边）
  • 卷line_counter到顶部
  • 如果为零则分支结束
  • 递减line_counter并回滚到堆栈的底部
  • 恢复上次停止的位置，打印字母
• reset_line 分支（左侧，绿色块）：
  • 重置cur_letter为“ @”
  • 从上次停止的地方继续播放，滚动/返回循环的顶部

MATL，8字节

感谢@Dennis，他建议 MATL应该合并模块化索引，以及@Suever，他有自动成对操作的想法。

1Y2t&+Q)

在线尝试！

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

Javascript，113 96 91 76字节

在控制台中运行的超短版本：

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

的JavaScript / HTML，140 123 118 105字节

更漂亮的版本，带有HTML输出，可让OP轻松复制和粘贴：

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

（编辑：我应该只使用字符串AZ而不是生成它）

（编辑2：感谢@Neil和@DanTheMan的输入（请参阅评论））

PowerShell，44字节

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}

R，47 42 41字节

write(rep(LETTERS,27)[-27*1:26],1,26,,'') 

在线尝试！

生成27个字母，删除第27个字母并打印在26列中。

改进灵感 @Giuseppe的解决方案。

Sesos，27 25字节

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

在线尝试！选中调试以查看生成的SBIN代码。^†

Sesos组装

上面的二进制文件是通过组合以下SASM代码生成的。

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)

这个怎么运作

我们首先将磁带初始化为 ABCDEFGHIJKLMNOPQRSTUVWXYZ。如下。

将26写入单元格，使磁带保持以下状态。

                                                     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

只要数据头下的单元格为非零，我们就可以执行以下操作。

将数字复制到左侧的两个单元格中，然后在最左侧的副本中添加64。

                                                   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

将最左边的副本移到原始位置，然后从最右边的副本中减去1。

                                                     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

该过程在26次迭代后停止，因为此时最右边的副本为0。我们向右移动一个单元格，因此初始化后磁带的最终状态如下。

     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

现在，我们准备通过重复以下过程直到数据头下的单元为零来生成输出。

首先，我们将字符打印在数据头下并向右移动，重复此步骤直到找到值为0的单元格。打印后ABCDEFGHIJKLMNOPQRSTUVWXYZ，胶带看起来如下。

                                                                                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

现在，我们将数据头向左移动27个单位（回到开头0），并重复打印移动组合，直到找到值为0的单元格为止。这将不打印任何内容，并按照以下说明留下胶带。

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

现在，我们将10写入当前单元格，打印相应的字符（换行符），并通过调用get空输入将单元格清零，使磁带保持不变。

之后，我们将单元格的内容移至当前单元格的右侧，然后将数据头移至右侧的单位。

      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

下一次迭代稍有不同。第一个打印步骤将进行打印BCDEFGHIJKLMNOPQRSTUVWXYZ，如下所述保留胶带。

                                                                                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

现在，我们将数据头向左移动27个单位。

 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

随后的打印循环A如下打印并离开胶带。

   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

我们再次打印换行符，将单元格的内容向右移动到当前单元格，然后将数据头向右移动到单位。

         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

再经过24次迭代后，将数据头移到右侧的最后一步使磁带处于以下状态。

                                                                                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

现在，数据头下的单元格为0，程序终止。

^† TIO使用较新版本的Sesos，它与SASM向后兼容，但生成的SBIN代码更短。

Haskell，56 53 52字节

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

相同长度：（使用@AndersKaseorg的建议）

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

要执行模块化的工作，您必须导入Data.Char以获得chr函数，74 59 58字节是我所能获得的最好的结果：（感谢@nimi提出了toEnum函数）

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

这可能要短得多，但是我不知道任何Haskell高尔夫技巧。

使用了mapM而不是mapM_（请参阅@Lynn的评论）

R，53个字节

for(i in 1:26)cat(LETTERS[c(i:26,1:i-1)],"\n",sep="")

这里是在线翻译。

视网膜，36 31字节

5字节感谢Martin Ender。

ž
{2`
$`
} T01`L`_L
\`。
$＆$'$`¶

前导换行很重要。

在线尝试！

学分。

Brain-Flak，222字节

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

在线尝试！

我是Brain-Flak的新手，所以也许可以打很多球，但至少是第一次尝试。它在左侧堆栈中存储27个完整字母，然后将字母向右移动，并用换行符替换每27个字母。

我的源代码有点混乱，但是我还是要添加它。

(((()()()()){})
    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

V，36，10字节

¬AZ25ñÙx$p

在线尝试！

这使用“ Latin1”编码。

说明：

¬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

C＃，98个字节

我试图查看是否可以生成比仅将它们初始化为字符串短的字母，但这实际上是不可能的。字母是26个字节，仅此片段

for(char a='A';a<'[';a++)

是25个字节。我认为初始化它们，然后在它们后面加上a + = a是一个很好的解决方案，但对于C＃，您会受到像Substring()和这样的函数的字节数的限制Console.WriteLine()。

我的98字节尝试：

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));

八度，27字节

我们添加了行向量和列向量，并且Octave很好地扩展了sigleton尺寸，不需要bsxfun（就像在Matlab中那样）。

[mod((v=0:25)+v',26)+65,'']

q，20个字节

(til 26)rotate\:.Q.A

Java中，190个 176 172 163字节

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);}}

Bash，66个字节

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

我在其中创建了一个完整的字母A，然后通过以其开头的字符n并附加前面的那些字符来打印26个旋转版本n。

Perl，42个字节

为此，我们对@Dom Hastings给予了充分的感谢。

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

或（相同字节数）：

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

需要-M5.010还是-E要运行，例如：

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'

我的旧答案（55个字节）：

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

需要 -M5.010运行。因此运行：

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

也许可以做的更短一些，但是我还不知道怎么做……