In một Tabula Recta!

Tabula Recta (đôi khi được gọi là 'Bảng Vigenere'), được tạo ra bởi Johannes Trithemius, và đã được sử dụng trong một số mật mã, bao gồm tất cả các biến thể của mật mã Vigenere của Bellaso và mật mã Trithemius. Nó trông như thế này:

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

Tôi thường xuyên cần điều này, nhưng không thể tìm thấy nó ở bất cứ đâu trên internet để sao chép và dán từ đó. Bởi vì bảng vuông quá dài và mất nhiều thời gian để nhập, mã của bạn phải càng ngắn càng tốt.

Quy tắc / Yêu cầu

• Mỗi bài nộp phải là một chương trình hoặc chức năng đầy đủ. Nếu nó là một hàm, nó phải được chạy bằng cách chỉ cần thêm lệnh gọi hàm vào cuối chương trình. Bất cứ điều gì khác (ví dụ như các tiêu đề trong C), phải được bao gồm.
• Nếu có thể, hãy cung cấp một liên kết đến một trang web nơi chương trình của bạn có thể được kiểm tra.
• Chương trình của bạn không được viết bất cứ điều gì STDERR.
• Lỗ hổng tiêu chuẩn bị cấm.
• Chương trình của bạn có thể xuất trong mọi trường hợp, nhưng nó phải được in (không phải là một mảng hoặc tương tự).

Chấm điểm

Các chương trình được ghi theo byte, theo UTF-8 theo mặc định hoặc một bộ ký tự khác bạn chọn.

Cuối cùng, câu trả lời có ít byte nhất sẽ giành chiến thắng.

Đệ trình

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành liên kết sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

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

Bảng xếp hạng

Dưới đây là một Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

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

Cảm ơn Downgoat vì đã tiết kiệm 1 byte. Mã số:

ADv=À

Giải trình:

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.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Vim, 25 23 byte

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

Trong trường hợp ↵là chìa khóa Return.

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

EDIT : chữ thường là được, vì vậy tôi có thể lưu hai phím.

Python 2, 59 57 53 byte

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

Cảm ơn @xsot cho -4 byte!

/// , 220 byte

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

Hãy thử trực tuyến!

Điều này đáng ngạc nhiên là không tầm thường và tôi không biết liệu nó có tối ưu hay không.

Cách duy nhất để giải quyết vấn đề như thế này trong /// là trích xuất các chuỗi con phổ biến. ( Hóa ra tôi đã sai. ) Tuy nhiên, do bản chất của đầu ra, nó không rõ ràng nên loại bỏ chất nền nào tốt nhất vì bạn thực sự không thể trích xuất toàn bộ bảng chữ cái do ngắt dòng. Vì vậy, bạn sẽ cần trích xuất một số chuỗi con của bảng chữ cái được bao bọc, nhưng sau đó sẽ có sự đánh đổi về thời gian bạn thực hiện các chuỗi con và loại nào bạn chọn.

Vì vậy, đây là những gì tôi đã làm. Đây là một tập lệnh CJam tìm thấy tất cả các chuỗi con có độ dài lên đến 25 trong chuỗi đã cho và với mỗi chuỗi sẽ tính toán bao nhiêu byte trích xuất của nó sẽ tiết kiệm. Về cơ bản nếu có các Nbản sao của Mchuỗi con dài, bạn sẽ lưu các (N-1)*(M-1) - 5chuỗi con, các chuỗi con này không chứa dấu gạch chéo. Ngoài ra, về mặt kỹ thuật, khi bạn đã trích xuất 8 chuỗi con hoặc hơn, phần bù không đổi ở cuối sẽ giảm xuống -4, nhưng tập lệnh không xem xét điều đó.

Dù sao, đây là những gì tôi đã làm với kịch bản:

• Chạy đoạn script đối với mã hiện tại (ban đầu chỉ là đầu ra).
• Trong số các chuỗi con mang lại sự cải tiến lớn nhất, chọn cái ngắn nhất. Nếu có một số, chọn số nhỏ nhất theo từ vựng (từ những gì tôi có thể nói, với đầu vào đã cho, điều này làm giảm sự chồng chéo giữa các chuỗi con).
• Thay thế tất cả các lần xuất hiện của chuỗi con được chọn trong mã bằng một chữ cái viết thường không sử dụng.
• Chuẩn bị /x/ABC/cho mã nơi xchữ cái được chọn và ABClà chuỗi con.
• Lặp lại cho đến khi không còn chất nền nào có thể tiết kiệm bất cứ thứ gì.

