Inspiriert von George Gibsons Print a Tabula Recta .

Sie müssen genau diesen Text drucken / ausgeben:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

(Ja, das habe ich von Hand getippt)

Sie dürfen nur Kleinbuchstaben anstelle von Großbuchstaben verwenden.

Ihre Fallauswahl muss jedoch im gesamten Text konsistent 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 = 87064; // 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 = 48934; // 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>

Excel, 19.604 Bytes

=CHAR(64+MAX(COLUMN(),ROW()))

Füge diese Formel ein A1und ziehe sie über die gesamte Fläche A1:Z26.

Byteanzahl:

1. Die Formel ist 27 Bytes.
2. Du musst es 26 ^ 2 mal kopieren. 27 * 26 * 26 = 19604.
3. Ich und andere dachten, die Punktzahl sollte niedriger sein, weil Sie die Formel nicht wirklich immer wieder eingeben müssen. Ich denke jetzt, dass es irrelevant ist - wir zählen die Größe des Programms, nicht die Arbeit, die damit verbracht wurde, es zu schreiben.
4. Zum Vergleich - siehe diese 28.187 Zeichen Antwort von JS - hat es offensichtlich jemand generiert, anstatt dies alles zu tippen , aber es ändert seine Größe nicht.

Vim, 43 Bytes

:h<_↵jjYZZPqqlmaYp`ajyl:norm v0r♥"↵`ajq25@q

Hier ↵repräsentiert Return ( 0x0a) und ♥repräsentiert Ctrl-R ( 0x12).

Nicht ganz so kurz wie meine Tabula Recta-Antwort, aber ...

Gelee, 6 Bytes

ØA»'j⁷

Probieren Sie es hier aus. Wenn ich gestern nicht faul gewesen wäre und diese Ein-Byte-Alternative implementiert hätte j⁷(durch Zeilenumbruch verbinden) ...

ØA      The uppercase alphabet.
  »'    Table of max(x, y).
    j⁷  Join by newlines.

Brainfuck, 103 96 95 91 87 Bytes

+++++[>+++++>++<<-]>+[[<<<+>>>-]----[<+>----]<+<<[>+>+>+<<<-]>-]>>[[<.>-]>[.>>]<<[<]>>]

Hierbei wird die Brainfuck-Konstante von Esolangs für 64 verwendet . Probieren Sie es online!

/// , 141 94 92 82 Bytes

/:/\\\\A//#/: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://:/\/a#
\/a\///A/#

Probieren Sie es online aus: Demonstration

Eine sehr lustige Sprache.

Erläuterung:

Kurzer Code, um nur ein 4x4-Quadrat zu drucken:

/:/\\\\A//#/:b:c:d://:/\/a#
\/a\///A/#

Der erste Ersatz /:/\\\\A/ersetzt :durch \\A. Das gibt:

/#/\\Ab\\Ac\\Ad\\A//\\A/\/a#
\/a\///A/#

Dann /#/\\Ab\\Ac\\Ad\\A//\\A/ersetzt #mit \Ab\Ac\Ad\A:

/\\A/\/a\Ab\Ac\Ad\A
\/a\///A/\Ab\Ac\Ad\A

Nun /\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//ersetzt jede \Ain den nachfolgenden Code durch /aAbAcAdA<newline>/a/, so ergibt sich:

/A//aAbAcAdA
/a/b/aAbAcAdA
/a/c/aAbAcAdA
/a/d/aAbAcAdA
/a/

Jetzt entfernt der erste Teil /A//alle As.

abcd
/a/b/abcd
/a/c/abcd
/a/d/abcd
/a/

Die ersten fünf Zeichen abcd<newline>werden gedruckt. Der nächste Befehl wird /a/b/ersetzt adurch b:

bbcd
/b/c/bbcd
/b/d/bbcd
/b/

Wieder werden die ersten fünf Zeichen bbcd<newline>gedruckt. Der nächste Befehl /b/c/ersetzt bdurch c:

cccd
/c/d/cccd
/c/

