O desafio

Sua tarefa é criar um programa ou função que produza o seguinte sem entrada:

a
bb
ccc
dddd
eeeee
ffffff
ggggggg
hhhhhhhh
iiiiiiiii
jjjjjjjjjj
kkkkkkkkkkk
llllllllllll
mmmmmmmmmmmmm
nnnnnnnnnnnnnn
ooooooooooooooo
pppppppppppppppp
qqqqqqqqqqqqqqqqq
rrrrrrrrrrrrrrrrrr
sssssssssssssssssss
tttttttttttttttttttt
uuuuuuuuuuuuuuuuuuuuu
vvvvvvvvvvvvvvvvvvvvvv
wwwwwwwwwwwwwwwwwwwwwww
xxxxxxxxxxxxxxxxxxxxxxxx
yyyyyyyyyyyyyyyyyyyyyyyyy
zzzzzzzzzzzzzzzzzzzzzzzzzz

Pontuação

Isso é código-golfe , então a resposta mais curta em cada idioma vence.

05AB1E , 2 bytes

Aƶ

Experimente online!

Observe que isso gera como uma lista de linhas, conforme o OP explicitamente permitido. O link usa uma versão com impressão bonita (unida por novas linhas).

Como funciona

• A produz o alfabeto em minúsculas.
• ƶ levanta o alfabeto (multiplica cada elemento pelo seu índice).
• » junta-se por novas linhas.

Python 2 , 36 bytes

i=1
exec'print chr(i+96)*i;i+=1;'*26

Experimente online!

APL (Dyalog) , 12 8 5 bytes ^SBCS

3 bytes salvos graças a @ngn

4 bytes salvos graças a @ Adám

⍴⍨⌸⎕A

As letras maiúsculas esclarecidas OP são válidas, assim como a saída como uma matriz de strings.

Experimente online!

Quão?

⌸nos fornece todas as letras do ⎕Aalfabeto com seus índices, entregues à função ⍴⍨com a letra como argumento à esquerda e o índice es como argumento à direita.

⍴⍨Resha ⍴ es seu argumento direito do comprimento fornecido pela sua esquerda. ⍨alterna a esquerda e a direita (portanto, o símbolo dela, parecendo o rosto de alguém lendo esta explicação).

Haskell , 27 bytes

[c<$['a'..c]|c<-['a'..'z']]

Experimente online! Retorna uma lista de linhas. (Obrigado a @totallyhuman por apontar que isso agora é permitido)

Explicação:

             c<-['a'..'z']  -- for each character c from 'a' to 'z'
[           |c<-['a'..'z']] -- build the list of
[   ['a'..c]|c<-['a'..'z']] -- the lists from 'a' to c, e.g. "abcd" for c='d'
[c<$['a'..c]|c<-['a'..'z']] -- with each element replaced by c itself, e.g. "dddd"

brainfuck , 74 bytes

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

Experimente online!

Explicação

++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+
TAPE:
  000
  010   C_NEWLINE
  026   V_ITERCOUNT
  097   V_ALPHA
 >001<  V_PRINTCOUNT
  000   T_PRINTCOUNT

V_ITERCOUNT TIMES:      <<[-   

  V_PRINTCOUNT TIMES:     >>[-
    INC T_PRINTCOUNT        >+
    OUTPUT V_ALPHA          <<.
                          >]

  RESTORE V_PRINTCOUNT    >[-<+>]
  INC V_PRINTCOUNT        <+
  INC V_ALPHA             <+
  OUTPUT C_NEWLINE        <<.
                        >]

Experimente online!

Befunge-98 (FBBI) , 27 bytes

1+:0\::'`j'@+\k:$$>:#,_$a,

onde é um caractere de substituição (ASCII 26)

Experimente online!

Usa letras maiúsculas e tem uma nova linha à direita.

Explicação

O código funciona armazenando um contador (0 inicialmente) e em cada loop:

• 1+ - Incrementa em 1
• :0\:: - Empurra as coisas para que a pilha fique assim: bottom [N, 0, N, N, N] top
• '`j'@ - Verifica se o contador é maior que 26
  • j'@- Se for, pulamos e saímos 'usando@
  • j'@- Caso contrário, executamos o ', que envia o valor ASCII @para a pilha

Agora a pilha fica assim: bottom [N, 0, N, N, 64] top

