En el menor número de bytes posible, escriba un programa o función que genere lo siguiente:

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

Se permite una nueva línea final. Puede encontrar una implementación de Python sin referencia aquí .

Pyth, 12 bytes

V+Gt_GXGNrN1

Demostración.

En Pyth, Ges el alfabeto en minúsculas. +Gt_Ges decir abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba, el carácter que debe estar en mayúscula en cada fila.

Vconfigura un bucle for sobre esta cadena, con Nla variable del bucle.

En el cuerpo, XGNrN1es una función de traducción de cadenas. Xtraduce G, el alfabeto, reemplazando Ncon rN1, la versión en mayúscula de N. r ... 1es la función mayúscula Esto da la salida deseada.

C, 73

A veces, el enfoque más simple es el mejor: imprime cada personaje uno por uno. esto supera muchos idiomas que realmente no debería.

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

explicación

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

Agradable y simple, creo.

Brainfuck (8 bits), 231 bytes

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

Ok, entonces nunca será el más corto, pero es la participación lo que cuenta ... ¿verdad?

Pruébelo aquí (asegúrese de marcar 'Memoria dinámica')

Binario de MS-DOS, 61

Este código no tiene que compilarse, se ejecutará en MS-DOS si lo escribe en un archivo llamado wave.com. El código en hexadecimal:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

O, si prefiere algo más legible, aquí es cómo producirlo usando debug.exe (la línea vacía después del código es 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 caracteres

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

Ejecución de muestra:

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,:)])

Gracias a Dennis Jaheruddin por salvarme 4 bytes.

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

Abusando de retroceder al bucle ...

Haskell 100 89 88 bytes

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

La función auxiliar lambda \(h,c:t)toma un par de listas de valores ascii y concatena ambas, pero con el primer valor de la segunda lista en mayúscula. La función principal divide el alfabeto en minúsculas (dado en ascii 97..122) en cada posición 0,..,24,25,24,..,0y llama a la lambda en cada paso. Antes de imprimir cada valor se convierte en el carácter correspondiente.

Scala 110 109 caracteres

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

Generar son series de -25 a 25 y usan el valor absoluto para reemplazar los caracteres con su versión en mayúscula. Gracias a manatwork por el consejo sobre el operador @.

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

Haskell, 81 bytes

Contando bytes como lo hizo @nimi; fes una acción IO que imprime la salida deseada.

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

Primer pase, probablemente se puede hacer mucho más corto. Usos Xpara sustituir y r1capitalizar.

V+KU26t_KXGNr@GN1

Pruébelo en línea aquí .

MATLAB - 58 bytes

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

Similar a la solución de Luis Mendo , pero usando las habilidades de transmisión de bsxfun.

Aprovechando que en ASCII, la diferencia entre un carácter en mayúscula y minúscula está exactamente a 32 valores uno del otro, primero generamos letras minúsculas a partir de los códigos ASCII 97 a 122, que son los códigos ASCII de minúscula a minúscula z respetuosamente, luego crear una matriz 51 fila que contiene los 26 códigos ASCII de 97 a 122. Por lo tanto, cada fila de esta matriz contiene una secuencia numérica de los valores de 97 a 122. a continuación, creamos otra matriz donde cada i ^TH fila de esta matriz contiene una 32 en la i ^th columna. Las primeras 26 filas de esta matriz tienen este patrón, que es esencialmente la matriz de identidad multiplicada por 32. La funcióneyecrea una matriz de identidad para ti. Las últimas 25 filas de esta matriz son la matriz de identidad escalada girada 90 grados.

Al tomar esta matriz de identidad ponderada personalizada y restarla con la primera matriz, y luego convertir los códigos ASCII resultantes en caracteres, se produce la secuencia deseada del "Sombrero Mexicano".

Ejecución de ejemplo

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

También puede ejecutar este ejemplo utilizando el entorno de octava en línea de IDEone. Octave es esencialmente MATLAB pero gratis: http://ideone.com/PknMe0

J, 31 23 bytes

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

8 bytes guardados gracias a @Mauris.

Pruébelo en línea aquí.

Perl, 51 bytes

Código de 50 bytes + parámetro de línea de comando de 1 byte

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

Se puede usar de la siguiente manera:

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