Cuối cùng, chúng tôi tiết kiệm thêm một vài byte bằng cách thay thế kết quả //bằng |và trả trước /|/\/\//(đây là lý do tại sao trích xuất các chuỗi con chỉ tốn 4 thay vì 5 byte sau chuỗi con thứ 8 hoặc hơn).

Như tôi đã nói, tôi không biết liệu điều này có tối ưu hay không và tôi thấy kết quả trông khá bất thường khá thú vị. Có thể có được một giải pháp ngắn hơn bằng cách chọn các chuỗi con không tối ưu (nhưng nhiều hơn) ở đâu đó bên dưới dòng. Tôi tự hỏi lớp phức tạp của vấn đề này là gì ...

C, 47 byte

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

Hãy thử nó trên Ideone

Một vòng lặp duy nhất, in bảng chữ cái cứ sau 26 ký tự nhưng với mỗi ký tự thứ 27 được thay thế bằng một dòng mới.

J, 15 byte

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

Phiên dịch trực tuyến .

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 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ câu trả lời tuyệt vời của Jakube cho thử thách L-ph.us, tôi nghĩ rằng tôi cũng sẽ thử sức với chương trình thực tế trong /// thay vì chỉ sử dụng nó để nén. Điều này khá khó khăn và tôi cần bốn lần thử, nhưng cuối cùng nó đã xuất hiện ngắn hơn nhiều so với giải pháp dựa trên nén của tôi .

Giải trình

Một đoạn mồi nhanh trên ///: về cơ bản trình thông dịch chỉ đọc ký tự mã theo ký tự và thực hiện các thao tác sau:

• Nếu nó không phải \cũng không phải là một /, in nó.
• Nếu đó là một \, in ký tự tiếp theo.
• Nếu đó là một /, hãy phân tích một /x/y/lệnh (có cùng quy tắc thoát) và liên tục thay thế tất cả xtrong mã còn lại bằng y.

Lấy thêm cảm hứng từ Jakube, để đơn giản, tôi sẽ chỉ giải thích một phiên bản 4 x 4 này:

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

Chúng tôi bắt đầu bằng cách thay thế những :thứ đó bằng thứ thứ hai và thứ ba /. Điều này sẽ kết thúc là mã xoay các hàng tiếp theo. Chúng tôi nhận được điều này:

/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

Các f, bvà xchỉ shorthands cho chuỗi thông thường, mà chúng tôi sẽ mở rộng bây giờ. Cái fnày là cho dấu gạch chéo, cái blà cho dấu gạch chéo ngược và cái xđược dùng \//để xuất hiện khá nhiều. Lý do tôi đang sử dụng các bí danh cho các chuỗi ký tự đơn /và \là chúng phải được thoát trong hướng dẫn thay thế đầu tiên, vì vậy tôi thực sự tiết kiệm được khá nhiều byte bằng cách không cần tất cả các dấu gạch chéo ngược đó. Đây là những gì chúng tôi nhận được sau khi x, fvà bđã được điền vào:

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

Rất dễ đọc.

Vì vậy, dòng đầu tiên chỉ được in nguyên văn. Sau đó, chúng ta đến phần sôi nổi xoay tất cả các hàng tiếp theo. Nó thực sự bao gồm bốn hướng dẫn khác nhau. Một điều cần chú ý là tôi đã thoát khỏi tất cả các lần xuất hiện Atrong các hướng dẫn này. Lý do cho điều này là vì nó cho phép tôi phân biệt As trong các hướng dẫn với As trong các hàng còn lại, chúng cần được xử lý khác nhau.

/\/\A/\//

Điều này phù hợp /Avà thay thế nó với /, loại bỏ A. Lưu ý rằng chuỗi con này chỉ xuất hiện ở phía trước của mỗi chuỗi ABCD, vì vậy, chuỗi này sẽ bỏ ký tự đầu tiên của tất cả các dòng tiếp theo:

/
\//\A_\//

Điều này phù hợp với một nguồn cấp dữ liệu theo sau là một dấu gạch chéo và thay thế nó bằng A_/. Vì vậy, điều này chèn một Aở cuối mỗi dòng, hoàn thành xoay vòng và cũng biến nguồn cấp dữ liệu thành một dấu gạch dưới.

/_\//
\//

