Imprimez une tabula recta!

La Tabula Recta (parfois appelée «table de Vigenere») a été créée par Johannes Trithemius et a été utilisée dans plusieurs chiffrements, y compris toutes les variantes du chiffrement Vigenere de Bellaso et du chiffrement de Trithemius. Cela ressemble à ceci:

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

J'ai souvent besoin de cela, mais je ne peux pas le copier et le coller sur Internet. Parce que la table carrée est très longue et qu'il faut beaucoup de temps pour la taper, votre code doit être aussi court que possible.

Règles / exigences

• Chaque soumission doit être un programme complet ou une fonction. S'il s'agit d'une fonction, vous devez l'exécuter en ajoutant uniquement l'appel de fonction au bas du programme. Tout le reste (par exemple les en-têtes en C) doit être inclus.
• Si cela est possible, fournissez un lien vers un site où votre programme peut être testé.
• Votre programme ne doit rien écrire à STDERR.
• Les échappatoires standard sont interdites.
• Votre programme peut sortir dans tous les cas, mais il doit être imprimé (pas un tableau ou similaire).

Notation

Les programmes sont notés en octets, en UTF-8 par défaut ou avec un jeu de caractères différent de votre choix.

Finalement, la réponse avec le moins d'octets va gagner.

Les soumissions

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

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

Merci à Downgoat d’ avoir économisé 1 octet. Code:

ADv=À

Explication:

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.

Utilise le codage CP-1252 . Essayez-le en ligne! .

Vim, 25 23 octets

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

Où ↵est la clé de retour.

: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 : les minuscules vont bien, je peux donc sauvegarder deux clés.

Python 2, 59 57 53 octets

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

Merci à @xsot pour -4 octets!

/// , 220 octets

/|/\/\///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

Essayez-le en ligne!

C'était étonnamment non trivial et je ne sais pas si c'est optimal.

Un seul problème pour ce problème dans /// est d'extraire des sous-chaînes communes. ( Il s'avère que je me suis trompé. ) Cependant, en raison de la nature du résultat, il est difficile de savoir quelle sous-chaîne doit être extraite, car vous ne pouvez pas extraire l'alphabet en entier à cause des sauts de ligne. Vous aurez donc besoin d'extraire des sous-chaînes de l'alphabet encapsulé, mais vous devrez également choisir une durée pendant laquelle vous créerez les sous-chaînes et celles que vous choisirez.

Alors voici ce que j'ai fait. Il s'agit d'un script CJam qui trouve toutes les sous-chaînes jusqu'à la longueur 25 dans la chaîne donnée et calcule le nombre d'octets que son extraction sauverait. En gros, s’il existe des Ncopies d’une longueur de Msous-chaîne, vous enregistrez les (N-1)*(M-1) - 5sous-chaînes, ces sous-chaînes ne contiennent pas de barres obliques. En outre, techniquement, lorsque vous avez déjà extrait environ 8 sous-chaînes, le décalage constant à la fin est réduit à -4, mais le script ne tient pas compte de cela.

Quoi qu'il en soit, voici ce que j'ai fait avec le script:

• Exécutez le script avec le code actuel (ce qui ne représente initialement que la sortie).
• Parmi les sous-chaînes qui offrent la plus grande amélioration, choisissez la plus courte. S'il y en a plusieurs, choisissez le plus petit lexicographiquement (d'après ce que je peux dire, pour une entrée donnée, cela réduit les chevauchements entre les sous-chaînes).
• Remplacez toutes les occurrences de la sous-chaîne choisie dans le code par une lettre minuscule non utilisée.
• Ajoutez /x/ABC/le code où xest la lettre choisie et ABCla sous-chaîne.
• Répétez cette opération jusqu'à ce qu'il ne reste plus de sous-chaînes qui pourraient sauver quoi que ce soit.

À la fin, nous économisons quelques octets de plus en remplaçant le résultat //par |et par le préfixe /|/\/\//(c’est pourquoi l’extraction des sous-chaînes ne coûte que 4 au lieu de 5 octets après la 8 e sous-chaîne ou plus).

Comme je l'ai dit, je ne sais pas si c'est optimal et je trouve le résultat plutôt irrégulier assez intéressant. Il serait peut-être possible de trouver une solution plus courte en choisissant des sous-chaînes non optimales (mais plus) quelque part dans la suite. Je me demande quelle est la classe de complexité de ce problème ...

C, 47 octets

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

Essayez sur Ideone

Une seule boucle, imprimant l'alphabet tous les 26 caractères, mais tous les 27 caractères étant remplacés par une nouvelle ligne.

J, 15 octets

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

