Schreiben Sie in so wenigen Bytes wie möglich ein Programm oder eine Funktion, die Folgendes ausgibt:

Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwxyZ
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
Abcdefghijklmnopqrstuvwxyz

Ein abschließender Zeilenumbruch ist zulässig. Eine Referenz zu ungolfed Python finden Sie hier .

Pyth, 12 Bytes

V+Gt_GXGNrN1

Demonstration.

In Pyth Gist das Kleinbuchstaben. +Gt_Gist abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbadas Zeichen, das in jeder Zeile in Großbuchstaben geschrieben werden muss.

VRichtet eine for-Schleife über dieser Zeichenfolge mit Nals Schleifenvariable ein.

Im Körper XGNrN1befindet sich eine String-Übersetzungsfunktion. Xübersetzt Gdas Alphabet und ersetzt es Ndurch rN1die Großbuchstabenversion von N. r ... 1ist die Großbuchstabenfunktion. Dies ergibt die gewünschte Ausgabe.

C 73

Manchmal ist der einfachste Ansatz der beste: Drucken Sie jedes Zeichen einzeln aus. Das schlägt viele Sprachen, die es eigentlich nicht sollte.

i;f(){for(i=1377;i--;)putchar(i%27?123-i%27-32*!(i/702?i%28-4:i%26):10);}

Erläuterung

i;f(){
   for(i=1377;i--;)
   putchar(i%27?                 //if I not divisible by 27
     123-i%27-                   //  print lowercase letter from ASCII 122 downards
       32*!(i/702?i%28-4:i%26)   //  subtract 32 to make it uppercase where necessary: above i=702, use i%28-4, below it use i%26
     :10);                       //if I divisible by 27 print a newline (10)
}

Python 2, 69 Bytes

i=25
exec"L=range(97,123);L[~abs(i)]^=32;i-=1;print bytearray(L);"*51

Schön und einfach, denke ich.

Brainfuck (8 Bit), 231 Byte

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

Ok, es wird nie die kürzeste sein, aber es ist die Teilnahme, die zählt ... richtig ?!

Probieren Sie es hier aus (stellen Sie sicher, dass 'Dynamischer Speicher' angekreuzt ist)

MS-DOS Binary, 61

Dieser Code muss nicht kompiliert werden. Er wird unter MS-DOS ausgeführt, wenn Sie ihn in eine Datei namens wave.com schreiben. Der Code in hex:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Oder, wenn Sie etwas besser lesbares bevorzugen, können Sie es wie folgt mit debug.exe erzeugen (die leere Zeile nach dem Code ist wichtig):

debug.exe wave.com
a
mov dx,13d
mov di,dx
mov cx,1a
mov al,61
stosb
inc ax
dec cx
jnz 10a
mov al,a
stosb
mov al,d
stosb
mov al,24
stosb
xor si,si
call 130
inc si
cmp si,1a
jnz 11a
mov si,18
call 130
dec si
jnz 126
call 130
ret
mov bx,dx
sub byte ptr [si+bx],20
mov ah,9
int 21
add byte ptr [si+bx],20
ret

rcx
3e
w
q

Ruby: 71 68 65 63 Zeichen

puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse

Probelauf:

bash-4.3$ ruby -e 'puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz

Matlab, 60 58 54 Bytes

I=32*eye(26);[ones(51,1)*(97:122) '']-[I;I(25:-1:1,:)])

Vielen Dank an Dennis Jaheruddin , der mir 4 Bytes gespart hat.

SWI-Prolog, 136 Bytes

a:-(R=0;R=1),between(1,26,I),(I=1,R=0;I\=1,nl),between(1,26,J),(R=0,L=I;R=1,L is 27-I),(J=L,K is J+64,put(K);J\=L,K is J+96,put(K)),\+!.

Backtracking missbrauchen, um eine Schleife zu erstellen ...

Haskell 100 89 88 Bytes

putStr$map toEnum.(\(h,c:t)->h++c-32:t++[10]).(`splitAt`[97..122]).(25-).abs=<<[-25..25]

Die Lambda-Hilfsfunktion verwendet \(h,c:t)zwei Listen mit ASCII-Werten und verknüpft beide, wobei jedoch der erste Wert der zweiten Liste groß geschrieben wird. Die Hauptfunktion teilt das Kleinbuchstaben (in ASCII 97..122) an jeder Position 0,..,24,25,24,..,0und ruft in jedem Schritt das Lambda auf. Vor dem Drucken wird jeder Wert in das entsprechende Zeichen umgewandelt.

Scala 110 109 Zeichen

val a=('a'to'z').map(c⇒('a'to'z').map(v⇒if(v==c)c.toUpper else v).mkString)
a++a.init.reverse foreach println

SQL (postgreSQL), 107 101