Wieder werden die ersten fünf Zeichen cccd<newline>gedruckt. Der nächste Befehl /c/d/ersetzt cdurch d:

dddd
/d/

Die ersten fünf Zeichen dddd<newline>werden gedruckt. Und der nächste Befehl /d/ist unvollständig und macht deshalb nichts.

Dyalog APL , 11 Bytes

⎕A[∘.⌈⍨⍳26]

A[... ]Elemente aus dem Großbuchstaben gemäß
    ∘.⌈⍨der Maximaltabelle
    ⍳26der ersten 26 Ganzzahlen auswählen

TryAPL online!

Mathematica, 69 65 57 Bytes

^{8 Bytes aufgrund von @MartinEnder gespeichert .}

FromCharacterCode[64+Max~Array~{26,26}]~StringRiffle~"
"&

Anonyme Funktion. Nimmt keine Eingabe an und gibt eine Zeichenfolge als Ausgabe zurück. Grundsätzlich gilt nur char('A' + max(x, y))für alle x , y von 1 bis 26.

/// 348 Bytes

/|/\/\///v/NNN|u/MMM|t/LLL|s/WXYZ|r/OOO|q/KLMa|p/RRRR|o/QQQQ|n/PPPP|m/SSS|l/EFGc|k/RSTb|j/UUUU|i/TTTT|h/WWW|g/VVV|f/XXXX|e/ZZZZZ|d/YYYYY|c/HIJq|b/UVs
|a/NOPQk/ABCDlBBCDlCCCDlDDDDlEEEElFFFFFFGcGGGGGGGcHHHHHHHcIIIIIIIIIJqJJJJJJJJJJqKKKKKKKKKKqttttMauuuuMavvvvNarrrrrPQknnnnQkooooQkppppRkmmmmmmSTbiiiiibjjjjjbgggggggVs
hhhhhhhWs
ffffffYZ
dddddZ
eeeeeZ

Probieren Sie es online!

Ich habe die gleiche Technik verwendet, um dies zu erstellen wie für meine Antwort auf die Herausforderung, auf der dies basierte . Ich musste das CJam-Skript jedoch korrigieren, da es Teilzeichenfolgen , die sich überlappen können, nicht richtig handhabte .

Retina , 41 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus. Der Zeilenvorschub ist signifikant.

26$*Z
{`^[^A].+
$&¶$&
}T0-2`L`_L`^(.)\1+

Erläuterung

26$*Z

Stellen Sie die Zeichenfolge auf 26 Kopien von ein Z. Dann {...}weist die Retina an, die verbleibenden zwei Anweisungen in einer Schleife auszuführen, bis sich die Zeichenfolge nicht mehr ändert.

{`^[^A].+
$&¶$&

Dupliziere die erste Zeile, wenn sie nicht mit einem beginnt A.

}T0-2`L`_L`^(.)\1+

Dies ist eine Transliterationsphase. Es wird nur angewendet, wenn die Zeichenfolge mit mindestens zwei Kopien desselben Zeichens beginnt. In diesem Fall werden alle Zeichen bis auf das letzte dekrementiert. Die Dekrementierung erfolgt durch Mapping L(Großbuchstaben) auf _L(Leerzeichen gefolgt von Großbuchstaben). Das "Alles bis auf das Letzte" wird durch das Limit angezeigt, -2das Retina anweist, nur alle Zeichen bis zum vorletzten im Match zu transliterieren.

Probieren Sie es online!

Haskell, 35 Bytes

a=['A'..'Z']
unlines$(<$>a).max<$>a

Python 2, 59 Bytes

n=0;exec'print bytearray([n+65]*n+range(n+65,91));n+=1;'*26

Teste es auf Ideone .

R, 58 Bytes

l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}

Dank der Operator-Priorität 2:i-1ist äquivalent zu 1:(i-1). Verwendet die eingebaute Konstante LETTERS, die das Alphabet in Großbuchstaben enthält. Alles andere ist eher selbsterklärend.
Verwendungszweck:

> l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

Sesos , 25 Bytes

0000000: 2829c0 756fc6 aecae2 aecd9c 39e09e 099c63 7d8e3d  ().uo.......9....c}.=
0000015: 65a7c0 39                                         e..9

