Dans le moins d’octets possible, écrivez un programme ou une fonction générant les éléments suivants:

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

Un retour à la ligne est autorisé. Vous pouvez trouver une référence ungolfed implémentation Python ici .

Pyth, 12 octets

V+Gt_GXGNrN1

Manifestation.

En Pyth, Gc'est l'alphabet minuscule. +Gt_Gest abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbale caractère qui doit être mis en majuscule dans chaque ligne.

Vconfigure une boucle for sur cette chaîne, avec Ncomme variable de boucle.

Dans le corps, XGNrN1est une fonction de traduction de chaîne. Xtraduit G, l’alphabet, en remplaçant Npar rN1, la version majuscule de N. r ... 1est la fonction majuscule. Cela donne la sortie souhaitée.

C, 73

Parfois, l'approche la plus simple est la meilleure: imprimez chaque caractère un par un. cela bat beaucoup de langues, il ne devrait vraiment pas.

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

explication

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 octets

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

Sympa et simple, je pense.

Brainfuck (8bit), 231 octets

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

Ok, donc ce ne sera jamais le plus court, mais c'est la participation qui compte ... pas vrai?!

Essayez-le ici (cochez la case 'Mémoire dynamique')

Binaire MS-DOS, 61

Ce code n'a pas besoin d'être compilé, il s'exécutera sous MS-DOS si vous l'écrivez dans un fichier nommé wave.com. Le code en hexadécimal:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Ou, si vous préférez quelque chose de plus lisible, voici comment le produire en utilisant debug.exe (la ligne vide après le code est importante):

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 caractères

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

Échantillon échantillon:

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 octets

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

Merci à Dennis Jaheruddin pour m'avoir sauvé 4 octets.

SWI-Prolog, 136 octets

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

Abuser de revenir en arrière pour boucler ...

Haskell 100 89 88 octets

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

La fonction d'assistance lambda \(h,c:t)prend une paire de listes de valeurs ascii et les concatène, mais avec la première valeur de la deuxième liste en majuscule. La fonction principale divise l’alphabet minuscule (donné en ascii 97..122) à chaque position 0,..,24,25,24,..,0et appelle le lambda à chaque étape. Avant l'impression, chaque valeur est convertie en caractère correspondant.

Scala 110 109 personnages

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

Generate est une série de -25 à 25 et utilise la valeur absolue pour remplacer les caractères par leur version majuscule. Merci à manatwork pour le conseil concernant l’opérateur @.

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

Haskell, 81 octets

Compter octets comme @nimi l'a fait; fest une action IO qui imprime la sortie souhaitée.

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 octets

Premier passage, peut probablement être beaucoup plus court. Utilisations Xpour substituer et r1capitaliser.

V+KU26t_KXGNr@GN1

Essayez-le en ligne ici .

MATLAB - 58 octets

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

Semblable à la solution de Luis Mendo , mais utilisant les capacités de diffusion de bsxfun.

Profitant qu'en ASCII, la différence entre les majuscules et les minuscules est à exactement 32 valeurs l'une de l'autre, nous générons d'abord des minuscules à partir des codes ASCII 97 à 122 qui sont les codes ASCII de minuscule a à minuscule respectueusement z, puis créez une matrice de 51 lignes contenant les 26 codes ASCII de 97 à 122. Chaque ligne de cette matrice contient donc une séquence numérique de valeurs de 97 à 122. Ensuite, nous créons une autre matrice dans laquelle chaque i ^ème ligne de cette matrice contient 32 dans la i ^ème colonne. Les 26 premières lignes de cette matrice ont ce motif, qui est essentiellement la matrice d’identité multipliée par 32. La fonctioneyecrée une matrice d'identité pour vous. Les 25 dernières lignes de cette matrice correspondent à la matrice d'identité mise à l'échelle pivotée à 90 degrés.

En prenant cette matrice d'identité pondérée personnalisée et en la soustrayant à la première matrice, puis en convertissant les codes ASCII résultants en caractères, la séquence souhaitée "Mexican Hat" est produite.

Exemple 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

Vous pouvez également exécuter cet exemple en utilisant l'environnement Octave en ligne d'IDEone. Octave est essentiellement MATLAB mais gratuit: http://ideone.com/PknMe0

J, 31 23 octets

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

8 octets enregistrés grâce à @Mauris.

Essayez-le en ligne ici.

Perl, 51 octets

Code de 50 octets + paramètre de ligne de commande de 1 octet

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

Peut être utilisé comme suit:

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

Ou en ligne ici (note j'ai dû ajouter ,"\n"à cela car je ne pouvais pas ajouter l'argument -l).

