Devi stampare questo testo esatto:

A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

Specifiche

• Newline finali finali sono consentite alla fine dell'output.
• Gli spazi finali aggiuntivi (U + 0020) sono consentiti alla fine di ogni riga, comprese le nuove righe finali finali.
• È possibile utilizzare tutte le lettere minuscole anziché tutte le maiuscole, ma non è possibile stampare in parte minuscole in parte maiuscole.
• È possibile restituire il testo come output di una funzione anziché stamparlo in un programma completo.

punteggio

Poiché si tratta di un triangolo e un triangolo ha 3 lati e 3 è un numero piccolo, il codice dovrebbe essere piccolo in termini di conteggio dei byte.

Vim, 37 byte

:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ

Leggenda

↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape

Logo, 232 207 196 190 byte

Qualcuno ha detto triangoli?

Tira fuori la bussola e il goniometro e facciamolo in modo grafico. La geometria utilizza un triangolo equilatero per allineare i risultati. In precedenza avevo un triangolo isoscele, ma comportava troppe cifre decimali. Questa modifica ha anche compattato l'output, riducendo la quantità di preparazione dello schermo e il cambio di font che ho dovuto fare.

Ho usato l' interprete online di Calormen per dare una svolta a questo. Se non hai abbastanza spazio sullo schermo, andrà a finire, ma puoi anche giocherellare con alcuni numeri per occupartene. Ho usato la modalità a schermo intero "F11" sul mio browser.

ht
pu
to r:n:b:l repeat:n[rt:b label char 90-:n lt:b fd:l] end
to t:s
fd 12 rt 120 bk 6
repeat 2[r:s 90 12]
repeat 2[rt 120 r:s 90-heading 24]
end
rt 90 label "Z lt 210
repeat 25[t repcount]

La rprocedura disegna una linea di ncaratteri. Il personaggio viene determinato automaticamente in base al numero di segmenti che deve utilizzare. Il bparametro indica quanto ruotare temporaneamente in modo che le lettere puntino nella giusta direzione. Il lparametro determina la distanza lineare tra le lettere.

La tprocedura passa alla posizione successiva e chiama la rfunzione quattro volte per creare un triangolo, ruotando quando necessario. L'ho chiamato due volte per il lato verticale perché richiedeva meno byte rispetto a chiamarlo una volta con una gestione speciale. La fine della procedura posiziona la tartaruga per l'inizio del triangolo successivo, un gradino sopra.

Zè un caso speciale, quindi lo stampiamo direttamente e ruotiamo come se avessimo appena finito un triangolo. Infine, tviene chiamato 25 volte.

Haskell, 58 byte

f x=init x++reverse x
t=unlines$f[f['A'..c]|c<-['A'..'Z']]

Definisce una funzione tche restituisce l'output come stringa.

f x=               define a helper function
init x             take the argument minus its last element
++                 and concatenate it with
reverse x          the argument reversed, producing ex. [a,b,c,b,a] from [a,b,c]

t=                                    define the main function
           [         |c<-['A'..'Z']]  for every char c from 'A' to 'Z'...
             ['A'..c]                 generate the range from 'A' to c
            f                         call the helper function to "reflect" it
          f                           call the helper function on the entire list
  unlines$                            join on newlines

Gelatina , 16 13 byte

Ṗ;Ṛ
ØAḣJÇ€Çj⁷

Grazie a @LeakyNun per giocare a golf con 3 byte!

Provalo online!

Come funziona

Ṗ;Ṛ        Helper link. Argument: A (array)

Ṗ          Pop; yield A without its last element.
  Ṛ        Reversed; yield A with inverted order.
 ;         Concatenate the results to both sides.


ØAḣJÇ€Çj⁷  Main link. No arguments.