Điều này khớp _/và thay thế nó bằng một dòng cấp theo sau là dấu gạch chéo. Lý do tôi cần thực hiện đường vòng này thông qua dấu gạch dưới là vì /// áp dụng mỗi lệnh lặp đi lặp lại cho đến khi chuỗi không còn phù hợp. Điều đó có nghĩa bạn không bao giờ có thể sử dụng một lệnh có dạng /x/axb/nơi x, avà blà chuỗi tùy ý, bởi vì sau khi thay thế xsẽ luôn luôn vẫn phù hợp. Cụ thể, điều này có nghĩa là chúng ta không thể chèn một cái gì đó vào trước một nguồn cấp dữ liệu. Chúng ta cần thay thế nguồn cấp dữ liệu trong quy trình và hoàn tác thay thế này.

/\\\A/\\B/

Điều này khớp \Avà thay thế nó bằng \B, để các hướng dẫn sau các hàng còn lại xử lý ký tự tiếp theo. Sau khi tất cả bốn hướng dẫn đã được xử lý, chuỗi còn lại trông như thế này:

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

Vì vậy, bây giờ hàng xoay đầu tiên được in, và sau đó bộ hướng dẫn tiếp theo xoay các hàng còn lại bằng một ô khác, v.v. Sau vòng quay cuối cùng, chúng tôi có thêm một vài hướng dẫn mà chúng tôi có thể bỏ qua và sau đó chúng tôi kết thúc bằng hướng dẫn không đầy đủ:

/\\\B/\\

Các hướng dẫn không đầy đủ ở cuối chỉ đơn giản là bị bỏ qua và chương trình kết thúc.

Thạch , 7 byte

ØAṙJṢj⁷

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

Trong đó ^Pcó nghĩa là "Điều khiển P", v.v. Đó là 47 byte, vì các phím F3 và F4 yêu cầu hai byte ASCII.

Sau khi nhập đầu vào bắt đầu, nó xác định một macro bàn phím để nhân đôi dòng và di chuyển ký tự đầu tiên đến cuối. Sau đó, nó chạy macro thêm 24 lần nữa.

JavaScript (ES6), 56 byte

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

Vâng, đúng vậy, một nửa mã của tôi là chuỗi chữ cái. Tốt nhất tôi có thể làm mà không cần bằng chữ là 81 byte:

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

Nếu bạn muốn một chương trình chứ không phải là một hàm, sau đó loại bỏ _=>và bọc lại console.log()với chi phí 10 byte.

Toán học 68 61 byte

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

Nhờ vào...

@MartinEnder (7 byte)

Python 2, 75 65 61 58 byte

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

Lấy bảng chữ cái với map(chr,range(65,91)), sau đó áp dụng thủ công thao tác dịch chuyển chuỗi.

Cảm ơn @LeakyNun và @TheBikingViking cho -4 byte!

Cảm ơn @xnor cho -3 byte!

C, 88 64 byte

Gọi f()mà không tranh luận.

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

Hãy thử nó trên ideone .

Piet , 247 byte / 190 codel

Hãy thử trực tuyến!

Vì vậy, việc này mất nhiều thời gian hơn tôi dự đoán và tôi có một vài ý tưởng về một số cách tiếp cận hiệu quả hơn (thân thiện với ngăn xếp hơn) khác, nhưng cuối cùng tôi đã làm được điều nguy hiểm (và sửa lỗi trình thông dịch và thêm các tính năng IDE dọc theo cách), vì vậy đây là. Hầu như không phải là ngôn ngữ hiệu quả nhất, nhưng rất nhiều niềm vui. Đây là chế độ xem lớn hơn và dấu vết hiển thị đường dẫn đã thực hiện. Lịch sử trên GitHub của tôi .

Là một ngôn ngữ dựa trên ngăn xếp, nó quá phức tạp để giải thích ngắn gọn, nhưng đây là một tổng quan cơ bản về những gì các phần / vòng lặp khác nhau làm. Tất cả các tên biến và hàm chỉ là để giải thích, vì không có biến hoặc hàm trong Piet.

