O programa deve imprimir o alfabeto quatro vezes: primeiro na ordem alfabética normal, segundo na ordem de um teclado qwerty, terceiro na ordem de um teclado dvorak e, finalmente, na ordem alfabética inversa. A saída deve se parecer com isso:

abcdefghijklmnopqrstuvwxyz
qwertyuiopasdfghjklzxcvbnm
pyfgcrlaoeuidhtnsqjkxbmwvz
zyxwvutsrqponmlkjihgfedcba

A saída não diferencia maiúsculas de minúsculas e você pode adicionar ou omitir novas linhas ou espaços onde desejar.

O problema : o programa deve ter menos de 104 caracteres ou, em outras palavras, menor que o comprimento do alfabeto multiplicado por quatro.

Aceitarei a resposta com o código mais curto, a menos que veja algo realmente inteligente ou interessante com o qual estou mais impressionado.

EDIT: Aceitarei a resposta mais curta na quarta-feira, 27/04/2011.

EDIT2: E o vencedor é (como sempre) Golfscript em 64 caracteres! O segundo lugar , atrás apenas de três caracteres, também está em Golfscript, com 67 caracteres, seguido por Bash em terceiro lugar com 72 caracteres.

Mas havia alguns outros que eu queria mencionar, como este , que, dependendo da sua definição, usava apenas 52 "caracteres", e este onde ele o escreveu em um idioma criado por ele.

Havia algumas pessoas que quebrou uma regra não escrita e não se qualificam, mas vou mencioná-los apenas para a sua maneira de pensar sem a caixa.

Python 2, 97 caracteres

q="qwertyuiopasdfghjklzxcvbnm"
a="".join(sorted(q))
print a,q,"pyfgcrlaoeuidhtnsqjkxbmwvz",a[::-1]

Classificar QWERTY e converter de volta da lista em string é mais curto que o próprio alfabeto! *

Outra opção para gerar o alfabeto em menos caracteres que o próprio alfabeto:

print map(chr,range(65,91))

Embora isso imprima uma lista de caracteres Python.

Não há muito a ser feito aqui no caminho da compactação de dados; encravar as letras em 5 bits salva apenas 39 caracteres, o que não é muito se você precisar desimpedi-las (e ainda precisar representar os bytes literalmente); parece que o zlib (apenas como exemplo) salva menos de 20 bytes; codificar a sequência como uma lista de deltas para a próxima letra ainda leva 5 bits para cada delta, porque o maior nessa sequência é -22:

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
 1, 1, 1, 1, 1, 1, 1, -9, 6, -18, 13, 2, 5, -4, -12, 6, 
 1, -15, 18, -15, 2, 1, 2, 1, 14, -2, -21, 19, -20, 12, 
 -1, 3, 9, -19, 1, -4, 15, -6, -11, 14, -10, 16, -12, -5, 
 4, 12, -6, 5, -2, -7, 1, 13, -22, 11, 10, -1, 4, 0, -1, 
 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]

_{* Embora apenas um pouco.}

PHP, 100 bytes

Conforme ISO 8859-1:

<?=base64_encode("i·yø!9%z)ª»-ºü1Ë:°z»rº*)jÇ_ä<\½¹æ§'àr¹Z¡ë¢vg²¨äŹ°¿<òÇî¶Êê¦æHâÞuÆÚ");

Para reproduzir de forma confiável,

printf '<?=base64_encode("' > 4times.php
printf abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba | base64 -d >> 4times.php
printf '");' > 4times.php

Rubi 1.9, 88 87 84 80

puts b=[*?a..?z],:qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz,b.reverse

Bash, 82

echo {a..z}
echo qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz
echo {z..a}

Python, 97 96 "caracteres"

Usando o uso da palavra "caracteres" liberalmente, aqui está um python que usa caracteres unicode de 16 bits para codificar 3 caracteres normais cada. O programa tem um total de 96 caracteres, 35 dos quais são os caracteres unicode mais estranhos que eu já vi.