ØA         Alphabet; set link argument and return value to "A...Z".
   J       Indices; yield [1, ..., 26].
  ḣ        Head; take the first, the first two, etc. elements of the alphabet.
           This yields ["A", AB", ..., "A...Z"].
    ǀ     Apply the helper link to each string.
      Ç    Apply the helper link to the array itself.
       j⁷  Join, separating by linefeeds.

Python, 74 byte

def f(x=66,s='A'):
 t=s+s[-2::-1];print t
 if x<91:f(x+1,s+chr(x));print t

Una funzione Python 2 che stampa e non accetta argomenti. L'idea chiave è generare il modello triangolare avanti e indietro con la ricorsione. Per prima cosa considera questa funzione più semplice che stampa le lettere 'A' fino a 'Z' e poi di nuovo su 'A':

def f(x=65):
 t=chr(x);print t
 if x<90:f(x+1);print t 

La funzione stampa prima "A" (codice char 65), quindi ricomincia a stampare "B" (66) e così via a "Z" (90). Da lì, smette di ricorrere. Sulla via del ritorno dello stack ricorsivo, stampa qualsiasi personaggio tstampato sullo stesso livello, da "Y" a "A".

Il codice principale fa lo stesso, tranne per il fatto che si accumula sfinora nella stringa di lettere e stampa la stringa su e giù s+s[-2::-1].

Grazie a xsot per 2 byte.

In Python 3, la stessa cosa è un byte più breve (73 byte) mettendo tutto su una riga.

def f(x=66,s='A'):t=s+s[-2::-1];print(t);x>90or[f(x+1,s+chr(x)),print(t)]

brainfuck, 1733 121 119 byte

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

Versione leggermente più leggibile:

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

Spiegazione forse per venire.

05AB1E , 20 13 12 6 byte

Salvato 2 byte grazie ad Adnan.
Salvato 6 byte grazie a Magic Octopus Urn e ad alcune nuove funzionalità linguistiche.

Aη€ûû»

Provalo online!

Spiegazione

Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines

J, 26 23 22 byte

f(f=:,1}.|.)\u:65+i.26

Spiegazione

,1}.|.  Monad f: Input: A
    |.  Reverse the items in A
 1}.    Drop the first item in the reversed A
,       Join A and the previous

f(f=:,1}.|.)\u:65+i.26
                  i.26  Create the range [0, 1, ..., 25]
               65+      Add 65 to each
             u:         Convert to characters to get 'A..Z'
  f=:,1}.|.             Define a verb f
 (         )\           Call f monadically on each prefix of 'A..Z'
f                       Call f again on that result

Python 3, 97 byte

s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
a=[s[:x]+s[x::-1]for x in range(26)]
print('\n'.join(a+a[24::-1]))

Ideone esso!

Rubino, 71 byte

Provalo su repl.it

s=*?A..?Y
s+=[?Z]+s.reverse
puts s.map{|e|k=[*?A...e]*'';k+e+k.reverse}

> <> , 60 byte

1"AA"1[v
?v:1-:}>:5d*=
o>l  ?!v
{$-}:1[\ao]{:}+::"@Z"@=?;=2*

Provalo online!

C, 272 247 234 230 144 137 byte:

( Ho salvato molti byte ( 272 -> 230) nel mio metodo precedente grazie a ottimi consigli e trucchi per giocare a golf da Sigalor ! )

( Salvato quasi 100 byte ( 230 -> 144) passando a un metodo migliore. )

main(q,i,e,x){for(q=0;q<51;q++){i=q>25 ? 25-(q-25):q;for(e=65;e<66+i;e++)printf("%c",e);for(x=64+i;x>64;x--)printf("%c",x);printf("\n");}}

La mia prima risposta in assoluto C. Ho appena iniziato l'autoapprendimento di recente, quindi vediamo come va.

C it in Action! (Ideone)

JavaScript (ES6), 81 byte

[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)

Mathematica 59 byte

Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]

Dyalog APL, 18 byte

↑(⊣,⌽)(⊣,1↓⌽)¨,\⎕a

R, 63 61 59 byte

