Il programma deve stampare l'alfabeto quattro volte: prima nell'ordine alfabetico normale, seconda nell'ordine di una tastiera qwerty, terza nell'ordine di una tastiera dvorak e infine nell'ordine alfabetico inverso. L'output dovrebbe assomigliare a questo:

abcdefghijklmnopqrstuvwxyz
qwertyuiopasdfghjklzxcvbnm
pyfgcrlaoeuidhtnsqjkxbmwvz
zyxwvutsrqponmlkjihgfedcba

L'output non fa distinzione tra maiuscole e minuscole e puoi aggiungere o omettere newline o spazi dove vuoi.

Il problema : il programma deve contenere meno di 104 caratteri o, in altre parole, inferiore alla lunghezza dell'alfabeto per quattro.

Accetterò la risposta con il codice più breve, a meno che non veda qualcosa di veramente intelligente o interessante di cui sono più colpito.

EDIT: accetterò la risposta più breve mercoledì 27/04/2011.

EDIT2: E il vincitore è (come al solito) Golfscript in 64 caratteri! Il secondo posto , dietro solo tre caratteri, è anche in Golfscript, con 67 caratteri, seguito da Bash al terzo posto con 72 caratteri.

Ma ce n'erano alcuni altri che volevo menzionare, come questo , che, a seconda della tua definizione, utilizzava solo 52 "caratteri", e questo in cui lo ha scritto in una lingua che ha creato.

C'erano alcune persone che hanno infranto una regola non scritta e non si sono qualificate, ma le citerò solo per il loro modo di pensare senza la scatola.

Python 2, 97 caratteri

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

L'ordinamento di QWERTY e la riconversione dall'elenco alla stringa sono più brevi dell'alfabeto stesso! *

Un'altra opzione per generare l'alfabeto in meno caratteri dell'alfabeto stesso:

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

Anche se questo stampa un elenco di caratteri Python.

Non c'è molto da fare qui in termini di compressione dei dati; il blocco delle lettere in 5 bit consente di salvare solo 39 caratteri, il che non è molto se è necessario sbloccarli (e si devono comunque rappresentare letteralmente i byte); sembra che zlib (solo come esempio) risparmi meno di 20 byte; la codifica della sequenza come un elenco di delta alla lettera successiva richiede ancora 5 bit per ciascun delta, poiché il più grande in questa sequenza è -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]

_{* Anche se solo leggermente.}

PHP, 100 byte

Come ISO 8859-1:

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

Per riprodurre in modo affidabile,

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

Rubino 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 "personaggi"

Prendendo il tuo uso della parola "caratteri" in modo liberale, ecco un po 'di pitone che usa caratteri unicode a 16 bit per codificare 3 caratteri normali ciascuno. Il programma ha un totale di 96 caratteri, 35 dei quali sono i più strani personaggi Unicode che abbia mai visto.

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

Non sono sicuro che la spazzatura Unicode arriverà anche se correttamente, quindi ecco un programma Python per generare il programma Python sopra:

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

Crediti: Alexander, Roger.

Golfscript, 64 caratteri

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

Nota: anche 64 byte. In realtà, giocare con Unicode e le modifiche di base sembra controproducente perché baseè una parola chiave troppo lunga.

Windows PowerShell, 89

Non particolarmente buono, ma almeno più corto della stringa di output:

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

Molto più breve ora che ho visto che c'è un rilassamento negli spazi bianchi. E ancora un po 'più breve, se ignoro il caso che mi è permesso.

Golfscript, 76 , 67 caratteri

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

• ha cambiato il codice rubino nella generazione dell'alfabeto Golfscript di Ventero .

CI - 92 caratteri

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

CI ("compilatore / interprete") è un linguaggio semplice basato su stack che ho creato per la sfida "Interprete auto-interpretante" ( link per rispondere ). Ho pubblicato quella risposta circa due ore prima che questa sfida fosse pubblicata. Non è GolfScript (che non ho ancora imparato ad apprendere), poiché il mio obiettivo era quello di abbreviare l'interprete.

Questo programma deve essere trasmesso ciall'interprete tramite input standard. L'interprete tratta i caratteri dopo una terminazione )come input per il programma. La mia lingua non supporta i letterali di stringa, quindi lo stdin sta prendendo il suo posto.

Python 2.7.X - 103 caratteri ironicamente ...

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

A quanto pare, la generazione dell'alfabeto in Python richiede più caratteri che codificarlo. Come importare l'alfabeto. Devo amare una lingua incentrata sulla leggibilità a volte.

C - 133 caratteri

Versione abbreviata da 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);
}

Uscita trasposta

Ecco una versione che trasporta l'output, per divertimento. 134 caratteri.

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

stampe:

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