Generieren Sie Serien von -25 bis 25 und ersetzen Sie Zeichen mit dem absoluten Wert durch ihre Großbuchstaben. Danke an manatwork für den Tipp zum @ -Operator.

select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)

Haskell, 81 Bytes

Zählen von Bytes wie @nimi; fist eine E / A-Aktion, die die gewünschte Ausgabe druckt.

x!y|x==min(50-y)y=65|0<1=97
f=mapM putStrLn[[toEnum$x+x!y|x<-[0..25]]|y<-[0..50]]

Pyth - 18 17 Bytes

Erster Durchgang, wahrscheinlich kann viel kürzer gemacht werden. Verwendet, um Xzu ersetzen und r1zu kapitalisieren.

V+KU26t_KXGNr@GN1

Probieren Sie es hier online aus .

MATLAB - 58 Bytes

char(bsxfun(@minus,97:122,32*[eye(25,26);rot90(eye(26))]))

Ähnlich wie die Lösung von Luis Mendo , jedoch mit den Sendefähigkeiten von bsxfun.

Ausgehend davon, dass in ASCII der Unterschied zwischen Groß- und Kleinbuchstaben genau 32 Werte voneinander entfernt ist, erzeugen wir zunächst Kleinbuchstaben aus den ASCII-Codes 97 bis 122, die dann jeweils die ASCII-Codes von Kleinbuchstaben a bis Kleinbuchstaben z sind Erstellen Sie eine Matrix mit 51 Zeilen, die die 26 ASCII-Codes von 97 bis 122 enthält. Daher enthält jede Zeile dieser Matrix eine numerische Folge von Werten von 97 bis 122. Als Nächstes erstellen wir eine weitere Matrix, in der jede i- ^te Zeile dieser Matrix a enthält 32 in der i- ^ten Spalte. Die ersten 26 Zeilen dieser Matrix haben dieses Muster, das im Wesentlichen die Identitätsmatrix multipliziert mit 32 ist. Die Funktioneyeerstellt für Sie eine Identitätsmatrix. Die letzten 25 Zeilen dieser Matrix sind die um 90 Grad gedrehten skalierten Identitätsmatrizen.

Indem diese benutzerdefinierte gewichtete Identitätsmatrix verwendet und diese mit der ersten Matrix subtrahiert und dann die resultierenden ASCII-Codes in Zeichen konvertiert wird, wird die gewünschte "Mexican Hat" -Sequenz erzeugt.

Beispiellauf

>> char(bsxfun(@minus,97:122,32*[eye(25,26);rot90(eye(26))]))

ans =

Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwxyZ
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
Abcdefghijklmnopqrstuvwxyz

Sie können dieses Beispiel auch in der Online-Octave-Umgebung von IDEone ausführen. Octave ist im Wesentlichen MATLAB, aber kostenlos: http://ideone.com/PknMe0

J, 31-23 Bytes

u:|:(97+i.26)-32*=|i:25

8 Bytes gespart dank @Mauris.

Probieren Sie es hier online aus.

Perl, 51 Bytes

50 Byte Code + 1 Byte Befehlszeilenparameter

@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25

Kann wie folgt verwendet werden:

perl -le '@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25'

Oder online hier (Anmerkung, die ich hinzufügen musste ,"\n", da ich das -l Argument nicht hinzufügen konnte).

Viel längere Methode Vor der oben verkürzten Version habe ich eine andere Methode ausprobiert, die ziemlich klobig war. Ich habe es trotzdem unten als Referenz gelassen.

86 Byte Code + 1 Byte Befehlszeilenargument

$_=join"",0,a..z,1;print s/1//r while s/(([A-Z])|0)(\D)|(.)((?2))(1)/\L\2\U\3\4\6\L\5/

Das erste Perl, das ich jemals richtig golfen habe, also stelle ich mir vor, dass damit eine Menge getan werden kann - bitte schlagen Sie Verbesserungen vor!

Kann wie folgt verwendet werden:

perl -le '$_=join"",0,a..z,1;print s/1//r while s/(([A-Z])|0)(\D)|(.)((?2))(1)/\L\2\U\3\4\6\L\5/'

Oder hier online (Anmerkung, ich musste hinzufügen. "\ N", da ich das -l-Argument nicht hinzufügen konnte).

Erläuterung

Der allgemeine Ansatz besteht darin, die Regex-Substitution zu verwenden, um die ganze harte Arbeit zu erledigen. Wir beginnen mit:

0abcdefghijklmnopqrstuvwxyz1

Dies entspricht (([A-Z])|0)(\D)und wird durch \U\3(\ U wird in Großbuchstaben geändert) ersetzt, um Folgendes zu erhalten:

Abcdefghijklmnopqrstuvwxyz1

