Imprima una Tabula Recta!

La Tabula Recta (a veces llamada 'Mesa Vigenere'), fue creada por Johannes Trithemius, y se ha utilizado en varias cifras, incluidas todas las variantes de la cifra Vigenere de Bellaso y la cifra Trithemius. Se parece a esto:

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

Frecuentemente necesito esto, pero no puedo encontrarlo en ningún lugar de Internet para copiar y pegar. Debido a que la tabla cuadrada es muy larga y requiere una gran cantidad de tiempo para escribir, su código debe ser lo más corto posible.

Reglas / requisitos

• Cada presentación debe ser un programa completo o una función. Si es una función, debe ser ejecutable solo necesitando agregar la llamada a la función al final del programa. Se debe incluir cualquier otra cosa (por ejemplo, encabezados en C).
• Si es posible, proporcione un enlace a un sitio donde se pueda probar su programa.
• Su programa no debe escribirle nada STDERR.
• Las lagunas estándar están prohibidas.
• Su programa puede generar resultados en cualquier caso, pero debe imprimirse (no una matriz ni similar)

Puntuación

Los programas se puntúan según los bytes, en UTF-8 de forma predeterminada o en un conjunto de caracteres diferente de su elección.

Eventualmente, la respuesta con la menor cantidad de bytes ganará.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores 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

Gracias a Downgoat por guardar 1 byte. Código:

ADv=À

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Vim, 25 23 bytes

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

¿Dónde ↵está la tecla de retorno?

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

EDITAR : minúsculas está bien, así que puedo guardar dos claves.

Python 2, 59 57 53 bytes

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

¡Gracias 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

Pruébalo en línea!

Esto fue sorprendentemente no trivial y no tengo idea de si es óptimo.

La única forma de jugar un problema como este en /// es extrayendo subcadenas comunes. ( Resulta que estaba equivocado ) . Sin embargo, debido a la naturaleza de la salida, no está claro qué subcadenas deberían extraerse mejor, ya que no se puede extraer todo el alfabeto debido a los saltos de línea. Por lo tanto, deberá extraer algunas subcadenas del alfabeto envuelto, pero luego hay compensaciones en términos de cuánto tiempo hace las subcadenas y cuáles elige.

Así que esto es lo que hice. Este es un script CJam que encuentra todas las subcadenas hasta una longitud de 25 en la cadena dada y para cada una de ellas calcula cuántos bytes ahorraría su extracción. Básicamente, si hay Ncopias de una Msubcadena de longitud , guardaría (N-1)*(M-1) - 5subcadenas, estas subcadenas no contienen barras inclinadas. Además, técnicamente, cuando ya ha extraído 8 subcadenas más o menos, el desplazamiento constante al final se reduce a -4, pero el script no lo considera.

De todos modos, esto es lo que hice con el script:

• Ejecute el script contra el código actual (que inicialmente es solo la salida).
• De las subcadenas que producen la mejora más grande, elija la más corta. Si hay varias, elija la lexicografía más pequeña (por lo que puedo decir, para la entrada dada esto reduce las superposiciones entre las subcadenas).
• Reemplace todas las apariciones de la subcadena elegida en el código con una letra minúscula no utilizada.
• Anteponga /x/ABC/al código donde xestá la letra elegida y ABCes la subcadena.
• Repita hasta que no queden subcadenas que puedan salvar algo.

Al final, ahorramos unos pocos bytes más al reemplazar el resultado //con |y anteponer /|/\/\//(es por eso que extraer subcadenas solo cuesta 4 en lugar de 5 bytes después de la octava subcadena más o menos).

Como dije, no tengo idea de si esto es óptimo y encuentro el resultado de aspecto bastante irregular bastante interesante. Es posible llegar a una solución más corta eligiendo subcadenas no óptimas (pero más) en algún punto de la línea. Me pregunto cuál es la clase de complejidad de este problema ...

C, 47 bytes

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

Pruébalo en Ideone

Un solo bucle, imprimiendo el alfabeto cada 26 caracteres pero con cada 27 caracteres reemplazados por una nueva línea.

J, 15 bytes

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

Intérprete en línea .

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:

Pruébalo en línea!

