Inspirowany przez George'a Gibsona Print a Tabula Recta .

Masz wydrukować / wydrukować ten dokładny tekst:

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

(Tak, wpisałem to ręcznie)

Możesz używać wszystkich małych liter zamiast wszystkich wielkich liter.

Jednak wybór wielkości liter musi być spójny w całym tekście.

Zasady / wymagania

• Każde zgłoszenie powinno być pełnym programem lub funkcją. Jeśli jest to funkcja, musi być uruchomiona, wystarczy dodać wywołanie funkcji na dole programu. Wszystko inne (np. Nagłówki w C) musi zostać uwzględnione.
• Jeśli to możliwe, podaj link do strony, na której można przetestować Twój program.
• Twój program nie może nic pisać STDERR.
• Standardowe luki są zabronione.
• Twój program może wysyłać dane w każdym przypadku, ale musi zostać wydrukowany (nie tablica lub podobny).

Punktacja

Programy są oceniane według bajtów, domyślnie w UTF-8 lub według innego zestawu znaków.

W końcu wygra odpowiedź z najmniejszą liczbą bajtów.

Zgłoszenia

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

/* 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 bajtów

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

Wklej tę formułę A1, a następnie przeciągnij A1:Z26.

Liczba bajtów:

1. Formuła ma 27 bajtów.
2. Musisz go skopiować 26 ^ 2 razy. 27 * 26 * 26 = 19604.
3. Ja i inni myśleliśmy, że wynik powinien być niższy, ponieważ tak naprawdę nie trzeba ciągle pisać formuły. Teraz myślę, że to nie ma znaczenia - liczymy rozmiar programu, a nie pracę poświęconą na jego pisanie.
4. Dla porównania - zobacz 28 187 znaków w odpowiedzi JS - oczywiście ktoś ją wygenerował, zamiast pisać to wszystko, ale to nie zmienia jego rozmiaru.

Vim, 43 bajty

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

Tutaj ↵reprezentuje Return ( 0x0a) i ♥Ctrl-R ( 0x12).

Nie tak krótkie, jak moja Tabula Recta, ale…

Galaretka, 6 bajtów

ØA»'j⁷

Wypróbuj tutaj. Gdybym tylko nie był wczoraj leniwy i wdrożył tę jednobajtową alternatywę dla j⁷(dołącz przez nowe linie)…

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

pieprzenie mózgu, 103 96 95 91 87 bajtów

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

Używa stałej mózgowej Esolangsa dla 64 . Wypróbuj online!

/// , 141 94 92 82 bajtów

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

Wypróbuj online: demonstracja

Całkiem fajny język.

Wyjaśnienie:

Skróć kod, aby wydrukować tylko kwadrat 4x4:

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

Pierwszy zamiennik /:/\\\\A/zastępuje :się \\A. To daje:

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

Następnie /#/\\Ab\\Ac\\Ad\\A//\\A/zastępuje #się \Ab\Ac\Ad\A:

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

Teraz /\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//zamienia każdy \Aw kolejnym kodzie na /aAbAcAdA<newline>/a/, więc powoduje to:

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

Teraz pierwsza część /A//usuwa wszystkie As.

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

Pierwsze pięć znaków abcd<newline>zostanie wydrukowanych. Kolejna komenda /a/b/zastępuje aprzez b, w wyniku:

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

Znów bbcd<newline>drukowanych jest pierwszych pięć znaków . Kolejna komenda /b/c/zastępuje bprzez c:

cccd
/c/d/cccd
/c/

Znów cccd<newline>drukowanych jest pierwszych pięć znaków . Kolejna komenda /c/d/zastępuje cprzez d:

dddd
/d/

Pierwsze pięć znaków dddd<newline>zostanie wydrukowanych. Następne polecenie /d/jest niepełne i dlatego nic nie robi.

Dyalog APL , 11 bajtów

⎕A[∘.⌈⍨⍳26]

A[... ]wybieraj elementy z wielkich liter zgodnie
    ∘.⌈⍨z maksymalną tabelą
    ⍳26pierwszych 26 liczb całkowitych

Wypróbuj APL online!

Mathematica, 69 65 57 bajtów

^{Zapisano 8 bajtów dzięki @MartinEnder .}

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

Funkcja anonimowa. Nie pobiera danych wejściowych i zwraca ciąg wyjściowy. Zasadniczo wystarczy char('A' + max(x, y))dla wszystkich x , y od 1 do 26.

/// , 348 bajtów

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

Wypróbuj online!

Użyłem tej samej techniki, aby to zbudować, jak dla mojej /// odpowiedzi na wyzwanie, na którym było oparte . Musiałem jednak naprawić skrypt CJam, ponieważ nie obsługiwał on poprawnie podciągów, które mogą się nakładać.

Siatkówka , 41 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1. Wiodące podawanie linii jest znaczące.

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

Wyjaśnienie

26$*Z

Ustaw ciąg na 26 kopii Z. Następnie {...}poinstruuj Retinę, aby wykonała pozostałe dwie instrukcje w pętli, aż łańcuch przestanie się zmieniać.

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

Duplikuj pierwszą linię, jeśli nie zaczyna się od A.

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

To jest etap transliteracji. Jest stosowany tylko wtedy, gdy ciąg zaczyna się od co najmniej dwóch kopii tego samego znaku. Jeśli tak, wszystkie z nich są pomniejszane. Zmniejszanie odbywa się poprzez odwzorowanie L(wielkie litery) na _L(puste, po których następuje wielkie litery). „Wszystkie oprócz ostatnich” jest wskazane przez limit, -2który mówi Retinie tylko o transliteracji wszystkich znaków do końca meczu.

Wypróbuj online!

Haskell, 35 bajtów

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

Python 2, 59 bajtów

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

Przetestuj na Ideone .

R, 58 bajtów

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

Dzięki pierwszeństwu operatora 2:i-1jest równoważne z 1:(i-1). Używa wbudowanej stałej, LETTERSktóra zawiera wielkie litery alfabetu. Wszystko inne jest raczej oczywiste.
Stosowanie:

> 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 bajtów

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

Wypróbuj online! Zaznacz opcję Debuguj, aby zobaczyć wygenerowany kod SBIN.

Montaż Sesos

Powyższy plik binarny został wygenerowany przez skompletowanie następującego kodu SASM.

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        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)

Jak to działa

Zaczynamy od inicjalizacji taśmy ABCDEFGHIJKLMNOPQRSTUVWXYZ. Jest to następujące.

Napisz 26 do komórki, pozostawiając taśmę w następującym stanie.

                                                       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

Dopóki komórka pod głowicą danych jest niezerowa, wykonujemy następujące czynności.

Skopiuj liczbę do dwóch komórek po lewej stronie i dodaj 64 do kopii najbardziej po lewej stronie.

                                                   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

Przenieś kopię po lewej stronie do oryginalnej lokalizacji, a następnie odejmij 1 od kopii po prawej stronie.

                                                     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

Proces zatrzymuje się po 26 iteracjach, ponieważ prawostronna kopia wynosi do tego czasu 0 . Przesuwamy komórkę w prawo, więc końcowy stan taśmy po inicjalizacji jest następujący.

     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

Teraz jesteśmy gotowi wygenerować wynik, powtarzając następujący proces, aż komórka pod głowicą danych wyniesie zero.

Najpierw przenosimy zawartość komórki pod głowicą danych o jedną jednostkę w lewo, a następnie przesuwamy w lewo, aż do ostatniej komórki z niezerową zawartością.

   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

Teraz drukujemy wszystkie komórki, zaczynając od tej pod głowicą danych i przesuwając się w prawo, aż znajdziemy komórkę 0 , zwiększając każdą drukowaną komórkę po wydrukowaniu. Po wydrukowaniu Ataśma wygląda następująco.

     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

Teraz ruszamy w prawo, ponownie drukując wszystkie komórki, aż napotkamy komórkę 0 . Po wydrukowaniu BCDEFGHIJKLMNOPQRSTUVWXYZtaśma wygląda następująco.

                                                                                  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

Teraz piszemy 10 do bieżącej komórki, wypisujemy odpowiedni znak (wysuw linii) i zerujemy komórkę z wywołaniem do getpustego wejścia, pozostawiając niezmienioną taśmę.

Na koniec przechodzimy do ostatniego niezerowego w lewo, przygotowując taśmę do następnej iteracji.

        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

Kolejna iteracja jest podobna. Najpierw przesuwamy 66 jedną komórkę w lewo, drukujemy obie 66 komórek ( BB) i zwiększamy je do 67 , następnie drukujemy pozostałe niezerowe komórki w prawo ( CDEFGHIJKLMNOPQRSTUVWXYZ), a na końcu umieszczamy głowicę danych na 67 , pozostawiając taśmę w następujący sposób .

           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

Po kolejnych 24 iteracjach oraz po wydrukowaniu ZZZZZZZZZZZZZZZZZZZZZZZZZZi wysunięciu linii taśmy pozostają w następującym stanie.

                                                                                  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

Przesunięcie głowicy danych w lewo do następnej niezerowej komórki spowoduje pozostawienie jej w bieżącej pozycji, więc komórka pod nią ma wartość 0 i pętla kończy się.

J, 13 bajtów

u:65+>./~i.26

Tłumacz online .

Wyjaśnienie

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 bajtów

1 bajt usunięty dzięki pomysłowi @ beaker,[...,''] aby użyć do konwersji na char.

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

Jest to anonimowa funkcja zwracająca tablicę znaków 2D.

Wypróbuj na Ideone .

Wyjaśnienie

gallery('minij',...) daje macierz, w której każdy wpis jest równy minimum jego indeksów wierszy i kolumn:

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

Jest on obracany o 180 stopni za pomocą rot90(...,2):

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

91-...Operacja daje kody ASCII wielkimi literami:

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

Wreszcie [...,'']łączy się poziomo z pustym łańcuchem. To powoduje konwersję do char.

PowerShell v2 +, 76 52 40 bajtów

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

Pętle od 65do 89. W każdej iteracji tworzymy tablicę za pomocą operatora przecinku, który składa się z bieżącej liczby $_pomnożonej przez zmienną pomocniczą po zwiększeniu $i++, połączoną z tablicą bieżącej liczby $_do 90. Jest to otoczone rzutowaniem tablicy -joinznaków i połączone razem w ciąg. Na przykład dla pierwszej iteracji ta tablica byłaby równoważna 65..90lub całemu alfabetowi. Druga iteracja byłaby 66+66..90lub cały alfabet z Bpowtórzeniem i nie A.

Wszystkie są pozostawione w potoku na końcu programu (jako tablica), a drukowanie na konsoli jest niejawne (domyślna .ToString()tablica jest oddzielona znakiem nowej linii, więc otrzymujemy to za darmo).

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 bajtów

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

czasami zastanawiam się, dlaczego nawet próbuję

edycja: naprawiono

Wypróbuj online

MATL, 10 bajtów

lY2t!2$X>c

Demo online (jeśli masz problemy z tym tłumaczem, wyślij mi ping na czacie MATL . Oto link do TIO na wypadek problemów)

Wyjaśnienie

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 bajtów

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

Bardzo podobny do mojej odpowiedzi na powiązane pytanie .

Zaoszczędzono 2 bajty dzięki @xnor (ponownie)!

Oktawa, 26 bajtów

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

Próbka uruchomiona na ideone .

05AB1E , 9 bajtów

Kod:

AAv¬N×?=¦

Wyjaśnienie:

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.

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

JavaScript ES6, 81 bajtów

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

Nie wymaga wyjaśnień.

R, 56 bajtów

Nie mam za co komentować, ale odpowiedź na @plannapus można nieco pograć w golfa, aby:

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

co daje tę samą wydajność:

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

Chociaż, jeśli dozwolona jest odpowiedź jako macierz ( tj. Jak tutaj ), moglibyśmy zrobić 49 bajtów:

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

R , 42 41 bajtów

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

Wypróbuj online!

Obok najkrótsza R odpowiedź jest wciąż nieco zbyt długo, ponieważ wypisuje wiersz po wierszu. Zastanawiałem się dziś nad innym pytaniem i zdałem sobie sprawę, że możliwe jest znacznie krótsze podejście: generuję macierz naraz za pomocą outeri pmax(maksimum równoległe), a następnie drukuję ją (*) w jednym kroku za pomocą write.

(*) technicznie rzecz biorąc, jest transponowany, ale na szczęście jest symetryczny na przekątnej.

Haskell, 53 46 bajtów

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

Zwraca pojedynczy ciąg z alfabetem L.

przejrzyj znaki iod Ado Zi zrób listę (length ['B'..i])kopii, ipo których następuje [i..'Z']. Łącz elementy z nowymi liniami pośrednimi.

Python 3, 71 65 bajtów

Dzięki @LeakyNun za -6 bajtów

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

Pełny program, który drukuje do STDOUT.

Jak to działa

Przypisujemy kody znaków do liter alfabetu, od 0for Ado 25for Z. Program zapętla się w przedziale [0, 25]z licznikiem linii i, który określa bieżący znak, który ma zostać powtórzony, długość powtarzanej sekcji oraz indeks znaków x. Po wywołaniu max(i,x)wszystkie znaki poniżej powtarzanego znaku są przymocowane do tego samego kodu. Dodanie 65i wywołanie chrkonwertuje wynikowe kody znaków na ich odpowiedniki ASCII; ''.joinłączy znaki i każda linia jest drukowana do STDOUT.

Wypróbuj na Ideone

𝔼𝕊𝕄𝕚𝕟, 12 znaków / 15 bajtów

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

Try it here (Chrome Canary only).

Zasadniczo port mojej odpowiedzi ES6.

R, 54 bajty

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

To rozwiązanie wykorzystuje wbudowaną stałą RLETTERS , która ... no cóż ... wymienia wielkie litery. Istnieje również stała lettersdla małych liter.

C, 78 70 67 bajtów

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

Kod korzysta z następujących technik gry w golfa dla C:

• pomiń podstawowe obejmuje (jak stdio.h)
• pomiń (zwróć) typy funkcji i zmiennych, ustawiając je na domyślne int
• użyj operatora trójskładnikowego zamiast bloków if-else
• użyj kodu ASCII litery zamiast jej reprezentacji char (tj. 65zamiast 'A')
• służy putchardo wyświetlania pojedynczego znaku
• nadużycie listy argumentów main
• służy puts("")do wyświetlania nowej linii

Ponadto reguła If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.nie zabrania wywoływania funkcji z parametrami (dzięki ABcDexter!).

Wypróbuj na Ideone

Wersja bez golfa (bez ostrzeżeń z gcc) wyglądałaby tak:

#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 bajtów

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

To String.lettersza długo: /

Musiałem dodać, .slice(1)ponieważ wiodący nowy wiersz jest niedozwolony

Wyjaśnienie

(|>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 bajtów (niekonkurencyjny)

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

Współpracuje z nocnym oddziałem . Niekonkurencyjne ... smutne jest to, że już miałem zmiany ... po prostu nigdy się nie zobowiązałem; _;