Diesen genauen Text drucken Sie aus:

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

Technische Daten

• Zusätzliche nachgestellte Zeilenumbrüche sind am Ende der Ausgabe zulässig.
• Zusätzliche nachgestellte Leerzeichen (U + 0020) sind am Ende jeder Zeile zulässig, einschließlich der zusätzlichen nachgestellten Zeilenumbrüche.
• Sie können alle Kleinbuchstaben anstelle von Großbuchstaben verwenden, jedoch nicht teilweise Kleinbuchstaben und teilweise Großbuchstaben drucken.
• Sie können den Text als Funktionsausgabe zurückgeben, anstatt ihn in einem vollständigen Programm zu drucken.

Wertung

Da dies ein Dreieck ist und ein Dreieck drei Seiten hat und 3 eine kleine Zahl ist, sollte Ihr Code in Bezug auf die Anzahl der Bytes klein sein.

Vim, 37 Bytes

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

Legende

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

Logo, 232 207 196 190 Bytes

Hat jemand Dreiecke gesagt?

Nehmen Sie Ihren Kompass und Winkelmesser heraus und lassen Sie uns dies auf grafische Weise tun. Die Geometrie verwendet ein gleichseitiges Dreieck, um die Ergebnisse auszurichten. Früher hatte ich ein gleichschenkliges Dreieck, aber es enthielt zu viele Dezimalstellen. Durch diese Änderung wurde auch die Ausgabe komprimiert, wodurch sich die Anzahl der Bildschirmvorbereitungen und Schriftänderungen verringerte, die ich durchführen musste.

Ich habe den Online-Dolmetscher von Calormen verwendet, um diesen zu konkretisieren. Wenn Sie nicht genug Platz auf dem Bildschirm haben, wird es sich ändern, aber Sie können auch mit einigen Zahlen experimentieren, um das zu erledigen. Ich habe in meinem Browser den Vollbildmodus "F11" verwendet.

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]

Die rProzedur zeichnet eine Reihe von nZeichen. Das Zeichen wird automatisch bestimmt, je nachdem, wie viele Segmente es verwenden soll. Der bParameter gibt an, wie viel vorübergehend gedreht werden muss, damit die Buchstaben in die richtige Richtung zeigen. Der lParameter bestimmt den linearen Abstand zwischen Buchstaben.

Die tProzedur wechselt zur nächsten Position und ruft die rFunktion viermal auf, um ein Dreieck zu erstellen, das bei Bedarf gedreht wird. Ich habe es zweimal für die vertikale Seite aufgerufen, weil das weniger Bytes in Anspruch nahm als das einmalige Aufrufen mit spezieller Behandlung. Das Ende des Vorgangs positioniert die Schildkröte für den Beginn des nächsten Dreiecks, einen Schritt darüber.

Zist ein Sonderfall, also drucken wir es einfach direkt und drehen es so, als ob wir gerade ein Dreieck fertiggestellt hätten. Schließlich twird 25 mal angerufen.

Haskell, 58 Bytes

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

Definiert eine Funktion t, die die Ausgabe als Zeichenfolge zurückgibt.

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

Jelly , 16 13 Bytes

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

Vielen Dank an @LeakyNun für das Golfen mit 3 Bytes!

Probieren Sie es online!

Wie es funktioniert

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

Eine Python 2-Funktion, die druckt und keine Argumente akzeptiert. Die Schlüsselidee besteht darin, das dreieckige Hin- und Rückmuster mit Rekursion zu erzeugen. Betrachten Sie zuerst diese einfachere Funktion, die die Buchstaben 'A' bis 'Z' und zurück bis 'A' druckt:

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

Die Funktion druckt zuerst "A" (Zeichencode 65), dann wieder "B" (66) und so weiter bis "Z" (90). Von dort hört es auf, sich zu wiederholen. Auf dem Weg zurück in den rekursiven Stapel druckt es jedes Zeichen, das tes auf derselben Ebene gedruckt hat, von "Y" zurück zu "A".

Der Hauptcode macht dasselbe, mit der Ausnahme, dass er sich sbis jetzt in der Buchstabenfolge ansammelt und die Auf- und Ab-Zeichenfolge druckt s+s[-2::-1].

Danke an xsot für 2 Bytes.

In Python 3 ist dasselbe ein Byte kürzer (73 Byte), indem alles in eine Zeile gesetzt wird.

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

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

Etwas besser lesbare Version:

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

Erklärung möglicherweise zu kommen.

05AB1E , 20 13 12 6 Bytes

2 Bytes gespart dank Adnan.
6 Bytes gespart dank Magic Octopus Urn und einigen neuen Sprachfunktionen.

Aη€ûû»

Probieren Sie es online!

Erläuterung

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

Erläuterung

,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 es!

Ruby, 71 Bytes

Probieren Sie es auf 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*

Probieren Sie es online!

C 272 247 234 230 144 137 Bytes:

( Ich habe in meiner vorherigen Methode viele Bytes ( 272 -> 230) gespart , dank großartiger Golftipps und -tricks von Sigalor ! )

( Durch Umstellung auf eine bessere Methode wurden fast 100 Byte ( 230 -> 144) eingespart. )

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

Meine erste Antwort in C. Ich habe gerade erst angefangen, es selbst zu lernen, also lass uns sehen, wie es läuft.

C es in Aktion! (Ideone)

JavaScript (ES6), 81 Byte

[...'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="")

Hilfreich LETTTERS[0] gibt keine Zeichen zurück.

Edit: habe dank @leakynun einen verloren

Edit: noch zwei dank @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

Geige

Javascript (mit externer Bibliothek-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))))

