El reto

Su tarea es crear un programa o función que genere lo siguiente sin 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

Tanteo

Este es el código de golf , por lo que gana la respuesta más corta en cada idioma.

05AB1E , 2 bytes

Aƶ

Pruébalo en línea!

Tenga en cuenta que esto se muestra como una lista de líneas, como lo permite explícitamente el OP. El enlace utiliza una versión con letra bonita (unida por líneas nuevas).

Cómo funciona

• A produce el alfabeto en minúsculas.
• ƶ levanta el alfabeto (multiplica cada elemento por su índice).
• » se une por nuevas líneas.

Python 2 , 36 bytes

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

Pruébalo en línea!

APL (Dyalog) , 12 8 5 bytes ^SBCS

3 bytes guardados gracias a @ngn

4 bytes guardados gracias a @ Adám

⍴⍨⌸⎕A

Las letras mayúsculas clarificadas por OP son válidas, así como las salidas como una matriz de cadenas.

Pruébalo en línea!

¿Cómo?

⌸nos da todas las letras del ⎕Aalfabeto con sus índices, entregados a la función ⍴⍨con la letra como argumento izquierdo y el índice es como argumento derecho.

⍴⍨resha ⍴ es su argumento de la derecha a la longitud suministrada por su izquierda. ⍨cambia la izquierda y la derecha (por lo tanto, el símbolo de la misma, se parece a la cara de alguien que lee esta explicación).

Haskell , 27 bytes

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

Pruébalo en línea! Devuelve una lista de líneas. (Gracias a @totallyhuman por señalar que esto ahora está permitido)

Explicación:

             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

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

Pruébalo en línea!

Explicación

++++++++[>+>+++>++++++++++++<<<-]>++>++>+>+
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        <<.
                        >]

Pruébalo en línea!

Befunge-98 (FBBI) , 27 bytes

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

donde es un carácter de sustitución (ASCII 26)

Pruébalo en línea!

Utiliza letras mayúsculas y tiene una nueva línea final.

Explicación

El código funciona almacenando un contador (0 inicialmente) y en cada bucle:

• 1+ - Incrementa en 1
• :0\:: - Empuja cosas para que la pila se vea así: bottom [N, 0, N, N, N] top
• '`j'@ - Comprueba si el contador es mayor que 26
  • j'@ - Si es así, saltamos sobre el ' y usando@
  • j'@- Si no es así, ejecutamos el ', que empuja el valor ASCII @a la pila

Ahora la pila se ve así: bottom [N, 0, N, N, 64] top

• +\ - Agrega, luego cambia los 2 principales: bottom [N, 0, (N+64), N] top la primera vez, esto es ASCII 65, oA
• k:- Duplica el segundo de los mejores (N+1)tiempos: ahora hay (N+2)valores de (N+64)en la pila (más el Ny0 de antes)
• $$ - Deseche los 2 valores principales: ahora solo hay N valores de(N+64)
• >:#,_- Imprime cada valor superior hasta llegar a un 0- esto significa Ncopias de(N+64) obtener impreso
• $ - Tira la 0 - Ahora la pila es soloN
• a, - Imprime una entrada

Y se repite

Me gusta cómo usé @ambos para terminar el programa y para agregar al contador.

rubí , 32 30 bytes

-2 bytes gracias a @EricDuminil.

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

Pruébalo en línea!

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 la Ventana Inmediata. :)

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

BASH, 59 54 40 bytes

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

Pruébalo en línea!

Gracias. 5 bytes a @Justin Mariner

Rubí, 38 bytes.

Devuelve una matriz de cadenas

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

-5 bytes gracias a totalmente humano

* -11 bytes gracias a algunos excelentes campos de golf de Jordan.

V , 9 bytes

¬az\ÓÎÛäl

Pruébalo en línea!

Hexdump:

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

MATL , 9 bytes

2Y2"@X@Y"

Pruébalo en línea!

Explicación

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 una nueva línea inicial (que está permitida).

Pruébalo en línea!

Jalea ,  5  4 bytes

