Drucken Sie eine Tabula Recta!

Die Tabula Recta (manchmal als "Vigenere-Tabelle" bezeichnet) wurde von Johannes Trithemius erstellt und in mehreren Chiffren verwendet, einschließlich aller Varianten der Bellaso-Vigenere-Chiffre und der Trithemius-Chiffre. Es sieht aus wie das:

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

Ich brauche das häufig, kann es aber nirgendwo im Internet finden, wo ich es kopieren und einfügen kann. Da der quadratische Tisch so lang ist und die Eingabe verdammt viel Zeit in Anspruch nimmt , muss Ihr Code so kurz wie möglich sein.

Regeln / Anforderungen

• Jede Einreichung sollte entweder ein vollständiges Programm oder eine Funktion sein. Wenn es sich um eine Funktion handelt, muss sie ausgeführt werden können, indem nur der Funktionsaufruf am Ende des Programms hinzugefügt wird. Alles andere (z. B. Überschriften in C) muss enthalten sein.
• Wenn es möglich ist, geben Sie einen Link zu einer Site an, auf der Ihr Programm getestet werden kann.
• Ihr Programm darf nichts schreiben STDERR.
• Standardlücken sind verboten.
• Ihr Programm kann in jedem Fall ausgeben, es muss jedoch gedruckt werden (kein Array oder ähnliches).

Wertung

Programme werden nach Bytes, standardmäßig in UTF-8 oder einem anderen Zeichensatz Ihrer Wahl bewertet.

Irgendwann gewinnt die Antwort mit den wenigsten Bytes.

Einreichungen

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

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

Vielen Dank an Downgoat für das Speichern von 1 Byte. Code:

ADv=À

Erläuterung:

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.

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Vim, 25 23 Bytes

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

Wo ↵ist die Return-Taste.

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

BEARBEITEN : Kleinbuchstaben sind in Ordnung, daher kann ich zwei Schlüssel speichern.

Python 2, 59 57 53 Bytes

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

Danke an @xsot für -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

Probieren Sie es online!

Dies war überraschend nicht trivial und ich habe keine Ahnung, ob es optimal ist.

Die einzige Möglichkeit, ein Problem wie dieses in /// zu lösen, besteht darin, gemeinsame Teilzeichenfolgen zu extrahieren. (Es stellte sich heraus, dass ich mich geirrt hatte. ) Aufgrund der Art der Ausgabe ist jedoch überhaupt nicht klar, welche Teilzeichenfolgen am besten extrahiert werden sollten, da Sie aufgrund der Zeilenumbrüche nicht das gesamte Alphabet extrahieren können. Sie müssen also einige Teilzeichenfolgen des umgebrochenen Alphabets extrahieren, aber dann gibt es Kompromisse in Bezug darauf, wie lange Sie die Teilzeichenfolgen erstellen und welche Sie auswählen.

Also hier ist was ich getan habe. Dies ist ein CJam-Skript, das alle Teilzeichenfolgen bis zur Länge 25 in der angegebenen Zeichenfolge findet und für jede von ihnen berechnet, wie viele Bytes durch das Extrahieren gespeichert würden. Grundsätzlich Nspeichern MSie Unterzeichenfolgen , wenn Kopien einer Längensubstring vorhanden sind. (N-1)*(M-1) - 5Diese Unterzeichenfolgen enthalten keine Schrägstriche. Technisch gesehen reduziert sich der konstante Versatz am Ende auf, wenn Sie bereits etwa 8 Teilzeichenfolgen extrahiert haben -4, aber das Skript berücksichtigt dies nicht.

Wie auch immer, hier ist was ich mit dem Skript gemacht habe:

• Führen Sie das Skript mit dem aktuellen Code aus (der anfänglich nur die Ausgabe ist).
• Wählen Sie aus den Teilzeichenfolgen mit der größten Verbesserung die kürzeste aus. Wenn mehrere vorhanden sind, wählen Sie die lexikografisch kleinste aus (soweit ich das beurteilen kann, werden bei der angegebenen Eingabe Überlappungen zwischen Teilzeichenfolgen reduziert).
• Ersetzen Sie alle Vorkommen der ausgewählten Teilzeichenfolge im Code durch einen nicht verwendeten Kleinbuchstaben.
• Stellen Sie /x/ABC/den Code voran, in dem xsich der gewählte Buchstabe und ABCdie Teilzeichenfolge befinden.
• Wiederholen Sie diesen Vorgang, bis keine Teilzeichenfolgen mehr vorhanden sind, die etwas speichern könnten.

