Роздрукуйте Tabula Recta!

Табула Ректа (іноді її називають «Таблиця Вігенера») була створена Йоганнесом Тритеміусом і використовувалася в декількох шифрах, включаючи всі варіанти шифра Вігенера Белласо та шифри Тритемія. Це виглядає приблизно так:

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

Мені це часто потрібно, але я не можу знайти його в Інтернеті для копіювання та вставки. Оскільки квадратний стіл настільки довгий і набирає страхітливих віків , ваш код повинен бути якомога коротшим.

Правила / Вимоги

• Кожне подання повинно бути або повною програмою, або функцією. Якщо це функція, її потрібно запускати, лише додаючи виклик функції в нижній частині програми. Все інше (наприклад, заголовки в 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 в даному рядку і для кожної з них обчислює, скільки байтів збереже його витяг. В основному, якщо є Nкопії Mпідрядок по довжині , ви збережете (N-1)*(M-1) - 5підрядки, ці підрядки не містять косої риски. Крім того, технічно, коли ви вже витягуєте 8 підрядів або близько того, постійне зміщення в кінці зводиться до -4, але сценарій цього не враховує.

У всякому разі, ось що я зробив зі сценарієм:

• Запустіть скрипт проти поточного коду (який спочатку є лише висновком).
• З підрядків, які дають найбільше вдосконалення, виберіть найкоротший. Якщо їх декілька, виберіть найменше лексикографічно (з того, що я можу сказати, для даного вводу це зменшує перекриття між підрядками).
• Замініть всі випадки обраної підрядки в коді невикористаною малою літерою.
• Додайте /x/ABC/до коду, де xзнаходиться обрана літера і ABCє підрядком.
• Повторюйте, поки не залишиться жодної підрядки, яка б нічого не врятувала.

Зрештою, ми врятуємо ще кілька байт, замінюючи отриманий //з |і випереджаючи /|/\/\//(тому витяг подстроки варто тільки 4 замість 5 байт після 8 підрядка або близько того ).

Як я вже говорив, я не маю поняття, чи оптимально це, і я вважаю досить нерегулярним результат досить цікавим. Можливо, можна дійти до більш короткого рішення, вибравши неоптимальні (але більше) підрядки десь внизу лінії. Цікаво, який клас складності цієї проблеми ...

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:

Спробуйте в Інтернеті!

Надихнувшись дивовижною відповіддю Якубе на виклик L-phabet, я подумав, що спробую свої сили і в реальному програмуванні ///, на відміну від простого використання його для стиснення. Це було досить хитро, і мені знадобилися чотири спроби, але врешті-решт це вийшло набагато коротше, ніж моє рішення на основі стиснення .

Пояснення

Швидкий буквар на ///: в основному інтерпретатор просто зчитує символ коду за символом і робить наступне:

• Якщо це не \ані a /, а надрукуйте.
• Якщо це а \, надрукуйте наступний символ.
• Якщо це 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в цих інструкціях. Причиною цього є те, що це дозволяє мені відрізнити As в інструкціях від As в решти рядків, які потрібно обробити по-різному.

/\/\A/\//

Це збігається /Aі замінює його /, видаляючи A. Зауважте, що ця підрядка відображається лише в передній частині кожного 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означає "Control 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 .

Піт , 247 байт / 190 коделів

Спробуйте в Інтернеті!

Отже, це зайняло набагато більше часу, ніж я передбачав, і у мене є кілька ідей щодо деяких інших більш ефективних (більш зручних для підходів) підходів, але я, нарешті, спрацював з небезпекою (і виправив помилку інтерпретатора та додав функції IDE уздовж спосіб), так ось воно. Навряд чи найефективніша мова, але весело. Ось більший вигляд і слід, який показує пройдений шлях. Історія на моєму GitHub .

Як мову на основі стека, це занадто складно, щоб коротко пояснити, але ось основний огляд того, що роблять різні розділи / петлі. Усі назви змінних та функцій - лише для пояснення, оскільки в Piet немає змінних чи функцій.

• Ініціалізація (зліва вліво): починається line_counterз 27, завантажує "@" як cur_letter, встановлює letter_count27
• Основна петля (починаючи з темно-фіолетового, центральний верх)
  • Укази letter_counter
  • Відгалуження до reset_lineнуля (легкий синій 2-блок)
  • Котиться cur_letterдо вершини стека
  • Гілки до check_doneif cur_letter > 'X'(чирок / червоний блок, права сторона)
  • Збільшення 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, що спрощує копіювання та вставлення ОП:

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

(EDIT: я повинен був просто використовувати рядок AZ, а не створювати його)

(EDIT 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 «s рішення .

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 до поточної комірки, друкуємо відповідний символ (linefeed) та нуль комірки із закликом до 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.

Хаскелл, 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 байт завдяки Мартіну Ендеру.

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

Провідна лінійна подача є значною.

Спробуйте в Інтернеті!

Кредити .

Мозок-Флак , 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 є хорошим рішенням, але з 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 чудово розширює розміри сиглетона, не потребуючи 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);}}

Баш, 66 байт

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

Я створюю повний алфавіт A, а потім надрукую 26 повернутих його версій, взявши символи, що починаються з цього місця nі додавши це попереднє положення 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}'  

Це, мабуть, можна зробити і коротше, але я не дізнався, як ... поки