Inspirado por Print a Tabula Recta de George Gibson .

Você deve imprimir / imprimir este texto exato:

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

(Sim, eu digitei isso manualmente)

Você tem permissão para usar todas as letras minúsculas em vez de todas as maiúsculas.

No entanto, sua escolha de caso deve ser consistente em todo o texto.

Regras / Requisitos

• Cada envio deve ser um programa ou função completo. Se for uma função, deve ser executável, bastando adicionar a chamada de função na parte inferior do programa. Qualquer outra coisa (por exemplo, cabeçalhos em C) deve ser incluída.
• Se possível, forneça um link para um site onde seu programa possa ser testado.
• Seu programa não deve escrever nada para STDERR.
• As brechas padrão são proibidas.
• Seu programa pode produzir em qualquer caso, mas deve ser impresso (não uma matriz ou similar).

Pontuação

Os programas são classificados de acordo com os bytes, em UTF-8, por padrão, ou com um conjunto de caracteres diferente de sua escolha.

Eventualmente, a resposta com o mínimo de bytes vencerá.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

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

Cole esta fórmula A1e arraste-a por todo o lado A1:Z26.

Contagem de bytes:

1. A fórmula é 27 bytes.
2. Você precisa copiá-lo 26 ^ 2 vezes. 27 * 26 * 26 = 19604.
3. Eu e outros pensamos que a pontuação deveria ser menor, porque você realmente não precisa digitar a fórmula várias vezes. Agora eu acho que é irrelevante - contamos o tamanho do programa, não o trabalho gasto para escrevê-lo.
4. Para comparação - veja esta resposta JS de 28.187 caracteres - obviamente, alguém o gerou em vez de digitar tudo isso, mas isso não muda seu tamanho.

Vim, 43 bytes

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

Aqui ↵representa Return ( 0x0a) e ♥representa Ctrl-R ( 0x12).

Não é tão curto quanto a minha resposta do Tabula Recta, mas…

Gelatina, 6 bytes

ØA»'j⁷

Experimente aqui. Se eu não tivesse sido preguiçoso ontem e implementado essa alternativa de um byte para j⁷(ingressar em novas linhas)…

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

brainfuck, 103 96 95 91 87 bytes

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

Isso usa a constante de troca cerebral de Esolangs por 64 . Experimente 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/#

Experimente online: Demonstração

Uma linguagem bastante divertida.

Explicação:

Reduza o código para imprimir apenas um quadrado 4x4:

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

A primeira substituição /:/\\\\A/substitui :por \\A. Isto dá:

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

Em seguida, /#/\\Ab\\Ac\\Ad\\A//\\A/substitui #por \Ab\Ac\Ad\A:

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

Agora /\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//substitui cada um \Ano código subsequente por /aAbAcAdA<newline>/a/, portanto, isso resulta em:

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

Agora a primeira parte /A//remove todos os As.

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

Os cinco primeiros caracteres abcd<newline>são impressos. O próximo comando /a/b/substitui apor b, resultando em:

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

Novamente, os cinco primeiros caracteres bbcd<newline>são impressos. O próximo comando /b/c/substitui bpor c:

cccd
/c/d/cccd
/c/

Novamente, os cinco primeiros caracteres cccd<newline>são impressos. O próximo comando /c/d/substitui cpor d:

dddd
/d/

Os cinco primeiros caracteres dddd<newline>são impressos. E o próximo comando /d/está incompleto e, portanto, não faz nada.

Dyalog APL , 11 bytes

⎕A[∘.⌈⍨⍳26]

A[... ]seleciona elementos do alfabeto maiúsculo de acordo com
    ∘.⌈⍨a tabela máxima dos
    ⍳2626 primeiros números inteiros

TryAPL online!

Mathematica, 69 65 57 bytes

^{Salvo 8 bytes devido a @MartinEnder .}

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

Função anônima. Não recebe entrada e retorna uma string como saída. Basicamente, leva apenas char('A' + max(x, y))para todos os x , y de 1 a 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

Experimente online!

Eu usei a mesma técnica para criar isso e para minha /// resposta ao desafio em que ele se baseou . No entanto, tive que corrigir o script CJam porque ele não manipulava corretamente substrings que podem se sobrepor.

Retina , 41 bytes

A contagem de bytes assume a codificação ISO 8859-1. O avanço de linha principal é significativo.

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

Explicação

26$*Z

