Você deve imprimir este texto exato:

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

Especificações

• Novas linhas extras à direita são permitidas no final da saída.
• Espaços extras à direita (U + 0020) são permitidos no final de cada linha, incluindo as novas linhas extras à direita.
• Você pode usar todas as letras minúsculas em vez de todas as maiúsculas, mas não pode imprimir parcialmente minúsculas e parcialmente maiúsculas.
• Você pode retornar o texto como uma saída de função em vez de imprimi-lo em um programa completo.

Pontuação

Como esse é um triângulo, e um triângulo possui 3 lados e 3 é um número pequeno, seu código deve ser pequeno em termos de contagem de bytes.

Vim, 37 bytes

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

lenda

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

Logotipo, 232 207196 190 bytes

Alguém disse triângulos?

Tire sua bússola e transferidor, e vamos fazer isso da maneira gráfica. A geometria usa um triângulo equilátero para alinhar os resultados. Eu já tinha um triângulo isósceles, mas envolvia muitas casas decimais. Essa alteração também compactou a saída, reduzindo a quantidade de preparação da tela e a alteração da fonte que eu precisava fazer.

Eu usei o intérprete online Calormen para elaborar este. Se você não tiver espaço suficiente na tela, isso vai acabar, mas você também pode mexer em alguns números para cuidar disso. Eu usei o modo de tela cheia "F11" no meu 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]

O rprocedimento desenha uma linha de ncaracteres. O caractere é determinado automaticamente, dependendo de quantos segmentos ele deve usar. O bparâmetro informa quanto girar temporariamente para que as letras estejam apontando na direção certa. O lparâmetro determina a distância linear entre as letras.

O tprocedimento passa para a próxima posição e chama a rfunção quatro vezes para criar um triângulo, girando quando apropriado. Liguei duas vezes para o lado vertical porque isso levou menos bytes do que chamá-lo uma vez com tratamento especial. O final do procedimento posiciona a tartaruga para o início do próximo triângulo, um passo acima.

Zé um caso especial, apenas imprimimos diretamente e giramos como se tivéssemos acabado de terminar um triângulo. Finalmente, té chamado 25 vezes.

Haskell, 58 bytes

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

Define uma função tque retorna a saída como uma sequência.

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

Geléia , 16 13 bytes

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

Graças a @LeakyNun por jogar fora 3 bytes!

Experimente online!

Como 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

Uma função Python 2 que imprime e não aceita argumentos. A idéia principal é gerar o padrão triangular de retorno e retorno com recursão. Primeiro, considere esta função mais simples que imprime as letras 'A' até 'Z' e volta para 'A':

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

A função imprime primeiro "A" (código de caractere 65), depois volta a imprimir "B" (66) e assim por diante para "Z" (90). A partir daí, ele pára de se repetir. No caminho de volta à pilha recursiva, ele imprime qualquer caractere timpresso na mesma camada, de "Y" a "A".

O código principal faz o mesmo, exceto que se acumula na ssequência de letras até o momento e imprime a sequência para cima e para baixo s+s[-2::-1].

Graças ao xsot por 2 bytes.

No Python 3, a mesma coisa é um byte mais curto (73 bytes), colocando tudo em uma linha.

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

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

Versão um pouco mais legível:

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

Explicação possivelmente para vir.

05AB1E , 20 13 12 6 bytes

Economizou 2 bytes graças a Adnan.
Economizou 6 bytes graças ao Magic Octopus Urn e algumas novas funcionalidades de idioma.

Aη€ûû»

Experimente online!

Explicação

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

Explicação

,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

Experimente em 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*

Experimente online!

C, 272 247 234 230 144 137 bytes:

( Salvei muitos bytes ( 272 -> 230) no meu método anterior, graças às ótimas dicas e truques de golfe de sigalor ! )

( Economizou quase 100 bytes ( 230 -> 144) mudando para um método melhor. )

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

Minha primeira resposta C. Eu comecei a aprender sozinho recentemente, então vamos ver como vai.

C em ação! (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="")

Prestativamente LETTTERS[0]não retorna nenhum personagem.

Edit: perdeu um graças a @leakynun

Edit: mais dois agradecimentos 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

Violino

Javascript (usando a biblioteca externa enumerável), 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))))

Link para a biblioteca: https://github.com/mvegh1/Enumerable

