W jak najmniejszej liczbie bajtów napisz program lub funkcję, która wyświetli następujące informacje:

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

Końcowy znak nowej linii jest dozwolony. Można znaleźć odniesienia ungolfed wdrożenie Pythona tutaj .

Pyth, 12 bajtów

V+Gt_GXGNrN1

Demonstracja.

W Pyth Gjest małymi literami. +Gt_Gto abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbaznak, który musi być pisany dużymi literami w każdym rzędzie.

Vustawia pętlę for na tym ciągu, ze Nzmienną loop.

W treści XGNrN1znajduje się funkcja tłumaczenia ciągu. Xtłumaczy G, alfabet, zastępując Nz rN1Z wielką wersji N. r ... 1jest funkcją wielkich liter. Daje to pożądaną moc wyjściową.

C, 73

Czasami najlepsze jest najprostsze podejście: wydrukuj każdą postać jeden po drugim. to bije wiele języków, których tak naprawdę nie powinno.

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

wyjaśnienie

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

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

Ładne i proste, tak myślę.

Brainfuck (8bit), 231 bajtów

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

Ok, więc nigdy nie będzie najkrótszy, ale liczy się udział… prawda ?!

Wypróbuj tutaj (zaznacz pole „Pamięć dynamiczna”)

MS-DOS Binary, 61

Ten kod nie musi być kompilowany, będzie działał w MS-DOS, jeśli zapiszesz go w pliku o nazwie wave.com. Kod szesnastkowy:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Lub, jeśli wolisz coś bardziej czytelnego, oto jak to zrobić za pomocą debug.exe (ważna jest pusta linia po kodzie):

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

Rubinowy: 71 68 65 63 znaków

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

Przykładowy przebieg:

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

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

Z podziękowaniami dla Dennisa Jaheruddina za uratowanie mnie 4 bajtów.

SWI-Prolog, 136 bajtów

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)),\+!.

Nadużywanie powrotu do pętli ...

Haskell 100 89 88 bajtów

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

Funkcja pomocnicza lambda \(h,c:t)pobiera parę list wartości ascii i łączy oba, ale pierwsza wartość drugiej listy jest wielka. Główna funkcja dzieli małe litery (podane w ascii 97..122) na każdej pozycji 0,..,24,25,24,..,0i wywołuje lambda na każdym kroku. Przed wydrukowaniem każda wartość zamienia się w odpowiedni znak.

Scala 110 109 znaków

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

Generuj to serie od -25 do 25 i używaj wartości bezwzględnej do zamiany znaków na ich duże litery. Dzięki manatwork za wskazówkę na temat operatora @.

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

Haskell, 81 bajtów

Liczenie bajtów tak jak @nimi; fto działanie we / wy, które drukuje pożądane wyjście.

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

Pierwsze przejście, prawdopodobnie może być znacznie krótsze. UżywaX do podstawiania i r1kapitalizacji.

V+KU26t_KXGNr@GN1

Wypróbuj online tutaj .

MATLAB - 58 bajtów

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

Podobne do rozwiązania Luisa Mendo , ale z wykorzystaniem możliwości nadawaniabsxfun .

Korzystając z tego, że w ASCII różnica między wielkimi i małymi literami wynosi dokładnie 32 wartości od siebie, najpierw generujemy małe litery z kodów ASCII od 97 do 122, które są odpowiednio kodami ASCII od małych a do małych z utwórz 51-wierszową macierz, która zawiera 26 kodów ASCII od 97 do 122. Dlatego też każdy wiersz tej macierzy zawiera liczbową sekwencję wartości od 97 do 122. Następnie tworzymy kolejną macierz, w której każdy i- ^ty wiersz tej macierzy zawiera 32 w i- ^tej kolumnie. Pierwsze 26 wierszy tej macierzy ma ten wzór, który jest w zasadzie macierzą tożsamości pomnożoną przez 32. Funkcjaeyetworzy dla ciebie macierz tożsamości. Ostatnie 25 wierszy tej macierzy to skalowana macierz tożsamości obrócona o 90 stopni.

Biorąc tę ​​niestandardowo ważoną macierz tożsamości i odejmując ją od pierwszej macierzy, a następnie przekształcając uzyskane kody ASCII w znaki, tworzona jest pożądana sekwencja „meksykańskiego kapelusza”.

Przykładowy bieg

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

Możesz również uruchomić ten przykład, używając internetowego środowiska Octave IDEone. Octave jest zasadniczo MATLAB, ale bezpłatny: http://ideone.com/PknMe0

J, 31 23 bajtów

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

8 bajtów zapisanych dzięki @Mauris.

Wypróbuj online tutaj.

Perl, 51 bajtów

Kod 50 bajtów + 1 bajtowy parametr wiersza poleceń

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

Może być używany w następujący sposób:

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

Lub online tutaj (uwaga, że ​​musiałem do tego dodać, ,"\n"ponieważ nie mogłem dodać -l arg).

