Stampa una Tabula Recta!

La Tabula Recta (a volte chiamata "Tabella di Vigenere"), è stata creata da Johannes Trithemius ed è stata utilizzata in diversi numeri, tra cui tutte le varianti del codice Vigenere di Bellaso e del codice Trithemius. Sembra così:

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

Ho spesso bisogno di questo, ma non riesco a trovarlo da nessuna parte su Internet per copiare e incollare. Poiché la tabella quadrata è così lunga e richiede tempi di scrittura lunghi , il codice deve essere il più corto possibile.

Regole / Requisiti

• Ogni invio dovrebbe essere un programma o una funzione completi. Se è una funzione, deve essere eseguibile solo aggiungendo la chiamata di funzione nella parte inferiore del programma. Qualsiasi altra cosa (ad es. Le intestazioni in C) deve essere inclusa.
• Se possibile, fornire un collegamento a un sito in cui è possibile testare il programma.
• Il tuo programma non deve scrivere nulla su STDERR.
• Sono vietate le scappatoie standard .
• Il tuo programma può essere emesso in ogni caso, ma deve essere stampato (non un array o simile).

punteggio

I programmi vengono classificati in base ai byte, in UTF-8 per impostazione predefinita o in un set di caratteri diverso a scelta.

Alla fine, vincerà la risposta con il minor numero di byte.

Inseriti

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

/* Configuration */

var QUESTION_ID = 86986; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

05AB1E , 6 5 byte

Grazie a Downgoat per aver salvato 1 byte. Codice:

ADv=À

Spiegazione:

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.

Utilizza la codifica CP-1252 . Provalo online! .

Vim, 25 23 byte

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

Dov'è ↵la chiave di ritorno.

: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 : le lettere minuscole vanno bene, quindi posso salvare due chiavi.

Python 2, 59 57 53 byte

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

Grazie a @xsot per -4 byte!

/// , 220 byte

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

Provalo online!

Questo è stato sorprendentemente non banale e non ho idea se sia ottimale.

L'unico modo per golfare un problema come questo in /// è estrarre sottostringhe comuni. ( Ho scoperto che mi sbagliavo. ) Tuttavia, a causa della natura dell'output non è affatto chiaro quali sottostringhe debbano essere estratte in quanto non è possibile estrarre l'intero alfabeto a causa delle interruzioni di riga. Quindi dovrai estrarre alcune sottostringhe dell'alfabeto avvolto, ma poi ci sono dei compromessi in termini di quanto tempo fai le sottostringhe e quali scegli.

Quindi ecco cosa ho fatto. Questo è uno script CJam che trova tutte le sottostringhe fino a una lunghezza di 25 nella stringa data e per ognuna di esse calcola quanti byte risparmierebbe la sua estrazione. Fondamentalmente se ci sono Ncopie di una Msottostringa di lunghezza , dovresti salvare le (N-1)*(M-1) - 5sottostringhe, queste sottostringhe non contengono barre. Inoltre, tecnicamente, quando hai già estratto 8 sottostringhe, l'offset costante alla fine si riduce a -4, ma lo script non lo considera.

Comunque, ecco cosa ho fatto con la sceneggiatura:

• Esegui lo script sul codice corrente (che inizialmente è solo l'output).
• Tra le sottostringhe che producono il massimo miglioramento, scegli quella più breve. Se ce ne sono diversi, scegli il più piccolo lessicograficamente (da quello che posso dire, per l'input dato questo riduce le sovrapposizioni tra sottostringhe).
• Sostituisci tutte le occorrenze della sottostringa scelta nel codice con una lettera minuscola inutilizzata.
• Prependi /x/ABC/al codice dove si xtrova la lettera scelta ed ABCè la sottostringa.
• Ripetere fino a quando non rimangono più sottostringhe che salverebbero nulla.

Alla fine, risparmiamo qualche byte in più sostituendo il risultante //con |e anteponendolo /|/\/\//(questo è il motivo per cui l'estrazione di sottostringhe costa solo 4 invece di 5 byte dopo l'ottava sottostringa o giù di lì).

Come ho detto, non ho idea di cosa sia ottimale e trovo il risultato piuttosto irregolare piuttosto interessante. Potrebbe essere possibile raggiungere una soluzione più breve scegliendo sottostringhe non ottimali (ma più) da qualche parte lungo la linea. Mi chiedo quale sia la classe di complessità di questo problema ...

C, 47 byte

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

Provalo su Ideone

Un singolo ciclo, stampando l'alfabeto ogni 26 caratteri ma con ogni 27 ° carattere sostituito da una nuova riga.

J, 15 byte

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

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

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

Provalo online!

Ispirato dalla straordinaria risposta di Jakube alla sfida L-phabet, ho pensato di provare anche a programmare in /// anziché usarlo per la compressione. Questo è stato piuttosto complicato e ho avuto bisogno di quattro tentativi, ma alla fine è risultato molto più corto della mia soluzione basata sulla compressione .

Spiegazione

Un rapido primer su ///: in pratica l'interprete legge il carattere carattere per carattere e fa quanto segue:

• Se non è né a \né a /, stampalo.
• Se è un \, stampa il personaggio successivo.
• Se è a /, analizza /x/y/un'istruzione (con le stesse regole di escape) e sostituisci ripetutamente tutto xnel codice rimanente con y.

Prendendo un po 'più di ispirazione da Jakube, per semplicità spiegherò solo una versione 4x4 di questo:

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

Iniziamo sostituendo quelli :con il materiale tra il secondo e il terzo /. Questo finirà per essere il codice che ruota le righe successive. Otteniamo questo:

/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

I f, be xsono solo delle scorciatoie per stringhe comuni, che espanderemo ora. La fIS per slash, la bè per backslash e la xè per \//che sembra venire un bel po '. Il motivo per cui sto usando gli alias per le sottostringhe a carattere singolo /ed \è che dovrebbero essere salvati nella prima istruzione di sostituzione, quindi sto effettivamente salvando parecchi byte non avendo bisogno di tutte quelle barre rovesciate. Ecco cosa si ottiene dopo x, fe bsono stati riempiti in:

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

Molto leggibile

Quindi la prima riga è stampata alla lettera. Quindi arriviamo alla parte funky che ruota tutte le altre file. In realtà consiste di quattro diverse istruzioni. Una cosa da notare è che sono sfuggito a tutte le occorrenze di Aqueste istruzioni. La ragione di ciò è che mi consente di distinguere As all'interno delle istruzioni da As nelle righe rimanenti, che devono essere elaborate in modo diverso.

/\/\A/\//

Questo corrisponde /Ae lo sostituisce con /, rimuovendo il A. Si noti che questa sottostringa appare solo nella parte anteriore di ciascuna ABCD, quindi questo rilascia il primo carattere di tutte le righe successive:

/
\//\A_\//

Questo corrisponde a un avanzamento riga seguito da una barra e lo sostituisce con A_/. Quindi questo inserisce un Aalla fine di ogni riga, completando la rotazione e trasforma anche l'avanzamento di riga in un carattere di sottolineatura.

/_\//
\//

Questo corrisponde _/e lo sostituisce con un avanzamento riga seguito da una barra. Il motivo per cui devo fare questa deviazione tramite il trattino basso è il fatto che /// applica ripetutamente ogni istruzione fino a quando la stringa non corrisponde più. Ciò significa che non è mai possibile utilizzare un'istruzione del modulo in /x/axb/cui x, ae bsono stringhe arbitrarie, perché dopo la sostituzione xcorrisponderà sempre. In particolare, ciò significa che non possiamo semplicemente inserire qualcosa davanti a un avanzamento di riga. Dobbiamo sostituire l'alimentazione di linea nel processo e annullare questa sostituzione.

/\\\A/\\B/

Questo corrisponde \Ae lo sostituisce con \B, in modo che le istruzioni dopo le righe rimanenti elaborino il carattere successivo. Dopo che tutte e quattro le istruzioni sono state elaborate, la stringa rimanente appare così:

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

Quindi ora viene stampata la prima riga ruotata, quindi la successiva serie di istruzioni ruota le righe rimanenti di un'altra cella e così via. Dopo l'ultima rotazione, abbiamo alcune ulteriori istruzioni che possiamo ignorare e quindi finiamo con l'istruzione incompleta:

/\\\B/\\

Le istruzioni incomplete alla fine vengono semplicemente ignorate e il programma termina.

Gelatina , 7 byte

ØAṙJṢj⁷

Provalo online!

Come funziona

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.

Emacs, 47 byte

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

Dove ^P significa "Control P", ecc. Sono 47 byte, poiché i tasti F3 e F4 richiedono due byte ASCII.

Dopo aver inserito l'input iniziale, definisce una macro della tastiera per duplicare la riga e spostare il primo carattere alla fine. Quindi esegue la macro altre 24 volte.

JavaScript (ES6), 56 byte

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

Sì, esatto, metà del mio codice è letteralmente la stringa dell'alfabeto. Il meglio che potrei fare senza il letterale è 81 byte:

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

Se si desidera un programma anziché una funzione, rimuovere _=>e avvolgere console.log()per un costo di 10 byte.

Mathematica 68 61 byte

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

Grazie a...

@MartinEnder (7 byte)

Python 2, 75 65 61 58 byte

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

Ottiene l'alfabeto con map(chr,range(65,91)), quindi applica manualmente l'operazione di spostamento delle stringhe.

Grazie a @LeakyNun e @TheBikingViking per -4 byte!

Grazie a @xnor per -3 byte!

C, 88 64 byte

Chiama f()senza argomenti.

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

Provalo su ideone .

Piet , 247 byte / 190 codici

Provalo online!

Quindi, ciò ha richiesto molto più tempo di quanto mi aspettassi, e ho alcune idee su alcuni altri approcci più efficienti (più compatibili con lo stack), ma alla fine ho fatto funzionare la cosa di pericolo (e ho risolto un bug dell'interprete e aggiunto funzionalità IDE lungo il modo), quindi eccolo qui. Difficilmente il linguaggio più efficiente in termini di byte, ma molto divertente. Ecco una vista più grande e una traccia che mostra il percorso intrapreso. Cronologia sul mio GitHub .

Essendo un linguaggio basato su stack, è troppo complicato per spiegare brevemente, ma ecco una panoramica di base di ciò che fanno le varie sezioni / loop. Tutti i nomi di variabili e funzioni sono solo a scopo esplicativo, in quanto non vi sono variabili o funzioni in Piet.

• Inizializzazione (in alto a sinistra): inizia line_counterda 27, carica '@' come cur_letter, imposta letter_countsu 27
• Anello principale (a partire da viola scuro, parte superiore centrale)
  • decrementi letter_counter
  • Si dirama su reset_linese zero (ciano chiaro a 2 blocchi)
  • Rotola cur_letterin cima alla pila
  • Filiali a check_done if cur_letter > 'X'(verde acqua / blocco rosso, lato destro)
  • incrementi cur_letter e genera (angolo in basso a destra)
  • Filiali a reset_letter if cur_letter > 'Y'(blocco verde chiaro, a sinistra)
  • Esegue il rollback di `letter_counter_ torna all'inizio dello stack, di nuovo all'inizio del loop
• reset_line ramo (grande quadrato rosa):
  • Emette il carattere di nuova riga
  • Reimposta letter_countsu 27
  • Continua di nuovo all'inizio del ciclo principale
• check_done ramo (metà destra all'interno)
  • Rotola line_counterverso l'alto
  • Si ramifica per terminare se zero
  • Diminuisce line_countere torna alla fine della pila
  • Riprende da dove si era interrotto, stampando la lettera
• reset_line ramo (lato sinistro, blocco verde):
  • Reimposta cur_lettersu "@"
  • Riprende da dove si era interrotto, rotolando / tornando all'inizio del ciclo

MATL , 8 byte

Grazie a @Dennis , che ha suggerito che MATL dovrebbe incorporare l'indicizzazione modulare, e a @Suever , che ha avuto l' idea delle operazioni automatiche a coppie.

1Y2t&+Q)

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

Una versione super-corta per l'esecuzione nella console:

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

Javascript / HTML, 140 123 118 105 byte

Una versione più carina, con un output HTML che semplifica la copia e incolla di OP:

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

(EDIT: avrei dovuto usare la stringa AZ invece di generarla)

(MODIFICA 2: Grazie a @Neil e @DanTheMan per il loro contributo (vedi commenti))

PowerShell, 44 byte

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

R, 47 42 41 byte

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

Provalo online!

Genera 27 alfabeti, rimuove 27 lettere e stampa in 26 colonne.

Miglioramento ispirato @Giuseppe 's soluzione .

Sesos , 27 25 byte

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

Provalo online! Controlla Debug per vedere il codice SBIN generato. ^†

Assemblaggio Sesos

Il file binario sopra è stato generato assemblando il seguente codice 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)

Come funziona

Iniziamo inizializzando il nastro su ABCDEFGHIJKLMNOPQRSTUVWXYZ. Questo è il seguente.

Scrivi 26 in una cella, lasciando il nastro nel seguente stato.

                                                     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

Finché la cella sotto l'intestazione dei dati è diversa da zero, facciamo quanto segue.

Copia il numero nelle due celle a sinistra e aggiungi 64 alla copia più a sinistra.

                                                   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

Sposta la copia più a sinistra nella posizione originale, quindi sottrai 1 dalla copia più a destra.

                                                     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

Il processo si interrompe dopo 26 iterazioni, poiché la copia più a destra è 0 per allora. Spostiamo una cella a destra, quindi lo stato finale del nastro dopo l'inizializzazione è il seguente.

     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

Ora siamo pronti a generare l'output, ripetendo il seguente processo fino a quando la cella sotto l'intestazione dei dati è zero.

Innanzitutto, stampiamo il carattere sotto l'intestazione dei dati e ci spostiamo a destra, ripetendo questo passaggio fino a quando una cella con valore 0 viene trovata . Dopo la stampa ABCDEFGHIJKLMNOPQRSTUVWXYZ, il nastro appare come segue.

                                                                                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

Ora spostiamo la testina dati 27 unità a sinistra (torna allo 0 iniziale ) e ripetiamo la combinazione print-move fino a una cella con valore 0 . Questo non stampa nulla e lascia il nastro come segue.

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

Adesso scriviamo 10 nella cella corrente, stampiamo il carattere corrispondente (avanzamento riga) e azzeriamo la cella con una chiamata su getsu input vuoto, lasciando invariato il nastro.

Successivamente, spostiamo il contenuto della cella a destra nella cella corrente, quindi spostiamo la testa dei dati sulle unità a destra.

      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 prossima iterazione è leggermente diversa. Viene stampato il primo passaggio di stampaBCDEFGHIJKLMNOPQRSTUVWXYZ viene , lasciando il nastro come segue.

                                                                                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

Ora spostiamo la testa dati 27 unità a sinistra.

 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

Viene stampato il ciclo di stampa successivo A e lascia il nastro come segue.

   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

Ancora una volta, stampiamo un avanzamento riga, spostiamo il contenuto della cella a destra nella cella corrente, quindi spostiamo la testina dati in unità a destra.

         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

Dopo le 24 altre iterazioni, il passaggio finale dello spostamento della testina dati verso destra lascia il nastro nel seguente stato.

                                                                                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 cella sotto l'intestazione dei dati è ora 0 e il programma termina.

^† TIO utilizza una versione più recente di Sesos, che è retrocompatibile per SASM, ma genera un codice SBIN più breve.

Haskell, 56 53 52 byte

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

stessa lunghezza: (usando un suggerimento di @AndersKaseorg)

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

per fare cose modulari devi importare Data.Char per ottenere la funzione chr, 74 59 58 Bytes era il migliore che potessi ottenere con quello: (grazie a @nimi per aver suggerito la funzione toEnum)

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

Questo potrebbe probabilmente essere molto più breve, ma non conosco nessun trucco da golf Haskell.

usato mapM invece di mapM_ (vedi il commento di @ Lynn)

R, 53 byte

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

Eccolo su un interprete online .

Retina, 36 31 byte

5 byte grazie a Martin Ender.

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

L'alimentazione principale è significativa.

Provalo online!

Credits .

Brain-Flak , 222 byte

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

Provalo online!

Sono nuovo di Brain-Flak, quindi forse questo può essere giocato molto a golf, ma almeno è un primo tentativo. Memorizza 27 alfabeti completi nella pila a sinistra, quindi sposta gli alfabeti a destra e sostituisce ogni 27a lettera con una nuova riga.

Il mio codice sorgente è un po 'confuso, ma lo aggiungerò comunque.

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf

V , 36 , 10 byte

¬AZ25ñÙx$p

Provalo online!

Questo utilizza la codifica "Latin1".

Spiegazione:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut

C #, 98 byte

Ho provato a vedere se riesco a generare lettere più brevi di una semplice inizializzazione come stringa, ma non è proprio possibile. Le lettere sono 26 byte e questo frammento da solo

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

è di 25 byte. Penso che inizializzarli e poi aggiungerli con un + = a sia una buona soluzione, ma con C # sei limitato dal numero di funzioni come Substring()e Console.WriteLine().

Il mio tentativo di 98 byte:

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

Ottava, 27 byte

Stiamo aggiungendo una riga e un vettore di colonna e Octave espande piacevolmente le dimensioni del sigleton, non è necessario bsxfun(come avresti bisogno in Matlab).

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

q, 20 byte

(til 26)rotate\:.Q.A

Java, 190 176 172 163 byte

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}

Bash, 66 byte

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

Creo un alfabeto completo A, quindi stampo 26 versioni ruotate prendendo i caratteri a partire da ne aggiungendo quelle precedenti n.

Perl, 42 byte

Credito completo a @Dom Hastings per questo.

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

Oppure (stesso conteggio byte):

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

Necessario -M5.010o -Eper funzionare, ad esempio:

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

La mia vecchia risposta (55 byte):

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

Bisogno -M5.010 di correre. Quindi corri con:

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

Probabilmente è possibile fare più breve però, ma non ho scoperto come ... ancora