• Khởi tạo (phía trên bên trái): bắt đầu line_countertừ 27, tải '@' là cur_letter, đặt letter_countthành 27
• Vòng lặp chính (bắt đầu từ màu tím đậm, trên cùng)
  • Giảm letter_counter
  • Nhánh tới reset_linenếu không (khối 2 màu lục lam nhạt)
  • Cuộn cur_letterlên đỉnh của ngăn xếp
  • Các nhánh tới check_donenếu cur_letter > 'X'(khối teal / đỏ, bên phải)
  • Tăng cur_lettervà xuất nó (góc dưới bên phải)
  • Nhánh để reset_letternếu cur_letter > 'Y'(khối màu xanh nhạt, bên trái)
  • Cuộn `letter_count_ trở lại đầu ngăn xếp, quay lại đầu vòng lặp
• reset_line nhánh (hình vuông lớn màu hồng):
  • Xuất ký tự dòng mới
  • Đặt lại letter_countđến 27
  • Tiếp tục quay lại đầu vòng lặp chính
• check_done nhánh (nửa bên phải)
  • Cuộn line_counterlên đầu
  • Chi nhánh kết thúc nếu không
  • Giảm line_countervà cuộn trở lại xuống dưới cùng của ngăn xếp
  • Tiếp tục nơi nó rời đi, in thư
• reset_line nhánh (bên trái, khối màu xanh lá cây):
  • Đặt lại cur_letterthành '@'
  • Tiếp tục nơi nó rời đi, lăn / quay trở lại đầu vòng

MATL , 8 byte

Cảm ơn @Dennis , người đã gợi ý rằng MATL nên kết hợp lập chỉ mục mô-đun và @Suever , người có ý tưởng về các hoạt động theo cặp tự động.

1Y2t&+Q)

Hãy thử trực tuyến!

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 byte

Một phiên bản siêu ngắn để chạy trong bảng điều khiển:

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

Javascript / HTML, 140 123 118 105 byte

Phiên bản đẹp hơn, với đầu ra HTML giúp OP dễ dàng sao chép và dán:

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

(EDIT: Tôi chỉ nên sử dụng chuỗi AZ thay vì tạo nó)

(EDIT 2: Cảm ơn @Neil và @DanTheMan vì thông tin đầu vào của họ (xem bình luận))

PowerShell, 44 byte

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

R, 47 42 41 byte

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

Hãy thử trực tuyến!

Tạo 27 bảng chữ cái, loại bỏ các chữ cái thứ 27 và in trong 26 cột.

Cải thiện lấy cảm hứng từ @Giuseppe 's giải pháp .

Sesos , 27 25 byte

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

Hãy thử trực tuyến! Kiểm tra gỡ lỗi để xem mã SBIN được tạo. ^†

Sesos lắp ráp

Tệp nhị phân ở trên đã được tạo bằng cách lắp ráp mã SASM sau.

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)

Làm thế nào nó hoạt động

Chúng tôi bắt đầu bằng cách khởi tạo băng từ ABCDEFGHIJKLMNOPQRSTUVWXYZ. Đây là như sau.

Viết 26 vào một ô, để lại băng ở trạng thái sau.

                                                     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

Miễn là ô dưới đầu dữ liệu khác không, chúng tôi thực hiện như sau.

Sao chép số vào hai ô bên trái và thêm 64 vào bản sao ngoài cùng bên trái.

                                                   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

Di chuyển bản sao ngoài cùng bên trái đến vị trí ban đầu, sau đó trừ 1 từ bản sao ngoài cùng bên phải.

                                                     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

Quá trình dừng lại sau 26 lần lặp, vì lúc đó bản sao ngoài cùng bên phải là 0 . Chúng tôi di chuyển một ô sang bên phải, vì vậy trạng thái cuối cùng của băng sau khi khởi tạo là như sau.

     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

Bây giờ chúng tôi đã sẵn sàng để tạo đầu ra, bằng cách lặp lại quy trình sau cho đến khi ô bên dưới đầu dữ liệu bằng không.

Đầu tiên, chúng tôi in ký tự dưới đầu dữ liệu và di chuyển sang phải, lặp lại bước này cho đến khi tìm thấy một ô có giá trị 0 . Sau khi in ABCDEFGHIJKLMNOPQRSTUVWXYZ, băng trông như sau.

                                                                                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

Bây giờ chúng ta di chuyển đầu dữ liệu 27 đơn vị sang trái (trở về đầu 0 ) và lặp lại kết hợp di chuyển in cho đến khi tìm thấy một ô có giá trị 0 . Điều này in không có gì và để lại băng như sau.

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

Bây giờ, chúng ta viết 10 vào ô hiện tại, in ký tự tương ứng (linefeed) và zero ô với lệnh gọi đến getđầu vào trống, giữ cho băng không thay đổi.

Sau đó, chúng tôi di chuyển nội dung của ô sang bên phải đến ô hiện tại, sau đó di chuyển đầu dữ liệu sang các đơn vị sang phải.

      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

Lặp lại tiếp theo là hơi khác nhau. Bước in đầu tiên in BCDEFGHIJKLMNOPQRSTUVWXYZ, để lại băng như sau.

                                                                                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

Bây giờ chúng tôi di chuyển đầu dữ liệu 27 đơn vị sang trái.

 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

Các vòng lặp in tiếp theo in Avà để lại băng như sau.

   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

Một lần nữa, chúng tôi in một nguồn cấp dữ liệu, di chuyển nội dung của ô sang bên phải đến ô hiện tại, sau đó di chuyển đầu dữ liệu sang các đơn vị ở bên phải.

         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

Sau 24 lần lặp nữa, bước cuối cùng của việc di chuyển đầu dữ liệu sang phải để lại băng ở trạng thái sau.

                                                                                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

Ô dưới đầu dữ liệu bây giờ là 0 và chương trình kết thúc.

^† TIO sử dụng một phiên bản mới hơn của Sesos, đó là tương thích ngược cho SASM, nhưng tạo ra mã sbin ngắn hơn.

Haskell, 56 53 52 byte

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

cùng độ dài: (sử dụng đề xuất của @AndersKaseorg)

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

để thực hiện công cụ mô-đun, bạn phải nhập Data.Char để có chức năng chr, 74 59 58 Byte là cách tốt nhất tôi có thể có với điều đó: (cảm ơn @nimi đã gợi ý chức năng toEnum)

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

Điều này có thể ngắn hơn nhiều, nhưng tôi không biết bất kỳ thủ thuật đánh gôn nào của Haskell.

đã sử dụng mapM thay vì mapM_ (xem bình luận của @ Lynn)

R, 53 byte

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

Đây là một thông dịch viên trực tuyến .

Võng mạc, 36 31 byte

5 byte nhờ Martin Ender.

Z
{2`
$ `
} T01`L`_L
\ `.
$ & $ '$ `

