No menor número de bytes possível, escreva um programa ou função que produz o seguinte:

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

Uma nova linha à direita é permitida. Você pode encontrar uma implementação de Python não destruída de referência aqui .

Pitão, 12 bytes

V+Gt_GXGNrN1

Demonstração.

Em Pyth, Gé o alfabeto em minúsculas. +Gt_Gé abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbao caractere que precisa ser maiúsculo em cada linha.

Vconfigura um loop for sobre essa string, com Ncomo a variável loop.

No corpo, XGNrN1é uma função de conversão de string. Xtraduz G, o alfabeto, substituindo Npor rN1, a versão maiúscula de N. r ... 1é a função maiúscula. Isso fornece a saída desejada.

C, 73

Às vezes, a melhor abordagem é a melhor: imprima todos os caracteres, um por um. isso supera muitas línguas que realmente não deveria.

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

explicação

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

Bonito e simples, eu acho.

Brainfuck (8 bits), 231 bytes

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

Ok, então nunca será o mais curto, mas é a participação que conta ... certo ?!

Experimente aqui (certifique-se de marcar 'Memória dinâmica')

Binário do MS-DOS, 61

Esse código não precisa ser compilado; ele será executado no MS-DOS se você o gravar em um arquivo chamado wave.com. O código em hexadecimal:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Ou, se você preferir algo mais legível, veja como produzi-lo usando o debug.exe (a linha vazia após o código é 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

Exemplo de execução:

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

Com agradecimentos a Dennis Jaheruddin por me salvar 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 do retrocesso para repetir ...

Haskell 100 89 88 bytes

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

A função auxiliar lambda \(h,c:t)pega um par de listas de valores ascii e concatena ambos, mas com o primeiro valor da segunda lista em maiúscula. A função principal divide o alfabeto em minúsculas (fornecido em ascii 97..122) em todas as posições 0,..,24,25,24,..,0e chama o lambda em cada etapa. Antes de imprimir, cada valor é transformado no caractere correspondente.

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

Generate são séries de -25 a 25 e usa o valor absoluto para substituir caracteres por sua versão em maiúscula. Obrigado ao manatwork pela dica sobre o operador @.

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

Haskell, 81 bytes

Contando bytes da maneira que o @nimi fazia; fé uma ação de E / S que imprime a saída desejada.

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

Pitão - 18 17 bytes

Primeira passagem, provavelmente pode ser feita muito mais curta. Usa Xpara substituir e r1capitalizar.

V+KU26t_KXGNr@GN1

Experimente online aqui .

MATLAB - 58 bytes

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

Semelhante à solução de Luis Mendo , mas usando as habilidades de transmissão debsxfun .

Aproveitando que em ASCII, a diferença entre um caractere maiúsculo e minúsculo está exatamente a 32 valores um do outro, primeiro geramos letras minúsculas dos códigos ASCII 97 a 122, que são os códigos ASCII de z minúsculo a para minúsculo respeitosamente, depois crie uma matriz de 51 linhas que contém os 26 códigos ASCII de 97 a 122. Portanto, cada linha dessa matriz contém uma sequência numérica de valores de 97 a 122. Em seguida, criamos outra matriz em que cada ^iésima linha dessa matriz contém um 32 na i- ^ésima coluna. As primeiras 26 linhas desta matriz possuem esse padrão, que é essencialmente a matriz de identidade multiplicada por 32. A funçãoeyecria uma matriz de identidade para você. As últimas 25 linhas desta matriz são a matriz de identidade em escala girada 90 graus.

Ao pegar essa matriz de identidade ponderada personalizada e subtraí-la com a primeira matriz, e depois converter os códigos ASCII resultantes em caracteres, é produzida a sequência desejada "Chapéu mexicano".

Exemplo de execução

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

Você também pode executar este exemplo usando o ambiente Octave on-line da IDEone. O Octave é essencialmente o MATLAB, mas é gratuito: http://ideone.com/PknMe0

J, 31 23 bytes

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

8 bytes salvos graças a @Mauris.

Experimente online aqui.

Perl, 51 bytes

Código de 50 bytes + parâmetro de linha de comando de 1 byte

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

Pode ser usado da seguinte maneira:

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

Ou online aqui (observe que eu tive que adicionar ,"\n"isso, pois não consegui adicionar o argumento -l arg).

Método muito mais longo Antes da versão abreviada acima, tentei um método diferente que acabou sendo bastante robusto. Deixei abaixo de qualquer maneira para referência.

Código de 86 bytes + linha de comando 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/

Primeiro Perl que eu já joguei corretamente, então imagino que há muito o que fazer com isso - sugira melhorias!

Pode ser usado da seguinte maneira:

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 online aqui (observe que eu tive que adicionar. "\ N", pois não consegui adicionar o -l arg).

Explicação

A abordagem geral é usar a substituição de regex para fazer todo o trabalho duro. Começamos com:

0abcdefghijklmnopqrstuvwxyz1

Isso corresponde (([A-Z])|0)(\D)e é substituído por \U\3(\ U muda para maiúsculas) para fornecer:

Abcdefghijklmnopqrstuvwxyz1

A partir deste ponto, continuamos a corresponder à mesma regex e a substituir por \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Agora, a segunda alternância da regex corresponde (.)((?2))(1)(que é igual a (.)([A-Z])(1)). Substituímos por \U\4\6\L\5para dar:

abcdefghijklmnopqrstuvwxY1z

Isso continua a corresponder e substituir até chegarmos a:

A1bcdefghijklmnopqrstuvwxyz

e não há mais correspondências regex.

Em cada ponto do loop, retiramos o '1' e imprimimos.

PHP, 87 71 69 bytes

Não é o mais curto, mas funciona como pretendido.
Obrigado a @manatwork por algumas dicas para reduzir muito o tamanho.
E, graças ao @Blackhole , o tamanho foi reduzido em 2 bytes.

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

Não é exatamente bonito, mas funciona.

PowerShell 3.0, 82 bytes

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

Arquitetura do tipo T21 do nó TIS - 216 215 bytes

Assista em ação aqui! Há um DOWNvídeo em que eu joguei mais tardeANY , mas é funcionalmente idêntico.

Esta linguagem não tem conceito de strings ou caracteres, então devo salientar que estou usando valores ASCII, ou seja, a saída começa 97, 66, 67... 88, 89, 90, 10, 65, 98...

Aqui está o código no formato dos dados salvos do TIS-100, para fins de pontuação:

@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

Explicação

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

Isso é muito longo, porque faz mais sentido codificar o alfabeto do que usar o absurdamente longo String.fromCharCodepara gerar os caracteres. Teste abaixo com o snippet Stack, que usa o ES5 com melhor suporte e abaixo.

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

Experimente online no intérprete CJam .

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

Melhorado por @MickyT

Montagem Linux, 289

Infelizmente, não é competitivo com idiomas de alto nível e provavelmente está longe de ser o ideal, mas bastante direto. Execute-o usando nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(o binário resultante tem apenas 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

montagem x86 para DOS, 41 bytes compilados

Binário:

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-fonte, salve como "wave.asm", compile com "nasm -f bin -o wave.com wave.asm" e execute com "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)));
}

Guardou 1 byte graças a @ Gunther34567 usando um ternário em vez deif

Salvo 4 bytes, aninhando esse ternário dentro do loop e movendo o alfabeto para fora do loop

Economizou 3 bytes combinando declarações inteiras graças a @eatonphil

Bash: 76 66 caracteres

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

Exemplo de execução:

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 + opção de linha de comando de 1 caractere + entrada de 1 caractere.)

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

Exemplo de execução:

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

A velha escola é imbatível, a menos que tenhamos operador / função / gerador de faixa / o que quer que seja em 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

Infelizmente o Math.abs é muito longo

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

Embora eu esteja sendo votado sem explicação, continuo minha luta

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 remover alguns bytes reorganizando as instruções do loop:

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

Aproveita o fato para \uque o próximo caractere seja impresso em maiúsculas no Perl.

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

Obrigado ao manatwork por salvar 31 bytes e corrigi-lo (meu código anterior não funcionou.)

q (37 caracteres)

Um primeiro corte

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