Méthode beaucoup plus longue Avant la version abrégée ci-dessus, j'ai essayé une méthode différente, qui s'est avérée plutôt épaisse. Je l'ai laissé ci-dessous quand même pour référence.

86 octets code + 1 octet argument de ligne de commande

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

Tout d'abord, Perl a bien joué au golf, alors j'imagine qu'il est possible de faire beaucoup de choses avec cela. Suggérez des améliorations!

Peut être utilisé comme suit:

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

Ou en ligne ici (note je devais ajouter. "\ N" à cela car je ne pouvais pas ajouter l'argument -l).

Explication

L’approche générale consiste à utiliser la substitution de regex pour faire tout le travail difficile. Nous commençons avec:

0abcdefghijklmnopqrstuvwxyz1

Ceci correspond (([A-Z])|0)(\D)et est remplacé par \U\3(\ U change en majuscule) pour donner:

Abcdefghijklmnopqrstuvwxyz1

À partir de ce moment, nous continuons à faire correspondre la même expression rationnelle et à la remplacer par \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Maintenant, la deuxième alternance des expressions rationnelles correspond (.)((?2))(1)(ce qui correspond à (.)([A-Z])(1)). Nous remplaçons par \U\4\6\L\5pour donner:

abcdefghijklmnopqrstuvwxY1z

Cela continue à correspondre et à remplacer jusqu'à atteindre:

A1bcdefghijklmnopqrstuvwxyz

et il n'y a plus de correspondance de regex.

À chaque point de la boucle, nous enlevons le «1» et l’imprimons.

PHP, 87 71 69 octets

Pas le plus court, mais cela fonctionne comme prévu.
Merci à @manatwork pour quelques conseils pour réduire sa taille de beaucoup.
Et grâce à @Blackhole , la taille a été réduite de 2 octets.

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

Pas vraiment joli, mais ça marche.

PowerShell 3.0, 82 octets

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

Architecture de type T21 de nœud TIS - 216 215 octets

Regardez-le en action ici! Il y a une DOWNvidéo dans laquelle j'ai joué au golf plus tard ANY, mais elle est fonctionnellement identique.

Ce langage n'a pas de concept de chaînes ni de caractères, je dois donc souligner que j'utilise les valeurs ASCII, c'est-à-dire que la sortie commence 97, 66, 67... 88, 89, 90, 10, 65, 98...

Voici le code au format des données de sauvegarde de TIS-100, à des fins de 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

Explication

JavaScript ES6, 121 octets

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

C'est vraiment long car il est plus logique de coder en dur l'alphabet que d'utiliser l'absurdement long String.fromCharCodepour générer les caractères. Testez-le ci-dessous avec l'extrait de pile, qui utilise l'ES5 et les versions ultérieures mieux prises en charge.

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 octets

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

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

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

Amélioré par @MickyT

Assemblage Linux, 289

Malheureusement, pas compétitif avec les langages de haut niveau et probablement loin d’être optimal, mais assez simple. Exécutez-le en utilisant nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(le binaire résultant ne fait que 568 octets):

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

Assemblage x86 pour DOS, 41 octets compilés

Binaire:

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

Code source, enregistrez sous "wave.asm", compilez avec "nasm -f bin -o wave.com wave.asm" et exécutez-vous avec "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)));}

Étendu

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

Sauvegardé 1 octet grâce à @ Gunther34567 en utilisant un ternaire au lieu deif

4 octets enregistrés, puis imbriquant ce ternaire dans la boucle et en déplaçant l'alphabet vers l'extérieur de la boucle

3 octets enregistrés combinant des déclarations d'entiers grâce à @eatonphil

Bash: 76 66 caractères

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

Échantillon échantillon:

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 caractères

(Code de 109 caractères + Option de ligne de commande de 1 caractère + Entrée de 1 caractère.)

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

Échantillon échantillon:

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

Javascript (ES6), 113 octets

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

110 octets

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

102 octets

La vieille école est imbattable à moins d’avoir un opérateur / une fonction / un générateur de gamme / quoi que ce soit dans 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 octets

Malheureusement, Math.abs est trop 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 octets

Bien que je sois descendu sans explication, je continue ma lutte

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

Nous pouvons réduire quelques octets en réorganisant les instructions de boucle:

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 octets

Profite de ce \ufait que le caractère suivant est imprimé en majuscule dans Perl.

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

Merci à manatwork d’avoir sauvé 31 octets et de les avoir réparés (mon code précédent ne fonctionnait pas.)

q (37 caractères)

Une première coupe

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