Am Ende sparen wir ein paar weitere Bytes, indem wir das Ergebnis //durch |und das vorangestellte ersetzen /|/\/\//(daher kostet das Extrahieren von Teilzeichenfolgen nach dem achten Teilzeichenfolgen nur 4 anstatt 5 Bytes oder so).

Wie gesagt, ich habe keine Ahnung, ob dies optimal ist und finde das eher unregelmäßig aussehende Ergebnis recht interessant. Möglicherweise können Sie zu einer kürzeren Lösung gelangen, indem Sie nicht optimale (aber mehr) Teilzeichenfolgen auswählen. Ich frage mich, was die Komplexitätsklasse dieses Problems ist ...

C 47 Bytes

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

Probieren Sie es auf Ideone

Eine einzelne Schleife, in der das Alphabet alle 26 Zeichen gedruckt wird, wobei jedoch jedes 27. Zeichen durch eine neue Zeile ersetzt wird.

J, 15 Bytes

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

Online-Dolmetscher .

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:

Probieren Sie es online!

Inspiriert von Jakubes erstaunlicher Antwort auf die L-Phabet-Herausforderung, dachte ich, ich würde mich auch beim eigentlichen Programmieren in /// versuchen, anstatt es nur für die Komprimierung zu verwenden. Das war ziemlich knifflig und ich brauchte vier Versuche, aber am Ende war es viel kürzer als meine auf Komprimierung basierende Lösung .

Erläuterung

Eine kurze Einführung zu ///: Im Grunde liest der Interpreter den Code nur zeichenweise und führt die folgenden Aktionen aus:

• Wenn es weder ein \noch ein ist /, drucken Sie es aus.
• Wenn es ein ist \, drucken Sie das nächste Zeichen.
• Wenn dies der /Fall ist, analysieren Sie eine /x/y/Anweisung (mit denselben Escape-Regeln) und ersetzen Sie alle Anweisungen xim verbleibenden Code wiederholt durch y.

Ich lasse mich von Jakube etwas mehr inspirieren und erkläre der Einfachheit halber nur eine 4x4-Version davon:

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

Wir beginnen damit, diese :durch das Zeug zwischen dem zweiten und dem dritten zu ersetzen /. Dies wird der Code sein, der die nachfolgenden Zeilen dreht. Wir bekommen das:

/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

Die f, bund xsind nur Kürzel für gemeinsame Strings, die wir jetzt erweitern werden. Das fist für Schrägstriche, das bist für Backslashes und das xist, \//wofür zufällig ziemlich viel aufkommt. Der Grund , warum ich bin mit Aliasnamen für die Einzelzeichenstrings /und \ist , dass sie in dem ersten Substitutionsbefehl maskiert werden müßten, so spare ich eigentlich ziemlich viele Bytes nicht all diese Schrägstriche zu benötigen. Hier ist , was wir nach bekommen x, fund bhaben in ausgefüllt:

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

Sehr gut lesbar.

Die erste Zeile wird also nur wörtlich gedruckt. Dann kommen wir zu dem funky Teil, der alle weiteren Reihen dreht. Es besteht eigentlich aus vier verschiedenen Anweisungen. Eine Sache zu bemerken ist, dass ich mich allen Vorkommnissen Ain dieser Anleitung entzogen habe. Der Grund dafür ist, dass ich As innerhalb der Anweisungen von As in den verbleibenden Zeilen unterscheiden kann, die unterschiedlich verarbeitet werden müssen.

/\/\A/\//

Dies entspricht /Aund ersetzt es durch /Entfernen des A. Beachten Sie, dass diese Teilzeichenfolge nur am ABCDAnfang jeder Zeile angezeigt wird. Dadurch wird das erste Zeichen aller folgenden Zeilen gelöscht:

/
\//\A_\//

Dies entspricht einem Zeilenvorschub gefolgt von einem Schrägstrich und ersetzt ihn durch A_/. Dies fügt also Aam Ende jeder Zeile ein, schließt die Drehung ab und verwandelt den Zeilenvorschub in einen Unterstrich.