Interprète en ligne .

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 octets

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

Essayez-le en ligne!

Inspiré par l'incroyable réponse de Jakube au défi L-phabet, j'ai pensé que je m'essayerais aussi à la programmation réelle de /// plutôt que de l'utiliser uniquement pour la compression. C'était assez compliqué et j'avais besoin de quatre tentatives, mais au final, le résultat était beaucoup plus court que ma solution basée sur la compression .

Explication

Une introduction rapide sur ///: en gros, l'interprète lit le code caractère par caractère et effectue les opérations suivantes:

• Si ce n'est \ni un /, imprimez-le.
• Si c'est un \, affiche le caractère suivant.
• Si c'est un /, analysez une /x/y/instruction (avec les mêmes règles d'échappement) et remplacez à plusieurs reprises tout xdans le code restant par y.

S'inspirant de Jakube, pour plus de simplicité, je vais expliquer une version 4x4 de ceci:

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

Nous commençons par remplacer ceux :avec le truc entre le deuxième et le troisième /. Cela finira par être le code qui fera pivoter les lignes suivantes. Nous obtenons ceci:

/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

Le f, bet ne xsont que pour les chaînes communes sténographies, que nous allons maintenant étendre. Le fpour les barres obliques, le bpour les barres obliques inverses et le xpour \//qui arrive souvent. La raison pour laquelle j'utilise des alias pour les sous - chaînes d'un seul caractère /et \est qu'ils auraient à être échappé dans la première instruction de substitution, donc je suis en fait économiser beaucoup d'octets par ne pas avoir besoin tous ces antislashs. Voici ce que nous obtenons après x, fet bont été remplies:

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

Très lisible.

Donc, la première ligne est simplement imprimée textuellement. Nous arrivons ensuite à la partie géniale qui fait pivoter toutes les lignes suivantes. Il consiste en fait en quatre instructions différentes. Une chose à noter est que j'ai échappé à toutes les occurrences de Aces instructions. La raison en est que cela me permet de distinguer As dans les instructions de As dans les lignes restantes, qui doivent être traitées différemment.

/\/\A/\//

Cela correspond /Aet le remplace par /, supprimant le A. Notez que cette sous-chaîne n'apparaît qu'au ABCDdébut de chaque élément , ce qui supprime le premier caractère de toutes les lignes suivantes:

/
\//\A_\//

Cela correspond à un saut de ligne suivi d'une barre oblique et le remplace par A_/. Donc, ceci insère un Aà la fin de chaque ligne, complétant la rotation et transforme le saut de ligne en trait de soulignement.

/_\//
\//

Cela correspond _/et le remplace par un saut de ligne suivi d'une barre oblique. La raison pour laquelle j'ai besoin de faire ce détour par le trait de soulignement est que /// applique chaque instruction plusieurs fois jusqu'à ce que la chaîne ne corresponde plus. Cela signifie que vous ne pouvez jamais utiliser une instruction de la forme /x/axb/où x, aet bsont des chaînes arbitraires, car après la substitution xcorrespondra toujours. Cela signifie notamment que nous ne pouvons pas simplement insérer quelque chose devant un saut de ligne. Nous devons remplacer le saut de ligne dans le processus et annuler ce remplacement.

/\\\A/\\B/

Cela correspond \Aet le remplace par \B, de sorte que les instructions après les lignes restantes traitent le caractère suivant. Une fois que les quatre instructions ont été traitées, la chaîne restante ressemble à ceci:

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

Alors maintenant, la première ligne tournée est imprimée, puis le jeu d'instructions suivant fait pivoter les lignes restantes d'une autre cellule, etc. Après la dernière rotation, nous avons quelques instructions supplémentaires que nous pouvons ignorer, puis nous terminons avec les instructions incomplètes:

/\\\B/\\

Les instructions incomplètes à la fin sont simplement ignorées et le programme se termine.

Gelée , 7 octets

ØAṙJṢj⁷

Essayez-le en ligne!

Comment ça fonctionne

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

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

Où ^Psignifie "Contrôle P", etc. C'est 47 octets, car les touches F3 et F4 nécessitent deux octets ASCII.

Après avoir saisi l'entrée de départ, il définit une macro de clavier pour dupliquer la ligne et déplacer le premier caractère à la fin. Il exécute ensuite la macro 24 fois supplémentaires.

JavaScript (ES6), 56 octets

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

Oui, c'est vrai, la moitié de mon code correspond au littéral de la chaîne de l'alphabet. Le mieux que je puisse faire sans le littéral est de 81 octets:

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

Si vous souhaitez un programme plutôt qu'une fonction, supprimez-le _=>et emballez-le console.log()pour un coût de 10 octets.

