[Question]
  [
In as few bytes as possible, write a program or function that outputs the following:
```
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
```
A trailing newline is permitted. You can find a reference ungolfed Python implementation [here](https://gist.github.com/katyaka/a2a74206d90451952146).
  
[Answer]
# Pyth, 12 bytes
```
V+Gt_GXGNrN1
```
[Demonstration.](https://pyth.herokuapp.com/?code=V%2BGt_GXGNrN1&debug=0)
In Pyth, `G` is the lowercase alphabet. `+Gt_G` is `abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba`, the character that needs to be uppercased in each row.
`V` sets up a for loop over this string, with `N` as the loop variable.
In the body, `XGNrN1` is a string translation function. `X` translates `G`, the alphabet, replacing `N` with `rN1`, the uppercase version of `N`. `r ... 1` is the uppercase function. This gives the desired output.
[Answer]
# C,73
Sometimes the simplest approach is best: print every character one by one. this beats a lot of languages it really shouldn't.
```
i;f(){for(i=1377;i--;)putchar(i%27?123-i%27-32*!(i/702?i%28-4:i%26):10);}
```
explanation
```
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)
}
```
[Answer]
# Python 2, 69 bytes
```
i=25
exec"L=range(97,123);L[~abs(i)]^=32;i-=1;print bytearray(L);"*51
```
Nice and simple, I think.
[Answer]
# Brainfuck (8bit), 231 bytes
```
++++++++++>++[>>+++++[-<+++++>]<[>>>>>[-]>[-]--[-----<+>]<----->[-]>----[----<+>]<++<<<+++++[-<<+++++>>]<<+>[>>>.+>+<<<<-<->]>>>+>.+<<<<<-[>>>>.+>+<<<<<-]<<<<[<+>>>>>>>>-<<<<<<<-]<[>+<-]>>>>>>>>+[<+<+>>-]<[>+<-]<<<<<.>>-]+<-<<++>>]
```
Ok, so it's never going to be the shortest, but it's the taking part that counts... right?!
Try it [here](http://copy.sh/brainfuck/) (ensure to tick 'Dynamic memory')
[Answer]
# MS-DOS Binary, 61
This code does not have to be compiled, it will run in MS-DOS if you write it into a file called wave.com . The code in hex:
```
ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3
```
Or, if you prefer something more readable, here is how to produce it using debug.exe (the empty line after the code is important):
```
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
```
[Answer]
# Ruby: ~~71~~ ~~68~~ ~~65~~ 63 characters
```
puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse
```
Sample run:
```
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
```
[Answer]
## Matlab, ~~60~~ ~~58~~ 54 bytes
```
I=32*eye(26);[ones(51,1)*(97:122) '']-[I;I(25:-1:1,:)])
```
With thanks to [Dennis Jaheruddin](https://codegolf.stackexchange.com/users/11159/dennis-jaheruddin) for saving me 4 bytes. 
[Answer]
# 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)),\+!.
```
Abusing backtracking to loop...
[Answer]
# Haskell ~~100~~ ~~89~~ 88 bytes
```
putStr$map toEnum.(\(h,c:t)->h++c-32:t++[10]).(`splitAt`[97..122]).(25-).abs=<<[-25..25]
```
The lambda helper function `\(h,c:t)` takes a pair of lists of ascii values and concatenates both, but with the first value of the second list capitalized. The main function splits the lowercase alphabet (given in ascii, `97..122`) at every position `0,..,24,25,24,..,0` and calls the lambda in every step. Before printing each value is turned into the corresponding character.
[Answer]
# Scala ~~110~~ 109 characters
```
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
```
[Answer]
# [Haskell](https://www.haskell.org/), 70 bytes
```
mapM putStrLn[[toEnum$x+sum[32|x+abs y/=90]|x<-[65..90]]|y<-[-25..25]]
```
I revisited this problem 6 years later and saved a bunch of bytes. Character growth!
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzPzexwFehoLQkuKTIJy86uiTfNa80V6VCu7g0N9rYqKZCOzGpWKFS39bSILamwkY32sxUTw/Ijq2pBHJ0jYA8I9PYWKAxmXkKtgpp//8lp@Ukphf/100uKAAA "Haskell – Try It Online")
# Haskell, 81 bytes
Counting bytes the way @nimi did; `f` is an IO action that prints the desired output.
```
x!y|x==min(50-y)y=65|0<1=97
f=mapM putStrLn[[toEnum$x+x!y|x<-[0..25]]|y<-[0..50]]
```
[Answer]
# SQL (postgreSQL), ~~107~~ 101
Generate are series from -25 to 25 and use the absolute value to replace characters with their uppercase version. Thanks to manatwork for the tip about the @ operator.
```
select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)
```
[Answer]
# Pyth - 18 17 bytes
First pass, probably can be made much shorter. Uses `X` to substitute and `r1` to capitalize.
```
V+KU26t_KXGNr@GN1
```
[Try it online here](http://pyth.herokuapp.com/?code=V%2BKU26t_KXGNr%40GN1&debug=1).
[Answer]
# J, ~~31~~ 23 bytes
```
u:|:(97+i.26)-32*=|i:25
```
8 bytes saved thanks to @Mauris.
[Try it online here.](http://tryj.tk/)
[Answer]
# MATLAB - 58 bytes
```
char(bsxfun(@minus,97:122,32*[eye(25,26);rot90(eye(26))]))
```
Similar to [Luis Mendo's solution](https://codegolf.stackexchange.com/a/53832/42418), but using the broadcasting abilities of [`bsxfun`](http://www.mathworks.com/help/matlab/ref/bsxfun.html).
Taking advantage that in ASCII, the difference between a capital and lower case character is exactly 32 values away from each other, we first generate lower case letters from ASCII codes 97 to 122 which are the ASCII codes from lowercase a to lowercase z respectfully, then create a 51 row matrix that contains the 26 ASCII codes from 97 to 122. Therefore, each row of this matrix contains a numerical sequence of values from 97 to 122. Next, we create another matrix where each ith row of this matrix contains a 32 in the ith column. The first 26 rows of this matrix has this pattern, which is essentially the identity matrix multiplied by 32. The function [`eye`](http://www.mathworks.com/help/matlab/ref/eye.html) creates an identity matrix for you. The last 25 rows of this matrix is the scaled identity matrix rotated 90 degrees.
By taking this custom weighted identity matrix and subtracting this with the first matrix, then converting the resulting ASCII codes into characters, the desired "Mexican Hat" sequence is produced.
# Example Run
```
>> 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
```
You can also run this example using IDEone's online Octave environment. Octave is essentially MATLAB but free: <http://ideone.com/PknMe0>
[Answer]
# Perl, 51 bytes
50 bytes code + 1 byte command line parameter
```
@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25
```
Can be used as follows:
```
perl -le '@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25'
```
Or online [here](http://ideone.com/ZCJjel) (note I had to add `,"\n"` to this as I couldn't add the -l arg).
---
**Much longer method**
Before the shortened version above, I tried a different method which ended up being pretty chunky. I've left it below anyway for reference.
86 bytes code + 1 byte command line arg
```
$_=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/
```
First Perl I've ever golfed properly so I imagine there's a lot that can be done with it - please do suggest improvements!
Can be used as followed:
```
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/'
```
Or online [here](http://ideone.com/mEA5Xm) (note I had to add ."\n" to this as I couldn't add the -l arg).
### Explanation
General approach is to use regex substitution to do all the hard work. We start off with:
```
0abcdefghijklmnopqrstuvwxyz1
```
This matches `(([A-Z])|0)(\D)` and gets replaced with `\U\3` (\U changes to uppercase) to give:
```
Abcdefghijklmnopqrstuvwxyz1
```
From this point onwards, we continue to match the same regex and replace with `\L\2\U\3`:
```
aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1
```
Now the second alternation of the regex matches, `(.)((?2))(1)` (which is the same as `(.)([A-Z])(1)`). We replace with `\U\4\6\L\5` to give:
```
abcdefghijklmnopqrstuvwxY1z
```
This continues to match and replace until we reach:
```
A1bcdefghijklmnopqrstuvwxyz
```
and there are no more regex matches.
At each point in the loop we strip off the '1' and print.
[Answer]
# PHP, ~~87~~ ~~71~~ 69 bytes
Not the shortest one, but it works as intended.  
Thanks to [@manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for a few tips to reduce it's size by a lot.  
And thanks to [@Blackhole](https://codegolf.stackexchange.com/users/11713/blackhole), the size was reduced by 2 bytes.
```
for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'
';
```
Not exactly pretty, but works.
[Answer]
## PowerShell 3.0, 82 bytes
```
$(0..25)+$(24..0)|%{$i=$_;[string](@(97..122)|%{[char]@($_,($_-32))[$_-eq$i+97]})}
```
[Answer]
# TIS Node Type T21 Architecture - ~~216~~ 215 bytes
![](https://i.stack.imgur.com/m9mit.png)
[Watch it in action here!](https://www.youtube.com/watch?v=7jipsgwtRW4) There's a `DOWN` in that video that I later golfed to `ANY`, but it's functionally identical.
This language has no concept of strings or characters, so I should point out that I'm using ASCII values, i.e. output begins `97, 66, 67`...`88, 89, 90, 10, 65, 98`...
Here's the code in the format of TIS-100's save data, for the purposes of scoring:
```
@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
```
**Explanation**
![](https://i.stack.imgur.com/yMCqU.png)
[Answer]
# JavaScript ES6, 121 bytes
```
_=>Array(51).fill('abcdefghijklmnopqrstuvwxyz').map((e,i)=>e.replace(/./g,(f,j)=>j==i|i+j==50?f.toUpperCase():f)).join`
`
```
This is really long because it makes more sense to hardcode the alphabet than to use the absurdly long `String.fromCharCode` to generate the characters. Test it out below with the Stack snippet, which uses better-supported ES5 and below.
```
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>
```
[Answer]
# CJam, 23 bytes
```
51{25-z~'{,97>'[2$+tN}/
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=51%7B25-z~'%7B%2C97%3E'%5B2%24%2BtN%7D%2F).
### How it works
```
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.
```
[Answer]
# R, ~~78~~ 70
```
M=replicate(26,c(letters,"\n"));diag(M)=LETTERS;cat(M,M[,25:1],sep="")
```
Improved by @MickyT
[Answer]
# Bash: ~~76~~ 66 characters
```
printf -va %s {a..z}
for c in {a..z} {y..a};{ echo ${a/$c/${c^}};}
```
Sample run:
```
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
```
[Answer]
# Linux Assembly, 289
Unfortunately not competitive with high level languages and probably far from optimal, but pretty straightforward. Run it using `nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a` (the resulting binary is just 568 bytes big):
```
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
```
[Answer]
# x86 assembly for DOS, 41 Bytes compiled
Binary:
```
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
```
Source code, save as "wave.asm", compile with "nasm -f bin -o wave.com wave.asm" and run with "dosbox wave.com"
```
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
```
[Answer]
# 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)));}
```
Expanded
```
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)));
}
```
Saved 1 byte thanks to [@Gunther34567](https://codegolf.stackexchange.com/users/37953/gunther34567) using a ternary instead of `if`
Saved 4 bytes then nesting that ternary inside the loop and moving the alphabet to the outside of the loop
Saved 3 bytes combining integer declarations thanks to [@eatonphil](https://codegolf.stackexchange.com/users/42769/eatonphil)
[Answer]
# awk, 91 bytes
```
awk 'BEGIN{for(i=0;i<51;i++)for(j=0;j<27;j++)printf("%c",j>25?10:i==j||j==50-i?j+65:j+97)}'
```
[Answer]
# Sed: ~~135~~ ~~119~~ ~~116~~ 111 characters
(109 character code + 1 character command line option + 1 character input.)
```
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//
```
Sample run:
```
bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
```
[Answer]
# Javascript (ES6), 113 bytes
```
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 is unbeatable unless we'll have range operator/function/generator/whatever 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
Unluckily Math.abs is too long
```
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
Though I've beeing downvoted without explanation I continue my struggle
```
for(c=-26;c++<25;){for(s='',i=26;i--;)s+=String.fromCharCode(c*c-i*i?122-i:90-i);console.log(s)}
```
We can shave off a couple of bytes by rearranging loop instructions:
```
for(c=-26;c++<25;console.log(s))for(s='',i=26;i--;s+=String.fromCharCode(c*c-i*i?122-i:90-i));
```
[Answer]
# Perl - ~~95~~ 64 bytes
Takes advantage of the fact `\u` makes the next character printed an uppercase in Perl.
```
for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}
```
Thanks to manatwork for saving 31 bytes and fixing it (my previous code did not work.)
]