/_\//
\//

Dies entspricht _/und ersetzt es durch einen Zeilenvorschub, gefolgt von einem Schrägstrich. Der Grund, warum ich diesen Umweg über den Unterstrich machen muss, ist die Tatsache, dass /// jede Anweisung wiederholt anwendet, bis die Zeichenfolge nicht mehr übereinstimmt. Das bedeutet , dass Sie nie eine Anweisung der Form verwenden können , /x/axb/wo x, aund bbeliebige Zeichenketten sind, denn nach dem Wechsel ximmer noch übereinstimmen. Dies bedeutet insbesondere, dass wir nicht einfach etwas vor einem Zeilenumbruch einfügen können. Wir müssen den Zeilenvorschub im Prozess ersetzen und diesen Austausch rückgängig machen.

/\\\A/\\B/

Dies stimmt überein \Aund ersetzt es durch \B, so dass die Anweisungen nach den verbleibenden Zeilen das nächste Zeichen verarbeiten. Nachdem alle vier Anweisungen verarbeitet wurden, sieht der verbleibende String folgendermaßen aus:

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

Jetzt wird die erste gedrehte Zeile gedruckt, und der nächste Befehlssatz dreht die verbleibenden Zeilen um eine andere Zelle und so weiter. Nach der letzten Umdrehung haben wir noch ein paar Anweisungen, die wir ignorieren können, und dann beenden wir die unvollständige Anweisung:

/\\\B/\\

Unvollständige Anweisungen am Ende werden einfach ignoriert und das Programm wird beendet.

Gelee , 7 Bytes

ØAṙJṢj⁷

Probieren Sie es online!

Wie es funktioniert

Ø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

Wobei ^P"Control P" usw. bedeutet. Das sind 47 Bytes, da die Tasten F3 und F4 zwei ASCII-Bytes erfordern.

Nach der Eingabe der Starteingabe wird ein Tastaturmakro definiert, um die Zeile zu duplizieren und das erste Zeichen ans Ende zu verschieben. Anschließend wird das Makro weitere 24 Mal ausgeführt.

JavaScript (ES6), 56 Byte

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

Ja, das stimmt, mein halber Code ist das Buchstabentext-Literal. Das Beste, was ich ohne das Literal machen könnte, sind 81 Bytes:

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

Wenn Sie ein Programm anstelle einer Funktion wünschen, entfernen Sie das _=>und wickeln Sie es console.log()für 10 Byte ein.

Mathematica 68 61 Bytes

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

Dank an...

@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

Ruft das Alphabet mit ab map(chr,range(65,91))und wendet dann die Zeichenfolgenverschiebungsoperation manuell an.

Danke an @LeakyNun und @TheBikingViking für -4 Bytes!

Danke an @xnor für -3 Bytes!

C 88-64 Bytes

Aufruf f()ohne Argumente.

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

Probiere es auf ideone aus .

Piet , 247 Bytes / 190 Codels

Probieren Sie es online!

Also nahm dies viel länger als ich erwartet hatte, und ich habe ein paar Ideen auf einige andere effizienter (mehr Stapel freundlich) annähert, aber ich habe endlich das Ding dang arbeiten (und fixiert einen Interpreter Fehler und hinzugefügt IDE - Funktionen entlang der Weg), also hier ist es. Kaum die byteeffizienteste Sprache, aber verdammt viel Spaß. Hier ist eine größere Ansicht und eine Spur, die den eingeschlagenen Weg zeigt. Geschichte auf meinem GitHub .

Als stapelbasierte Sprache ist es viel zu kompliziert, um es kurz zu erklären, aber hier ist ein grundlegender Überblick darüber, was die verschiedenen Abschnitte / Schleifen tun. Alle Variablen- und Funktionsnamen dienen nur der Erklärung, da Piet keine Variablen oder Funktionen enthält.