Probieren Sie es online! Prüfen 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
        rwd 1, add 1, fwd 1, sub 1
    jnz
    nop
        rwd 1
    jnz
    fwd 1
    jmp
        put, add 1, fwd 1
    jnz
    fwd 1
    jmp
        put, fwd 1
    jnz
    add 10, put, get
    nop
        rwd 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 der Kopie ganz links 64 hinzu .

                                                   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 dann 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 die Kopie ganz rechts bis dahin 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 verschieben wir den Inhalt der Zelle unter dem Datenkopf eine Einheit nach links und dann nach links bis zur letzten Zelle mit einem Inhalt ungleich Null.

   v
0 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 drucken wir alle Zellen, beginnend mit der unter dem Datenkopf, und bewegen uns nach rechts, bis wir eine 0- Zelle finden, die jede gedruckte Zelle nach dem Drucken inkrementiert. Nach dem Drucken Asieht das Band wie folgt aus.

     v
0 66 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 uns nach rechts und drucken erneut alle Zellen, bis eine 0- Zelle angetroffen wird. Nach dem Drucken BCDEFGHIJKLMNOPQRSTUVWXYZsieht das Band wie folgt aus.

                                                                                  v
0 66 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 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.

Schließlich bewegen wir uns zu der letzten Stelle ungleich Null nach links und bereiten das Band für die nächste Iteration vor.

        v
0 66 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 ähnlich. Wir verschieben 66 zuerst eine Zelle nach links, drucken beide 66 Zellen ( BB) und erhöhen sie auf 67 , drucken dann die verbleibenden Zellen ungleich Null nach rechts ( CDEFGHIJKLMNOPQRSTUVWXYZ) und platzieren schließlich den Datenkopf auf 67 , wobei wir das Band wie folgt belassen .

           v
0 66 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 und nach dem Drucken ZZZZZZZZZZZZZZZZZZZZZZZZZZund einem Zeilenvorschub verbleiben die Bänder im folgenden Zustand.

                                                                                  v
0 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 0 0

Wenn Sie den Datenkopf nach links zur nächsten Zelle ungleich Null bewegen, bleibt er an seiner aktuellen Position. Die Zelle darunter ist also 0, und die Schleife wird beendet.

J, 13 Bytes

u:65+>./~i.26

Online-Dolmetscher .

Erläuterung

u:65+>./~i.26
         i.26  generate [0 1 ... 25]
       /~      build a table...
     >.        ...of maximum
  65+          add 65 to each element
u:             convert to unicode

Matlab / Octave, 43 39 Bytes

1 Byte entfernt, dank der Idee von @beaker [...,''], das Konvertieren in char zu verwenden.

@()[91-rot90(gallery('minij',26),2),'']

Dies ist eine anonyme Funktion, die ein 2D-Zeichen-Array zurückgibt.

Probieren Sie es auf Ideone .

Erläuterung

gallery('minij',...) gibt eine Matrix an, in der jeder Eintrag dem Minimum seiner Zeilen- und Spaltenindizes entspricht:

 1     1     1     1  ...
 1     2     2     2
 1     2     3     3
 1     2     3     4
 ...

Dies wird um 180 Grad gedreht mit rot90(...,2):

26    25    24    23  ...
25    25    24    23
24    24    24    23
23    23    23    23
...  

Die 91-...Operation gibt die ASCII-Codes von Großbuchstaben an:

65    66    67    68
66    66    67    68
67    67    67    68
68    68    69    68 ...
...

Schließlich [...,'']verkettet horizontal mit einem leeren String. Dies hat den Effekt, dass in char konvertiert wird.

PowerShell v2 +, 76 52 40 Byte

65..90|%{-join[char[]](,$_*$i+++$_..90)}