Dẫn đầu dòng là đáng kể.

Hãy thử trực tuyến!

Tín dụng .

Brain-Flak , 222 byte

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

Hãy thử trực tuyến!

Tôi chưa quen với Brain-Flak, vì vậy có lẽ điều này có thể được chơi golf rất nhiều, nhưng ít nhất đó là lần thử đầu tiên. Nó lưu trữ 27 bảng chữ cái đầy đủ trên ngăn xếp bên trái, sau đó di chuyển các bảng chữ cái sang phải và thay thế mỗi chữ cái thứ 27 bằng một dòng mới.

Mã nguồn của tôi hơi khó hiểu, tuy nhiên tôi sẽ thêm nó vào.

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

¬AZ25ñÙx$p

Hãy thử trực tuyến!

Điều này sử dụng mã hóa "Latin1".

Giải trình:

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

Tôi đã cố gắng xem liệu tôi có thể tạo ra các chữ cái ngắn hơn là chỉ khởi tạo chúng dưới dạng chuỗi hay không, nhưng nó không thực sự khả thi. Các chữ cái là 26 byte và đoạn mã này một mình

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

là 25 byte. Tôi nghĩ khởi tạo chúng và sau đó nối thêm chúng bằng + = a là một giải pháp tốt, nhưng với C #, bạn bị giới hạn bởi số lượng lớn các hàm như Substring()và Console.WriteLine().

Nỗ lực của tôi ở 98 byte:

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

Octave, 27 byte

Chúng tôi đang thêm một hàng và một vectơ cột và Octave mở rộng độc đáo các kích thước sigleton, không cần bsxfun(như bạn sẽ cần trong Matlab).

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

q, 20 byte

(til 26)rotate\:.Q.A

Java, 190 176 172 163 byte

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 byte

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

Tôi tạo một bảng chữ cái đầy đủ A, sau đó in 26 phiên bản xoay của nó bằng cách lấy các ký tự bắt đầu nvà nối thêm các vị trí trước đó n.

Perl, 42 byte

Tín dụng đầy đủ cho @Dom Hastings cho việc này.

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

Hoặc (cùng số byte):

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

Nhu cầu -M5.010hoặc -Eđể chạy, ví dụ:

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

Câu trả lời cũ của tôi (55 byte):

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

Cần -M5.010chạy. Vì vậy, chạy với:

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

Có lẽ có thể làm ngắn hơn, nhưng tôi đã không tìm ra cách ...