Vous devez imprimer ce texte exact:

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

Spécifications

• Les nouvelles lignes de fin sont autorisées à la fin de la sortie.
• Des espaces de fin supplémentaires (U + 0020) sont autorisés à la fin de chaque ligne, y compris les nouvelles lignes de fin.
• Vous pouvez utiliser toutes les minuscules au lieu de toutes les majuscules, mais vous ne pouvez pas imprimer partiellement minuscule, partiellement partiellement majuscule.
• Vous pouvez renvoyer le texte sous forme de sortie de fonction au lieu de l'imprimer dans un programme complet.

Notation

Comme il s'agit d'un triangle et que celui-ci a 3 côtés et que 3 est un petit nombre, votre code doit être petit en termes de nombre d'octets.

Vim, 37 octets

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

Légende

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

Logo, 232 207 196 190 octets

Est-ce que quelqu'un a dit des triangles?

Sortez votre boussole et votre rapporteur et procédons de manière graphique. La géométrie utilise un triangle équilatéral pour aligner les résultats. J'avais précédemment un triangle isocèle, mais celui-ci impliquait trop de décimales. Cette modification a également compacté la sortie, réduisant ainsi le nombre de préparations d'écran et de modifications de polices que je devais faire.

J'ai utilisé l' interprète en ligne Calormen pour étoffer celui-ci. Si vous ne disposez pas de suffisamment d’écran, cela s’emballe, mais vous pouvez aussi manipuler des chiffres pour s’occuper de cela. J'ai utilisé le mode plein écran "F11" sur mon navigateur.

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 rprocédure dessine une ligne de ncaractères. Le caractère est déterminé automatiquement en fonction du nombre de segments à utiliser. Le bparamètre indique la quantité de rotation temporaire à effectuer pour que les lettres soient orientées dans la bonne direction. Le lparamètre détermine la distance linéaire entre les lettres.

La tprocédure passe à la position suivante et appelle la rfonction quatre fois pour créer un triangle, en effectuant une rotation si nécessaire. Je l'ai appelé deux fois pour le côté vertical car cela prenait moins d'octets que si on l'appelait une fois avec un traitement spécial. La fin de la procédure positionne la tortue pour le début du prochain triangle, une étape plus haut.

Zest un cas spécial, nous l’imprimons donc directement et nous tournons comme si nous venions de terminer un triangle. Enfin, test appelé 25 fois.

Haskell, 58 octets

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

Définit une fonction tqui renvoie la sortie sous forme de chaîne.

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ée , 16 à 13 octets

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

Merci à @ LeakyNun pour le golf de 3 octets!

Essayez-le en ligne!

Comment ça fonctionne

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

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

Une fonction Python 2 qui imprime et ne prend aucun argument. L'idée principale est de générer le motif triangulaire aller-retour avec récursivité. Considérons d’abord cette fonction plus simple qui imprime les lettres «A» jusqu’à «Z» et de nouveau à «A»:

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

La fonction commence par imprimer "A" (code 65), puis revient à imprimer "B" (66) et ainsi de suite sur "Z" (90). A partir de là, ça cesse de récurer. En redescendant la pile récursive, il imprime le caractère timprimé sur le même calque, de "Y" à "A".

Le code principal fait la même chose, à la différence qu’il s’accumule sjusqu’à présent dans la chaîne de lettres et imprime la chaîne en haut et en bas s+s[-2::-1].

Merci à xsot pour 2 octets.

En Python 3, la même chose est un octet plus court (73 octets) en mettant tout sur une seule ligne.

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 octets

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

Version légèrement plus lisible:

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

Explication à venir éventuellement.

05AB1E , 20 13 12 6 octets

Sauvegardé 2 octets grâce à Adnan.
Sauvegardé 6 octets grâce à Magic Octopus Urn et à de nouvelles fonctionnalités linguistiques.

Aη€ûû»

Essayez-le en ligne!

Explication

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

J, 26 23 22 octets

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

Explication

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

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

Ideone ça!

Ruby, 71 octets

Essayez-le sur repl.it

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

> <> , 60 octets

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

Essayez-le en ligne!

C, 272 247 234 230 144 144 137 octets:

( Sauvegardé de nombreux octets ( 272 -> 230) dans ma méthode précédente grâce aux excellents conseils et astuces de sigalor concernant le golf ! )

( Sauvegardé près de 100 octets ( 230 -> 144) en passant à une meilleure méthode. )

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

Ma première réponse dans C. Je viens de commencer l'auto-apprentissage récemment, alors voyons comment ça se passe.

C it en action! (Idéone)

JavaScript (ES6), 81 octets

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

Mathematica 59 octets

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

Dyalog APL, 18 octets

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

R, 63 61 59 octets

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

Utilement LETTTERS[0]ne renvoie aucun caractère.

Edit: perdu un grâce à @leakynun

Edit: deux autres grâce à @plannapus

TSQL, 159 octets

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

Violon

