Imprima um Tabula Recta!

O Tabula Recta (às vezes chamado de 'Tabela Vigenere'), foi criado por Johannes Trithemius e foi usado em várias cifras, incluindo todas as variantes da cifra Vigenere de Bellaso e da cifra Trithemius. Se parece com isso:

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

Frequentemente preciso disso, mas não consigo encontrá-lo em nenhum lugar da Internet para copiar e colar. Como a tabela quadrada é muito longa e leva muito tempo para digitar, seu código deve ser o mais curto possível.

Regras / Requisitos

• Cada envio deve ser um programa ou uma função completa. Se for uma função, deve ser executável, bastando adicionar a chamada de função na parte inferior do programa. Qualquer outra coisa (por exemplo, cabeçalhos em C) deve ser incluída.
• Se possível, forneça um link para um site onde seu programa possa ser testado.
• Seu programa não deve escrever nada para STDERR.
• As brechas padrão são proibidas.
• Seu programa pode produzir em qualquer caso, mas deve ser impresso (não uma matriz ou similar).

Pontuação

Os programas são classificados de acordo com os bytes, em UTF-8, por padrão, ou com um conjunto de caracteres diferente de sua escolha.

Eventualmente, a resposta com o mínimo de bytes vencerá.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números em seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou deseja listar as penalidades de sinalizador de intérprete separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

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

Agradecemos ao Downgoat por economizar 1 byte. Código:

ADv=À

Explicação:

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.

Usa a codificação CP-1252 . Experimente online! .

Vim, 25 23 bytes

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

Onde ↵está a tecla 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 : minúsculas está ok, então eu posso salvar duas chaves.

Python 2, 59 57 53 bytes

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

Graças a @xsot por -4 bytes!

/// , 220 bytes

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

Experimente online!

Isso foi surpreendentemente não trivial e não tenho idéia se é ideal.

A única maneira de resolver um problema como esse em /// é extrair substrings comuns. ( Acontece que eu estava errado. ) No entanto, devido à natureza da saída, não está claro quais substrings devem ser melhor extraídos, pois você não pode extrair o alfabeto inteiro devido às quebras de linha. Portanto, você precisará extrair algumas substrings do alfabeto empacotado, mas existem trocas em termos de quanto tempo você cria os substrings e quais você escolhe.

Então aqui está o que eu fiz. Este é um script CJam que localiza todas as subseqüências até o comprimento 25 na sequência especificada e, para cada uma delas, calcula quantos bytes sua extração salvaria. Basicamente, se houver Ncópias de uma Msubstring de comprimento , você salvaria (N-1)*(M-1) - 5substrings, esses substrings não contêm barras. Além disso, tecnicamente, quando você já extrai 8 substrings, o deslocamento constante no final reduz para -4, mas o script não considera isso.

Enfim, aqui está o que eu fiz com o script:

• Execute o script no código atual (que inicialmente é apenas a saída).
• Das substrings que produzem a maior melhoria, escolha a menor. Se houver vários, escolha o menor lexicograficamente (pelo que posso dizer, para a entrada fornecida isso reduz as sobreposições entre substrings).
• Substitua todas as ocorrências da substring escolhida no código por uma letra minúscula não usada.
• Anexar /x/ABC/ao código onde xestá a letra escolhida e ABCa substring.
• Repita até que não haja substrings que salvariam algo.

No final, economizamos mais alguns bytes substituindo o resultado //por |e acrescentando /|/\/\//(é por isso que a extração de substrings custa apenas 4 em vez de 5 bytes após o 8º substring).

Como eu disse, não tenho idéia se isso é ótimo e acho o resultado de aparência irregular bastante interessante. Pode ser possível chegar a uma solução mais curta escolhendo substrings não ideais (mas mais) em algum lugar abaixo da linha. Gostaria de saber qual é a classe de complexidade deste problema ...

C, 47 bytes

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

Experimente no Ideone

Um único loop, imprimindo o alfabeto a cada 26 caracteres, mas a cada 27 caracteres substituídos por uma nova linha.

J, 15 bytes

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

Intérprete online .

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 bytes

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:

Experimente online!