Defina a sequência para 26 cópias de Z. Em seguida, {...}instrua Retina a executar as duas instruções restantes em um loop até que a corda pare de mudar.

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

Duplique a primeira linha se ela não começar com um A.

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

Este é um estágio de transliteração. É aplicada apenas se a sequência começar com pelo menos duas cópias do mesmo caractere. Nesse caso, todos, exceto o último desses caracteres, são diminuídos. A diminuição ocorre por mapeamento L(alfabeto maiúsculo) para _L(em branco seguido de alfabeto maiúsculo). O "tudo menos o último" é indicado pelo limite -2que informa ao Retina apenas para transliterar todos os caracteres até o penúltimo na partida.

Experimente 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 em Ideone .

R, 58 bytes

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

Graças à precedência do operador, 2:i-1é equivalente a 1:(i-1). Usa a constante interna LETTERSque contém o alfabeto em maiúsculas. Tudo o resto é bastante auto-explicativo.
Uso:

> 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

Experimente online! Marque Debug para ver o código SBIN gerado.

Montagem Sesos

O arquivo binário acima foi gerado montando o seguinte código 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)

Como funciona

Começamos inicializando a fita para ABCDEFGHIJKLMNOPQRSTUVWXYZ. Isto é o seguinte.

Escreva 26 em uma célula, deixando a fita no seguinte estado.

                                                       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

Desde que a célula sob o cabeçalho de dados seja diferente de zero, fazemos o seguinte.

Copie o número para as duas células à esquerda e adicione 64 à cópia mais à esquerda.

                                                   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

Mova a cópia mais à esquerda para o local original e subtraia 1 da cópia mais à direita.

                                                     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

O processo para após 26 iterações, pois a cópia mais à direita é 0 até então. Movemos uma célula para a direita, para que o estado final da fita após a inicialização seja o seguinte.

     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

Agora estamos prontos para gerar a saída, repetindo o processo a seguir até que a célula sob o cabeçalho de dados seja zero.

Primeiro, movemos o conteúdo da célula sob o cabeçalho de dados uma unidade para a esquerda, depois movemos para a esquerda até a última célula com um conteúdo diferente de zero.

   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

Agora, imprimimos todas as células, começando pela célula sob o cabeçalho de dados e movendo-nos para a direita até encontrarmos uma célula 0 , incrementando cada célula impressa após imprimi-la. Após a impressão A, a fita fica da seguinte maneira.

     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

Agora vamos para a direita, novamente imprimindo todas as células até encontrar uma célula 0 . Após a impressão BCDEFGHIJKLMNOPQRSTUVWXYZ, a fita fica da seguinte maneira.

                                                                                  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

Agora, escrevemos 10 na célula atual, imprimimos o caractere correspondente (avanço de linha) e zeramos a célula com uma chamada para getentrada vazia, deixando a fita inalterada.

Finalmente, passamos para o último diferente de zero à esquerda, preparando a fita para a próxima iteração.

        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

A próxima iteração é semelhante. Primeiro movemos 66 uma célula para a esquerda, imprimimos as 66 células ( BB) e aumentamos para 67 , depois imprimimos as células diferentes de zero restantes para a direita ( CDEFGHIJKLMNOPQRSTUVWXYZ) e finalmente colocamos os dados em 67 , deixando a fita da seguinte maneira .

           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

Após mais 24 iterações e após a impressão ZZZZZZZZZZZZZZZZZZZZZZZZZZe avanço de linha, as fitas são deixadas no seguinte estado.

                                                                                  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

Mover o cabeçalho de dados para a esquerda para a próxima célula diferente de zero o deixará em sua posição atual; portanto, a célula abaixo dele é 0 e o loop termina.

J, 13 bytes

u:65+>./~i.26

Intérprete online .

Explicação

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 removido graças à idéia de @ beaker de usar [...,'']para converter para char.

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

Esta é uma função anônima que retorna uma matriz de caracteres 2D.

Experimente em Ideone .

Explicação

gallery('minij',...) fornece uma matriz na qual cada entrada é igual ao mínimo de seus índices de linha e coluna:

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

É girado 180 graus com rot90(...,2):

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

A 91-...operação fornece os códigos ASCII de letras maiúsculas:

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

Finalmente [...,'']concatena horizontalmente com uma sequência vazia. Isso tem o efeito de converter para char.

PowerShell v2 +, 76 52 40 bytes

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

