Imprimir / imprimir o alfabeto L

65

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.

Freira Furada
fonte
11
Relacionado .
Leaky Nun
5
A saída (como o valor de retorno de uma função) pode ser uma matriz de linhas?
Maçaneta
@ Doorknob eu diria que não.
Leaky Nun
@GeorgeGibson Yes.
Leaky Nun
@LeakyNun É permitida uma nova linha à direita?
Jakube 1/08/16

Respostas:

61

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.
Ugoren
fonte
22
isso me fez rir, você deve postar em sking meta como contar isso
Rohan Jhunjhunwala
19
Uma contagem justa para isso seria 45: (1) digite A1:Z26na caixa de nome (à esquerda da barra de fórmulas) [ 7 bytes]; (2) digite =CHAR(64+MAX(COLUMN(),ROW()))+ enter na barra de fórmulas [ 30 bytes]; (3) digite Alt E I D Alt E I Rpara preencher o intervalo selecionado [ 8 bytes]. Total 7 + 30 + 8 = 45 .
31416 Joffan
8
Não acho que a contagem do preenchimento automático seja uma quantidade menor de bytes. Então, sem dúvida, eu poderia diminuir meu java argumentando que o netbeans era concluído automaticamente. Eu acho que a medida por teclas digitadas 46 teclas digitadas é mais justo
Rohan Jhunjhunwala
3
@rohan Eu, por exemplo, ficaria perfeitamente bem se você chamasse Java + de autocompletar uma linguagem.
John Dvorak
5
@Joffan [A1:Z26]="=CHAR(64+MAX(COLUMN(),ROW()))"é de 40 bytes e ainda é elegante
Anastasiya-Romanova秀
39

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…

insira a descrição da imagem aqui

Lynn
fonte
3
o que. a. inferno. é. esta. esquecido por Deus. Magia.
precisa saber é o seguinte
11
Que página de ajuda você está abrindo? Quando eu faço h<_↵isso me leva a:help at_t
DJMcMayhem
Estou abrindo v_b_<_exampleno Vim 7.4 para Cygwin.
Lynn
@haneefmubarak Sim, é a magia do Vim.
Cromo
28

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.
Lynn
fonte
7
Argh, ninja por alguns minutos ... Essa alternativa não teria ajudado, já que a corrente se bifurcaria.
Dennis
Pergunta estúpida, mas se isso é de 6 bytes, em que conjunto de caracteres está?
Sr. Lister
@ MrLister: adicionei um link para a página de código Jelly no título da resposta.
Lynn
Participar por linefeed é Y.
PurkkaKoodari
@ Pietu1998 Acho Ypós data o desafio embora
caird coinheringaahing
17

brainfuck, 103 96 95 91 87 bytes

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

Isso usa a constante de troca cerebral de Esolangs por 64 . Experimente online!

Dennis
fonte
16

/// , 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.

Jakube
fonte
Porra, isso é inteligente. Bom trabalho. :) Alguma idéia para uma solução nesse sentido para o desafio de tabula recta?
Martin Ender
@MartinEnder Não, ainda não. Vou dar uma olhada à noite. Já estendeu o horário do almoço para uma hora inteira (o dobro do normal) por causa desse desafio.
Jakube
Eu descobri algo (com muita ajuda de suas idéias, especialmente a maneira como você modifica as instruções subseqüentes para processar um personagem após o outro).
Martin Ender
15

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!

Adão
fonte
10

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.

LegionMammal978
fonte
5
Parabéns por 10k!
Loovjo 31/07
9

/// , 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.

Martin Ender
fonte
Eu realmente preciso aprender esse idioma ...
George Gibson
9

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!

Martin Ender
fonte
2
Parabéns por 100k! :)
Yytsi 01/08/16
8

Haskell, 35 bytes

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

Python 2, 59 bytes

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

Teste em Ideone .

Dennis
fonte
7

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
plannapus
fonte
Um novo usuário tem uma sugestão para golf a sua resposta aqui
Kritixi Lithos
7

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.

Dennis
fonte
7

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
Freira Furada
fonte
6

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.

Luis Mendo
fonte
11
Uso muito inteligente degallery
Suever
2
Pena que não gallery('maxij',...), não é ? ;)
Martin Ender
@MartinEnder Totally! :-) BTW, eu estou esperando o builtin Mathematica ...
Luis Mendo
Você espera muito, esse é um desafio baseado em string. : P
Martin Ender
6

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
AdmBorkBork
fonte
6

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

