Masz wydrukować dokładnie ten tekst:

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

Okular

• Dodatkowe końcowe znaki nowej linii są dozwolone na końcu danych wyjściowych.
• Dopuszczalne są dodatkowe spacje końcowe (U + 0020) na końcu każdej linii, w tym dodatkowe znaki nowej linii.
• Można używać wszystkich małych liter zamiast wszystkich wielkich liter, ale nie można drukować częściowo małych, a częściowo dużych.
• Możesz zwrócić tekst jako wynik funkcji zamiast drukować go w pełnym programie.

Punktacja

Ponieważ jest to trójkąt, a trójkąt ma 3 boki, a 3 to mała liczba, twój kod powinien być mały pod względem liczby bajtów.

Vim, 37 bajtów

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

Legenda

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

Logo, 232 207 196 190 bajtów

Czy ktoś powiedział trójkąty?

Wyjmij kompas i kątomierz i zróbmy to w sposób graficzny. Geometria wykorzystuje trójkąt równoboczny do wyrównania wyników. Wcześniej miałem trójkąt równoramienny, ale zawierał on zbyt wiele miejsc po przecinku. Ta zmiana również skompaktowała dane wyjściowe, zmniejszając stopień przygotowania ekranu i zmiany czcionek, które musiałem zrobić.

Użyłem interpretera internetowego Calormen, żeby go rozwinąć. Jeśli nie masz wystarczającej liczby nieruchomości na ekranie, wszystko się zawinie, ale możesz też zająć się pewnymi liczbami, aby się tym zająć. W przeglądarce korzystałem z trybu pełnoekranowego „F11”.

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]

rProcedura rysuje linię nznaków. Postać jest określana automatycznie w zależności od tego, ile segmentów ma użyć. Ten bparametr mówi, o ile należy tymczasowo obrócić, aby litery były skierowane we właściwym kierunku. Ten lparametr określa liniową odległość między literami.

Te tetapy procedury do następnego stanowiska i wywołuje rfunkcja czterokrotnie tworzyć trójkąt, obrotowy, gdy to właściwe. Nazwałem go dwa razy dla strony pionowej, ponieważ zajęło to mniej bajtów niż wywołanie go raz ze specjalną obsługą. Koniec procedury ustawia żółwia na początek następnego trójkąta, jeden krok powyżej.

Zto specjalny przypadek, więc po prostu drukujemy go bezpośrednio i obracamy tak, jakbyśmy właśnie zakończyli trójkąt. Wreszcie tnazywa się 25 razy.

Haskell, 58 bajtów

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

Definiuje funkcję, tktóra zwraca dane wyjściowe jako ciąg.

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

Galaretka , 16 13 bajtów

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

Dzięki @LeakyNun za grę w golfa z 3 bajtów!

Wypróbuj online!

Jak to działa

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

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

Funkcja Python 2, która drukuje i nie przyjmuje argumentów. Kluczową ideą jest wygenerowanie trójkątnego wzoru tam i z powrotem z rekurencją. Najpierw rozważ tę prostszą funkcję, która drukuje litery „A” do „Z”, a następnie z powrotem do „A”:

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

Funkcja najpierw drukuje „A” (kod znaków 65), a następnie powraca, aby wydrukować „B” (66) i tak dalej do „Z” (90). Stamtąd przestaje się powtarzać. Po drodze z powrotem w dół stosu rekurencyjnego drukuje dowolny znak twydrukowany na tej samej warstwie, od „Y” z powrotem do „A”.

Główny kod robi to samo, tyle że do stej pory kumuluje się w ciąg liter i drukuje ciąg w górę iw dółs+s[-2::-1] .

Dzięki xsot za 2 bajty.

W Pythonie 3 ta sama rzecz jest krótsza o bajt (73 bajty) poprzez umieszczenie wszystkiego w jednym wierszu.

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 bajtów

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

Nieco bardziej czytelna wersja:

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

Wyjaśnienie, które może nadejść.

05AB1E , 20 13 12 6 bajtów

Zaoszczędzono 2 bajty dzięki Adnan.
Oszczędność 6 bajtów dzięki Magic Octopus Urn i nowym funkcjom językowym.

Aη€ûû»

Wypróbuj online!

Wyjaśnienie

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

J, 26 23 22 bajtów

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

Wyjaśnienie

,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 bajtów

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

Ideone to!

Rubinowy, 71 bajtów

Wypróbuj na repl.it

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

> <> , 60 bajtów

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

Wypróbuj online!

C, 272 247 234 230 144 137 bajtów:

( Zapisałem wiele bajtów ( 272 -> 230) w mojej poprzedniej metodzie dzięki świetnym wskazówkom i sztuczkom golfowym z sigalor ! )

( Zaoszczędzono prawie 100 bajtów ( 230 -> 144), przechodząc na lepszą metodę ).

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

Moja pierwsza odpowiedź w życiu C. Niedawno zacząłem sam się uczyć, więc zobaczmy, jak to będzie.

C it in Action! (Ideone)

JavaScript (ES6), 81 bajtów

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

Mathematica 59 bajtów

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

Dyalog APL, 18 bajtów

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

R, 63 61 59 bajtów

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

Pomocnie LETTTERS[0]nie zwraca żadnych znaków.

Edycja: straciłem jedną dzięki @leakynun

Edycja: jeszcze dwa dzięki @plannapus

TSQL, 159 bajtów

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

Skrzypce

JavaScript (przy użyciu zewnętrznej biblioteki-Enumerable), 135 bajtów

_.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 do biblioteki: https://github.com/mvegh1/Enumerable