Mathematica 68 61 octets

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

Grâce à...

@MartinEnder (7 octets)

Python 2, 75 65 61 58 octets

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

Obtient l'alphabet avec map(chr,range(65,91)), puis applique manuellement l'opération de décalage de chaîne.

Merci à @LeakyNun et @TheBikingViking pour -4 octets!

Merci à @xnor pour -3 octets!

C, 88 64 octets

Appel f()sans arguments.

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

Essayez sur ideone .

Piet , 247 octets / 190 codels

Essayez-le en ligne!

Donc, cela a pris beaucoup plus de temps que prévu et j’ai quelques idées sur d’autres approches plus efficaces (plus faciles à empiler), mais j’ai enfin réussi à faire fonctionner le problème (et à corriger un bogue d’interprète et à ajouter des fonctionnalités IDE le long de la chemin), alors le voici. Pas le langage le plus efficace en octets, mais vraiment très amusant. Voici une vue plus grande et une trace indiquant le chemin emprunté. Histoire sur mon GitHub .

En tant que langage basé sur des piles, il est beaucoup trop compliqué d'expliquer brièvement, mais voici un aperçu de base de ce que font les différentes sections / boucles. Tous les noms de variables et de fonctions sont simplement explicatifs, car Piet ne contient aucune variable ou fonction.