downrep_nation
fonte
Na verdade, eu não porque eu também estou usando o console que exigiria que eu digite System.Console que ninguém faz.
31416 Decreto
considerar a criação j = 97 e i beilieve (char) j + i + "" pode trabalhar e ser mais curto, mas eu só sei java, então eu não tenho certeza
Rohan Jhunjhunwala
j é usado como um deslocamento para o primeiro caractere. se eu fizer j = 97 eu preciso fazer j ++ aswell
downrep_nation
2
O que é triste é que a sua ~ 50% mais do que a solução brainfuck
fyrepenguin
11
Isso não gera a resposta correta quando eu o executo. Você pode adicionar um link para experimentá-lo?
TheLethalCoder
5

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.
Suever
fonte
5

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)!

Cobre
fonte
11
Assim como antes, é mais curto para transformar execem forusar o caráter atual que está sendo iterado: for c in a:a[:i]=[c]*i;i+=1;print'%c'*26%tuple(a).
Xnor
Uau, isso é ótimo: D
ABcDexter 2/16/16
4

Oitava, 26 bytes

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

Amostra executada em ideone .

taça
fonte
Muito agradável! Eu continuo esquecendo o [...,'']truque
Luis Mendo
11
@LuisMendo Realmente economiza apenas 1 byte, mas é chamativo! : D
copo
4

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

Adnan
fonte
4

Javascript ES6, 81 bytes

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

Auto-explicativo.

Mama Fun Roll
fonte
Algo como [... "LETRAS"]. Mapa seria mais curto?
May
Essa foi a minha abordagem original, mas tem 2 bytes a mais.
Mama Fun Roll
Essa foi a abordagem que eu pensei quando vi este desafio
MayorMonty
Geralmente, é melhor usar replaceover mapquando iterando sobre strings char-by-char.
Mama Fun Roll
11
De a.slice(y)onde vem a variável a?
Gcampbell 31/07
4

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})
Nutle
fonte
Eu deixei um comentário sobre a resposta @plannapus redirecionando-o para a sua resposta
Kritixi Lithos
Isso é bom, mas ainda há uma abordagem mais curto
Giuseppe
4

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.

Giuseppe
fonte
3

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.

nimi
fonte
3

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

TheBikingViking
fonte
3

, 12 caracteres / 15 bytes

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

Try it here (Chrome Canary only).

Basicamente, uma porta da minha resposta ES6.

Mama Fun Roll
fonte
Eu não estou conseguindo ZZZZZZZZZZZZZZZ...a linha de fundo. Só conseguindo um Z.
Cwallenpoole
Qual navegador você está usando?
Mama Fun Roll
11
De fato, @cwallenpoole, captura de tela do código em execução no Chrome Canary.
Mama Fun Roll
+1 para se livrar dessa pontuação negativa. Não funciona no Google Chrome, mas funciona no FireFox.
Kevin Cruijssen
Tentei FF também, mas não funcionou. Ah bem. Removido -1.
precisa saber é o seguinte
3

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.

Frédéric
fonte
Estou sendo um pouco exigente, mas isso gera uma matriz, não o texto exato desejado (ou seja, o resultado desejado não deve ter todas as aspas, espaços, nomes de nomes, nomes de colunas etc.).
plannapus
3

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;
}
sigalor
fonte
Salve 8 bytes: f(i,j){for(i=0;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}. Você não precisa de um programa completo, apenas de uma função que execute as mesmas operações sempre que for chamada (o que faz).
Owacoder 01/08/19
@owacoder Obrigado, corrigi-lo.
sigalor
Você pode remover isso i=0;e fazer a chamada de função como f(0,0)?
ABcDexter 2/08/16
11
@ABcDexter Sim, isso deve funcionar (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 parece proibir isso, porque não diz que os parâmetros de tempo para a chamada de função são permitidos). De qualquer forma, deixo que a mainchamada seja feita f(0), porque a inicialização do segundo loop for (aquele com jo contador) é necessária.
Sigalor #
@sigalor Sim, precisamente. Eu estava tentando me em C, mas viu que o seu código é mais curto :)
ABcDexter
3

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; _;

Downgoat
fonte
Eu pensei algo como 65@"90obras para String.letters
Conor O'Brien