Wyzwanie

Twoim zadaniem jest utworzenie programu lub funkcji, która generuje następujące dane bez danych wejściowych:

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w każdym języku.

05AB1E , 2 bajty

Aƶ

Wypróbuj online!

Zauważ, że dane wyjściowe są listą wierszy, co wyraźnie dozwolone PO. Link używa wersji z ładnym nadrukiem (połączone nowymi liniami).

Jak to działa

• A daje małe litery alfabetu.
• ƶ podnosi alfabet (mnoży każdy element przez jego indeks).
• » dołącza przez nowe linie.

Python 2 , 36 bajtów

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

Wypróbuj online!

APL (Dyalog) , 12 8 5 bajtów ^SBCS

3 bajty zapisane dzięki @ngn

4 bajty zapisane dzięki @ Adám

⍴⍨⌸⎕A

Poprawione wielkie litery OP są poprawne, a także są wyświetlane jako tablica ciągów.

Wypróbuj online!

W jaki sposób?

⌸ daje nam każdą literę w ⎕A alfabecie z jego indeksami, przekazanymi do funkcji ⍴⍨z literą jako lewym argumentem i indeksem es jako prawym argumentem.

⍴⍨podaje prawy argument na długość podaną przez lewy argument. ⍨przełącza lewy i prawy (dlatego jego symbol, wyglądający jak twarz osoby czytającej to objaśnienie).

Haskell , 27 bajtów

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

Wypróbuj online! Zwraca listę wierszy. (Dzięki @totallyhuman za zwrócenie uwagi, że jest to teraz dozwolone)

Wyjaśnienie:

             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"

pieprzenie mózgu , 74 bajty

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

Wypróbuj online!

Wyjaśnienie

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

Wypróbuj online!

Befunge-98 (FBBI) , 27 bajtów

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

gdzie jest znakiem podstawienia (ASCII 26)

Wypróbuj online!

Używa wielkich liter i ma znak nowej linii.

Wyjaśnienie

Kod działa poprzez przechowywanie licznika (początkowo 0) i w każdej pętli:

• 1+ - Zwiększa to o 1
• :0\:: - Pcha rzeczy, aby stos wyglądał tak: bottom [N, 0, N, N, N] top
• '`j'@ - Sprawdza, czy licznik jest większy niż 26
  • j'@- Jeśli tak, przeskakujemy 'i wychodzimy za pomocą@
  • j'@- Jeśli nie, wykonujemy polecenie ', które wypycha wartość ASCII @na stos

Teraz stos wygląda następująco: bottom [N, 0, N, N, 64] top

• +\- Dodaje, a następnie przełącza górną 2: za bottom [N, 0, (N+64), N] top pierwszym razem jest to ASCII 65 lubA
• k:- Duplikuje drugi z najwyższych (N+1)czasów - teraz są (N+2)wartości (N+64)na stosie (plus te Ni 0wcześniej)
• $$- Wyrzuć 2 najwyższe wartości - teraz są tylko Nwartości(N+64)
• >:#,_- Drukuje każdą najwyższą wartość, aż dojdzie do 0- oznacza to, że Nkopie (N+64)są drukowane
• $- Wyrzuca 0- Teraz stos jest sprawiedliwyN
• a, - Drukuje enter

I to się powtarza

Podoba mi się, jak użyłem @obu do zakończenia programu i do dodania do licznika.

Rubin , 32 30 bajtów

-2 bajty dzięki @EricDuminil.

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

Wypróbuj online!

JavaScript (ES6), 54 bajty

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

O.innerText = f()

<pre id=O></pre>

Excel VBA, 38 bajtów

Korzystanie z okna natychmiastowego. :)

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

BASH, 59 54 40 bajtów

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

Wypróbuj online!

dzięki. 5 bajtów na @Justin Mariner

Rubinowy, 38 bajtów

Zwraca tablicę ciągów

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

-5 bajtów dzięki całkowicie ludzkiemu

* -11 bajtów dzięki doskonałemu golfowi Jordana.

V , 9 bajtów

¬az\ÓÎÛäl

Wypróbuj online!

Hexdump:

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

MATL, 9 bytes

2Y2"@X@Y"

Try it online!

Wyjaśnienie

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)

Prints a leading newline (which is allowed).

Try it online!

Jelly,  5  4 bytes

^{sneaky Python implementation abuse}

-1 byte thanks to Adám (outputting a list of lines has been allowed; as, now, has writing a function rather than a program)

Øa×J

A niladic link that returns a list of strings, the lines
(to print it with the newlines as a full program just add Y back in).

Try it online! (the footer calls the link as a nilad (¢) and gets the Python representation of the result (ŒṘ) for clarity as the default full-program behaviour would smash the result together like abbccc...)

How?

Ø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

Try it online!

Uses broadcast multiplication with ones to get a big square 26x26 matrix of the desired letters. Next, the lower triangular part is taken, and implicitly printed.

Also 11 bytes:

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

Javascript, 87 bytes, 72 bytes (A lot of thank to @steenbergh)

My first answer too:

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

Japt, 9 7 bytes

Outputs an array of lines

;C¬Ëp°E

Try it

Explanation

Split (¬) the lowercase alphabet (;C) to an array of characters, map over the array (Ë) and repeat (p) the current element by the current index (E) incremented (°) times.

Pip, 9 bytes

FczPcX++i

Try it online!

In pseudocode, this is

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

where z is preset to the lowercase alphabet and i is preset to 0.

Map-based solutions take one extra byte because they need the -n flag to display on multiple lines:

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

Try it online!

With comments

# 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 thanks to nimi.

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

Try it online!

This is not a snippet, it is a nullary function (one that takes no arguments) that outputs a list of lines which is allowed because of this meta consensus.

R, 38 bytes

A relatively uninteresting answer. Iterate for i from 1 to 26, print the ith letter of the alphabet i times (with an implicit line break).

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

Try it online!

A more interesting approach might be to use something like the following:

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

This gives us all the letters in the right amount, but no linebreaks. Perhaps someone smarter than me can figure out a way to use that to make a golfier answer.

Perl 5, 19 bytes

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

Try it online!

Rust, 82 bytes

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

I had hoped that it would've been a lot shorter, but explicitly converting/casting between types takes a lot of bytes :(

Try it online!

PHP, 47 46 bytes

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

or

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

Run with -nr or try it online.

J, 18 17 bytes

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

Explanation:

              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:

Try it online!

Perl 6,  24  23 bytes

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

Try it

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

Try it

Octave, 25 24 bytes

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

Try it online!

Saved one byte thanks to Giuseppe who informed me that OP allows upper case letters.

Explanation:

Create a vector x with the ASCII-values of the upper case alphabet, and transpose it. Add the negated x (thus 26 zeros, in a row vector, in order to create a grid with (the ASCII-values of):

AAAA
BBBB
CCCC

Take the lower triangular matrix and convert to characters by concatenating with the empty string.

C (gcc), 48 bytes 50 bytes

Re-runnable version, as per cleblanc and Steadybox in the comments below.

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

Try it online!

Japt, 17 16 11 bytes

_{-5 bytes thanks to Oliver}

In ISO-8859-1

;26ÆCgX pXÄ

Not the best score, but I'm still a novice. Any suggestions are very welcome.

Outputs list of lines, as OP allowed. Link contains 3 bytes more for newlines.

Try it 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)