La mia prima esperienza con J. L'idea è semplicemente di usare il numero canonico (lessicografico) della permutazione richiesta; sfortunatamente questo richiede più caratteri che codificarlo. Ma se si potesse trovare un'espressione aritmetica (usando i poteri e quant'altro) che produce i numeri magici, potrebbe essere abbreviata.

Python, 90 caratteri unicode

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

eseguire su ideone - http://ideone.com/R2dlI o codepad - http://codepad.org/lp77NL9w

Javascript 139 121

nuovo:

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

vecchio:

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

Lua - 111 caratteri

Batte C e C ++! :-)

print'abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba'

Versione "intelligente" in Lua

129 caratteri

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 caratteri

Questo non soddisfa i requisiti in quanto raggiunge oltre 104 caratteri, ma è stato divertente da realizzare. Forse qualcuno avrà qualche suggerimento.

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

Questo viene compilato su GCC 4.5.1 (altri non testati). Sì per aver omesso #includi, tipi di ritorno e dichiarazioni variabili! L'hardcoding avrebbe comportato un programma più breve, ma non è affatto divertente.

Versione bianca:

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 zoppo

Ecco la versione scadente dell'hardcoded e non riesce ancora a tagliare.

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

PHP 88 byte

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

J - 69 char

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

Spiegazione:

• (,\:~) y- Ordina yin ordine decrescente ( \:~) e aggiungi ( ,) ay .

• x (,~|.) y- Inverti ( |.) ye aggiungilo alla parte anteriore dix .

• x F&G y- Esegui (G y) F (G y), ovvero esegui Fsui risultati dell'applicazioneG agli argomenti.

Quindi, tutti insieme, aggiungiamo l'alfabeto, all'indietro, sia alle stringhe Dvorak che a quelle QWERTY inverse, quindi invertiamo quella QWERTY / alfabeto e la mettiamo di fronte a quella Dvorak / alfabeto.

Bash, 64

Sono in ritardo alla festa, ma ho una soluzione a 64 caratteri. Il programma deve essere salvato su disco per funzionare

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

Come funziona:

{a..z}e {z..a}sono piuttosto autoesplicativi, ma fondamentalmente ciò stampa solo ogni personaggio in quel rispettivo intervallo.

$(sed 1d $0|base64) emette il programma, ignora la prima riga, quindi la passa attraverso un codificatore base64 (come hanno fatto alcuni altri esempi).

Il motivo è più breve di altri esempi simili ...

... è perché il {a..z} intervalli sono più brevi delle codifiche base64, quindi ho solo bisogno di codificare base64 metà della stringa. E poiché sto leggendo i dati binari dal file anziché memorizzarli in una stringa, non ho bisogno di sfuggire a nessun carattere nel codice.

Come ricreare questo script:

Se il codice non copia / incolla correttamente da Stack Exchange al tuo editor di testo, esegui quanto segue nella riga di comando (shell agnostic):

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

Quindi eseguire:

bash alphabetgolf

05AB1E , 25 byte

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

Provalo online!

Spiegazione

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

È un po 'triste quando il modo più breve per fare qualcosa in una lingua è codificarlo.

#include <iostream>

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

J (77)

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

Rasato 3 caratteri usando una variabile:

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

Rasato altri 2 personaggi usando un approccio a livello di valore:

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

Haskell (95)

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

Perl (51)

Non esiste una regola che dice che non posso.

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

Q (68)

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

Uscite:

"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfg     
crlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba"

Ho provato a trovare un miglioramento nell'hard-coding dei due secondi ma non ne ho trovato uno.

K - 69 char

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

Spiegazione:

• 26#a:- Assegna i due layout di tastiera a a, quindi prendi i primi 26 caratteri.

• b:a@<- Ordina ae assegnalo a b: <fornisce la permutazione per un ordinamento crescente e @ci consente di indicizzarlo aper ordinarlo.

• b,a,|- Aggiungi in una riga b, quindi a, quindi il contrario ( |) di b.

Pyth, 57

G"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"VG

Alfabeto, stringa, alfabeto rovesciato. G è l'alfabeto. La stampa è implicita.

Dyalog APL , 60 byte

⎕A'QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ',⌽⎕A

stampe:

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ ZYXWVUTSRQPONMLKJIHGFEDCBA

Che è consentito secondo OP:

L'output non fa distinzione tra maiuscole e minuscole e puoi aggiungere o omettere newline o spazi dove vuoi.

Jelly, 36 byte (non concorrenti)

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U

Provalo online!

Spiegazione:

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

05AB1E , 60 59 byte

AÂ"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz"»

Provalo online!

AÂ - spinge l'alfabeto biforcato.

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

» - Stampa pila.

05AB1E , 57 byte (se non ti interessa casualmente \ n)

AÂ"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"»

Provalo online!