Debe imprimir este texto exacto:

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

Especificaciones

• Se permiten nuevas líneas adicionales al final de la salida.
• Se permiten espacios finales adicionales (U + 0020) al final de cada línea, incluidas las nuevas líneas finales adicionales.
• Puede usar todas las minúsculas en lugar de todas las mayúsculas, pero no puede imprimir parcialmente minúsculas y parcialmente mayúsculas.
• Puede devolver el texto como una salida de función en lugar de imprimirlo en un programa completo.

Puntuación

Dado que este es un triángulo, y un triángulo tiene 3 lados, y 3 es un número pequeño, su código debe ser pequeño en términos de conteo de bytes.

Vim, 37 bytes

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

Leyenda

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

Logotipo, 232 207 196 190 bytes

¿Alguien dijo triángulos?

Saca tu brújula y transportador, y hagámoslo de forma gráfica. La geometría usa un triángulo equilátero para alinear los resultados. Anteriormente tenía un triángulo isósceles, pero involucraba demasiados decimales. Este cambio también compactó la salida, reduciendo la cantidad de preparación de pantalla y el cambio de fuente que tuve que hacer.

He utilizado el intérprete de línea Calormen para dar cuerpo éste hacia fuera. Si no tiene suficiente espacio en la pantalla, se ajustará, pero también puede manipular algunos números para encargarse de eso. Utilicé el modo de pantalla completa "F11" en mi navegador.

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]

El rprocedimiento dibuja una línea de ncaracteres. El carácter se determina automáticamente dependiendo de cuántos segmentos se le indique que use. El bparámetro le indica cuánto girar temporalmente para que las letras apunten en la dirección correcta. El lparámetro determina la distancia lineal entre letras.

El tprocedimiento avanza a la siguiente posición y llama a la rfunción cuatro veces para crear un triángulo, rotando cuando sea apropiado. Lo llamé dos veces para el lado vertical porque eso tomó menos bytes que llamarlo una vez con un manejo especial. El final del procedimiento posiciona a la tortuga para el inicio del siguiente triángulo, un paso más arriba.

Zes un caso especial, por lo que simplemente lo imprimimos directamente y lo rotamos como si acabara de terminar un triángulo. Finalmente, tse llama 25 veces.

Haskell, 58 bytes

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

Define una función tque devuelve la salida como una cadena.

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

Jalea , 16 13 bytes

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

¡Gracias a @LeakyNun por jugar 3 bytes!

Pruébalo en línea!

Cómo funciona

Ṗ;Ṛ        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 bytes

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 función de Python 2 que imprime y no toma argumentos. La idea clave es generar el patrón triangular de ida y vuelta con recursión. Primero considere esta función más simple que imprime las letras 'A' hasta 'Z' y baja de nuevo a 'A':

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

La función primero imprime "A" (código de caracteres 65), luego vuelve a imprimir "B" (66) y así sucesivamente en "Z" (90). A partir de ahí, deja de recurrir. En el camino de regreso a la pila recursiva, imprime cualquier carácter tque imprima en la misma capa, desde "Y" hasta "A".

El código principal hace lo mismo, excepto que se acumula en sla cadena de letras hasta el momento e imprime la cadena hacia arriba y hacia abajo s+s[-2::-1].

Gracias a xsot por 2 bytes.

En Python 3, lo mismo es un byte más corto (73 bytes) al poner todo en una línea.

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 bytes

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

Versión ligeramente más legible:

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

Explicación posiblemente por venir.

05AB1E , 20 13 12 6 bytes

Guardado 2 bytes gracias a Adnan.
Guardado 6 bytes gracias a Magic Octopus Urn y algunas nuevas funciones de lenguaje.

Aη€ûû»

Pruébalo en línea!

Explicación

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

J, 26 23 22 bytes

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

Explicación

,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 bytes

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

Ideone it!

Ruby, 71 bytes

Pruébalo en repl.it

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

> <> , 60 bytes

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

Pruébalo en línea!

C, 272 247 234 230 144 137 bytes:

(¡ Ahorré muchos bytes ( 272 -> 230) en mi método anterior gracias a excelentes consejos y trucos de golf de sigalor ! )

(Se guardaron casi 100 bytes ( 230 -> 144) al cambiar a un método mejor ) .

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

Mi primera respuesta en entrar C. Acabo de comenzar a aprenderlo recientemente, así que veamos cómo funciona.

C en acción! (Ideona)

JavaScript (ES6), 81 bytes

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

Mathematica 59 bytes

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

Dyalog APL, 18 bytes

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

R, 63 61 59 bytes

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

Con ayuda LETTTERS[0]no devuelve ningún personaje.

Editar: perdido uno gracias a @leakynun

Editar: dos más gracias a @plannapus

TSQL, 159 bytes

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

Violín

Javascript (usando una biblioteca externa enumerable), 135 bytes

_.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))))