for i in range(104):print chr((ord(u'ࠠᒃ⃦ⵉ��割廕��匓�เ᳅ⵉૹ�懬ࣅű傎ᱨ�⤰〷�弙劶��ⶍKᓇࡤ^A'[i/3])>>i%3*5&31)+97),

Não tenho certeza se o lixo unicode virá corretamente, então aqui está um programa python para gerar o programa python acima:

#!/usr/bin/python                                                                                                                                                                 
import codecs
f=codecs.open('alpha.py','w','utf-8')
f.write('#!/usr/bin/python\n')
f.write('# coding=utf-8\n')
f.write('for i in range(104):print chr((ord(u\"')
S='''abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcbaa'''
for i in xrange(0,104,3):
 n=32*32*(ord(S[i+2])-97)+32*(ord(S[i+1])-97)+ord(S[i+0])-97
 f.write(u'%c'%n)
f.write('"[i/3])>>i%3*5&31)+97),\n')

Bash, 72

echo {a..z} qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz {z..a}

EDIT: removido tr -d.

Créditos: Alexander, Roger.

Golfscript, 64 caracteres

"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz".$2%\1$-1%

Nota: também 64 bytes. Na verdade, jogar com as mudanças de base e Unicode parece contraproducente, porque baseé uma palavra-chave muito longa.

Windows PowerShell, 89

Não é particularmente bom, mas pelo menos mais curto que a sequência de saída:

[char[]](65..90)
'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'
[char[]](90..65))

Muito menor agora que vi que há um relaxamento no espaço em branco. E um pouco mais baixo ainda, se eu ignorar o caso que me é permitido.

Golfscript, 76 , 67 caracteres

123,97>+."qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"\-1%

• mudou o código ruby ​​para a geração do alfabeto Golfscript da Ventero .

CI - 92 caracteres

'a(1p'z((,0(4d)(.$)<)$)(0c0c.1+2p$.)>)$)qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz

O CI ("Compilador / Intérprete") é uma linguagem simples baseada em pilha que criei para o desafio "Autointerpretação de intérpretes" ( link para resposta ). Publiquei essa resposta cerca de duas horas antes do lançamento deste desafio. Não é um GolfScript (que ainda não aprendi a aprender), pois meu objetivo era tornar o intérprete curto.

Este programa deve ser passado para o ci intérprete através da entrada padrão. O intérprete trata os caracteres após o término )como entrada para o programa. Meu idioma não suporta literais de string, então o stdin está tomando seu lugar.

Python 2.7.X - 103 caracteres ironicamente ...

a='abcdefghijklmnopqrstuvwxyz'
print a,'qwertyuiopasdfghjklzxcvbnm pyfgcrlaoeuidhtnsqjkxbmwvz',a[::-1]

Como se vê, gerar o alfabeto em python requer mais caracteres do que codificá-lo. Assim como a importação do alfabeto. Às vezes é preciso amar uma linguagem centrada na legibilidade.

C - 133 caracteres

Versão abreviada de Casey:

main(i){char a[105];strcpy(a+26,"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");for(i=0;i<26;)a[i]=a[103-i]=i+++65;puts(a);}

Espaços em branco:

main(i) {
    char a[105];
    strcpy(a+26, "qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");
    for(i=0;i<26;)
        a[i]=a[103-i]=i+++65;
    puts(a);
}

Saída transposta

Aqui está uma versão que transpõe a saída, por diversão. 134 caracteres.

main(i){char*a="qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz";for(i=0;i<26;i++,a++)printf("%c%c%c%c\n",i+65,*a,*(a+25),90-i);}

Espaços em branco:

main(i){
  char*a="qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz";
  for(i=0;i<26;i++,a++)
    printf("%c%c%c%c\n",i+65,*a,*(a+25),90-i);
}

Impressões:

AqmZ
BwpY
CeyX
DrfW
EtgV
FycU
GurT
HilS
IoaR
JpoQ
KaeP
LsuO
MdiN
NfdM
OghL
PhtK
QjnJ
RksI
SlqH
TzjG
UxkF
VcxE
WvbD
XbmC
YnwB
ZmvA

J