Javascript (en utilisant une bibliothèque externe-Enumerable), 135 octets

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

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication de code: Créez une plage d’entités commençant à 1, pour un compte de 51. Pour chacune d’elles, écrivez une ligne en fonction de la variable pred. Faites de la magie JS avec des variables globales et la mise en cache ... et le tour est joué. Pour chaque int de WriteLine, nous créons la plage de gauche des entrées et les stockons dans un "g" global, ainsi que la jonction de chaînes (écriture) avec un ""délimiteur et mappons chaque int sur le mappage de chaîne sur le code de caractère int. Ensuite, nous concattrons le côté droit en prenant le renversement de cette séquence (et en sautant le premier élément car cela correspondra au dernier élément de la commande d'origine ...), en écrivant avec la même logique. EDIT: Mise à jour des composants internes de Write dans la bibliothèque. Une séquence vide écrira une chaîne vide au lieu de null maintenant. Cela a également rasé 15 octets de la réponse

Powershell, 61 52 octets

Merci à TimmyD d’avoir économisé 9 octets!

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

Parcourt les valeurs ASCII pour les lettres majuscules en avant, puis en arrière. Pour chaque numéro, cela crée un tableau des X premiers chiffres, supprime le X-1er numéro, puis ajoute l'inverse des premiers X chiffres, qui sont tous ensuite convertis en caractères et réunis dans une chaîne.

Cheddar , 102 96 79 69 67 octets

17 octets grâce à Downgoat et source d’inspiration pour 10 autres.

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

Le fait que les chaînes puissent concaténer mais pas les tableaux signifie que je devrais convertir les deux plages en chaînes, concaténer, puis reconvertir en tableaux.

De plus, le fait de vfuseproduire un newliens de premier plan signifie que j’aurais besoin de générer la première ligne manuellement puis de concaténer le reste.

@" en tant que dyade (fonction à deux arguments) peut convertir directement en chaîne, mais ne fonctionne pas pour la plage inversée (si le premier argument est plus grand que le second).

Gamme était demi-inclus. Après le correctif, il est devenu inclusif.

Usage

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 octets (non concurrents)

Dans la dernière version avec tous les correctifs, la réponse est:

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

mais c'était fait après le challenge.

C, 93 octets

Appel f()sans arguments.

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

Essayez sur ideone .

VBA, 94 octets

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

Appeler dans la fenêtre immédiate avec? T

Juste pour expliquer ce qui se passe: j’utilise deux fois la fonction Abs pour refléter à la fois le chemin de l’alphabet et la longueur de la ligne. Il est bien adapté à la tâche en raison de la valeur extrême unique dans les deux cas, qui correspond au passage par zéro de la variable pré-Abs.

En tant que simple jeu de commandes dans la fenêtre Immédiat de VBA, plutôt qu’un programme ou une fonction, les éléments suivants auraient besoin de 72 octets:

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

(avec merci à @GuitarPicker)

Python, 73 71 octets

Merci à @xnor pour la récursion

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

Explication

• Paramètres :
  • x est la valeur ascii de la lettre suivante de l'alphabet
  • s est un accumulateur pour l'alphabet
  • test une ligne dans le triangle (ie s+ s backwards)
• Retour : tsi l'alphabet est terminé (c'est-à-dire que nous sommes au centre)
• Sinon : t+f(...)+tavec:
  • x incrémenté
  • s annexé à la lettre suivante
  • tréinitialiser à s+ s backwards+\n

Mise à jour

• -2 [16-08-05] Supprimez les majuscules \n(+1) et les raccourcis conditionnels (-3), grâce à @xnor

HTML + CSS, 884 caractères

(763 caractères HTML + 121 caractères CSS)

Juste expansion Leaky Nun 's commentaire sur MonkeyZeus ' s réponse . (Bien que je puisse mal interpréter le commentaire…)

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 octets

Crédits à Fataliser pour son aide tout au long.

4 octets grâce à Fatalize et inspiration pour 4 autres octets.

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

Essayez-le en ligne!

Prédicat 0 (prédicat 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.

Prédicat 1 (prédicat auxiliaire)

Cela construit essentiellement un palindrome à partir de la chaîne donnée.

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

R, 127 125 octets

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

Pas complètement satisfait de cette solution, en particulier des deux forboucles, mais ne pourrait pas venir avec quelque chose de mieux!
LETTERScontient les lettres majuscules.

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

ifelseest un moyen plus simple de décompresser if... else...et fonctionne de la manière suivante:ifelse(condition,action if TRUE, action if FALSE)

Une autre solution de 125 octets:

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 octets

Sans utiliser String (131 octets)

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

Codé

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

Avec chaîne (173 octets)

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

Codé

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

Merci à manatwork et à Kevin Cruijssen

brainfuck, 79 octets

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

Formaté:

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

Essayez-le en ligne

Sesos , 27 octets

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

Essayez-le en ligne! Cochez Debug pour voir le code SBIN généré.

Assemblage Sesos

Le fichier binaire ci-dessus a été généré en assemblant le code SASM suivant.

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 octets

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

Pas gagnant, bien sûr, mais le voilà, précédant Martin Ender ...