Schleifen von 65bis 89. Bei jeder Iteration erstellen wir ein Array mit dem Komma-Operator, der aus der aktuellen Zahl $_multipliziert mit der nachträglich inkrementierten Hilfsvariablen besteht $i++und mit einem Array der aktuellen Zahl $_bis verknüpft ist 90. Das ist in einem Char-Array-Cast gekapselt und -joinzu einer Zeichenfolge zusammengefasst. Bei der ersten Iteration würde dieses Array beispielsweise 65..90dem gesamten Alphabet entsprechen. Die zweite Iteration wäre 66+66..90, oder das ganze Alphabet mit Bwiederholten und nein A.

Diese werden alle am Programmende in der Pipeline belassen (als Array), und das Drucken auf die Konsole ist implizit (der Standardwert .ToString()für ein Array wird durch Zeilenvorschub getrennt, sodass wir ihn kostenlos erhalten).

PS C:\Tools\Scripts\golfing> .\print-the-l-phabet.ps1
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

C #, 147 Bytes

void e(){for(int i=0,j=97;i<26;i++,j++)Console.WriteLine(new string((char)j,i)+new string(Enumerable.Range(j,26-i).Select(n=>(char)n).ToArray()));}

Manchmal frage ich mich, warum ich es überhaupt versuche

edit: repariert es

Probieren Sie es online aus

MATL, 10 Bytes

lY2t!2$X>c

Online-Demo (Wenn Sie Probleme mit diesem Interpreter haben, rufen Sie mich im MATL-Chat an . Außerdem finden Sie hier den TIO-Link, falls Sie Probleme haben.)

Erläuterung

lY2     % Push an array of characters to the stack: 'AB...Z'
t!      % Duplicate and transpose
2$X>    % Take the element-wise maximum between these two (with expansion)
c       % Explicitly convert back to characters
        % Implicitly display the result.

Python 2, 76 70 68 Bytes

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

Sehr ähnlich zu meiner Antwort auf die verknüpfte Frage .

2 Bytes gespart dank @xnor (wieder)!

Oktave, 26 Bytes