Explicação do código: Crie um intervalo de ints começando em 1, para uma contagem de 51. Para cada um, escreva uma linha de acordo com o pred complexo. Faça alguma magia JS com variáveis ​​globais e cache ... e pronto. Para cada int no WriteLine, estamos criando o intervalo de entradas à esquerda e armazenando no global "g", e String Joining (Write) com ""delimitador e mapeando cada int para o mapeamento String para o código int char. Em seguida, concatizamos o lado direito, fazendo a reversão dessa sequência (e pulando o primeiro elemento, porque isso corresponderá ao último elemento da ordem original ...), escrevendo com a mesma lógica. EDIT: Atualizados os internos de gravação na biblioteca. Uma sequência vazia gravará uma sequência vazia em vez de nula agora. Isso também eliminou 15 bytes da resposta

Powershell, 61 52 bytes

Agradecimentos a TimmyD por salvar 9 bytes!

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

Faz um loop através dos valores ASCII para letras maiúsculas para frente e depois para trás. Para cada número, isso cria uma matriz dos primeiros números X, remove o número X-1 e adiciona o reverso dos primeiros números X, que são todos convertidos em caracteres e agrupados em uma sequência.

Queijo Cheddar , 102 96 79 69 67 bytes

17 bytes graças ao Downgoat e inspiração para mais 10.

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

O fato de que seqüências de caracteres podem concatenar, mas não matrizes, significa que eu teria que converter os dois intervalos em seqüências de caracteres, concatenar e depois converter novamente em matrizes.

Além disso, o fato de vfuseproduzir um newliens principal significa que eu precisaria gerar a primeira linha manualmente e depois concatenar com o resto.

@" como uma díade (função de dois argumentos) pode converter diretamente em string, mas não funciona para o intervalo invertido (se o primeiro argumento for maior que o segundo).

O alcance era meio inclusivo. Após a correção, tornou-se 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 (não concorrente)

Na versão mais recente com todas as correções, a resposta é:

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

mas foi feito após o desafio.

C, 93 bytes

Ligue f()sem 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));}

Experimente em 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

Ligue na janela Imediata com? T

Apenas para explicar o que está acontecendo: uso a função Abs duas vezes, para refletir a rotação do alfabeto e o comprimento da linha. É adequado para a tarefa devido ao valor extremo único em ambos os casos, que corresponde ao cruzamento zero da variável pré-Abs.

Como um conjunto simples de comandos na janela Imediata do VBA, em vez de um programa ou função, o seguinte precisaria de 72 bytes:

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

(com agradecimentos a @GuitarPicker)

Python, 73 71 bytes

Obrigado a @xnor pela recursão

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

Explicação

• Parâmetros :
  • x é o valor ascii da próxima letra do alfabeto
  • s é um acumulador para o alfabeto
  • té uma linha no triângulo (ou seja, s+ s backwards)
• Retorno : tse o alfabeto estiver pronto (ou seja, estamos no centro)
• Outro : t+f(...)+tcom:
  • x incrementado
  • s anexado com a próxima letra
  • tredefinir para s+ s backwards+\n

Atualizar

• -2 [16-08-05] Remova o \ncondicional inicial (+1) e abreviado (-3) graças a @xnor

HTML + CSS, 884 caracteres

(763 caracteres HTML + 121 caracteres CSS)

Apenas expansão Leaky Nun 's comentário sobre MonkeyZeus ' s resposta . (Embora eu possa interpretar mal o comentário ...)

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

Braquilog , 37 29 bytes

Créditos a Fatalize por sua assistência por toda parte.

4 bytes graças a Fatalize, e inspiração para outros 4 bytes.

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

Experimente online!

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)

Basicamente, isso cria um palíndromo a partir da string especificada.

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

R, 127 125 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"))

Não completamente satisfeito com esta solução, especialmente os dois forloops, mas não pôde vir com algo melhor!
LETTERScontém as letras maiúsculas.

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é uma maneira mais curta de cancelar o envio if... else...e funciona da seguinte maneira:ifelse(condition,action if TRUE, action if FALSE)

Uma solução de outros 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

Sem 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":"")));

Com String (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);

Graças a manatwork e Kevin Cruijssen

brainfuck, 79 bytes

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

Formatado:

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

Experimente online

Sesos , 27 bytes

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

Experimente online! Marque Debug para ver o código SBIN gerado.

Montagem Sesos

O arquivo binário acima foi gerado montando o seguinte 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

Não vencendo, é claro, mas aqui está, anterior a Martin Ender ...