La sfida

Il tuo compito è creare un programma o una funzione che produca quanto segue senza input:

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

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua.

05AB1E , 2 byte

Aƶ

Provalo online!

Si noti che ciò genera un elenco di righe, come consentito esplicitamente dall'OP. Il collegamento utilizza una versione con pretty-print (unita da newline).

Come funziona

• A restituisce l'alfabeto minuscolo.
• ƶ solleva l'alfabeto (moltiplica ciascun elemento per il suo indice).
• » si unisce a newline.

Python 2 , 36 byte

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

Provalo online!

APL (Dyalog) , 12 8 5 byte ^SBCS

3 byte salvati grazie a @ngn

4 byte salvati grazie a @ Adám

⍴⍨⌸⎕A

Le lettere maiuscole chiarite OP sono valide, così come l'output come una matrice di stringhe.

Provalo online!

Come?

⌸ci dà ogni lettera nella ⎕Alphabet con i suoi indici in esso, consegnato nella funzione ⍴⍨con la lettera come argomento di sinistra e l'indice ES come argomento di destra.

⍴⍨Resha ⍴ es il suo argomento a destra alla lunghezza fornita dal suo sinistro. ⍨cambia sinistra e destra (quindi il suo simbolo, assomigliando al volto di qualcuno che legge questa spiegazione).

Haskell , 27 byte

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

Provalo online! Restituisce un elenco di righe. (Grazie a @totallyhuman per aver sottolineato che questo è ora consentito)

Spiegazione:

             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 byte

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

Provalo online!

Spiegazione

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

Provalo online!

Befunge-98 (FBBI) , 27 byte

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

dove è un carattere sostitutivo (ASCII 26)

Provalo online!

Utilizza lettere maiuscole e ha una nuova riga finale.

Spiegazione

Il codice funziona memorizzando un contatore (0 inizialmente) e su ogni ciclo:

• 1+ - Incrementa di 1
• :0\:: - Spinge le cose in modo che lo stack assomigli a questo: bottom [N, 0, N, N, N] top
• '`j'@ - Verifica se il contatore è maggiore di 26
  • j'@- Se lo è, saltiamo sopra 'e usciamo@
  • j'@- In caso contrario, eseguiamo il comando ', che inserisce il valore ASCII @nello stack

Ora lo stack è simile al seguente: bottom [N, 0, N, N, 64] top

• +\- Aggiunge, quindi passa in alto 2: bottom [N, 0, (N+64), N] top la prima volta, questo è ASCII 65 oA
• k:- Duplica il secondo dai (N+1)tempi migliori - ora ci sono (N+2)valori di (N+64)nello stack (più i Ne 0dai precedenti)
• $$- Butta via i primi 2 valori - ora ci sono solo Nvalori di(N+64)
• >:#,_- Stampa ogni valore superiore fino a quando non arriva a 0- questo significa che vengono stampate Ncopie di(N+64)
• $- Getta via il 0- Ora lo stack è giustoN
• a, - Stampa un invio

E si ripete

Mi piace come ho usato @entrambi per terminare il programma e per aggiungerli al contatore.

Rubino , 32 30 byte

-2 byte grazie a @EricDuminil.

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

Provalo online!

JavaScript (ES6), 54 byte

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

O.innerText = f()

<pre id=O></pre>

Excel VBA, 38 byte

Utilizzando la finestra immediata. :)

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

BASH, 59 54 40 byte

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

Provalo online!

grazie. 5 byte a @Justin Mariner

Rubino, 38 byte

Restituisce una matrice di stringhe

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

-5 byte grazie a totalmente umano

* -11 byte grazie all'eccellente golf della Giordania.

V , 9 byte

¬az\ÓÎÛäl

Provalo online!

hexdump:

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

MATL , 9 byte

2Y2"@X@Y"

Provalo online!

Spiegazione

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 byte

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

Stampa una nuova riga iniziale (che è consentita).

Provalo online!

Gelatina ,  5  4 byte