disp([max(L=65:90,L'),''])

Probelauf auf ideone .

05AB1E , 9 Bytes

Code:

AAv¬N×?=¦

Erläuterung:

AA         # Push the alphabet twice.
  v        # For each in the alphabet.
   ¬       # Get the first character and
    N×     # multiply by the iteration variable.
      ?    # Pop and print.
       =   # Print the initial alphabet without popping.
        ¦  # Remove the first character of the initial alphabet and repeat.

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

Javascript ES6, 81 Bytes

x=>[...a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map((x,y)=>x.repeat(y)+a.slice(y)).join`
`

Selbsterklärend.

R, 56 Bytes

Ich habe keinen Sprecher zum Kommentieren, aber die Antwort von @plannapus lässt sich ein wenig reduzieren auf:

for(i in 1:26)cat({L=LETTERS;L[1:i]=L[i];L},"\n",sep="")

Daraus ergibt sich die gleiche Ausgabe:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

Wenn die Antwort als Matrix zulässig ist ( dh wie hier ), könnten wir 49 Bytes ausführen:

sapply(1:26,function(l){L=LETTERS;L[1:l]=L[l];L})

R , 42 41 Bytes

write(outer(L<-LETTERS,L,pmax),'',26,,'')

Probieren Sie es online!

Die nächst kürzere R-Antwort ist immer noch etwas zu lang, da sie zeilenweise ausgedruckt wird. Ich habe heute früher über eine andere Frage nachgedacht und festgestellt, dass ein viel kürzerer Ansatz für diese Frage möglich ist: Ich erstelle die Matrix auf einmal mit outerund pmax(maximal parallel) und drucke sie dann in einem Schritt mit (*) aus write.

(*) Technisch gesehen ist es transponiert, aber glücklicherweise symmetrisch über seine Diagonale.

Haskell, 53 46 Bytes

unlines[(i<$['B'..i])++[i..'Z']|i<-['A'..'Z']]

Gibt eine einzelne Zeichenfolge mit dem L-Phabet zurück.

Gehen Sie die Zeichen ivon Abis durch Zund erstellen Sie eine Liste der (length ['B'..i])Kopien von igefolgt von[i..'Z'] . Verbinden Sie Elemente mit dazwischen liegenden Zeilenumbrüchen.

Python 3, 71 65 Bytes

Vielen Dank an @LeakyNun für -6 Bytes

r=range(26)
for i in r:print(''.join(chr(max(i,x)+65)for x in r))

Ein vollständiges Programm, das auf STDOUT gedruckt wird.

Wie es funktioniert

Wir weisen den Buchstaben des Alphabets Zeichencodes zu, von 0für Abis 25für Z. Das Programm durchläuft das Intervall [0, 25]mit einem Zeilenzähler i, der das aktuelle zu wiederholende Zeichen und die Länge des wiederholten Abschnitts sowie einen Zeichenindex bestimmt x. Durch Aufrufen max(i,x)werden alle Zeichen unterhalb des wiederholten Zeichens an den Zeichencode desselben geklemmt. Durch Hinzufügen 65und Aufrufen werden chrdie resultierenden Zeichencodes in ihre ASCII-Entsprechungen konvertiert. ''.joinverkettet die Zeichen und jede Zeile wird auf STDOUT gedruckt.

Probieren Sie es auf Ideone

𝔼𝕊𝕄𝕚𝕟 12 Zeichen / 15 Byte

ᶐⓢ⒨Ċ_+ᶐč_)ü⬬

Try it here (Chrome Canary only).

Grundsätzlich ein Port meiner ES6 Antwort.

R, 54 Bytes

v=L=LETTERS;for(i in 2:26){L[1:i]=L[i];v=cbind(v,L)};v

Diese Lösung verwendet die eingebaute Konstante RLETTERS , die ... nun ... die Großbuchstaben auflistet. Es gibt auch die Konstante lettersfür Kleinbuchstaben.

C 78 70 67 Bytes

f(i,j){for(;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}

Der Code verwendet die folgenden Golftechniken für C:

• weglassen basic includes (like stdio.h )
• lassen Sie die Typen von Funktionen und Variablen weg (geben Sie sie zurück) und setzen Sie sie standardmäßig auf int
• Verwenden Sie den ternären Operator anstelle von if-else-Blöcken
• Verwenden Sie den ASCII - Code eines Buchstabens anstelle seiner Zeichenrepräsentation (dh 65anstelle von'A' )
• Verwenden Sie putchardiese Taste, um ein einzelnes Zeichen auszugeben
• Hauptargumentliste des Missbrauchs
• Verwenden Sie, puts("")um eine neue Zeile auszugeben

Außerdem If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.verbietet die Regel nicht, die Funktion mit Parametern aufzurufen (dank ABcDexter!).

Probieren Sie es auf Ideone

Eine ungolfed version (ohne warnungen mit gcc) würde so aussehen:

#include <stdio.h>

#define MAX(x, y) (x>y ? x : y)

int main()
{
    for(int i=0; i<26; i++)
    {
        for(int j=0; j<26; j++)
            printf("%c", MAX(i, j) + 'A');
        printf("\n");
    }
    return 0;
}

Cheddar, 90 Bytes

(|>26).map(i->String.letters.chars.map((j,k,l)->k<i?l[i]:j).fuse).vfuse.slice(1)

Das String.letters ist zu lang: /

Musste eine hinzufügen .slice(1) weil führende Newline nicht erlaubt ist

Erläuterung

(|>26)       // Range from [0, 26)
.map(i->     // Loop through that range
 String.letters.chars // Alphabet array
  .map(               // Loop through alphabet
  (j,k,l) ->          // j = letter, j = index, l = alphabet
    k<i?l[i]:j        // Basically `l[max(k,i)]` 
  ).fuse     // Collapse the array
).vfuse      // Join on newlines

Cheddar, 65 Bytes (nicht konkurrierend)

(|>26).map(i->String.letters.map((j,k,l)->k<i?l[i]:j).fuse).vfuse

Arbeitet mit dem nächtlichen Zweig . Nicht konkurrierend ... trauriger Teil ist, dass ich die Änderungen bereits hatte ... nur nie festgeschrieben; _;