Inspirado por la sorprendente respuesta de Jakube al desafío L-phabet, pensé que también probaría mi suerte en la programación real en /// en lugar de solo usarlo para la compresión. Esto fue bastante complicado y necesitaba cuatro intentos, pero al final salió mucho más corto que mi solución basada en compresión .

Explicación

Una introducción rápida en ///: básicamente el intérprete solo lee el código carácter por carácter y hace lo siguiente:

• Si no es ni a \ni a /, imprímalo.
• Si es un \, imprime el siguiente personaje.
• Si es a /, analiza una /x/y/instrucción (con las mismas reglas de escape) y sustituye repetidamente todo xel código restante con y.

Tomando un poco más de inspiración de Jakube, por simplicidad solo explicaré una versión 4x4 de esto:

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

Comenzamos reemplazando aquellos :con las cosas entre el segundo y el tercero /. Esto terminará siendo el código que rota las filas subsiguientes. Obtenemos esto:

/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

Los f, by xson solo shorthands para cadenas comunes, que expandiremos ahora. El fes para barras inclinadas, bes para barras diagonales inversas y xes para lo \//que resulta bastante. La razón por la que estoy usando alias para las subcadenas de un solo carácter /y \es que tendrían que escapar en la primera instrucción de sustitución, por lo que en realidad estoy ahorrando muchos bytes al no necesitar todas esas barras invertidas. Esto es lo que obtenemos después x, fy bse han rellenado:

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

Muy legible

Entonces, la primera línea se imprime textualmente. Luego llegamos a la parte funky que gira todas las filas adicionales. En realidad consta de cuatro instrucciones diferentes. Una cosa a tener en cuenta es que he escapado de todas las ocurrencias Adentro de estas instrucciones. La razón de esto es que me permite distinguir As dentro de las instrucciones de As en las filas restantes, que deben procesarse de manera diferente.

/\/\A/\//

Esto coincide /Ay lo reemplaza con /, eliminando el A. Tenga en cuenta que esta subcadena solo aparece en la parte frontal de cada una ABCD, por lo que se elimina el primer carácter de todas las líneas posteriores:

/
\//\A_\//

Esto coincide con un salto de línea seguido de una barra diagonal y lo reemplaza por A_/. Entonces esto inserta un Aal final de cada línea, completando la rotación y también convierte el salto de línea en un guión bajo.

/_\//
\//

Esto coincide _/y lo reemplaza con un salto de línea seguido de una barra diagonal. La razón por la que necesito hacer este desvío a través del guión bajo es el hecho de que /// aplica cada instrucción repetidamente hasta que la cadena ya no coincida. Eso significa que nunca puede usar una instrucción de la forma /x/axb/donde x, ay bson cadenas arbitrarias, porque después de la sustitución xsiempre coincidirá. En particular, esto significa que no podemos simplemente insertar algo delante de un salto de línea. Necesitamos reemplazar el salto de línea en el proceso y deshacer este reemplazo.

/\\\A/\\B/

Esto coincide \Ay lo reemplaza con \B, de modo que las instrucciones después de las filas restantes procesan el siguiente carácter. Después de que se hayan procesado las cuatro instrucciones, la cadena restante se ve así:

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

Entonces, ahora se imprime la primera fila girada, y luego el siguiente conjunto de instrucciones gira las filas restantes por otra celda y así sucesivamente. Después de la última rotación, tenemos algunas instrucciones más que podemos ignorar y luego terminamos con la instrucción incompleta:

/\\\B/\\

Las instrucciones incompletas al final simplemente se ignoran y el programa finaliza.

Jalea , 7 bytes

ØAṙJṢj⁷

Pruébalo en línea!

Cómo 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

Dónde ^P significa "Control P", etc. Eso es 47 bytes, ya que las teclas F3 y F4 requieren dos bytes ASCII.

Después de ingresar la entrada inicial, define una macro de teclado para duplicar la línea y mover el primer carácter al final. Luego ejecuta la macro otras 24 veces.

JavaScript (ES6), 56 bytes

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

Sí, es cierto, la mitad de mi código es el literal de la cadena del alfabeto. Lo mejor que podría hacer sin el literal es 81 bytes:

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

Si desea un programa en lugar de una función, elimine _=>y envuelva console.log()por un costo de 10 bytes.

Mathematica 68 61 bytes

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

Gracias 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

Obtiene el alfabeto con map(chr,range(65,91)), luego aplica manualmente la operación de cambio de cadena.