x=:(97+/i.26){a.
x
261329910883437428257896643x A.x
247073478763191548160234722x A.x
(_1+/-i.26){x

Minha primeira experiência com J. A idéia é simplesmente usar o número canônico (lexicográfico) da permutação necessária; infelizmente, isso requer mais caracteres do que codificá-lo. Mas se alguém pudesse encontrar alguma expressão aritmética (usando poderes e outros enfeites) produzindo os números mágicos, ela poderia ser reduzida.

Python, 90 caracteres unicode

#coding:u8
print u"扡摣晥桧橩汫湭灯牱瑳癵硷穹睱牥祴極灯獡晤桧歪穬捸扶浮祰杦牣慬敯極桤湴煳歪扸睭究祺睸當獴煲潰浮歬楪杨敦捤慢".encode("u16")[2:]

execute em ideone - http://ideone.com/R2dlI ou codepad - http://codepad.org/lp77NL9w

Javascript 139 121

Novo:

q='qwertyuiopasdfghjklzxcvbnm'
a=q.split('').sort()
alert(a.join('')+q+'pyfgcrlaoeuidhtnsqjkxbmwvz'+a.reverse().join(''))

velho:

a=[]
a[26]='qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'
for(i=0;i<26;i++)a[i]=a[52-i]=String.fromCharCode(i+65)
alert(a.join(''))

Lua - 111 caracteres

Bate C e C ++! :-)

print'abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba'

Versão "inteligente" em Lua

129 caracteres

q='qwertyuiopasdfghjklzxcvbnm'a={q:byte(1,-1)}table.sort(a)a=q.char(unpack(a))print(a,q,'pyfgcrlaoeuidhtnsqjkxbmwvz',a:reverse())

Espaços em branco:

q='qwertyuiopasdfghjklzxcvbnm'
a={q:byte(1,-1)}
table.sort(a)
a=q.char(unpack(a))
print(a,q,'pyfgcrlaoeuidhtnsqjkxbmwvz',a:reverse())

C - 163 135 caracteres

Isso não atende aos requisitos, pois possui mais de 104 caracteres, mas foi divertido de fazer. Talvez alguém tenha algumas sugestões.

main(i){char a[105];strcpy(&a[26],"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");for(i=0;i<26;)a[i]=a[103-i]=i+++65;puts(a);}

Isso é compilado no GCC 4.5.1 (outros não testados). Yay por omitir #includes, tipos de retorno e declarações de variáveis! A codificação física resultaria em um programa mais curto, mas isso não é divertido.

Versão em espaço em branco:

main(i) {                                                                                   
    char a[105];                                                                        
    strcpy(&a[26], "qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz");                 
    for(i=0;i<26;)                                                                          
        a[i]=a[103-i]=i+++65;                                                               
    puts(a);                                                                                
}

C - 124 122 coxo

Aqui está a versão codificada lame, e ainda não faz o corte.

main(){puts("abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba");}

PHP 88 bytes

<?=$a=join(range(a,z)),~Žˆš‹†Š–žŒ›™˜—•”“…‡œ‰‘’†™˜œ“žšŠ–›—‹‘ŒŽ•”‡’ˆ‰…,strrev($a);

J - 69 char

'pyfgcrlaoeuidhtnsqjkxbmwvz'(,~|.)&(,\:~)'mnbvcxzlkjhgfdsapoiuytrewq'

Explicação:

• (,\:~) y- Classifique yem ordem decrescente ( \:~) e acrescente ( ,) isso a y.

• x (,~|.) y- Inverta ( |.) ye anexe-o à frente de x.

• x F&G y- Executar (G y) F (G y), ou seja, executar Fos resultados da aplicação Gaos argumentos.

Então, todos juntos, anexamos o alfabeto, ao contrário, às cordas Dvorak e QWERTY reversa, depois invertemos a QWERTY / alfabeto e colocamos na frente da Dvorak / alfabeto.

Bash, 64

Estou muito atrasado para a festa, mas tenho uma solução de 64 caracteres. O programa precisa ser salvo no disco para funcionar

echo {a..z} $(sed 1d $0|base64) {z..a};exit
««·+¢¢–¬uø!ŽIsÅËÛžjr~+•ªº'a¶{*ŽL[›ó

Como funciona:

{a..z}e {z..a}são bastante auto-explicativos, mas basicamente isso apenas imprime todos os caracteres desse intervalo.

$(sed 1d $0|base64) gera o programa, ignora a primeira linha e passa-o através de um codificador base64 (como outros exemplos fizeram).

O motivo é mais curto que outros exemplos semelhantes ...

... é porque os {a..z}intervalos são mais curtos que as codificações base64, então eu só preciso codificar base64 metade da string. E como estou lendo os dados binários do arquivo, em vez de armazená-los em uma string, não preciso escapar de nenhum caractere no código.

Como recriar este script:

Se o código não copiar / colar corretamente do Stack Exchange para o seu editor de texto, execute o seguinte na linha de comando (independente de shell):

echo 'echo {a..z} $(sed 1d $0|base64) {z..a};exit' > alphabetgolf
echo 'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz' | base64 -d >> alphabetgolf

Então, para executar:

bash alphabetgolf

05AB1E , 25 bytes

AžW.•8t”a$äJÚ₁вƒüu¯Cê•AR»

Experimente online!

Explicação

A                          # Push alphabet                    
 žW                        # Push qwerty string
   .•8t”a$äJÚ₁вƒüu¯Cê•     # Push compressed dvorak string
                      AR   # Push reversed alphabet
                         » # Join entire stack with newlines

C ++

É meio triste quando a maneira mais curta de fazer algo em um idioma é codificá-lo.

#include <iostream>

int main()
{
 std::cout<<"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba";
}

J (77)

(,|.@(26&{.))(,~/:~@(26&{.))'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'

Raspou 3 caracteres usando uma variável:

(,|.@a)(,~/:~@(a=.26&{.))'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'

Raspou mais 2 caracteres usando uma abordagem de nível de valor:

(|.a),~t,~a=./:~26{.t=.'qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz'

Haskell (95)

main=putStr$['a'..'z']++"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"++['z','y'..'a']

Perl (51)

Não existe uma regra que diga que não posso.

use LWP::Simple;print get("http://bit.ly/fGkflf");

Q (68)

.Q.a,"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz",(|:).Q.a

Saídas:

"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfg     
crlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba"

Tentou encontrar uma melhoria na codificação embutida nos dois do meio, mas não apresentou um.

K - 69 char

b,a,|b:a@<26#a:"qwertyuiopasdfghjklzxcvbnmpyfgcrlaeouidhtnsqjkxbmwvz"

Explicação:

• 26#a:- Atribua os dois layouts de teclado ae, em seguida, pegue os 26 primeiros caracteres.

• b:a@<- Classificar ae atribuir isso a b: <fornece a permutação para uma classificação crescente e @permite indexar apara classificá-la.

• b,a,|- Anexe em uma linha e b, em seguida a, inverta ( |) de b.

Pyth, 57

G"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"VG

Alfabeto, string, alfabeto invertido. G é o alfabeto. A impressão está implícita.

Dyalog APL , 60 bytes

⎕A'QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ',⌽⎕A

Impressões:

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ ZYXWVUTSRQPONMLKJIHGFEDCBA

O que é permitido de acordo com o OP:

A saída não diferencia maiúsculas de minúsculas e você pode adicionar ou omitir novas linhas ou espaços onde desejar.

Gelatina, 36 bytes (não concorrente)

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U

Experimente online!

Explicação:

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U    |
Øa;                                     | alphabet
   Øq;                                  | list with all rows of the qwerty keyboard
      “pyfgcrlaoeuidhtnsqjkxbmwvz”;     | string
                                   U    | reverse

05AB1E , 60 59 bytes

AÂ"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz"»

Experimente online!

AÂ - empurra o alfabeto bifurcado.

"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz" - Empurra qwerty e drovak.

» - Imprime a pilha.

05AB1E , 57 bytes (se você não se importa com aleatório \ n)

AÂ"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"»

Experimente online!