• Initialisation (en haut à gauche): commence line_counterà 27, charge '@' en tant que cur_letter, définie letter_countà 27
• Boucle principale (à partir de violet foncé, centre en haut)
  • Décrements letter_counter
  • Branches à reset_linesi zéro (cyan clair à 2 blocs)
  • Rolls cur_letterau sommet de la pile
  • Branches to check_doneif cur_letter > 'X'(sarcelle / bloc rouge, côté droit)
  • Incrémente cur_letteret affiche le résultat (coin inférieur droit)
  • Branches to reset_letterif cur_letter > 'Y'(bloc vert clair, gauche)
  • Rolls `letter_counter_ retour en haut de la pile, retour en haut de la boucle
• reset_line branche (grand carré rose):
  • Affiche le caractère de nouvelle ligne
  • Réinitialise letter_countà 27
  • Continue en haut de la boucle principale
• check_done branche (moitié droite à l'intérieur)
  • Rolls line_counterto top
  • Branches à terminer si zéro
  • Décrémente line_counteret revient au bas de la pile
  • Reprend où il s’est arrêté en imprimant une lettre
• reset_line branche (côté gauche, bloc vert):
  • Réinitialisation cur_letterà '@'
  • Reprend là où il s’était arrêté en roulant / retournant au sommet de la boucle

MATL , 8 octets

Merci à @Dennis , qui a suggéré que MATL devrait incorporer une indexation modulaire, et à @Suever , qui a eu l’ idée des opérations par paires automatiques.

1Y2t&+Q)

Essayez-le en ligne!

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 octets

Une version très courte pour fonctionner dans la console:

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

Javascript / HTML, 140 123 118 105 octets

Une version plus jolie, avec une sortie HTML qui permet à l'OP de copier et coller plus facilement:

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

(EDIT: J'aurais juste utilisé la chaîne AZ au lieu de la générer)

(EDIT 2: Merci à @Neil et @DanTheMan pour leur contribution (voir commentaires))

PowerShell, 44 octets

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

R, 47 42 41 octets

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

Essayez-le en ligne!

Génère 27 alphabètes, supprime les 27e lettres et imprime en 26 colonnes.

Amélioration inspirée par la solution de @Giuseppe .

Sesos , 27 25 octets

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

Essayez-le en ligne! Cochez Debug pour voir le code SBIN généré. ^†

Assemblage Sesos

Le fichier binaire ci-dessus a été généré en assemblant le code SASM suivant.

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)

Comment ça fonctionne

Nous commençons par initialiser la bande à ABCDEFGHIJKLMNOPQRSTUVWXYZ. Ceci est comme suit.

Ecrivez 26 dans une cellule en laissant la bande dans l'état suivant.

                                                     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

Tant que la cellule sous l'en-tête de données est non nulle, nous procédons comme suit.

Copiez le numéro dans les deux cellules à gauche et ajoutez 64 à la copie la plus à gauche.

                                                   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

Déplacez la copie la plus à gauche vers l'emplacement d'origine, puis soustrayez 1 de la copie la plus à droite.

                                                     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

Le processus s'arrête après 26 itérations, car la copie la plus à droite est 0 à ce moment-là. Nous déplaçons une cellule vers la droite, l'état final de la bande après l'initialisation est le suivant.

     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

Nous sommes maintenant prêts à générer la sortie en répétant le processus suivant jusqu'à ce que la cellule située sous l'en-tête de données soit à zéro.

Tout d'abord, nous imprimons le caractère sous l'en-tête de données et nous nous déplaçons à droite, en répétant cette étape jusqu'à ce qu'une cellule de valeur 0 soit trouvée. Après l’impression ABCDEFGHIJKLMNOPQRSTUVWXYZ, la bande se présente comme suit.

                                                                                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

Maintenant, nous déplaçons la tête de données de 27 unités vers la gauche (de retour au 0 ) et répétons la combinaison impression-déplacement jusqu'à ce qu'une cellule de valeur 0 soit trouvée. Cela n'imprime rien et laisse la bande comme suit.

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

Maintenant, nous écrivons 10 dans la cellule en cours, imprimons le caractère correspondant (saut de ligne) et remettons à zéro la cellule avec un appel à getsur une entrée vide, en laissant la bande inchangée.

Ensuite, nous déplaçons le contenu de la cellule vers la droite vers la cellule actuelle, puis nous déplaçons la tête de données vers les unités vers la droite.

      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 prochaine itération est légèrement différente. La première étape d'impression s'imprime BCDEFGHIJKLMNOPQRSTUVWXYZen laissant la bande comme suit.

                                                                                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

Nous déplaçons maintenant la tête de données de 27 unités vers la gauche.

 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 boucle d’impression suivante imprime Aet laisse la bande comme suit.

   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

Une fois encore, nous imprimons un saut de ligne, déplaçons le contenu de la cellule de droite à la cellule actuelle, puis la tête de données vers les unités de droite.

         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

Après 24 autres itérations, la dernière étape du déplacement de la tête de données vers la droite laisse la bande dans l'état suivant.

                                                                                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 cellule sous l'en-tête de données est maintenant 0 et le programme se termine.

^† TIO utilise une version plus récente de Sesos, qui est rétro-compatible pour SASM, mais génère un code SBIN plus court.

Haskell, 56 53 52 octets

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

même longueur: (suggestion de @AndersKaseorg)

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

pour faire des choses modulaires, vous devez importer Data.Char pour obtenir la fonction chr, 74 59 58 octets était le meilleur que je pouvais obtenir avec ça: (merci à @nimi pour avoir suggéré la fonction toEnum)

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

Cela pourrait probablement être beaucoup plus court, mais je ne connais aucun tour de golf chez Haskell.

mapM utilisé à la place de mapM_ (voir le commentaire de @ Lynn)

R, 53 octets

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

La voici sur un interprète en ligne .

Retina, 36 31 octets

5 octets grâce à Martin Ender.

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

Le saut de ligne est significatif.

Essayez-le en ligne!

Crédits .

Brain-Flak , 222 octets

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

Essayez-le en ligne!

Je suis nouveau à Brain-Flak, alors peut-être que cela peut être joué au golf beaucoup, mais au moins c'est un premier essai. Il stocke 27 alphabets complets sur la pile de gauche, puis les déplace à droite et les remplace toutes les 27 lettres par une nouvelle ligne.

Mon code source est un peu déroutant, mais je l’ajouterai quand même.

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

¬AZ25ñÙx$p

Essayez-le en ligne!

Ceci utilise le codage "Latin1".

Explication:

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

J'ai essayé de voir si je pouvais générer des lettres plus courtes qu'une simple initialisation sous forme de chaîne, mais ce n'est pas vraiment possible. Les lettres sont 26 octets et cet extrait seul

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

est 25 octets. Je pense que les initialiser et ensuite les ajouter avec un + = a est une bonne solution, mais avec C #, vous êtes limité par le nombre de fonctions telles que Substring()et Console.WriteLine().

Ma tentative à 98 octets:

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

Octave, 27 octets

Nous ajoutons un vecteur ligne et colonne, et Octave étend bien les dimensions de sigleton, ce qui est inutile bsxfun(comme dans Matlab).

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

q, 20 octets

(til 26)rotate\:.Q.A

Java, 190 176 172 163 octets

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 octets

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

Je crée un alphabet complet dans A, puis en imprime 26 versions pivotées en prenant les caractères commençant par net en ajoutant ceux qui précèdent n.

Perl, 42 octets

Nous remercions @Dom Hastings pour cela.

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

Ou (même nombre d'octets):

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

A besoin -M5.010ou -Eà courir, par exemple:

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

Mon ancienne réponse (55 octets):

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

Besoin -M5.010de courir. Alors courez avec:

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

Il est probablement possible de faire plus court cependant, mais je n'ai pas encore découvert comment ... encore