^{subdolo abuso dell'implementazione di Python}

-1 byte grazie ad Adám (l'output di un elenco di righe è stato consentito; come, ora, ha la scrittura di una funzione piuttosto che un programma)

Øa×J

Un collegamento niladico che restituisce un elenco di stringhe, le righe
(per stamparlo con le nuove righe come programma completo basta aggiungere Ynuovamente ).

Provalo online! (il piè di pagina chiama il collegamento come nilad (¢) e ottiene la rappresentazione Python del risultato (ŒṘ) per chiarezza poiché il comportamento predefinito del programma completo distruggerebbe il risultato insiemeabbccc...)

Come?

Ø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 byte

2Y2t!g*!YRc

Provalo online!

Utilizza la moltiplicazione broadcast con quelli per ottenere una matrice quadrata grande 26x26 delle lettere desiderate. Successivamente, viene presa la parte triangolare inferiore e viene implicitamente stampata.

Anche 11 byte:

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

Javascript, 87 byte , 72 byte (Mille grazie a @steenbergh)

Anche la mia prima risposta:

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

Japt , 9 7 byte

Emette un array di linee

;C¬Ëp°E

Provalo

Spiegazione

Dividi ( ¬) l'alfabeto minuscolo ( ;C) in una matrice di caratteri, mappa sull'array ( Ë) e ripeti ( p) l'elemento corrente per l'indice corrente ( E) incrementato ( °) volte.

Pip , 9 byte

FczPcX++i

Provalo online!

In pseudocodice, questo è

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

dove zè preimpostato in lettere minuscole ed iè preimpostato su 0.

Le soluzioni basate su mappa richiedono un byte in più perché hanno bisogno che il -nflag sia visualizzato su più righe:

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

Acc !! , 66 byte

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

Provalo online!

Con commenti

# 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 byte

-12 byte grazie a nimi.

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

Provalo online!

Questo non è uno snippet, è una funzione nulla (una che non accetta argomenti) che genera un elenco di righe consentite a causa di questo meta consenso .

R , 38 byte

Una risposta relativamente poco interessante. Scorrere ida 1 a 26, stampare la ilettera th dei itempi alfabetici (con un'interruzione di riga implicita).

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

Provalo online!

Un approccio più interessante potrebbe essere quello di utilizzare qualcosa di simile al seguente:

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

Questo ci dà tutte le lettere nella giusta quantità, ma senza interruzioni di riga. Forse qualcuno più intelligente di me può capire un modo per usarlo per fare una risposta da golfista.

Perl 5 , 19 byte

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

Provalo online!

Ruggine , 82 byte

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

Avevo sperato che sarebbe stato molto più breve, ma la conversione / il cast esplicito tra tipi richiede molti byte :(

Provalo online!

PHP, 47 46 byte

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

o

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

Corri con -nro provalo online .

J , 18 17 byte

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

Spiegazione:

              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:

Provalo online!

Perl 6 ,  24  23 byte

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

Provalo

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

Provalo

Ottava , 25 24 byte

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

Provalo online!

Salvataggio di un byte grazie a Giuseppe che mi ha informato che OP consente lettere maiuscole.

Spiegazione:

Crea un vettore xcon i valori ASCII dell'alfabeto maiuscolo e trasponilo. Aggiungi gli negati x(quindi 26 zeri, in un vettore di riga, per creare una griglia con (i valori ASCII di):

AAAA
BBBB
CCCC

Prendi la matrice triangolare inferiore e converti in caratteri concatenando con la stringa vuota.

C (gcc) , 48 byte 50 byte

Versione riutilizzabile, come da cleblanc e Steadybox nei commenti qui sotto.

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

Provalo online!

Japt, 17 16 11 byte

_{-5 byte grazie a Oliver}

In ISO-8859-1

;26ÆCgX pXÄ

Non è il miglior punteggio, ma sono ancora alle prime armi. Qualsiasi suggerimento è molto gradito.

Elenco delle righe di output, come consentito dall'OP. Il collegamento contiene 3 byte in più per le newline.

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