Dado que no hay entrada, envíe este patrón alfabético interesante en cualquier caso (el caso tiene que ser consistente) a través de un método de salida aceptado :

UNA
AB
ACBC
ADBDCD
AEBECEDE
AFBFCFDFEF
AGBGCGDGEGFG
AHBHCHDHEHFHGH
AIBICIDIEIFIGIHI
AJBJCJDJEJFJGJHJIJ
AKBKCKDKEKFKGKHKIKJK
ALBLCLDLELFLGLHLILJLKL
AMBMCMDMEMFMGMHMIMJMKMLM
ANBNCNDNENFNGNHNINJNKNLNMN
AOBOCODOEOFOGOHOIOJOKOLOMONO
APBPCPDPEPFPGPHPIPJPKPLPMPNPOP
AQBQCQDQEQFQGQHQIQJQKQLQMQNQOQPQ
ARBRCRDRERFRGRHRIRJRKRLRMRNRORPRQR
ASBSCSDSESFSGSHSISJSKSLSMSNSOSPSQSRS
ATBTCTDTETFTGTHTITJTKTLTMTNTOTPTQTRTST
AUBUCUDUEUFUGUHUIUJUKULUMUNUOUPUQURUSUTU
AVBVCVDVEVFVGVHVIVJVKVLVMVNVOVPVQVRVSVTVUV
AWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVW
AXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWX
AYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPYQYRYSYTYUYVYWYXY
AZBZCZDZEZFZGZHZIZJZKZLZMZNZOZPZQZRZSZTZUZVZWZXZYZ

Los espacios finales y las nuevas líneas son aceptables, las lagunas estándar no están permitidas, y esto resulta ser un código de golf , por lo que gana la respuesta más corta en bytes.

Lienzo , 7 bytes.

Ｚ［Ｋ＊¹＋］

Pruébalo aquí!

Explicación:

Ｚ［     ］ for each prefix of the uppercase alphabet
    Ｋ        pop off the last letter
     ＊       and join the rest of the string with that character
      ¹＋     and append the current iterated character to it

Jalea , 9 bytes

ØAjṪ$Ƥż¹Y

Pruébalo en línea!

Cómo funciona

ØAjṪ$Ƥż¹Y  Main link. No arguments.

ØA         Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
     Ƥ     Map the link to the left over all prefixes, i.e., ["A", "AB", ...].
    $        Combine the two links to the left into a chain.
   Ṫ           Tail; yield and remove the last letter of each prefix.
  j            Join the remainder, using that letter as separator.
      ż¹   Zip the resulting strings and the letters of the alphabet.
        Y  Separate the results by linefeeds.

C, 82 bytes

f(i,j){for(i=!puts("A");++i<26;puts(""))for(j=0;j++<i*2;)putchar(65+(j&1?j/2:i));}

Pruébalo en línea!

R , 50 bytes