Loops de 65para 89. A cada iteração, estamos construindo uma matriz usando o operador de vírgula que consiste no número atual $_multiplicado pela variável auxiliar pós-incrementada $i++, concatenada com uma matriz do número atual $_para 90. Isso é encapsulado em um elenco de conjunto de caracteres e -joineditado em uma sequência. Por exemplo, para a primeira iteração, essa matriz seria equivalente 65..90ou todo o alfabeto. A segunda iteração seria 66+66..90, ou o alfabeto inteiro com Brepetido e não A.

Todos eles são deixados no pipeline no final do programa (como uma matriz), e a impressão no console é implícita (o padrão .ToString()para uma matriz é separado por nova linha, por isso é gratuito).

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

às vezes me pergunto por que estou tentando

edit: fix it

Experimente online

MATL, 10 bytes

lY2t!2$X>c

Demonstração on-line (se você tiver problemas com esse intérprete, envie um ping para mim no chat do MATL . Além disso, aqui está o link do TIO, caso você tenha problemas)

Explicação

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)

Muito parecido com a minha resposta à pergunta vinculada .

Economizou 2 bytes graças a @xnor (novamente)!

Oitava, 26 bytes

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

Amostra executada em ideone .

05AB1E , 9 bytes

Código:

AAv¬N×?=¦

Explicação:

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.

Usa a codificação CP-1252 . Experimente online! .

Javascript ES6, 81 bytes

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

Auto-explicativo.

R, 56 bytes

Não tenha o representante para comentar, mas a resposta do @plannapus pode ser um pouco reduzida para:

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

resultando na mesma saída:

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

Porém, se a resposta como matriz for permitida ( como aqui ), poderíamos fazer 49 bytes:

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

R , 42 bytes

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

Experimente online!

A próxima resposta R mais curta ainda é um pouco longa, pois imprime linha por linha. Eu estava pensando em outra pergunta hoje mais cedo e percebi que era possível uma abordagem muito mais curta para essa: eu gero a matriz de uma só vez usando outere pmax(máximo paralelo) e depois imprimo (*) em uma etapa com write.

(*) tecnicamente, sua transposição, mas felizmente simétrica em sua diagonal.

Haskell, 53 46 bytes

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

Retorna uma única string com o alfabeto L.

percorra os caracteres ide Apara Ze faça uma lista de (length ['B'..i])cópias iseguidas de [i..'Z']. Junte elementos com novas linhas no meio.

Python 3, 71 65 bytes

Graças a @LeakyNun por -6 bytes

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

Um programa completo que imprime em STDOUT.

Como funciona

Nós atribuir códigos de caracteres para as letras do alfabeto, a partir 0de Apara 25para Z. O programa faz um loop no intervalo [0, 25]com um contador de linha i, que determina o caractere atual a ser repetido e o comprimento da seção repetida, e um índice de caracteres x. Ao chamar max(i,x), todos os caracteres abaixo do caractere repetido são fixados no código do mesmo. Adicionar 65e chamar chrconverte os códigos de caracteres resultantes em seus equivalentes ASCII; ''.joinconcatena os caracteres e cada linha é impressa em STDOUT.

Experimente no Ideone

, 12 caracteres / 15 bytes

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

Try it here (Chrome Canary only).

Basicamente, uma porta da minha resposta ES6.

R, 54 bytes

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

Esta solução usa a constante interna RLETTERS , que ... bem ... lista as letras maiúsculas. Há também a constante letterspara letras minúsculas.

C, 78 70 67 bytes

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

O código utiliza as seguintes técnicas de golfe para C:

• omitir básico inclui (como stdio.h)
• omitir (retornar) tipos de funções e variáveis, tornando-os padrão para int
• use o operador ternário em vez de blocos if-else
• use o código ASCII de uma letra em vez de sua representação char (ou seja, em 65vez de 'A')
• use putcharpara gerar um único caractere
• lista de argumentos do abuso principal
• use puts("")para gerar uma nova linha

Além disso, a regra If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.não proíbe que a função seja chamada com parâmetros (graças ao ABcDexter!).

Experimente no Ideone

Uma versão não gasta (sem nenhum aviso com o gcc) seria assim:

#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;
}

Queijo Cheddar, 90 bytes

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

Isso String.lettersé muito longo: /

Foi necessário adicionar um .slice(1)porque a nova linha principal não é permitida

Explicação

(|>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 (não concorrente)

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

Trabalha com o ramo noturno . Não competir ... a parte triste é que eu já tive as mudanças ... só nunca cometei; _;