O en línea aquí (tenga en cuenta que tuve que agregar ,"\n"a esto ya que no pude agregar el argumento -l).

Método mucho más largo Antes de la versión abreviada anterior, probé un método diferente que terminó siendo bastante grueso. Lo dejé a continuación de todos modos para referencia.

Código de 86 bytes + línea de comando de 1 byte 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/

Primero Perl, he jugado al golf correctamente, así que imagino que se puede hacer mucho con él. ¡Sugiera mejoras!

Se puede usar de la siguiente manera:

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

O en línea aquí (tenga en cuenta que tuve que agregar "\ n" a esto ya que no pude agregar el argumento -l).

Explicación

El enfoque general es utilizar la sustitución de expresiones regulares para hacer todo el trabajo duro. Comenzamos con:

0abcdefghijklmnopqrstuvwxyz1

Esto coincide (([A-Z])|0)(\D)y se reemplaza con \U\3(\ U cambia a mayúsculas) para dar:

Abcdefghijklmnopqrstuvwxyz1

Desde este punto en adelante, continuamos haciendo coincidir la misma expresión regular y reemplazando con \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Ahora la segunda alternancia de las expresiones regulares coincide (.)((?2))(1)(que es lo mismo que (.)([A-Z])(1)). Reemplazamos con \U\4\6\L\5para dar:

abcdefghijklmnopqrstuvwxY1z

Esto continúa coincidiendo y reemplazando hasta llegar a:

A1bcdefghijklmnopqrstuvwxyz

y no hay más coincidencias de expresiones regulares.

En cada punto del bucle, quitamos el '1' e imprimimos.

PHP 87 71 69 bytes

No es el más corto, pero funciona según lo previsto.
Gracias a @manatwork por algunos consejos para reducir mucho su tamaño.
Y gracias a @Blackhole , el tamaño se redujo en 2 bytes.

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

No es exactamente bonito, pero funciona.

PowerShell 3.0, 82 bytes

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

Arquitectura del tipo de nodo TIS T21 - 216 215 bytes

¡Míralo en acción aquí! Hay un DOWNvideo en ese video que luego jugué ANY, pero es funcionalmente idéntico.

Este lenguaje no tiene concepto de cadenas o caracteres, por lo que debo señalar que estoy usando valores ASCII, es decir, la salida comienza 97, 66, 67... 88, 89, 90, 10, 65, 98...

Aquí está el código en el formato de los datos guardados de TIS-100, a los efectos de puntuación:

@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

Explicación

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

Esto es realmente largo porque tiene más sentido codificar el alfabeto que usar el absurdamente largo String.fromCharCodepara generar los caracteres. Pruébelo a continuación con el fragmento de pila, que utiliza ES5 mejor compatible y más abajo.

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

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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

Mejorado por @MickyT

Asamblea de Linux, 289

Desafortunadamente, no es competitivo con lenguajes de alto nivel y probablemente está lejos de ser óptimo, pero es bastante sencillo. Ejecútelo usando nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(el binario resultante tiene solo 568 bytes):

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

Ensamblado x86 para DOS, 41 bytes compilados

Binario:

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

Código fuente, guardar como "wave.asm", compilar con "nasm -f bin -o wave.com wave.asm" y ejecutar con "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)));}

Expandido

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

Guardado 1 byte gracias a @ Gunther34567 usando un ternario en lugar deif

Guardado 4 bytes y luego anidando ese ternario dentro del bucle y moviendo el alfabeto hacia el exterior del bucle

Guardado 3 bytes combinando declaraciones enteras gracias a @eatonphil

Bash: 76 66 caracteres

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

Ejecución de muestra:

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 caracteres

(Código de 109 caracteres + opción de línea de comando de 1 carácter + entrada de 1 carácter).

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

Ejecución de muestra:

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

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

La vieja escuela es inmejorable a menos que tengamos operador de rango / función / generador / lo que sea en 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

Desafortunadamente Math.abs es demasiado largo

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

Aunque he sido rechazado sin explicación, continúo mi lucha

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

Podemos recortar un par de bytes reorganizando las instrucciones del bucle:

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

Aprovecha el hecho de \uque el siguiente personaje está impreso en mayúscula en Perl.

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

Gracias a manatwork por guardar 31 bytes y arreglarlo (mi código anterior no funcionó).

q (37 caracteres)

Un primer corte

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