Распечатать Tabula Recta!

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 по умолчанию или другой набор символов по вашему выбору.

В конце концов ответ с наименьшим количеством байтов победит.

Материалы

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# 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

Leaderboard

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

/* 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, я решил попробовать свои силы и в реальном программировании на ///, а не просто использовать его для сжатия. Это было довольно сложно, и мне понадобилось четыре попытки, но в итоге получилось намного короче, чем мое решение на основе сжатия .

объяснение

Быстрый учебник по ///: в основном интерпретатор просто читает символ за символом и делает следующее:

• Если это ни то, \ни другое /, распечатайте его.
• Если это \, напечатайте следующий символ.
• Если это /, проанализируйте /x/y/инструкцию (с теми же правилами экранирования) и несколько раз замените все xв оставшемся коде на y.

Взяв немного больше вдохновения от Якуба, для простоты я просто объясню версию 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 .

Piet , 247 байт / 190 кодов

Попробуйте онлайн!

Таким образом, это заняло гораздо больше времени, чем я ожидал, и у меня есть несколько идей относительно некоторых других более эффективных (более стековых) подходов, но я наконец-то заработал чертовски полезную вещь ( исправил ошибку интерпретатора и добавил функции IDE вдоль кстати), так вот оно и есть. Вряд ли самый эффективный язык, но чертовски весело. Вот увеличенный вид и след, показывающий пройденный путь. История на моем GitHub .

Как язык, основанный на стеке, он слишком запутан, чтобы кратко объяснять, но вот основной обзор того, что делают различные секции / циклы. Все имена переменных и функций приведены только для пояснения, поскольку в Piet нет переменных или функций.

• Инициализация (слева вверху): начинается line_counterс 27, загружается как @ cur_letter, устанавливаетletter_count на 27
• Основной цикл (начиная с темно-фиолетового, по центру)
  • Декрементирует letter_counter
  • Филиалы в reset_line если ноль (светло-голубой 2-блок)
  • Рулоны cur_letter на вершину стека
  • Филиалы к check_doneеслиcur_letter > 'X' (чирок / красный блок, правая сторона)
  • Надбавки cur_letter и выводит его (нижний правый угол)
  • Филиалы к reset_letterеслиcur_letter > 'Y' (светло-зеленый блок, слева)
  • Откатывает `letter_counter_ к началу стека, к началу цикла
• reset_line ветка (большой розовый квадрат):
  • Вывод символа новой строки
  • Сбрасывает letter_countдо 27
  • Продолжает вернуться к началу основного цикла
• check_done ветвь (правая половина внутри)
  • Rolls line_counterto top
  • Ветви заканчиваются, если ноль
  • Уменьшение 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 «s решение .

Sesos , 27 25 байт

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

Попробуйте онлайн! Проверьте Debug, чтобы увидеть сгенерированный код SBIN. ^†

Сесос сборка

Двоичный файл выше был сгенерирован путем сборки следующего кода 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="")

Вот он на онлайн переводчике .

Retina, 36 31 байт

5 байтов благодаря Мартину Эндеру.

Z
{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 является хорошим решением, но с 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}'  

Возможно, возможно сделать короче, но я не выяснил, как ... пока