• +\- Adiciona e depois alterna entre as 2 principais: na bottom [N, 0, (N+64), N] top primeira vez, é ASCII 65 ouA
• k:- Duplicatas a segunda das principais (N+1)vezes - agora há (N+2)valores de (N+64)na pilha (mais o Ne 0de mais cedo)
• $$- Jogue fora os 2 principais valores - agora existem apenas Nvalores de(N+64)
• >:#,_- Imprime cada valor máximo até chegar a 0- isso significa Ncópias de (N+64)impressões
• $- Joga fora o 0- Agora a pilha é apenasN
• a, - Imprime uma entrada

E repete

Eu gosto de como usei os @dois para finalizar o programa e adicionar ao contador.

Ruby , 32 30 bytes

-2 bytes graças a @EricDuminil.

27.times{|n|puts (n+96).chr*n}

Experimente online!

JavaScript (ES6), 54 bytes

f=(n=9)=>++n<36?n.toString(36).repeat(n-9)+`
`+f(n):''

O.innerText = f()

<pre id=O></pre>

Excel VBA, 38 bytes

Usando a janela imediata. :)

[A1:A26]="=REPT(CHAR(96+ROW()),ROW())"

BASH, 59 54 40 bytes

for l in {a..z};{
a+=a
echo ${a//a/$l}
}

Experimente online!

THX. 5 bytes para @Justin Mariner

Ruby, 38 bytes

Retorna uma matriz de strings

->{(a=*?a..?z).map{|x|x*-~a.index(x)}}

-5 bytes graças a totallyhuman

* -11 bytes graças a um excelente golfe da Jordânia.

V , 9 bytes

¬az\ÓÎÛäl

Experimente online!

Hexdump:

00000000: ac61 7a5c d3ce dbe4 6c                   .az\....l

MATL , 9 bytes

2Y2"@X@Y"

Experimente online!

Explicação

2Y2     % Push string 'abc...z'
"       % For char in that string each
  @     %   Push current char
  X@    %   Push iteration index (1-based)
  Y"    %   Run-length decoding: repeat char that many times
        % Implicit end. Implicit display

Python 3 , 37 bytes

for k in range(27):print(chr(k+96)*k)

Imprime uma nova linha inicial (o que é permitido).

Experimente online!

Geléia ,  5  4 bytes

^{abuso sorrateiro de implementação de Python}

-1 byte graças a Adám (a saída de uma lista de linhas foi permitida; como, agora, está escrevendo uma função em vez de um programa)

Øa×J

Um link niládico que retorna uma lista de strings, as linhas
(para imprimi-lo com as novas linhas como um programa completo, basta adicionar Ynovamente ).

Experimente online! (o rodapé chama o link como nilad (¢) e obtém a representação em Python do resultado (ŒṘ) para maior clareza, pois o comportamento padrão do programa completo esmagaria o resultado como se fosseabbccc...)

Quão?

Øa×J - main link: no arguments
Øa   - yield the alphabet = ['a','b','c',...,'z']
   J - range of length    = [1,2,3,...,26]
  ×  - multiplication     = ["a","bb","ccc",...,"zzzzzzzzzzzzzzzzzzzzzzzzzz"]
     - (Python multiplication lengthens chars to strings - not usually a Jelly thing)

MATL , 11 bytes

2Y2t!g*!YRc

Experimente online!

Utiliza a multiplicação de difusão com uns para obter uma grande matriz quadrada 26x26 das letras desejadas. Em seguida, a parte triangular inferior é obtida e impressa implicitamente.

Também 11 bytes:

2Y2!t~!+YRc  % Using broadcast addition with zeroes
2Y2!l26X"YR  % Using 'repmat'

Javascript, 87 bytes , 72 bytes (Muito obrigado a @steenbergh)

Minha primeira resposta também:

for(i=1,j=97;j<123;){console.log(String.fromCharCode(j++).repeat(i++))};

Japonês , 9 7 bytes

Produz uma matriz de linhas

;C¬Ëp°E

Tente

Explicação

Divida ( ¬) o alfabeto em minúsculas ( ;C) em uma matriz de caracteres, mapeie sobre a matriz ( Ë) e repita ( p) o elemento atual pelo índice atual ( E) incrementado ( °) vezes.

Pip , 9 bytes

FczPcX++i

Experimente online!

No pseudocódigo, isso é

For-each c in z
    Print (c string-multiply ++i)

onde zé predefinido para o alfabeto em minúsculas e ié predefinido para 0.

As soluções baseadas em mapas usam um byte extra porque precisam que o -nsinalizador seja exibido em várias linhas:

{aX++i}Mz
B X_+1MEz

Acc !! , 66 bytes

Count i while 26-i {
Count j while i+1-j {
Write 97+i
}
Write 10
}

Experimente online!

Com comentários

# Loop i from 0 to 25
Count i while 26-i {
    # Loop j from 0 to i (inclusive)
    Count j while i+1-j {
        # Print a letter
        Write 97+i
    }
    # Print a newline
    Write 10
}

Haskell , 31 bytes

-12 bytes graças a nimi.

zipWith replicate[1..26]['a'..]

Experimente online!

Este não é um trecho, é uma função nula (que não aceita argumentos) que gera uma lista de linhas permitidas devido a esse meta consenso .

R , 38 bytes

Uma resposta relativamente desinteressante. Itere ide 1 a 26, imprima a iletra th dos itempos do alfabeto (com uma quebra de linha implícita).

for(i in 1:26)print(rep(letters[i],i))

Experimente online!

Uma abordagem mais interessante pode ser usar algo como o seguinte:

cat(letters[(1:351*2)^.5+.5])

Isso nos dá todas as letras na quantidade certa, mas não há quebras de linha. Talvez alguém mais esperto que eu possa descobrir uma maneira de usá-la para obter uma resposta mais eficiente.

Perl 5 , 19 bytes

say$_ x++$"for a..z

Experimente online!

Ferrugem , 82 bytes

||for i in 1..27u8{println!("{}",((i+96) as char).to_string().repeat(i as usize))}

Eu esperava que fosse muito mais curto, mas a conversão / conversão explícita entre tipos requer muitos bytes :(

Experimente online!

PHP, 47 46 bytes

for($c=a;$i<26;)echo"
",str_pad($c,++$i,$c++);

ou

for($c=a;$i<26;)echo str_pad("
",++$i+1,$c++);

Corra com -nrou experimente online .

J , 18 17 bytes

a.{~(#"0+&96)i.27

Explicação:

              i.27      - list of integers 0 - 26
     (   +&96)          - adds 96 to the above list (starting offset of 'a')
      #"0               - copies the right argument left argument times  
  {~                    - select items from a list (arguments reversed)
a.                      - the whole alphabet


#"0 +&96 is a hook, which means that at first +96 is applied to the list i.27,
resulting in a list 96, 97, 98... 122, then #"0 is applied to this result. 
So it is evaluated as ((i.27)#"0(96+i.27)){a:

Experimente online!

Perl 6 ,  24  23 bytes

.say for 'a'..'z'Zx 1..*

Tente

.say for 'a'..*Zx 1..26

Tente

Oitava , 25 24 bytes

['',tril((x=65:90)'+~x)]

Experimente online!

Economizei um byte graças a Giuseppe, que me informou que o OP permite letras maiúsculas.

Explicação:

Crie um vetor xcom os valores ASCII do alfabeto maiúsculo e transponha-o. Adicione o negado x(assim, 26 zeros, em um vetor de linha, para criar uma grade com (os valores ASCII de):

AAAA
BBBB
CCCC

Pegue a matriz triangular inferior e converta em caracteres concatenando com a sequência vazia.

C (gcc) , 48 bytes 50 bytes

Versão re-executável, conforme cleblanc e Steadybox nos comentários abaixo.

s[9];main(i){for(;i<27;)puts(memset(s,i+95,i++));}

Experimente online!

Japonês, 17 16 11 bytes

_{-5 bytes graças a Oliver}

Na ISO-8859-1

;26ÆCgX pXÄ

Não é a melhor pontuação, mas ainda sou um novato. Todas as sugestões são bem-vindas.

Lista de linhas de saída, conforme OP permitido. O link contém mais 3 bytes para novas linhas.

Experimente online!

;                      - Use string variables
 26                    - Literal 26
   Æ                   - For range 0..26
    C                  - Alphabet
     gX                -         . character at index X
        pXÄ            - Duplicate X+1 times
                       - End function (implicit)