Ab diesem Zeitpunkt passen wir weiterhin denselben regulären Ausdruck an und ersetzen ihn durch \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Jetzt stimmt die zweite Abwechslung des regulären Ausdrucks überein (.)((?2))(1)(das ist dasselbe wie (.)([A-Z])(1)). Wir ersetzen mit \U\4\6\L\5zu geben:

abcdefghijklmnopqrstuvwxY1z

Dies passt und ersetzt so lange, bis wir Folgendes erreichen:

A1bcdefghijklmnopqrstuvwxyz

und es gibt keine regulären Übereinstimmungen mehr.

An jedem Punkt in der Schleife streifen wir die '1' ab und drucken.

PHP, 87 71 69 Bytes

Nicht die kürzeste, aber sie funktioniert wie vorgesehen.
Vielen Dank an @manatwork für ein paar Tipps, um die Größe um ein Vielfaches zu reduzieren.
Und dank @Blackhole konnte die Größe um 2 Bytes reduziert werden.

for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'
';

Nicht gerade hübsch, aber funktioniert.

PowerShell 3.0, 82 Byte

$(0..25)+$(24..0)|%{$i=$_;[string](@(97..122)|%{[char]@($_,($_-32))[$_-eq$i+97]})}

TIS-Knotentyp T21-Architektur - 216 215 Bytes

Sehen Sie es hier in Aktion! Es gibt ein DOWNVideo in dem ich später Golf gespielt habe ANY, aber es ist funktional identisch.

Diese Sprache kennt keine Zeichenketten oder Zeichen, daher sollte ich darauf hinweisen, dass ich ASCII-Werte verwende, dh die Ausgabe beginnt 97, 66, 67... 88, 89, 90, 10, 65, 98...

Hier ist der Code im Format der Sicherungsdaten des TIS-100 zum Zwecke der Bewertung:

@5
ADD 25
L:MOV 27 ANY
SUB 1
JGZ L
MOV 25 ANY
JRO -1
@6
JRO 2
S:MOV 10 ANY
ADD 65
MOV ACC ANY
SUB 90
JEZ S
ADD 26
@9
MOV 32 ANY
ADD UP
L:MOV 0 ANY
SUB 1
JGZ L
@10
MOV UP ACC
ADD ANY
SUB 42
D:JEZ D
ADD 42
MOV ACC ANY

Erläuterung

JavaScript ES6, 121 Byte

_=>Array(51).fill('abcdefghijklmnopqrstuvwxyz').map((e,i)=>e.replace(/./g,(f,j)=>j==i|i+j==50?f.toUpperCase():f)).join`
`

Dies ist sehr lang, da es sinnvoller ist, das Alphabet fest zu codieren, als die absurd lange Zeit String.fromCharCodezu verwenden, um die Zeichen zu generieren. Testen Sie es unten mit dem Stack-Snippet, das ES5 mit besserer Unterstützung und darunter verwendet.

f=function(){
  return Array(51).fill('abcdefghijklmnopqrstuvwxyz').map(function(e,i){
    return e.replace(/./g,function(f,j){
      return j==i|i+j==50?f.toUpperCase():f
    })
  }).join('\n')
}

// Polyfill for ES6-only fill()
Array.prototype.fill = Array.prototype.fill || function(val){
  for(i=0;i<this.length;i++){
    this[i] = val
  }
  return this
}

document.getElementById('p').innerText=f()

<pre id="p"></pre>

CJam, 23 Bytes