Objaśnienie kodu: Utwórz zakres liczb całkowitych zaczynając od 1, dla liczby 51. Dla każdego napisz wiersz zgodnie ze złożonym pred. Wykonaj czar JS przy użyciu zmiennych globalnych i buforowania ... i voila. Dla każdej int w WriteLine tworzymy lewy zakres ints i zapisujemy je w globalnym „g”, i String Joining (Write) z ""separatorem i mapujemy każdą int na mapowanie String na kod int int char. Następnie konkatujemy prawą stronę, wykonując odwrócenie tej sekwencji (i pomijając pierwszy element, ponieważ będzie on pasował do ostatniego elementu pierwotnej kolejności ...), pisząc z tą samą logiką. EDYCJA: Zaktualizowano elementy wewnętrzne zapisu w bibliotece. Pusta sekwencja zapisze teraz pusty ciąg zamiast null. Ogoliło to również 15 bajtów odpowiedzi

PowerShell, 61 52 bajtów

Dzięki TimmyD za oszczędność 9 bajtów!

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

Pętle przechodzą przez wartości ASCII dla wielkich liter do przodu, a następnie do tyłu. Dla każdej liczby tworzy to tablicę pierwszych liczb X, usuwa liczbę X-1, a następnie dodaje odwrotność pierwszych liczb X, które są następnie rzutowane na znaki i łączone w ciąg.

Cheddar , 102 96 79 69 67 bajtów

17 bajtów dzięki Downgoat i inspiracja na kolejne 10.

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

Fakt, że łańcuchy mogą łączyć, ale nie tablice, oznacza, że ​​musiałbym przekonwertować dwa zakresy na łańcuchy, konkatenować, a następnie przekonwertować z powrotem na tablice.

Ponadto fakt, że vfuseprodukuje wiodące newliens oznacza, że ​​musiałbym wygenerować pierwszą linię ręcznie, a następnie połączyć się z resztą.

@" ponieważ diada (funkcja dwóch argumentów) może konwertować bezpośrednio na ciąg znaków, ale nie działa dla odwróconego zakresu (jeśli pierwszy argument jest większy niż drugi).

Zakres był w połowie wliczony. Po usunięciu błędu stało się ono włączone.

Stosowanie

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 bajtów (niekonkurencyjny)

W najnowszej wersji ze wszystkimi poprawkami odpowiedź brzmi:

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

ale powstał po wyzwaniu.

C, 93 bajty

Zadzwoń f()bez argumentów.

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

Wypróbuj na ideone .

VBA, 94 bajty

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

Zadzwoń w Natychmiastowym oknie za pomocą? T

Aby wyjaśnić, co się dzieje: używam dwukrotnie funkcji Abs, aby odzwierciedlić zarówno ruch alfabetu, jak i długość linii. Jest dobrze dostosowany do zadania ze względu na jedną ekstremalną wartość w obu przypadkach, która odpowiada zerowemu przejściu zmiennej pre-Abs.

Jako prosty zestaw poleceń w oknie Natychmiastowe VBA, a nie program lub funkcja, następujące wymagałyby 72 bajtów:

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

(dzięki dzięki @GuitarPicker)

Python, 73 71 bajtów

Dzięki @xnor za rekursję

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

Wyjaśnienie

• Parametry :
  • x to wartość ascii następnej litery w alfabecie
  • s jest akumulatorem dla alfabetu
  • tjest linią w trójkącie (tj. s+ s backwards)
• Powrót : tjeśli alfabet jest gotowy (tj. Jesteśmy w centrum)
• W przeciwnym razie : t+f(...)+tz:
  • x zwiększony
  • s dołączony do następnego listu
  • tzresetować do s+ s backwards+\n

Aktualizacja

• -2 [16-08-05] Usuń wiodące \n(+1) i skrócone warunkowe (-3) wszystko dzięki @xnor

HTML + CSS, 884 znaków

(763 znaki HTML + 121 znaków CSS)

Tylko rozszerza Dziurawy Nun „s komentarz na MonkeyZeus ” s odpowiedź . (Chociaż mogę źle odczytać komentarz…)

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 bajtów

Podziękowania dla Fatalize za jego pomoc przez cały czas.

4 bajty dzięki Fatalize i inspiracja dla kolejnych 4 bajtów.

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

Wypróbuj online!

Predykat 0 (główny predykat)

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

Predykat 1 (orzecznik pomocniczy)

To w zasadzie buduje palindrom z podanego ciągu.

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

R, 127 125 bajtów

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

Nie do końca usatysfakcjonowany tym rozwiązaniem, zwłaszcza dwiema forpętlami, ale nie mógł zaoferować czegoś lepszego!
LETTERSzawiera wielkie litery.

Nie golfowany:

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

ifelsejest krótszym sposobem na odpalenie if... else...i działa w ten sposób:ifelse(condition,action if TRUE, action if FALSE)

Inne 125 bajtowe rozwiązanie:

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 bajtów

Bez użycia ciągu (131 bajtów)

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

Z ciągiem (173 bajtów)

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

Dzięki manatwork i Kevin Cruijssen

pieprzenie mózgu, 79 bajtów

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

Sformatowany:

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

Wypróbuj online

Sesos , 27 bajtów

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

Wypróbuj online! Sprawdź debugowanie opcję aby zobaczyć wygenerowany kod SBIN.

Montaż Sesos

Powyższy plik binarny został wygenerowany przez skompletowanie następującego kodu 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 bajtów

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

Oczywiście nie wygrywa, ale oto jest, wyprzedzając Martina Endera ...