Inspirado pela incrível resposta de Jakube ao desafio do alfabeto L, pensei em tentar a minha mão também na programação real em ///, em vez de apenas usá-la para compactação. Isso foi bastante complicado e eu precisei de quatro tentativas, mas no final saiu muito mais curto que minha solução baseada em compactação .

Explicação

Um iniciador rápido em ///: basicamente o intérprete apenas lê o caractere de código por caractere e faz o seguinte:

• Se não for \nem um /, imprima-o.
• Se for um \, imprima o próximo caractere.
• Se for um /, analise uma /x/y/instrução (com as mesmas regras de escape) e substitua repetidamente tudo xno código restante por y.

Inspirando-me um pouco mais em Jakube, para simplificar, explicarei uma versão 4x4 disso:

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

Começamos substituindo aqueles :com o material entre o segundo e o terceiro /. Isso acabará sendo o código que gira as linhas subseqüentes. Temos isso:

/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

O f, be xsão apenas atalhos para sequências comuns, que expandiremos agora. O fé para barras, o bé para barras invertidas e o xé o \//que acontece bastante. A razão pela qual estou usando aliases para as substrings de caractere único /e \é que elas precisam ser escapadas na primeira instrução de substituição, então estou economizando bastante bytes por não precisar de todas as barras invertidas. Aqui está o que nós temos depois x, fe bforam preenchidos:

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

Muito legível.

Portanto, a primeira linha é impressa literalmente. Então chegamos à parte descolada que gira todas as outras linhas. Na verdade, consiste em quatro instruções diferentes. Uma coisa a notar é que eu escapei de todas as ocorrências Adentro destas instruções. A razão para isso é que me permite distinguir As nas instruções de As nas linhas restantes, que precisam ser processadas de maneira diferente.

/\/\A/\//

Isso corresponde /Ae o substitui por /, removendo o A. Observe que essa subcadeia aparece apenas na frente de cada uma ABCD, portanto, elimina o primeiro caractere de todas as linhas subseqüentes:

/
\//\A_\//

Isso corresponde a um avanço de linha seguido por uma barra e o substitui por A_/. Portanto, isso insere um Ano final de cada linha, completando a rotação e também transforma o avanço de linha em um sublinhado.

/_\//
\//

Isso corresponde _/e o substitui por um avanço de linha seguido por uma barra. A razão pela qual eu preciso fazer esse desvio através do sublinhado é o fato de que /// aplica cada instrução repetidamente até que a string não corresponda mais. Isso significa que você nunca pode usar uma instrução da forma /x/axb/onde x, ae bsão seqüências arbitrárias, porque após a substituição xsempre sempre corresponderá. Em particular, isso significa que não podemos simplesmente inserir algo na frente de um avanço de linha. Precisamos substituir o avanço de linha no processo e desfazer essa substituição.

/\\\A/\\B/

Isso corresponde \Ae o substitui por \B, para que as instruções após as linhas restantes processem o próximo caractere. Após todas as quatro instruções terem sido processadas, a sequência restante fica assim:

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

Portanto, agora a primeira linha girada é impressa e o próximo conjunto de instruções gira as linhas restantes por outra célula e assim por diante. Após a última rotação, temos mais algumas instruções que podemos ignorar e terminamos com a instrução incompleta:

/\\\B/\\

Instruções incompletas no final são simplesmente ignoradas e o programa termina.

Geléia , 7 bytes

ØAṙJṢj⁷

Experimente online!

Como funciona

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

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

Onde ^Psignifica "Control P", etc. São 47 bytes, pois as teclas F3 e F4 requerem dois bytes ASCII.

Depois de inserir a entrada inicial, define uma macro do teclado para duplicar a linha e mover o primeiro caractere para o final. Em seguida, executa a macro mais 24 vezes.

JavaScript (ES6), 56 bytes

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

Sim, isso mesmo, metade do meu código é a literal do alfabeto. O melhor que eu poderia fazer sem o literal é 81 bytes:

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

Se você deseja um programa em vez de uma função, remova _=>e envolva console.log()por um custo de 10 bytes.

Mathematica 68 61 bytes

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

Graças a...

@MartinEnder (7 bytes)

Python 2, 75 65 61 58 bytes

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

Obtém o alfabeto map(chr,range(65,91))e aplica manualmente a operação de deslocamento de string.

Obrigado a @LeakyNun e @TheBikingViking por -4 bytes!