for(i in c(1:26,25:1))cat(LETTERS[c(1:i,i:1-1)],"
",sep="")

Utilmente LETTTERS[0]non restituisce alcun personaggio.

Modifica: perso uno grazie a @leakynun

Modifica: altri due grazie a @plannapus

TSQL, 159 byte

DECLARE @ varchar(52)='ABCDEFGHIJKLMNOPQRSTUVWXY',@o varchar(max)SELECT @+='Z'+REVERSE(@)+'
',@o=@
WHILE''<@
SELECT @=STUFF(@,LEN(@)/2,2,''),@o=@+@o+@
PRINT @o

Violino

Javascript (utilizzando una libreria esterna enumerabile), 135 byte

_.Range(1,51).WriteLine(x=>(g=_.Range(65,x>25?52-x:x)).Write("",y=>(w=String.fromCharCode)(y))+(g.Reverse().Skip(1).Write("",y=>w(y))))

Link alla biblioteca: https://github.com/mvegh1/Enumerable

Spiegazione del codice: creare un intervallo di ints a partire da 1, per un conteggio di 51. Per ciascuno, scrivere una riga in base a pred complesso. Esegui alcuni maghi JS con variabili globali e cache ... e voilà. Per ogni int in WriteLine, stiamo creando l'intervallo per la mano sinistra di ints e lo memorizziamo nella "g" globale, e String Joining (Write) con ""delimitatore e mappando ogni int sulla mappatura String al codice char int. Quindi, concatichiamo il lato destro prendendo l'inversione di quella sequenza (e saltando il primo elemento perché corrisponderà all'ultimo elemento dell'ordine originale ...), scrivendo con la stessa logica. EDIT: aggiornati gli interni di Write nella libreria. Una sequenza vuota scriverà una stringa vuota anziché null ora. Ciò ha anche eliminato 15 byte dalla risposta

Powershell, 61 52 byte

Grazie a TimmyD per aver salvato 9 byte!

65..90+89..65|%{-join[char[]]((65..$_-ne$_)+$_..65)}

Passa attraverso i valori ASCII per le lettere maiuscole in avanti, quindi indietro. Per ogni numero, questo crea una matrice dei primi numeri X, rimuove il numero X-1st, quindi aggiunge il retro dei primi numeri X, che viene poi tutto castato in caratteri e unito in una stringa.

Cheddar , 102 96 79 69 67 byte

17 byte grazie a Downgoat e ispirazione per altri 10.

"A"+(2@"27+@"(25|>1)).bytes.map(i->65@"(64+i)+@"((64+i)|>65)).vfuse

Il fatto che le stringhe possano concatenare ma non matrici significa che dovrei convertire i due intervalli in stringhe, concatenare e quindi riconvertire in matrici.

Inoltre, il fatto che vfuseproduca un newliens leader significa che avrei bisogno di generare manualmente la prima riga e poi concatenarla al resto.

@" poiché una diade (funzione a due argomenti) può convertire direttamente in stringa, ma non funziona per l'intervallo inverso (se il primo argomento è più grande del secondo).

La gamma era semi-inclusiva. Dopo la correzione dei bug è diventato inclusivo.

uso

cheddar> "A"+(2@"27+@"(25|>1)).bytes.map(i->(65@"(64+i)+@"((64+i)|>65))).vfuse
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A"

Cheddar, 55 byte (non concorrenti)

Nella sua ultima versione con tutte le correzioni, la risposta è:

(|>25+24|>0).map(i->65@"(65+i)+(i?(64+i)@"65:"")).vfuse

ma è stato realizzato dopo la sfida.

C, 93 byte

Chiama f()senza argomenti.

g(l,n){putchar(l);n?g(l+1,--n),putchar(l):0;}f(n){for(n=-26;++n<26;puts(""))g(65,25-abs(n));}

Provalo su ideone .

VBA, 94 byte

Function T:For j=-25To 25:k=25-Abs(j):For i=-k To k:T=T &Chr(65+k-Abs(i)):Next:T=T &vbLf:Next

Chiama nella finestra immediata con? T

Giusto per spiegare cosa sta succedendo: uso due volte la funzione Abs, per riflettere sia la traslazione dell'alfabeto sia la lunghezza della linea. È adatto all'attività a causa del singolo valore estremo in entrambi i casi, che corrisponde all'attraversamento zero della variabile pre-Abs.

Come semplice set di comandi nella finestra immediata di VBA, piuttosto che un programma o una funzione, sarebbero necessari 72 byte:

For j=-25To 25:k=25-Abs(j):For i=-k To k:?Chr(65+k-Abs(i));:Next:?:Next

(grazie a @GuitarPicker)

Python, 73 71 byte

Grazie a @xnor per la ricorsione

f=lambda x=66,s='A',t='':x/92*t or t+f(x+1,s+chr(x),s+s[-2::-1]+"\n")+t

Spiegazione

• Parametri :
  • x è il valore ASCII della lettera successiva dell'alfabeto
  • s è un accumulatore per l'alfabeto
  • tè una linea nel triangolo (cioè s+ s backwards)
• Ritorno : tse l'alfabeto è terminato (ovvero siamo al centro)
• Altro : t+f(...)+tcon:
  • x incrementato
  • s allegato alla lettera successiva
  • treimpostare su s+ s backwards+\n

Aggiornare

• -2 [16-08-05] Rimuovi condizionale iniziale \n(+1) e ridotto (-3) tutto grazie a @xnor

HTML + CSS, 884 caratteri

(763 caratteri HTML + 121 caratteri CSS)

Proprio in espansione Leaky Nun 's commento su MonkeyZeus ' s risposta . (Anche se potrei leggere male il commento ...)

p{margin:0}p:before{content:"ABCDEFGH"}p:after{content:"HGFEDCBA"}a:before{content:"IJKLMNOP"}a:after{content:"PONMLKJI"}

<pre>A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
<p>I</p><p>IJI</p><p>IJKJI</p><p>IJKLKJI</p><p>IJKLMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNOPONMLKJI</p><p><a>Q</p><p><a>QRQ</p><p><a>QRSRQ</p><p><a>QRSTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXYZYXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTSRQ</p><p><a>QRSRQ</p><p><a>QRQ</p><p><a>Q</a></p><p>IJKLMNOPONMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMLKJI</p><p>IJKLKJI</p><p>IJKJI</p><p>IJI</p><p>I</p>ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