• Initialisierung (oben links): Startet line_counterbei 27, lädt '@' wie cur_letter, setzt letter_countauf 27
• Hauptschleife (ab dunkelviolett, Mitte oben)
  • Abnahmen letter_counter
  • Verzweigt auf reset_lineNull (heller Cyan-2-Block)
  • Rollt cur_letteran die Spitze des Stapels
  • Zweige nach check_doneif cur_letter > 'X'(blaugrün / roter Block, rechte Seite)
  • Inkrementiert cur_letterund gibt es aus (rechte untere Ecke)
  • Verzweigt nach reset_letterif cur_letter > 'Y'(hellgrüner Block links)
  • Rollt `letter_counter_ zurück zum Anfang des Stapels, zurück zum Anfang der Schleife
• reset_line Zweig (großes rosa Quadrat):
  • Gibt das Newline-Zeichen aus
  • Setzt letter_countauf 27 zurück
  • Fährt zurück zum Anfang der Hauptschleife
• check_done Ast (rechte Hälfte innen)
  • Brötchen line_counternach oben
  • Zweige bis zum Ende, wenn Null
  • Dekrementiert line_counterund rollt zurück zum Stapelende
  • Fährt dort fort, wo es aufgehört hat, und druckt Brief
• reset_line Abzweig (linke Seite, grüner Block):
  • Setzt cur_letterauf '@' zurück
  • Fährt dort fort, wo es aufgehört hat und rollt / kehrt zum Anfang der Schleife zurück

MATL , 8 Bytes

Dank an @Dennis , der vorgeschlagen hat, dass MATL eine modulare Indizierung beinhalten soll, und an @Suever , der die Idee hatte, automatische paarweise Operationen durchzuführen.

1Y2t&+Q)

Probieren Sie es online!

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display

Javascript, 113 96 91 76 Bytes

Eine superkurze Version zum Laufen in der Konsole:

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

Javascript / HTML, 140 123 118 105 Bytes

Eine schönere Version mit einer HTML-Ausgabe, die OP das Kopieren und Einfügen erleichtert:

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

(BEARBEITEN: Ich hätte nur die Zeichenfolge AZ verwenden sollen, anstatt sie zu generieren)

(EDIT 2: Danke an @Neil und @DanTheMan für die Eingabe (siehe Kommentare))

PowerShell, 44 Byte

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

R, 47 42 41 Bytes

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

Probieren Sie es online!

Erzeugt 27 Buchstaben, entfernt 27. Buchstaben und druckt in 26 Spalten.

Verbesserung von inspiriert @Giuseppe ‚s Lösung .

Sesos , 27 25 Bytes

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

Probieren Sie es online! Überprüfen Sie Debug , um den generierten SBIN-Code anzuzeigen. ^†

Sesos Montage

Die obige Binärdatei wurde durch Zusammenstellen des folgenden SASM-Codes generiert.

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)

Wie es funktioniert

Wir beginnen mit der Initialisierung des Bandes auf ABCDEFGHIJKLMNOPQRSTUVWXYZ. Das ist wie folgt.

Schreiben Sie 26 in eine Zelle und lassen Sie das Band im folgenden Zustand.

                                                     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

Solange die Zelle unter dem Datenkopf nicht Null ist, gehen wir wie folgt vor.

Kopieren Sie die Nummer in die beiden Zellen links und fügen Sie sie hinzu der Kopie ganz links 64 .

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

Verschieben Sie die Kopie ganz links an die ursprüngliche Position und subtrahieren Sie sie 1 von der Kopie ganz rechts.

                                                     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

Der Vorgang stoppt nach 26 Iterationen, da sich die Kopie ganz rechts befindet 0 ist. Wir verschieben eine Zelle nach rechts, so dass der endgültige Zustand des Bands nach der Initialisierung wie folgt ist.

     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

Jetzt können Sie die Ausgabe generieren, indem Sie den folgenden Vorgang wiederholen, bis die Zelle unter dem Datenkopf Null ist.

Zuerst drucken wir das Zeichen unter den Datenkopf und bewegen uns nach rechts, wobei wir diesen Schritt wiederholen, bis eine Zelle mit dem Wert 0 gefunden wird. Nach dem DruckenABCDEFGHIJKLMNOPQRSTUVWXYZ sieht das Band wie folgt aus.

                                                                                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

Jetzt bewegen wir den Datenkopf 27 Einheiten nach links (zurück zur führenden 0 ) und wiederholen die Druck-Verschiebungs-Kombination, bis eine Zelle mit dem Wert 0 gefunden wird. Dies druckt nichts und lässt das Band wie folgt.

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

Jetzt schreiben wir 10 in die aktuelle Zelle, drucken das entsprechende Zeichen (Zeilenvorschub) und setzen die Zelle mit einem Aufruf von getbei leerer Eingabe auf Null , wobei das Band unverändert bleibt.

Anschließend verschieben wir den Inhalt der Zelle nach rechts in die aktuelle Zelle und verschieben den Datenkopf in Einheiten nach rechts.

      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

Die nächste Iteration ist etwas anders. Der erste Druckschritt wird gedrucktBCDEFGHIJKLMNOPQRSTUVWXYZ , wobei das Band wie folgt belassen wird.

                                                                                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

Jetzt bewegen wir den Datenkopf 27 Einheiten nach links.

 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

Die nachfolgende Druckschleife druckt Aund verlässt das Band wie folgt.

   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

Wir drucken erneut einen Zeilenvorschub, verschieben den Inhalt der Zelle nach rechts in die aktuelle Zelle und den Datenkopf in Einheiten nach rechts.

         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

Nach weiteren 24 Iterationen verbleibt das Band im folgenden Zustand, wenn Sie den Datenkopf nach rechts bewegen.

                                                                                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

Die Zelle unter dem Datenkopf ist jetzt 0 und das Programm wird beendet.

^† TIO verwendet eine neuere Version von Sesos, die für SASM abwärtskompatibel ist, jedoch kürzeren SBIN-Code generiert.

Haskell, 56 53 52 Bytes

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

gleiche Länge: (mit einem Vorschlag von @AndersKaseorg)

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

um modulare Sachen zu machen, muss man Data.Char importieren, um die chr-Funktion zu erhalten. 74 59 58 Bytes waren das Beste, was ich damit bekommen konnte: (Danke an @nimi für den Vorschlag der toEnum-Funktion)

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

Dies könnte wahrscheinlich viel kürzer sein, aber ich kenne keine Haskell-Golftricks.

Verwendete mapM anstelle von mapM_ (siehe @Lynns Kommentar)

R, 53 Bytes

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

Hier handelt es sich um einen Online-Dolmetscher .

Retina, 36 31 Bytes

5 Bytes dank Martin Ender.

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

Der Zeilenvorschub ist signifikant.

Probieren Sie es online!

Credits .

Brain-Flak , 222 Bytes

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

Probieren Sie es online!

Ich bin neu in Brain-Flak, also kann man vielleicht viel Golf spielen, aber es ist zumindest ein erster Versuch. Es speichert 27 vollständige Alphabete auf dem linken Stapel, verschiebt die Alphabete dann nach rechts und ersetzt jeden 27. Buchstaben durch eine neue Zeile.

Mein Quellcode ist ein bisschen verwirrend, aber ich werde ihn trotzdem hinzufügen.

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

Probieren Sie es online!

Dies verwendet die "Latin1" -Codierung.

Erläuterung:

¬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

Ich habe versucht zu sehen, ob ich die Buchstaben kürzer erzeugen kann, als sie nur als Zeichenfolge zu initialisieren, aber das ist nicht wirklich möglich. Die Buchstaben sind 26 Bytes und dieses Snippet alleine

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

ist 25 Bytes. Ich denke, sie zu initialisieren und sie dann mit einem + = a anzuhängen, ist eine gute Lösung, aber mit C # sind Sie durch die Anzahl der Funktionen wie Substring()und begrenzt Console.WriteLine().

Mein Versuch mit 98 Bytes:

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

Oktave, 27 Bytes

Wir fügen einen Zeilen- und einen Spaltenvektor hinzu, und Octave erweitert die Sigleton-Dimensionen, ohne dass dies erforderlich ist bsxfun(wie Sie es in Matlab benötigen würden).

[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

Ich erstelle ein vollständiges Alphabet und drucke Adann 26 gedrehte Versionen davon aus, indem ich die Zeichen beginnend an nder vorhergehenden Position anhänge n.

Perl, 42 Bytes

Voller Dank an @Dom Hastings dafür.

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

Oder (gleiche Byteanzahl):

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

Muss -M5.010oder muss -Eausgeführt werden, zum Beispiel:

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

Meine alte Antwort (55 Bytes):

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

Müssen -M5.010rennen. Also lauf mit:

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

Es ist wahrscheinlich möglich, etwas kürzer zu machen, aber ich habe noch nicht herausgefunden, wie