Non dato alcun input, genera questo interessante modello alfabetico in entrambi i casi (il caso deve essere coerente) tramite un metodo di output accettato :

UN
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

Spazi di trascinamento e newline sono accettabili, le scappatoie standard sono vietate, e questo sembra essere code-golf , quindi vince la risposta più breve in byte!

Tela , 7 byte

Ｚ［Ｋ＊¹＋］

Provalo qui!

Spiegazione:

Ｚ［     ］ 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

Gelatina , 9 byte

ØAjṪ$Ƥż¹Y

Provalo online!

Come funziona

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

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

Provalo online!

R , 50 byte

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

Provalo online!

Forse la parte più intelligente qui sta usando letters[0]per la stringa vuota per arrivare cat(character(0),'\n',sep="A")a stampare la prima riga.

Carbone , 9 byte

Ｅα⁺⪫…ακιι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

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

Provalo online!

6502 routine codice macchina (C64), 39 byte

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

Sottoprogramma di codice macchina indipendente dalla posizione, clobber A, X e Y.

Demo online

La demo si carica su $C000, quindi usa SYS49152per chiamare la routine.

Smontaggio commentato:

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 byte

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

-1 byte grazie a @ OlivierGrégoire stampando direttamente anziché restituire

Spiegazione:

Provalo online.

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 byte

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

Provalo online!

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

Il problema qui è la prima riga

l'utilizzo o s kaggiungerà un scarattere eparatore aggiuntivo all'inizio di ogni riga e non avrà un carattere salla fine. Questo è OK perché la linea tsalterà sulle seguenti due linee quando x=0. Ciò significa che osarà ancora vuoto. Quindi, o s =rimuoverà il primo scarattere da o, e quindi possiamo semplicemente stampare o sper avere l'ultimo appropriato s.

JavaScript (ES6), 81 byte

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

Salvare 9 byte se un valore di ritorno dell'array di stringhe è accettabile.

Japt ( -Rbandiera), 14 12 byte

-2 byte grazie a @Shaggy

;B¬
ËiU¯E qD

Provalo online!

Haskell , 49 48 byte

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

Provalo online!

Modifica: -1 byte grazie a totalmente umano!

PowerShell , 56 byte

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

Provalo online!

Cicli 65di 89ogni iterazione costruire una charmatrice di 65al numero attuale $_, allora -joins che matrice insieme in una stringa con il carattere successivo, quindi chiodini su che carattere alla fine.

Modificare il 89con un altro numero ASCII per vedere meglio il comportamento.

> <> , 44 34 byte

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

Provalo online!

> <> , 44 byte

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

Provalo online!

Mentre utilizzo un percorso diverso per produrre l'output ho pubblicato la mia risposta> <>; L'altra> <> risposta può essere trovata qui.

Grazie mille a Jo King per lo spotting, non ho dovuto continuare a mettere "A" in pila se ho appena confrontato con "Z" invece di 26. (-10 byte)

Spiegazione

La spiegazione seguirà il flusso del codice.

"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. 

Gelatina , 12 byte

ØA;\;€Ṫ$€YFḊ

Provalo online!

Bah ha appena ottenuto ØAjṪ$ƤżØAYche è un passaggio tra questo e la soluzione già pubblicata di Dennis: /

Pyth , 13 byte

+\ajmPjedd._G

Provalo qui! , Alternativa

Quello che conduce aperò ...

Gelatina , 13 byte

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

Provalo online!

Spiegazione

Ø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 in parte del modo in cui le stringhe e gli elenchi di caratteri differiscono in Jelly

Python 2 , 92 86 79 75 64 byte

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

Provalo online!

11 byte grazie a Rod.

APL + WIN, 51 byte

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

Spiegazione:

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 byte

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

Provalo online!

Come funziona:

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 byte

Questo è in realtà ciò che ha ispirato questa sfida:

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

Provalo online!

Tela , 11 10 byte

Ｚ｛Ｚ²╷ｍ¹＊×］

Provalo qui!

GNU M4, 119 byte

Il peggio finora. Bene, il tempo è già passato ...

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)

Buccia , 13 byte

Γ·:mhSzJḣ…"AZ

Provalo online!

Spiegazione

Questo leader Arovina davvero le cose -.-

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

Porta dalla risposta di Kevin Cruijssen :

91 90 byte

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

Provalo online!

132 122 110 109 104 103 byte

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

Provalo online!

• Sostituisci ()con _per mostrare che dichiariamo una variabile non utilizzata. Grazie Kevin Cruijssen.

Gelatina , 22 byte

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

Provalo online!

Come funziona:

                       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 byte

Funzione anonima che non accetta input e output sulla console

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

Provalo online!

Visual Basic .NET (Mono) , 134 byte

Funzione dichiarata che non accetta input e output sulla console

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

Provalo online!

Rubino , 44 34 byte

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

Provalo online!

Grazie benj2240 per averlo ridotto a 37 byte. E naturalmente cancellato 44 blah blah.

05AB1E , 29 byte

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

Provalo online!