51{25-z~'{,97>'[2$+tN}/

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

51{                  }/ e# For I from 0 to 50:
   25-                  e#   Compute J := I - 25.
                        e#   This maps [0 ... 50] to [-25 ... 25].
      z                 e#   Compute K := abs(J).
                        e#   This maps [-25 ... 25] to [25 ... 0 ... 25].
       ~                e#   Compute L := ~K = -(K + 1).
                        e#   This maps [25 ... 0 ... 25] to [-26 ... -1 ... -26].
        '{,             e#   Push ['\0' ... 'z'].
           97>          e#   Discard the first 97. Pushes ['a' ... 'z'].
              '[2$+     e#   Add L to '['. Pushes 'A' for -26, 'Z' for -1.
                   t    e#   Set ['a' ... 'z'][L] to '[' + L.
                    N   e#   Push a linefeed.

R 78, 70

M=replicate(26,c(letters,"\n"));diag(M)=LETTERS;cat(M,M[,25:1],sep="")

Verbessert von @MickyT

Linux Assembly, 289

Leider nicht konkurrenzfähig mit Hochsprachen und wahrscheinlich alles andere als optimal, aber ziemlich unkompliziert. Führen Sie es mit nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(die resultierende Binärdatei ist nur 568 Byte groß) aus:

section .data
s:db 'abcdefghijklmnopqrstuvwxyz',10
section .text
global _start
_start:
mov esi,0
a:call c
inc esi
cmp esi,26
jne a
mov esi,24
b:call c
dec esi
jnz b
call c
mov eax,1
call d
c:mov ecx,s
sub byte [ecx+esi],32
mov eax,4
mov edx,27
d:mov ebx,1
int 80h
add byte [ecx+esi],32
ret

x86-Assembly für DOS, 41 Bytes kompiliert

Binär:

00000000  b9 e6 ff b3 61 b8 61 02  50 38 d8 75 02 24 df 88
00000010  c2 cd 21 58 40 3c 7b 75  ef b2 0a cd 21 41 79 02
00000020  43 43 4b 80 f9 19 75 dd  c3

Quellcode, als "wave.asm" speichern, mit "nasm -f bin -o wave.com wave.asm" kompilieren und mit "dosbox wave.com" ausführen

org 100h 
section .text
start:
mov cx,-26
mov bl,'a'
next_line:
mov ax, 0261h
next_char:
push ax
cmp al,bl
jnz lower_case
and al,255-32
lower_case:
mov dl,al
int 21h
pop ax
inc ax
cmp al,'z'+1
jnz next_char
mov dl,0ah
int 21h
inc cx
jns move_left
inc bx
inc bx
move_left:
dec bx
cmp cl,25
jnz next_line
ret

C #, 140 139 135 132

void f(){int d=1,i=0;var s="abcdefghijklmnopqrstuvwxyz\n";for(;i>=0;i+=d=i==25?-1:d)Console.Write(s.Replace(s[i],(char)(s[i]-32)));}

Erweitert

void f()
{
    int d = 1, i =0;
    var s = "abcdefghijklmnopqrstuvwxyz\n";
    for (; i >= 0; i += d = i == 25 ? -1 : d)
        Console.Write(s.Replace(s[i], (char)(s[i] - 32)));
}

1 Byte dank @ Gunther34567 gespeichert mit einem Ternär anstelle vonif

4 Bytes gespeichert, dann das ternäre Element innerhalb der Schleife verschachtelt und das Alphabet außerhalb der Schleife verschoben

Dank @eatonphil wurden 3 Byte gespeichert, die Integer-Deklarationen kombinieren

Bash: 76 66 Zeichen

printf -va %s {a..z}
for c in {a..z} {y..a};{ echo ${a/$c/${c^}};}

Probelauf:

bash-4.3$ printf -va %s {a..z};for c in {a..z} {y..a};{ echo ${a/$c/${c^}};} | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz

Sed: 135 119 116 111 Zeichen

(109 Zeichen Code + 1 Zeichen Befehlszeilenoption + 1 Zeichen Eingabe.)

s/.*/abcdefghijklmnopqrstuvwxyz/
h;H;G;H;G;H;g;G
s/.{,28}/\u&/gp
s/$/\t/
:;s/(\w+\n?)\t(.*)/\t\2\1/;t
s/.*Z//

Probelauf:

bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz

Javascript (ES6), 113 Byte

c=-1;while(c++<50){console.log('abcdefghijklmnopqrstuvwxyz'.replace(/./g,(x,i)=>i==c|i+c==50?x.toUpperCase():x))}

110 Bytes

for(c=-1;c++<50;)console.log('abcdefghijklmnopqrstuvwxyz'.replace(/./g,(x,i)=>i==c|i+c==50?x.toUpperCase():x))

102 Bytes

Old School ist unschlagbar, es sei denn, wir haben Range Operator / Funktion / Generator / was auch immer in js

for(c=-1;c++<50;){for(s='',i=-1;i++<25;)s+=String.fromCharCode(i+(i==c|i+c==50?65:97));console.log(s)}

100 Bytes

Leider ist Math.abs zu lang

for(c=51;c--;){for(s='',i=26;i--;)s+=String.fromCharCode(c+i==25|c-i==25?90-i:122-i);console.log(s)}

96 94 Bytes

Obwohl ich ohne Erklärung abgelehnt worden bin, setze ich meinen Kampf fort

for(c=-26;c++<25;){for(s='',i=26;i--;)s+=String.fromCharCode(c*c-i*i?122-i:90-i);console.log(s)}

Wir können ein paar Bytes abschneiden, indem wir die Schleifenanweisungen neu anordnen:

for(c=-26;c++<25;console.log(s))for(s='',i=26;i--;s+=String.fromCharCode(c*c-i*i?122-i:90-i));

Perl - 95 64 Bytes

Nutzt die Tatsache aus, \udass das nächste gedruckte Zeichen in Perl in Großbuchstaben geschrieben wird.

for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}

Dank an manatwork für das Speichern und Reparieren von 31 Bytes (mein vorheriger Code hat nicht funktioniert.)

q (37 Zeichen)

Ein erster Schnitt

@[.Q.a;;upper]'[(raze(|:\)til 26)_26]