Znacznie dłuższa metoda Przed powyższą skróconą wersją wypróbowałem inną metodę, która okazała się dość masywna. I tak zostawiłem to dla odniesienia.

86 bajtów kodu + 1 bajt arg wiersza poleceń

$_=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/

Pierwszy Perl, w jaki kiedykolwiek grałem poprawnie w golfa, więc wyobrażam sobie, że można wiele z tym zrobić - sugeruj ulepszenia!

Można użyć w następujący sposób:

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

Lub online tutaj (uwaga, że ​​musiałem dodać. \ N ", ponieważ nie mogłem dodać -l arg).

Wyjaśnienie

Ogólne podejście polega na użyciu podstawienia wyrażenia regularnego, aby wykonać całą ciężką pracę. Zaczynamy od:

0abcdefghijklmnopqrstuvwxyz1

To pasuje (([A-Z])|0)(\D)i zostaje zastąpione przez \U\3(\ U zmiany na wielkie litery), aby dać:

Abcdefghijklmnopqrstuvwxyz1

Od tego momentu kontynuujemy dopasowywanie tego samego wyrażenia regularnego i zamieniamy na \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Teraz druga alternatywa dopasowania wyrażeń regularnych (.)((?2))(1)(która jest taka sama jak (.)([A-Z])(1)). Zamieniamy na, \U\4\6\L\5aby dać:

abcdefghijklmnopqrstuvwxY1z

To się dopasowuje i zastępuje, dopóki nie osiągniemy:

A1bcdefghijklmnopqrstuvwxyz

i nie ma już dopasowań wyrażeń regularnych.

W każdym punkcie pętli usuwamy „1” i drukujemy.

PHP, 87 71 69 bajtów

Nie najkrótszy, ale działa zgodnie z przeznaczeniem.
Dzięki @manatwork za kilka wskazówek, jak znacznie zmniejszyć jego rozmiar.
Dzięki @Blackhole rozmiar został zmniejszony o 2 bajty.

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

Niezupełnie ładny, ale działa.

PowerShell 3.0, 82 bajty

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

Architektura węzła TIS Typ T21 - 216 215 bajtów

Zobacz tutaj w akcji! Jest DOWNw tym filmie, do którego później grałem w golfa ANY, ale jest funkcjonalnie identyczny.

Język ten nie ma pojęcia lub ciągów znaków, więc muszę podkreślić, że używam wartości ASCII, czyli wyjście zaczyna 97, 66, 67... 88, 89, 90, 10, 65, 98...

Oto kod w formacie zapisywania danych TIS-100 do celów punktacji:

@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

Wyjaśnienie

JavaScript ES6, 121 bajtów

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

Jest to naprawdę długie, ponieważ bardziej sensowne jest kodowanie alfabetu na sztywno niż używanie absurdalnie długiego czasu String.fromCharCodedo generowania znaków. Przetestuj go poniżej za pomocą fragmentu stosu, który używa lepiej obsługiwanego ES5 i niższego.

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 bajty

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

Wypróbuj online w interpretatorze CJam .

Jak to działa

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

Ulepszony przez @MickyT

Zestaw Linux, 289

Niestety nie jest konkurencyjny dla języków wysokiego poziomu i prawdopodobnie daleki od optymalnego, ale dość prosty. Uruchom go przy użyciu nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(wynikowy plik binarny ma tylko 568 bajtów):

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

Zestaw x86 dla DOS, skompilowano 41 bajtów

Dwójkowy:

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

Kod źródłowy, zapisz jako „wave.asm”, skompiluj z „nasm -f bin -o wave.com wave.asm” i uruchom z „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

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

Rozszerzony

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

Zapisano 1 bajt dzięki @ Gunther34567 przy użyciu trójki zamiastif

Zapisano 4 bajty, a następnie zagnieżdżono trójskładnik wewnątrz pętli i przeniesiono alfabet na zewnątrz pętli

Zaoszczędź 3 bajty łącząc deklaracje liczb całkowitych dzięki @eatonphil

Bash: 76 66 znaków

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

Przykładowy przebieg:

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

(Kod 109 znaków + 1 wiersz opcji wiersza poleceń + 1 znak wprowadzania).

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//

Przykładowy przebieg:

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

JavaScript (ES6), 113 bajtów

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

110 bajtów

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

102 bajty

Stara szkoła jest nie do pobicia, chyba że będziemy mieli operatora zasięgu / funkcję / generator / cokolwiek w 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 bajtów

Niestety Math.abs jest za długi

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 bajty

Mimo że zostałem odrzucony bez wyjaśnienia, kontynuuję walkę

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

Możemy ogolić kilka bajtów, zmieniając instrukcje pętli:

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

Wykorzystuje fakt, \uże kolejna postać drukuje wielkie litery w Perlu.

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

Dzięki manatwork za zapisanie 31 bajtów i naprawienie go (mój poprzedni kod nie działał.)

q (37 znaków)

Pierwsze cięcie

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