Brachylog , 37 29 byte

Ringraziamenti a Fatalize per la sua assistenza in tutto.

4 byte grazie a Fatalize e ispirazione per altri 4 byte.

@A:1&e:"a"yr:1&cw@Nw\
:Lc.r.!

Provalo online!

Predicato 0 (predicato principale)

@A:1&e:"a"yr:1&cw@Nw\
@A:1&                  Apply predicate 1 to @A, which is
                       basically "abcdefghijklmnopqrstuvwxyz"
     e                 Choose one element from the result (choice point)
      :"a"yr               generate substring from element to "a"
            :1&            apply predicate 1
               c           concatenate
                w          write to STDOUT
                 @Nw       write "\n" to STDOUT
                    \  Backtrack to last choice point to choose
                       another element until there is no more
                       choice left, then halt.

Predicato 1 (predicato ausiliario)

Questo fondamentalmente costruisce un palindromo dalla stringa data.

:Lc.r.!
:Lc.     output is [input:L]
   .r.   output reversed is still output
      !  stop searching after the first output

R, 127 125 byte

k=cat;L=LETTERS;for(i in 1:26)k(c(L[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

Non completamente soddisfatto di questa soluzione, in particolare i due forloop, ma non è riuscito a trovare qualcosa di meglio!
LETTERScontiene le lettere maiuscole.

Ungolfed:

for(i in 1:26){
  cat(c(LETTERS[1:i],LETTERS[(i-1):0],"\n"))
               }

for(i in 1:26){
  cat(c(LETTERS[0:(26-i)],LETTERS[ifelse((25-i)>=0,25-i,0):0],"\n"))
               }

ifelseè un modo più breve per annullare if... else...e funziona in questo modo:ifelse(condition,action if TRUE, action if FALSE)

Un'altra soluzione di 125 byte:

for(i in 1:26)(k=cat)(c((L=LETTERS)[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

Java 131 byte

Senza usare String (131 byte)

public static void main(String[] args) {
    for(int i = 0 ,k=1; i>-1; i+=k){
        for(int c= 65, d = 1; c>64;){
            d = d>-1 & c < 65+i?1:-1;
            System.out.print((char)c+((c+=d)<65?"\n":""));
        }
        k = k>-1 & i < 25?1:-1;
    }
}

Codegolfed

for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));

Con stringa (173 byte)

String a="abcdefghijklmnopqrstuvwxyz";
for(int i = 1 ,k=1; i>0; i+=k==1?1:-1){
    System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i));
    k = k>-1 & i < 26?1:-1;
}

Codegolfed

String a="abcdefghijklmnopqrstuvwxyz";for(int i=1,k=1;i>0;k=k>-1&i<26?1:-1,System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i)),i+=k==1?1:-1);

Grazie a manatwork e Kevin Cruijssen

Brainfuck, 79 byte

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

formattato:

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

Provalo online

Sesos , 27 byte

0000000: a85ab9 ac5daa f8b1c7 785f9b b961f7 665c1b 73ccfc  .Z..]....x_..a.f\.s..
0000015: c01ecb 987303                                     ....s.

Provalo online! Controlla Debug per vedere il codice SBIN generato.

Assemblaggio Sesos

Il file binario sopra è stato generato assemblando il seguente codice SASM.

add 65, rwd 1, add 10, rwd 2, add 25
jmp
    fwd 3
    jmp
        put, fwd 1
    jnz
    rwd 1
    jmp
        fwd 1, add 1, fwd 1, add 1, rwd 2, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    rwd 1, add 1, rwd 2
    jmp
        put, rwd 1
    jnz
    rwd 1, sub 1
jnz
fwd 3
jmp
    jmp
        put, fwd 1
    jnz
    rwd 1, get, rwd 1
    jmp
        put, rwd 1
    jnz
    fwd 2
; jnz (implicit)

/// , 208 byte

/'/\/\///+/BA
AB'-/DC+CD'&/FE-EF')/HG&GH'=/JI)IJ'|/LK=KL'7/NM|MN'1/PO7OP'q/RQ1QR'p/TSqST'6/VUpUV'[/XW6WX/A
A+C+C-E-E&G&G)I)I=K=K|M|M7O7O1Q1QqSqSpUpU6W6W[Y[YZY[Y[W6W6UpUpSqSqQ1Q1O7O7M|M|K=K=I)I)G&G&E-E-C+C+A
A

Naturalmente non vince, ma eccolo qui, che precede Martin Ender ...