Enlace a la biblioteca: https://github.com/mvegh1/Enumerable

Explicación del código: cree un rango de entradas que comience en 1, para un conteo de 51. Para cada una, escriba una línea de acuerdo con la pred. Compleja. Realice algunas tareas de JS con variables globales y almacenamiento en caché ... y listo. Para cada int en WriteLine, estamos creando el rango de entradas a la izquierda y almacenando en "g" global, y String Joining (Write) con ""delimitador y asignando cada int a la asignación de String al código int char. Luego, concatenamos el lado derecho tomando la inversión de esa secuencia (y omitiendo el primer elemento porque coincidirá con el último elemento del orden original ...), escribiendo con la misma lógica. EDITAR: se actualizaron las partes internas de Write en la biblioteca. Una secuencia vacía escribirá una cadena vacía en lugar de nula ahora. Esto también redujo 15 bytes de la respuesta

Powershell, 61 52 bytes

¡Gracias a TimmyD por guardar 9 bytes!

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

Recorre los valores ASCII para letras mayúsculas hacia adelante y luego hacia atrás. Para cada número, esto crea una matriz de los primeros números X, elimina el número X-1st, luego agrega el reverso de los primeros números X, que luego se convierten en caracteres y se unen en una cadena.

Cheddar , 102 96 79 69 67 bytes

17 bytes gracias a Downgoat, e inspiración para 10 más.

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

El hecho de que las cadenas pueden concatenar pero no matrices significa que tendría que convertir los dos rangos en cadenas, concatenar y luego volver a convertirlas en matrices.

Además, el hecho de que vfuseproduzca un newliens principal significa que necesitaría generar la primera línea manualmente y luego concat al resto.

@" como una diada (función de dos argumentos) puede convertirse en cadena directamente, pero no funciona para el rango inverso (si el primer argumento es mayor que el segundo).

El rango era medio inclusivo. Después de la corrección de errores se hizo 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 bytes (no competidor)

En la última versión con todas las correcciones, la respuesta es:

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

pero fue hecho después del desafío.

C, 93 bytes

Llamar f()sin argumentos.

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));}

Pruébalo con ideone .

VBA, 94 bytes

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

Llamar en la ventana Inmediato con? T

Solo para explicar lo que está sucediendo: uso la función Abs dos veces, para reflejar tanto el recorrido del alfabeto como la longitud de la línea. Se adapta bien a la tarea debido al valor extremo único en ambos casos, que corresponde al cruce por cero de la variable pre-Abs.

Como un conjunto simple de comandos en la ventana Inmediato de VBA, en lugar de un programa o función, lo siguiente necesitaría 72 bytes:

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

(con agradecimiento a @GuitarPicker)

Python, 73 71 bytes

Gracias a @xnor por la recursividad

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

Explicación

• Parámetros :
  • x es el valor ascii de la siguiente letra del alfabeto
  • s es un acumulador para el alfabeto
  • tes una línea en el triángulo (es decir, s+ s backwards)
• Regreso : tsi el alfabeto está listo (es decir, estamos en el centro)
• De lo contrario : t+f(...)+tcon:
  • x incrementado
  • s adjunto con la siguiente carta
  • trestablecer a s+ s backwards+\n

Actualizar

• -2 [16-08-05] Elimina el inicio \n(+1) y el condicional acortado (-3) todo gracias a @xnor

HTML + CSS, 884 caracteres

(763 caracteres HTML + 121 caracteres CSS)

Simplemente expandiendo el comentario de Leaky Nun sobre la respuesta de MonkeyZeus . (Aunque podría leer mal el comentario ...)

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 bytes

Créditos para Fatalizar por su ayuda en todo momento.

4 bytes gracias a Fatalize, e inspiración para otros 4 bytes.

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

Pruébalo en línea!

Predicado 0 (predicado principal)

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

Predicado 1 (predicado auxiliar)

Esto básicamente construye un palíndromo a partir de la cadena dada.

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

R, 127125 bytes

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

No estoy completamente satisfecho con esta solución, especialmente los dos forbucles, ¡pero no podría venir con algo mejor!
LETTERScontiene las letras mayúsculas.

Sin golf:

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

ifelsees una forma más corta de deshacer if... else...y funciona de esta manera:ifelse(condition,action if TRUE, action if FALSE)

Otra solución de 125 bytes:

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 bytes

Sin usar String (131 bytes)

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 cadena (173 bytes)

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

Gracias a manatwork y Kevin Cruijssen

brainfuck, 79 bytes

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

Formateado:

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

Pruébalo en línea

Sesos , 27 bytes

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

Pruébalo en línea! Verifique la depuración para ver el código SBIN generado.

Asamblea Sesos

El archivo binario anterior se ha generado al ensamblar el siguiente código 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 bytes

/'/\/\///+/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

No ganar, por supuesto, pero aquí está, anterior a Martin Ender ...