¡Gracias a @LeakyNun y @TheBikingViking por -4 bytes!

¡Gracias a @xnor por -3 bytes!

C, 88 64 bytes

Llamar f()sin argumentos.

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

Pruébalo con ideone .

Piet , 247 bytes / 190 codeles

Pruébalo en línea!

Entonces, esto tomó mucho más tiempo de lo que había anticipado, y tengo algunas ideas sobre otros enfoques más eficientes (más aptos para la pila), pero finalmente conseguí que funcionara el problema (y solucioné un error de interpretación y agregué características IDE a lo largo del proceso). manera), así que aquí está. Apenas el lenguaje más eficiente en bytes, pero muy divertido. Aquí hay una vista más grande y un rastro que muestra el camino tomado. Historia en mi GitHub .

Como lenguaje basado en la pila, es demasiado complicado explicarlo brevemente, pero aquí hay una descripción básica de lo que hacen las diferentes secciones / bucles. Todos los nombres de variables y funciones son solo para explicación, ya que no hay variables o funciones en Piet.

• Inicialización (superior izquierda): comienza line_counteren 27, carga '@' como cur_letter, se establece letter_counten 27
• Bucle principal (comenzando en púrpura oscuro, centro superior)
  • Decrementos letter_counter
  • Se ramifica a reset_linecero (bloque cian claro de 2 bloques)
  • Rollos cur_lettera la cima de la pila
  • Se ramifica a check_doneif cur_letter > 'X'(verde azulado / bloque rojo, lado derecho)
  • Aumenta cur_lettery genera (esquina inferior derecha)
  • Se ramifica a reset_letterif cur_letter > 'Y'(bloque verde claro, izquierda)
  • Rolls `letter_counter_ de regreso a la parte superior de la pila, de regreso a la parte superior del bucle
• reset_line rama (gran cuadrado rosa):
  • Salida de caracteres de nueva línea
  • Restablece letter_counta 27
  • Continúa de vuelta al principio del bucle principal
• check_done rama (mitad derecha dentro)
  • Rollos line_counterhacia arriba
  • Ramas para terminar si cero
  • Disminuye line_countery regresa al fondo de la pila
  • Se reanuda donde lo dejó, imprimiendo la carta
• reset_line rama (lado izquierdo, bloque verde):
  • Restablece cur_lettera '@'
  • Se reanuda donde lo dejó, girando / volviendo a la parte superior del bucle

MATL , 8 bytes

Gracias a @Dennis , quien sugirió que MATL debería incorporar indexación modular, y a @Suever , quien tuvo la idea de operaciones automáticas por pares.

1Y2t&+Q)

Pruébalo en línea!

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

Una versión súper corta para ejecutar en la consola:

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

Javascript / HTML, 140 123 118 105 bytes

Una versión más bonita, con una salida HTML que facilita que OP copie y pegue:

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

(EDITAR: debería haber usado la cadena AZ en lugar de generarla)

(EDITAR 2: Gracias a @Neil y @DanTheMan por sus comentarios (ver comentarios))

PowerShell, 44 bytes

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

R, 47 42 41 bytes

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

Pruébalo en línea!

Genera 27 alfabetas, elimina las letras 27 e imprime en 26 columnas.

Mejora inspirada en la solución de @Giuseppe .

Sesos , 27 25 bytes

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

Pruébalo en línea! Verifique la depuración para ver el código SBIN generado. ^†

Asamblea Sesos

El archivo binario anterior se ha generado al ensamblar el siguiente 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)

Cómo funciona

Comenzamos inicializando la cinta a ABCDEFGHIJKLMNOPQRSTUVWXYZ. Esto es lo siguiente.

Escriba 26 en una celda, dejando la cinta en el siguiente 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

Siempre que la celda debajo del encabezado de datos no sea cero, hacemos lo siguiente.

Copiar el número a las dos celdas a la izquierda y añadir 64 a la copia más a la izquierda.

                                                   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

Mueva la copia más a la izquierda a la ubicación original, luego reste 1 de la copia más a la derecha.

                                                     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

El proceso se detiene después de 26 iteraciones, ya que la copia más a la derecha es 0 para entonces. Movimos una celda a la derecha, por lo que el estado final de la cinta después de la inicialización es el siguiente.

     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

Ahora estamos listos para generar la salida, repitiendo el siguiente proceso hasta que la celda debajo del encabezado de datos sea cero.

Primero, imprimimos el carácter debajo del encabezado de datos y nos movemos hacia la derecha, repitiendo este paso hasta encontrar una celda con valor 0 . Después de imprimir ABCDEFGHIJKLMNOPQRSTUVWXYZ, la cinta se ve de la siguiente manera.

                                                                                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

Ahora movemos el cabezal de datos 27 unidades hacia la izquierda (de vuelta al 0 inicial ) y repetimos la combinación de impresión-movimiento hasta que se encuentre una celda con valor 0 . Esto no imprime nada y deja la cinta de la siguiente manera.

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

Ahora, escribimos 10 en la celda actual, imprimimos el carácter correspondiente (salto de línea) y ponemos a cero la celda con una llamada a una getentrada vacía, dejando la cinta sin cambios.

Después, movemos el contenido de la celda a la derecha a la celda actual, luego movemos el cabezal de datos a las unidades a la derecha.

      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

La siguiente iteración es ligeramente diferente. Se imprime el primer paso de impresión BCDEFGHIJKLMNOPQRSTUVWXYZ, dejando la cinta de la siguiente manera.

                                                                                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

Ahora movemos el cabezal de datos 27 unidades hacia la izquierda.

 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

El siguiente ciclo de impresión imprime Ay deja la cinta de la siguiente manera.

   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

Una vez más, imprimimos un salto de línea, movemos el contenido de la celda a la derecha a la celda actual, luego movemos el cabezal de datos a las unidades a la derecha.

         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

Después de 24 iteraciones más, el paso final de mover el cabezal de datos a la derecha deja la cinta en el siguiente 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

La celda debajo del encabezado de datos ahora es 0 y el programa termina.

^† TIO utiliza una versión más reciente de Sesos, que es compatible con versiones anteriores para SASM, pero genera un código SBIN más corto.

Haskell, 56 53 52 Bytes

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

misma longitud: (utilizando una sugerencia de @AndersKaseorg)

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

para hacer cosas modulares, debe importar Data.Char para obtener la función chr, 74 59 58 Bytes fue lo mejor que pude obtener con eso: (gracias a @nimi por sugerir la función toEnum)

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

Esto probablemente podría ser mucho más corto, pero no conozco ningún truco de golf de Haskell.

usó mapM en lugar de mapM_ (vea el comentario de @ Lynn)

R, 53 bytes

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

Aquí está en un intérprete en línea .

Retina, 36 31 bytes

5 bytes gracias a Martin Ender.

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

El avance de línea principal es significativo.

Pruébalo en línea!

Créditos .

Brain-Flak , 222 bytes

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

Pruébalo en línea!

Soy nuevo en Brain-Flak, así que tal vez esto se pueda jugar mucho, pero al menos es un primer intento. Almacena 27 alfabetos completos en la pila izquierda, luego mueve los alfabetos hacia la derecha y reemplaza cada letra 27 por una nueva línea.

Mi código fuente es un poco confuso, pero lo agregaré de todos modos.

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

Pruébalo en línea!

Esto usa la codificación "Latin1".

Explicación:

¬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

He tratado de ver si puedo generar las letras más cortas que solo inicializarlas como una cadena, pero en realidad no es posible. Las letras son de 26 bytes y este fragmento solo

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

es de 25 bytes. Creo que inicializarlos y luego agregarlos con a + = a es una buena solución, pero con C # está limitado por el recuento de funciones como Substring()y Console.WriteLine().

Mi intento en 98 bytes:

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

Octava, 27 bytes

Estamos agregando una fila y un vector de columna, y Octave expande muy bien las dimensiones del esqueleto, no es necesario bsxfun(como lo haría en 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

Creo un alfabeto completo A, luego imprimo 26 versiones rotadas tomando los caracteres que comienzan en ny agregando las posiciones anteriores n.

Perl, 42 bytes

Crédito total a @Dom Hastings por esto.

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

O (mismo recuento de bytes):

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

Necesita -M5.010o -Eejecutarse, por ejemplo:

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

Mi vieja respuesta (55 bytes):

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

Necesito -M5.010correr. Entonces corre con:

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

Sin embargo, probablemente sea posible hacerlo más corto, pero no descubrí cómo ... todavía