^{abuso de implementación furtiva de Python}

-1 byte gracias a Adám (la salida de una lista de líneas se ha permitido; ya que ahora tiene una función de escritura en lugar de un programa)

Øa×J

Un enlace niládico que devuelve una lista de cadenas, las líneas
(para imprimirlo con las nuevas líneas como un programa completo, solo agregue Ynuevamente ).

Pruébalo en línea! (el pie de página llama al enlace como nilad (¢) y obtiene la representación de Python del resultado (ŒṘ) para mayor claridad ya que el comportamiento predeterminado del programa completo aplastaría el resultado comoabbccc...)

¿Cómo?

Ø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

Pruébalo en línea!

Utiliza la multiplicación de difusión con unos para obtener una matriz cuadrada grande de 26x26 de las letras deseadas. A continuación, se toma la parte triangular inferior y se imprime implícitamente.

También 11 bytes:

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

Javascript, 87 bytes , 72 bytes (Muchas gracias a @steenbergh)

Mi primera respuesta también:

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

Japt , 9 7 bytes

Emite una matriz de líneas

;C¬Ëp°E

Intentalo

Explicación

Divide ( ¬) el alfabeto en minúsculas ( ;C) en una matriz de caracteres, mapea sobre la matriz ( Ë) y repite ( p) el elemento actual por el índice actual ( E) incrementado ( °) veces.

Pip , 9 bytes

FczPcX++i

Pruébalo en línea!

En pseudocódigo, esto es

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

donde zestá preestablecido al alfabeto en minúscula yi está preestablecido a 0.

Las soluciones basadas en mapas toman un byte adicional porque necesitan que el -nindicador se muestre en varias líneas:

{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
}

Pruébalo en línea!

Con comentarios

# 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 gracias a nimi.

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

Pruébalo en línea!

Esto no es un fragmento, es una función nula (una que no toma argumentos) que genera una lista de líneas que está permitida debido a este meta consenso .

R , 38 bytes

Una respuesta relativamente poco interesante. Itere ide 1 a 26, imprima la iletra de la letra del alfabeto iveces (con un salto de línea implícito).

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

Pruébalo en línea!

Un enfoque más interesante podría ser usar algo como lo siguiente:

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

Esto nos da todas las letras en la cantidad correcta, pero sin saltos de línea. Quizás alguien más inteligente que yo pueda encontrar una manera de usar eso para dar una respuesta más golfista.

Perl 5 , 19 bytes

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

Pruébalo en línea!

Óxido , 82 bytes

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

Tenía la esperanza de que hubiera sido mucho más corto, pero la conversión / conversión explícita entre tipos requiere muchos bytes :(

Pruébalo en línea!

PHP, 47 46 bytes

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

o

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

Ejecutar -nro probarlo en línea .

J , 18 17 bytes

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

Explicación:

              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:

Pruébalo en línea!

Perl 6 ,  24  23 bytes

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

Intentalo

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

Intentalo

Octava , 25 24 bytes

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

Pruébalo en línea!

Ahorré un byte gracias a Giuseppe, quien me informó que OP permite letras mayúsculas.

Explicación:

Cree un vector xcon los valores ASCII del alfabeto en mayúsculas y transpórtelo. Agregue el negado x(por lo tanto, 26 ceros, en un vector de fila, para crear una cuadrícula con (los valores ASCII de):

AAAA
BBBB
CCCC

Tome la matriz triangular inferior y conviértala en caracteres concatenando con la cadena vacía.

C (gcc) , 48 bytes 50 bytes

Versión re-ejecutable, según cleblanc y Steadybox en los comentarios a continuación.

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

Pruébalo en línea!

Japt, 17 16 11 bytes

_{-5 bytes gracias a Oliver}

En ISO-8859-1

;26ÆCgX pXÄ

No es el mejor puntaje, pero sigo siendo un novato. Cualquier sugerencia es muy bienvenida.

Lista de salidas de líneas, según OP permitido. El enlace contiene 3 bytes más para líneas nuevas.

Pruébalo en línea!

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