Obrigado a @xnor por -3 bytes!

C, 88 64 bytes

Ligue f()sem argumentos.

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

Experimente em ideone .

Piet , 247 bytes / 190 codéis

Experimente Online!

Portanto, isso levou muito mais tempo do que eu havia previsto, e tenho algumas idéias sobre outras abordagens mais eficientes (mais compatíveis com a pilha), mas finalmente consegui resolver o problema ( corrigi um erro de intérprete e adicionei recursos de IDE ao longo do caminho), então aqui está. Dificilmente a linguagem mais eficiente em bytes, mas muito divertida. Aqui está uma visão ampliada e um rastreamento mostrando o caminho percorrido. História no meu GitHub .

Como uma linguagem baseada em pilha, é complicado demais para explicar brevemente, mas aqui está uma visão geral básica do que as várias seções / loops fazem. Todos os nomes de variáveis ​​e funções são apenas para explicação, pois não existem variáveis ​​ou funções no Piet.

• Inicialização (canto superior esquerdo): começa line_counterem 27, carrega '@' como cur_letter, define letter_countcomo 27
• Laço principal (começando em roxo escuro, no centro)
  • Decrementos letter_counter
  • Ramifica para reset_linese zero (ciano claro 2 blocos)
  • Rola cur_letterpara o topo da pilha
  • Ramos para check_doneif cur_letter > 'X'(cerceta / bloco vermelho, lado direito)
  • Incrementa cur_lettere gera (canto inferior direito)
  • Ramifica para reset_letterif cur_letter > 'Y'(bloco verde claro, à esquerda)
  • Rola `letter_counter_ de volta ao topo da pilha, de volta ao topo do loop
• reset_line ramo (grande quadrado rosa):
  • Gera caractere de nova linha
  • Redefine letter_countpara 27
  • Continua de volta ao topo do loop principal
• check_done ramo (metade direita dentro)
  • Rola line_counterpara o topo
  • Ramificações para terminar se zero
  • Decrementa line_countere rola de volta para o final da pilha
  • Continua onde parou, imprimindo carta
• reset_line ramo (lado esquerdo, bloco verde):
  • Redefine cur_letterpara '@'
  • Continua onde parou, rolando / retornando ao topo do loop

MATL , 8 bytes

Agradecemos a @Dennis , que sugeriu que o MATL incorporasse a indexação modular, e a @Suever , que teve a idéia de operações automáticas em pares.

1Y2t&+Q)

Experimente online!

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×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 bytes

Uma versão super curta para execução no console:

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

Javascript / HTML, 140 123 118 105 bytes

Uma versão mais bonita, com uma saída HTML que facilita ao OP copiar e colar:

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

(Edição: Eu deveria ter usado apenas a string AZ em vez de gerá-la)

(EDIT 2: Obrigado a @Neil e @DanTheMan por suas contribuições (ver comentários))

PowerShell, 44 bytes

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

R, 47 42 41 bytes

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

Experimente online!

Gera 27 alfabetos, remove 27ª letras e imprime em 26 colunas.

Melhoria inspirado por @Giuseppe da solução .

Sesos , 27 25 bytes

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

Experimente online! Marque Debug para ver o código SBIN gerado. ^†

Montagem Sesos

O arquivo binário acima foi gerado montando o seguinte código 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)

Como funciona

Começamos inicializando a fita para ABCDEFGHIJKLMNOPQRSTUVWXYZ. Isto é o seguinte.

Escreva 26 em uma célula, deixando a fita no seguinte estado.

                                                     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

Desde que a célula sob o cabeçalho de dados seja diferente de zero, fazemos o seguinte.

Copie o número para as duas células à esquerda e adicione 64 à cópia mais à esquerda.

                                                   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

Mova a cópia mais à esquerda para o local original e subtraia 1 da cópia mais à direita.

                                                     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

O processo para após 26 iterações, pois a cópia mais à direita é 0 até então. Movemos uma célula para a direita, para que o estado final da fita após a inicialização seja o seguinte.

     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

Agora estamos prontos para gerar a saída, repetindo o processo a seguir até que a célula sob o cabeçalho de dados seja zero.

Primeiro, imprimimos o caractere sob o cabeçalho de dados e movemos para a direita, repetindo esta etapa até que uma célula com o valor 0 seja encontrada. Após a impressão ABCDEFGHIJKLMNOPQRSTUVWXYZ, a fita fica da seguinte maneira.

                                                                                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

Agora, movemos a cabeça de dados 27 unidades para a esquerda (de volta ao 0 inicial ) e repetimos a combinação de impressão e movimentação até que uma célula com o valor 0 seja encontrada. Isso não imprime nada e deixa a fita da seguinte maneira.

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

Agora, escrevemos 10 na célula atual, imprimimos o caractere correspondente (avanço de linha) e zeramos a célula com uma chamada getna entrada vazia, deixando a fita inalterada.

Depois, movemos o conteúdo da célula da direita para a célula atual e, em seguida, movemos o cabeçalho dos dados para as unidades da direita.

      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 próxima iteração é um pouco diferente. A primeira etapa de impressão é impressa BCDEFGHIJKLMNOPQRSTUVWXYZ, deixando a fita da seguinte maneira.

                                                                                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

Agora, movemos a cabeça de dados 27 unidades para a esquerda.

 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

O loop de impressão subsequente imprime Ae sai da fita da seguinte maneira.

   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

Mais uma vez, imprimimos um avanço de linha, movemos o conteúdo da célula da direita para a célula atual e, em seguida, movemos o cabeçalho dos dados para as unidades da direita.

         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

Após mais 24 iterações, a etapa final de mover a cabeça de dados para a direita deixa a fita no seguinte estado.

                                                                                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

A célula sob o cabeçalho de dados agora é 0 e o programa termina.

^{† O} TIO usa uma versão mais recente do Sesos, compatível com versões anteriores do SASM, mas gera um código SBIN mais curto.

Haskell, 56 53 52 Bytes

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

mesmo comprimento: (usando uma sugestão de @AndersKaseorg)

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

Para fazer coisas modulares, é necessário importar o Data.Char para obter a função chr, 74 59 58 bytes foi o melhor que consegui com isso: (obrigado a @nimi por sugerir a função toEnum)

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

Provavelmente poderia ser muito mais curto, mas não conheço nenhum truque de golfe de Haskell.

usou mapM em vez de mapM_ (consulte o comentário de @ Lynn)

R, 53 bytes

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

Aqui está em um intérprete online .

Retina, 36 31 bytes

5 bytes graças a Martin Ender.

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

O avanço de linha principal é significativo.

Experimente online!

Créditos .

Flak cerebral , 222 bytes

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

Experimente online!

Eu sou novo no Brain-Flak, então talvez isso possa ser muito praticado, mas pelo menos é uma primeira tentativa. Ele armazena 27 alfabetos completos na pilha esquerda, depois move os alfabetos para a direita e substitui cada 27ª letra por uma nova linha.

Meu código fonte é um pouco confuso, mas vou adicioná-lo.

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

¬AZ25ñÙx$p

Experimente online!

Isso usa a codificação "Latin1".

Explicação:

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

Tentei ver se consigo gerar as letras mais curtas do que apenas inicializá-las como uma string, mas não é realmente possível. As letras são 26 bytes e somente este trecho

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

é de 25 bytes. Eu acho que inicializá-los e depois anexá-los com um + = a é uma boa solução, mas com o C # você é limitado pelo número de bytes de funções como Substring()e Console.WriteLine().

Minha tentativa de 98 bytes:

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

Oitava, 27 bytes

Estamos adicionando uma linha e um vetor de coluna, e o Octave expande muito bem as dimensões sigleton, sem necessidade bsxfun(como você precisaria no Matlab).

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

q, 20 bytes

(til 26)rotate\:.Q.A

Java, 190 176 172 163 bytes

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 bytes

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

Crio um alfabeto completo e A, em seguida, imprimo 26 versões rotacionadas, pegando os caracteres que começam em ne anexando as posições anteriores n.

Perl, 42 bytes

Crédito total para @Dom Hastings por isso.

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

Ou (mesma contagem de bytes):

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

Precisa -M5.010ou -Eé executado, por exemplo:

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

Minha resposta antiga (55 bytes):

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

Precisa -M5.010correr. Então corra com:

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

Provavelmente é possível fazer mais curto, mas eu não descobri como ... ainda