Le programme doit imprimer quatre fois l'alphabet: le premier dans l'ordre alphabétique normal, le deuxième dans l'ordre d'un clavier qwerty, le troisième dans l'ordre d'un clavier dvorak et enfin dans l'ordre alphabétique inverse. La sortie devrait ressembler à ceci:

abcdefghijklmnopqrstuvwxyz
qwertyuiopasdfghjklzxcvbnm
pyfgcrlaoeuidhtnsqjkxbmwvz
zyxwvutsrqponmlkjihgfedcba

La sortie ne fait pas la différence entre les majuscules et les minuscules et vous pouvez ajouter ou supprimer des nouvelles lignes ou des espaces à votre guise.

La capture : le programme doit comporter moins de 104 caractères, ou en d’autres termes, une longueur inférieure à la longueur de l’alphabet multipliée par quatre.

J'accepterai la réponse avec le code le plus court, à moins que je ne voie quelque chose d'intelligent ou d'intéressant qui m'impressionne davantage.

EDIT: J'accepterai la réponse la plus courte mercredi, 27/04/2011.

EDIT2: Et le gagnant est (comme d'habitude) Golfscript en 64 caractères! La deuxième place , qui n’a que trois personnages derrière, est également classée dans Golfscript, avec 67 caractères, suivie par Bash, troisième avec 72 caractères.

Mais il y avait quelques autres personnes que je voulais mentionner, comme celle-ci , qui, selon votre définition, n’utilisait que 52 "caractères", et celle où il l’a écrit dans une langue qu’il a créée.

Il y avait quelques personnes qui ont éclaté une règle non écrite et ne sont pas admissibles, mais je vais les mentionner seulement pour leur façon de penser sans la boîte.

Python 2, 97 caractères

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

Le tri QWERTY et la conversion de chaîne en chaîne sont plus courts que l'alphabet lui-même! *

Une autre option pour générer l’alphabet en moins de caractères que l’alphabet lui-même:

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

Bien que cela affiche une liste de caractères Python.

Il n’ya pas grand chose à faire ici en matière de compression de données; brouiller les lettres en 5 bits ne sauve que 39 caractères, ce qui est peu si vous devez ensuite les débloquer (et vous devez toujours représenter les octets littéralement); il semble que zlib (juste à titre d'exemple) économise moins de 20 octets; coder la séquence sous forme de liste de deltas à la lettre suivante nécessite encore 5 bits pour chaque delta, car le plus grand de cette séquence est -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]

_{* Bien que légèrement.}

PHP, 100 octets

En tant qu'ISO 8859-1:

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

Pour reproduire de manière fiable,

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

Ruby 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 "personnages"

Prenant votre utilisation du mot "caractères" généreusement, voici un python qui utilise des caractères unicode 16 bits pour coder 3 caractères normaux chacun. Le programme comprend 96 caractères, dont 35 sont les plus étranges caractères unicode que j'ai jamais vus.

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

Je ne suis pas sûr que la corbeille unicode viendra bien, alors voici un programme python pour générer le programme python ci-dessus:

#!/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: supprimé tr -d.

Crédits: Alexander, Roger.

Golfscript, 64 caractères

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

Remarque: également 64 octets. En fait, jouer avec Unicode et les changements de base semble contre-productif car basec'est un mot-clé trop long.

Windows PowerShell, 89

Pas particulièrement bon, mais au moins plus court que la chaîne de sortie:

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

Bien plus court maintenant que j'ai vu qu'il y a une relaxation sur les espaces blancs. Et un peu plus court encore, si j'ignore les cas qui me sont permis.

Golfscript, 76 , 67 caractères

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

• a changé le code ruby ​​pour la génération de l'alphabet Golfscript de Ventero .

CI - 92 caractères

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

CI ("Compiler / Interpreter") est un langage simple basé sur une pile que j'ai créé pour le défi "Interprète auto-interprété" ( lien vers la réponse ). J'ai posté cette réponse environ deux heures avant que ce défi ne soit posté. Ce n'est pas GolfScript (que je n'ai pas encore appris à apprendre), mon objectif étant de rendre l'interprète court.

Ce programme doit être transmis à l' ciinterprète via une entrée standard. L'interprète traite les caractères après une terminaison )comme une entrée du programme. Ma langue ne supporte pas les littéraux de chaîne, stdin prend donc sa place.

Python 2.7.X - 103 caractères ironiquement ...

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

Il s'avère que générer l'alphabet en python nécessite plus de caractères que de le coder en dur. De même que l'importation de l'alphabet. Il faut parfois aimer une langue centrée sur la lisibilité.

C - 133 caractères

Version abrégée 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);}

Whitespaced:

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

Sortie transposée

Voici une version qui fait une sortie transposée, pour le plaisir. 134 caractères.

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

Whitespaced:

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

Impressions:

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