Link zur Bibliothek: https://github.com/mvegh1/Enumerable

Codeerklärung: Erstellen Sie einen Bereich von Ints beginnend bei 1 für eine Anzahl von 51. Schreiben Sie für jede Zeile eine Zeile gemäß komplexem pred. Machen Sie etwas JS-Zauberei mit globalen Variablen und Caching ... und Voila. Für jedes int in WriteLine erstellen wir den linken Bereich von ints und speichern ihn in globalem "g" und String Joining (Write) mit ""Trennzeichen und ordnen jedes int dem String zu, der dem int-Zeichencode zugeordnet ist. Dann konzentrieren wir uns auf die rechte Seite, indem wir die Umkehrung dieser Sequenz nehmen (und das erste Element überspringen, da dies mit dem letzten Element der ursprünglichen Reihenfolge übereinstimmt ...) und mit derselben Logik schreiben. EDIT: Aktualisiert die Interna von Write in der Bibliothek. Eine leere Sequenz schreibt jetzt eine leere Zeichenfolge anstelle von null. Dies sparte auch 15 Bytes der Antwort ein

Powershell, 61 52 Bytes

Danke an TimmyD für das Speichern von 9 Bytes!

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

Durchläuft ASCII-Werte für Großbuchstaben vorwärts und rückwärts. Für jede Zahl wird ein Array der ersten X-Nummern erstellt, die erste X-Nummer entfernt und dann die Umkehrung der ersten X-Nummern hinzugefügt, die dann in Zeichen umgewandelt und zu einer Zeichenfolge verbunden werden.

Cheddar , 102 96 79 69 67 Bytes

17 Bytes dank Downgoat und Inspiration für 10 weitere.

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

Die Tatsache, dass Zeichenfolgen verketten können, aber keine Arrays, bedeutet, dass ich die beiden Bereiche in Zeichenfolgen konvertieren, verketten und dann wieder in Arrays konvertieren müsste.

Auch die Tatsache, dass vfuse ein führender Neuzugang erzeugt wird, bedeutet auch, dass ich die erste Zeile manuell generieren und mich dann auf den Rest konzentrieren müsste.

@" als dyad (Zwei-Argument-Funktion) kann direkt in einen String konvertiert werden, funktioniert jedoch nicht für den umgekehrten Bereich (wenn das erste Argument größer als das zweite ist).

Reichweite war halb inklusive. Nach dem Bugfix wurde es inklusive.

Verwendungszweck

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 (nicht konkurrierend)

In der neuesten Version mit allen Korrekturen lautet die Antwort:

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

aber es wurde nach der Herausforderung gemacht.

C 93 Bytes

Aufruf f()ohne Argumente.

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

Probiere es auf ideone aus .

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

Rufen Sie im Sofortfenster mit? T auf

Um nur zu erklären, was los ist: Ich verwende die Abs-Funktion zweimal, um sowohl die Alphabet-Traverse als auch die Zeilenlänge wiederzugeben. Es ist für die Aufgabe gut geeignet, da in beiden Fällen nur ein Extremwert vorliegt, der dem Nulldurchgang der Variablen vor Abs entspricht.

Als einfacher Befehlssatz im VBA-Direktfenster werden anstelle eines Programms oder einer Funktion 72 Byte benötigt:

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

(danke an @GuitarPicker)

Python, 73 71 Bytes

Vielen Dank an @xnor für die Rekursion

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

Erläuterung

• Parameter :
  • x ist der ASCII-Wert des nächsten Buchstabens im Alphabet
  • s ist ein akkumulator für das alphabet
  • tist eine Linie im Dreieck (dh s+ s backwards)
• Return : twenn das Alphabet fertig ist (dh wir sind in der Mitte)
• Sonst : t+f(...)+tmit:
  • x erhöht
  • s mit dem nächsten Brief angehängt
  • tauf s+ s backwards+ zurücksetzen\n

Aktualisieren

• -2 [16-08-05] Entferne alle führenden \n(+1) und verkürzten bedingten (-3) dank @xnor

HTML + CSS, 884 Zeichen

(763 Zeichen HTML + 121 Zeichen CSS)

Gerade expandierende Leaky Nun 's Kommentar auf MonkeyZeus ' s Antwort . (Obwohl ich den Kommentar falsch lesen könnte ...)

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

Dank an Fatalize für seine Unterstützung.

4 Bytes dank Fatalize und Inspiration für weitere 4 Bytes.

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

Probieren Sie es online!

Prädikat 0 (Hauptprädikat)

@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ädikat 1 (Hilfsprädikat)

Dies baut im Grunde ein Palindrom aus der gegebenen Zeichenfolge auf.

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

Mit dieser Lösung nicht ganz zufrieden, besonders mit den beiden forSchleifen, aber mit etwas Besserem geht es nicht!
LETTERSenthält die Großbuchstaben.

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

ifelseist ein kürzerer Weg zum Abmelden if... else...und funktioniert so:ifelse(condition,action if TRUE, action if FALSE)

Eine andere 125-Byte-Lösung:

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

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

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

Vielen Dank an Manatwork und Kevin Cruijssen

Brainfuck, 79 Bytes

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

Formatiert:

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

Probieren Sie es online aus

Sesos , 27 Bytes

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

Probieren Sie es online! Überprüfen Sie das Debuggen , um den generierten SBIN-Code anzuzeigen.

Sesos Montage

Die obige Binärdatei wurde durch Zusammenstellen des folgenden SASM-Codes generiert.

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

Natürlich nicht gewinnen, aber hier ist es, vor Martin Ender ...