l=LETTERS
for(i in 0:25)cat(l[0:i],"
",sep=l[i+1])

Pruébalo en línea!

Quizás la parte más inteligente aquí es usar letters[0]la cadena vacía cat(character(0),'\n',sep="A")para imprimir la primera línea.

Carbón de leña , 9 bytes

Ｅα⁺⪫…ακιι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 α          Predefined uppercase alphabet
Ｅ           Map over each character
    …ακ     Get current prefix of alphabet
   ⪫   ι    Join with current character
  ⁺     ι   Append current character
            Implicitly print on separate lines

Python 2 , 56 bytes

n=65;s='';exec'c=chr(n);print c.join(s)+c;s+=c;n+=1;'*26

Pruébalo en línea!

6502 rutina de código de máquina (C64), 39 bytes

A9 41 20 D2 FF AA A8 84 FB E4 FB B0 0B 8A 20 D2 FF 98 20 D2 FF E8 D0 F1 A9 0D
20 D2 FF A2 41 C0 5A F0 03 C8 D0 E1 60

Subrutina de código de máquina independiente de la posición, clobbers A, X e Y.

Demostración en línea

La demostración se carga a las $C000, así que úsela SYS49152para llamar a la rutina.

Desmontaje comentado:

A9 41       LDA #$41            ; 'A'
20 D2 FF    JSR $FFD2           ; Kernal CHROUT (output character)
AA          TAX                 ; copy to X (current pos)
A8          TAY                 ; copy to Y (current endpos)
  .outerloop:
84 FB       STY $FB             ; endpos to temporary
  .innerloop:
E4 FB       CPX $FB             ; compare pos with endpos
B0 0B       BCS .eol            ; reached -> do end of line
8A          TXA                 ; current pos to accu
20 D2 FF    JSR $FFD2           ; and output
98          TYA                 ; endpos to accu
20 D2 FF    JSR $FFD2           ; and output
E8          INX                 ; next character
D0 F1       BNE .innerloop      ; (repeat)
  .eol:
A9 0D       LDA #$0D            ; load newline
20 D2 FF    JSR $FFD2           ; and output
A2 41       LDX #$41            ; re-init current pos to 'A'
C0 5A       CPY #$5A            ; test endpos to 'Z'
F0 03       BEQ .done           ; done when 'Z' reached
C8          INY                 ; next endpos
D0 E1       BNE .outerloop      ; (repeat)
  .done:
60          RTS

Java 8, 93 91 90 bytes

v->{String t="";for(char c=64;++c<91;t+=c)System.out.println(t.join(c+"",t.split(""))+c);}

-1 byte gracias a @ OlivierGrégoire imprimiendo directamente en lugar de devolver

Explicación:

Pruébalo en línea.

v->{                     // Method with empty unused parameter and String return-type
  String t="";           //  Temp-String, starting empty
  for(char c=64;++c<91;  //  Loop over the letters of the alphabet:
      t+=c)              //    After every iteration: append the letter to the temp-String
    System.out.println(  //   Print with trailing new-line:
       r.join(c+"",t.split(""))
                         //    The temp-String with the current letter as delimiter
       +c);}             //    + the current letter as trailing character 

SNOBOL4 (CSNOBOL4) , 169 143 bytes

i &ucase len(x) . r len(1) . s
 o =
 i =
t r len(i) len(1) . k :f(o)
 o =o s k
 i =i + 1 :(t)
o o s =
 output =o s
 x =lt(x,25) x + 1 :s(i)
end

Pruébalo en línea!

i &ucase len(x) . r len(1) . s	;* set r to the first x characters and s to the x+1th.
 o =				;* set o,i to empty string
 i =
t r len(i) len(1) . k :f(o)	;* set k to the ith letter of r. on failure (no match), go to o.
 o =o s k			;* concatenate o,s,k
 i =i + 1 :(t)			;* increment i, goto t
o o s =				;* remove the first occurrence of s (the first character for x>1, and nothing otherwise)
 output =o s			;* output o concatenated with s
 x =lt(x,25) x + 1 :s(i)	;* increment x, goto i if x<25.
end

El problema aquí es la primera línea.

el uso o s kagregará un scarácter de separador adicional al comienzo de cada línea y tampoco tendrá uno sal final. Esto está bien porque la línea tsaltará sobre las siguientes dos líneas cuando x=0. Esto significa que otodavía estará en blanco. Por lo tanto, o s =eliminaremos el primer scarácter de o, y luego simplemente podremos imprimir o spara tener el último apropiado s.

JavaScript (ES6), 81 bytes

f=
_=>[..."ABCDEFGHIJKLMNOPQRSTUVWXYZ"].map((c,i,a)=>a.slice(0,i).join(c)+c).join`
`
;document.write('<pre>'+f());

Ahorre 9 bytes si el valor de retorno de una matriz de cadenas es aceptable.

Japt ( -Rbandera), 14 12 bytes

-2 bytes gracias a @Shaggy

;B¬
ËiU¯E qD

¡Pruébelo en línea!

Haskell , 49 48 bytes

'A':unlines[init['A'..x]>>=(:[x])|x<-['A'..'Z']]

Pruébalo en línea!

Editar: -1 byte gracias a totalmente humano!

PowerShell , 56 bytes

"A";65..89|%{([char[]](65..$_)-join[char]++$_)+[char]$_}

Pruébalo en línea!

Bucles 65a 89, cada iteración construye una charmatriz 65con el número actual $_, luego -joinune esa matriz en una cadena con el siguiente carácter, luego agrega ese carácter al final.

Cambie el 89a otro número ASCII para ver mejor el comportamiento.

> <> , 44 34 bytes

"BA"oao"ZA"\=?;1+40.
o1+:{::o}=?\:

Pruébalo en línea!

> <> , 44 bytes

"A"o10ao\55*=?;1+40.
1+:{:}=?\:"A"+o{:}"A"+o

Pruébalo en línea!

Como uso una ruta diferente para producir el resultado, publiqué mi propia respuesta> <>; La otra respuesta> <> se puede encontrar aquí.

Muchas gracias a Jo King por ver que no necesitaba seguir poniendo "A" en la pila si solo lo comparaba con "Z" en lugar de 26. (-10 bytes)

Explicación

La explicación seguirá el flujo del código.

"BA"                 : Push "BA" onto the stack;
                       [] -> [66, 65]
    oao              : Print the stack top then print a new line;
                       [66, 65] -> [66]
       "ZA"\         : Push "ZA" onto the stack then move down to line 2;
                       [66, 90, 65]
o          \:        : Duplicate the stack top then print
 1+:                 : Add one to the stack top then duplicate;
                       [66, 90, 65, 65]
    {::              : Shift the stack right 1 place then duplicate the stack top twice;
                       [90, 65, 65, 66, 66]
       o}            : Print the stack top then shift the stack left 1 place;
                       [66, 90, 65, 65, 66]
         =?\         : Comparison for equality on the top 2 stack items then move to line 1 if equal otherwise continue on line 2;
                       [66, 90, 65]
           \=?;      : Comparison for equality on the top 2 stack items then quit if equal else continue on line 1;
                       [66]
               1+    : Add 1 to the stack top;
                       [67]
                 40. : Move the code pointer to column 4 row 0 of the code box and continue execution of code. 

Jalea , 12 bytes

ØA;\;€Ṫ$€YFḊ

Pruébalo en línea!

Bah acaba de entender ØAjṪ$ƤżØAYcuál es un paso entre esto y la solución ya publicada de Dennis: /

Pyth , 13 bytes

+\ajmPjedd._G

Pruébalo aquí! , alternativa

Sin aembargo, ese liderazgo ...

Jalea , 13 bytes

ØA¹Ƥ+"¹Ṗ€Yṭ”A

Pruébalo en línea!

Explicación

ØA¹Ƥ+"¹Ṗ€Yṭ”A  Main Link
ØA              Uppercase Alphabet
  ¹Ƥ            Prefixes
    +"¹         Doubly-vectorized addition to identity (uppercase alphabet) (gives lists of lists of strings)
       Ṗ€      a[:-1] of each (get rid of the double letters at the end)
         Y     Join on newlines
          ṭ”A  "A" + the result

abusa parcialmente de la forma en que las cadenas y las listas de personajes difieren en Jelly

Python 2 , 92 86 79 75 64 bytes

s=map(chr,range(65,91))
for d in s:print d.join(s[:ord(d)-65])+d

Pruébalo en línea!

11 bytes gracias a Rod.

APL + WIN, 51 bytes

⍎∊'a←⎕av[65+⍳26]⋄a[n←1]',25⍴⊂'⋄,⊃a[⍳n-1],¨a[n←n+1]'

Explicación:

a←⎕av[65+⍳26] create a vector of upper case letters

a[n←1] first A

25⍴⊂'⋄,⊃a[⍳n-1],¨a[n←n+1]' create an implicit loop to concatenate subsequent letters

> <> , 47 bytes

d2*:1-v
-&$:?!\$:&$:1
1-:?!v\69*-$1-:
+*88~< 1o

Pruébalo en línea!

Cómo funciona:

d2*:1-v Initialise the stack with 26 (outer loop counter) and 26-1 (inner loop counter)
....
....
....

....
-&$:?!\$:&$:1 Repeatedly make copies of both counters
....          And decrement the inner loop counter
....          Go to third line when inner loop counter is 0

....            Add -54 to the stack (for the newline) and decrement the outer loop counter
....            Initialise the inner loop counter as outer-1
1-:?!v\69*-$1-: If the inner counter is 0, go to the fourth line, else back to the second.
....

....
....      
....      Transform numbers and -54s into letters and newlines by adding 64
+*88~< 1o Output each character until it runs out of stack and errors

Acc !! 84 bytes

Esto es realmente lo que inspiró este desafío:

Write 65
Count i while i-26 {
Count b while b-i {
Write b+65
Write i+65
}
Write 10
}

Pruébalo en línea!

Lienzo , 11 10 bytes

Ｚ｛Ｚ²╷ｍ¹＊×］

Pruébalo aquí!

GNU M4, 119 bytes

Lo peor hasta ahora. Bueno, el tiempo ya pasó ...

define(f,`ifelse($1,$2,,`format(%c%c,$1,$2)`'f(incr($1),$2)')')define(g,`f(65,$1)ifelse($1,90,,`
g(incr($1))')')A
g(66)

Casco , 13 bytes

Γ·:mhSzJḣ…"AZ

Pruébalo en línea!

Explicación

Este liderazgo Arealmente arruina las cosas.

          "AZ  -- string literal: "AZ"
         …     -- fill gaps: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     S         -- with alphabet and
        ḣ      -- | alphabet rangified: ["A","AB","ABC",…,"AB……XYZ"]
      zJ       -- : zipWith join: ["A","ABB","ACBCC","ADBDCDD",…,"AZB……ZYZZ"]
Γ              -- pattern match (x:xs) with the following function (x is "A" and xs ["ABB","ACBCC",…,"A……ZYZZ"]
 · mh          -- | drop the last element of each element of xs: ["AB","ACBC",…,"A……ZYZ"]
  :            -- | cons (construct list): ["A","AB","ACBC",…,"A……ZYZ"]
               -- : strings are printed implicitly

C # (.NET Core)

Puerto de la respuesta de Kevin Cruijssen :

91 90 bytes

_=>{var t="";for(char c='@';++c<91;t+=c)Console.WriteLine(string.Join(c+"",t.Skip(0))+c);}

Pruébalo en línea!

132 122 110 109 104 103 bytes

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Select((c,i)=>string.Join(""+c,"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Take(i))+c)

Pruébalo en línea!

• Reemplace ()con _para mostrar que declaramos una variable no utilizada. Gracias Kevin Cruijssen.

Jalea , 22 bytes

ØAż€Ð€`F€µJ’Ḥ»1ż@¹ḣ/€Y

Pruébalo en línea!

Cómo funciona:

                       take argument implicitly
ØA                     the uppercase alphabet
    Ѐ`                for C in the alphabet
  ż€                     appends C to every letter in the alphabet
       F€              flatten every sublist
          J            get indices
           ’           subtract 1
            Ḥ          and double
             »1        take max([n, 1])
         µ     ż@¹     interleave alphabet list and indices
                  ḣ/€  reduce on head() for each element
                     Y join on newline
                       implicitly output

uBASIC , 80 bytes

Función anónima que no lleva entradas y salidas a la consola.

0?"A":ForI=65To89:ForJ=65ToI:?Left$(Chr$(J),1)+Left$(Chr$(I+1),1);:NextJ:?:NextI

Pruébalo en línea!

Visual Basic .NET (Mono) , 134 bytes

Función declarada que no lleva entradas y salidas a la consola

Module M
Sub Main
Dim S,I,J
S="A"
For I=65To 90
Console.WriteLine(S)
S=""
For J=65To I
S+=Chr(J)+Chr(I+1)
Next
Next
End Sub
End Module

Pruébalo en línea!

Ruby , 44 34 bytes

?A.upto(?Z){|w|puts [*?A...w]*w+w}

Pruébalo en línea!

Gracias benj2240 por bajarlo a 37 bytes. Y, por supuesto, tachado 44 bla, bla.

05AB1E , 29 bytes

'A,Au©.sRí¦®RSDgÝ×Rs)ø˜.Bíø»=

Pruébalo en línea!