Ma première expérience avec J. L'idée est simplement d'utiliser le numéro canonique (lexicographique) de la permutation requise; Malheureusement, cela prend plus de caractères que de coder en dur. Mais si l'on pouvait trouver une expression arithmétique (utilisant des pouvoirs ou autres) donnant les nombres magiques, elle pourrait être raccourcie.

Python, 90 caractères unicode

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

exécuter à ideone - http://ideone.com/R2dlI ou codepad - http://codepad.org/lp77NL9w

Javascript 139 121

Nouveau:

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

vieux:

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

Lua - 111 personnages

Beats C et C ++! :-)

print'abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba'

Version "intelligente" en Lua

129 caractères

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

Whitespaced:

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

C - 163 135 caractères

Cela ne répond pas aux exigences car il compte plus de 104 caractères, mais c'était amusant à créer. Peut-être que quelqu'un aura des suggestions.

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

Ceci compile sur GCC 4.5.1 (autres non testés). Oui pour omettre #includes, les types de retour et les déclarations de variable! Le codage en dur aurait abouti à un programme plus court, mais ce n'est pas amusant.

Version en blanc:

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 boiteux

Voici la version boiteuse codée en dur, et elle ne fait toujours pas la coupe.

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

PHP 88 octets

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

J - 69 caractères

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

Explication:

• (,\:~) y- Triez ypar ordre décroissant ( \:~) et ajoutez ( ,) cela à y.

• x (,~|.) y- Inverser ( |.) yet l’ajouter à l’avant de x.

• x F&G y- Exécuter (G y) F (G y), c’est-à-dire utiliser Fles résultats de l’application Gaux arguments.

Donc, tous ensemble, nous ajoutons l’alphabet, à l’arrière, aux chaînes Dvorak et reverse-QWERTY, puis inversons le code QWERTY / alphabet et le plaçons devant celui Dvorak / alphabet.

Bash, 64

Je suis très en retard à la fête, mais j'ai une solution à 64 caractères. Le programme doit être enregistré sur le disque pour fonctionner

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

Comment ça marche:

{a..z}et {z..a}sont assez explicites, mais en gros, cela n'imprime que tous les caractères de cette plage.

$(sed 1d $0|base64) sort le programme, ignore la première ligne, puis le passe à travers un encodeur base64 (comme l'ont fait d'autres exemples).

La raison pour laquelle cela est plus court que d'autres exemples similaires ...

... c'est parce que les {a..z}plages sont plus courtes que les encodages base64, je n'ai donc besoin que d'encoder en base64 la moitié de la chaîne. Et comme je lis les données binaires d'un fichier plutôt que de les stocker dans une chaîne, je n'ai pas besoin d'échapper à un caractère du code.

Comment recréer ce script:

Si le code ne copie / colle pas correctement de Stack Exchange dans votre éditeur de texte, exécutez la commande suivante dans votre ligne de commande (non-agniste du shell):

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

Puis pour courir:

bash alphabetgolf

05AB1E , 25 octets

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

Essayez-le en ligne!

Explication

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

C'est un peu triste quand le moyen le plus rapide de faire quelque chose dans une langue est de le coder en dur.

#include <iostream>

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

J (77)

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

Rasé 3 caractères en utilisant une variable:

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

Rasé 2 caractères supplémentaires en utilisant une approche de niveau valeur:

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

Haskell (95)

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

Perl (51)

Aucune règle ne dit que je ne peux pas.

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

Q (68)

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

Les sorties:

"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfg     
crlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba"

J'ai essayé de trouver une amélioration sur le codage en dur des deux médians, mais je n’en ai pas trouvé un.

K - 69 caractères

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

Explication:

• 26#a:- Attribuez les deux dispositions de clavier à a, puis prenez les 26 premiers caractères.

• b:a@<- Trier aet assigner cela à b: <fournit la permutation pour un tri croissant et @nous permet d'indexer aafin de le trier.

• b,a,|- Ajouter dans une ligne b, puis a, puis l’inverse ( |) de b.

Pyth, 57

G"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"VG

Alphabet, chaîne, alphabet inversé. G est l'alphabet. L'impression est implicite.

Dyalog APL , 60 octets

⎕A'QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ',⌽⎕A

Impressions:

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ ZYXWVUTSRQPONMLKJIHGFEDCBA

Qui est autorisé selon l'OP:

La sortie ne fait pas la différence entre les majuscules et les minuscules et vous pouvez ajouter ou supprimer des nouvelles lignes ou des espaces à votre guise.

Gelée, 36 octets (non concurrente)

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U

Essayez-le en ligne!

Explication:

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

05AB1E , 60 59 octets

AÂ"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz"»

Essayez-le en ligne!

AÂ - pousse l'alphabet bifurqué.

"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz" - Pousse qwerty et drovak.

» - Empile la pile.

05AB1E , 57 octets (Si vous ne vous souciez pas du hasard \ n)

AÂ"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"»

Essayez-le en ligne!