Das Programm muss das Alphabet viermal drucken: erstens in der normalen alphabetischen Reihenfolge, zweitens in der Reihenfolge einer QWERTY-Tastatur, drittens in der Reihenfolge einer Dvorak-Tastatur und zuletzt in umgekehrter alphabetischer Reihenfolge. Die Ausgabe sollte ungefähr so ​​aussehen:

abcdefghijklmnopqrstuvwxyz
qwertyuiopasdfghjklzxcvbnm
pyfgcrlaoeuidhtnsqjkxbmwvz
zyxwvutsrqponmlkjihgfedcba

Bei der Ausgabe wird nicht zwischen Groß- und Kleinschreibung unterschieden. Sie können Zeilenumbrüche oder Leerzeichen beliebig hinzufügen oder weglassen.

Der Haken : Das Programm muss kürzer als 104 Zeichen sein, oder, mit anderen Worten, kürzer als die Länge des Alphabets mal vier.

Ich akzeptiere die Antwort mit dem kürzesten Code, es sei denn, ich sehe etwas wirklich Kluges oder Interessantes, von dem ich mehr beeindruckt bin.

EDIT: Ich akzeptiere die kürzeste Antwort am Mittwoch, den 27.04.2011.

EDIT2: Und der Gewinner ist (wie immer) Golfscript in 64 Zeichen! Der zweite Platz , der nur um drei Zeichen zurückliegt, ist ebenfalls in Golfscript mit 67 Zeichen, gefolgt von Bash auf dem dritten Platz mit 72 Zeichen.

Aber es gab ein paar andere, die ich erwähnen wollte, wie dieses , das, abhängig von Ihrer Definition, nur 52 "Zeichen" verwendete, und dieses, in dem er es in einer von ihm erstellten Sprache schrieb.

Es gab ein paar Leute , die gegen eine ungeschriebene Regel verstoßen und sich nicht qualifiziert haben, aber ich werde sie nur für ihre Denkweise ohne die Box erwähnen.

Python 2, 97 Zeichen

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

Das Sortieren von QWERTY und das Zurückkonvertieren von Liste zu Zeichenfolge ist kürzer als das Alphabet selbst! *

Eine weitere Option zum Generieren des Alphabets in weniger Zeichen als das Alphabet selbst:

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

Obwohl dies eine Python-Liste von Zeichen druckt.

In Bezug auf die Datenkomprimierung ist hier nicht viel zu tun. Wenn Sie die Buchstaben in 5 Bits zusammenfassen, werden nur 39 Zeichen gespart, was nicht viel ist, wenn Sie sie dann wieder entfernen müssen (und die Bytes immer noch buchstäblich darstellen müssen). Es sieht so aus, als würde zlib (nur als Beispiel) weniger als 20 Bytes speichern. Das Codieren der Sequenz als Liste von Deltas bis zum nächsten Buchstaben benötigt immer noch 5 Bits für jedes Delta, da die größte in dieser Sequenz -22 ist:

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

_{* Obwohl nur geringfügig.}

PHP, 100 Bytes

Wie ISO 8859-1:

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

Um zuverlässig zu reproduzieren,

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

Wenn Sie das Wort "Zeichen" großzügig verwenden, finden Sie hier einen Python, der 16-Bit-Unicode-Zeichen verwendet, um jeweils 3 normale Zeichen zu codieren. Das Programm besteht aus 96 Zeichen, von denen 35 die seltsamsten Unicode-Zeichen sind, die ich je gesehen habe.

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

Ich bin mir nicht sicher, ob der Unicode-Garbage korrekt ankommt. Deshalb hier ein Python-Programm, um das obige Python-Programm zu generieren:

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

Credits: Alexander, Roger.

Golfscript, 64 Zeichen

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

Anmerkung: auch 64 Bytes. Tatsächlich scheint das Spielen mit Unicode und Basisänderungen kontraproduktiv zu sein, da basees sich um ein zu langes Schlüsselwort handelt.

Windows PowerShell, 89

Nicht besonders gut, aber zumindest kürzer als die Ausgabezeichenfolge:

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

Viel kürzer, als ich sah, dass sich das Leerzeichen entspannt. Und noch ein bisschen kürzer, wenn ich den Fall ignoriere, den ich darf.

Golfscript, 76 , 67 Zeichen

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

• Ruby-Code in Venteros Golfscript-Alphabet geändert .

CI - 92 Zeichen

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

CI ("Compiler / Interpreter") ist eine einfache stapelbasierte Sprache, die ich für die Herausforderung "Self-Interpreting Interpreter" erstellt habe ( Link zur Antwort ). Ich habe diese Antwort ungefähr zwei Stunden vor der Veröffentlichung dieser Herausforderung gepostet. Es ist kein GolfScript (was ich noch nicht gelernt habe), mein Ziel war es, den Dolmetscher kurz zu machen.

Dieses Programm muss ciüber die Standardeingabe an den Interpreter übergeben werden. Der Interpreter behandelt Zeichen nach einem Abbruch )als Eingabe in das Programm. Meine Sprache unterstützt keine Zeichenkettenliterale, daher nimmt stdin seinen Platz ein.

Python 2.7.X - 103 Zeichen ironischerweise ...

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

Wie sich herausstellt, benötigt das Generieren des Alphabets in Python mehr Zeichen als das Hardcodieren. Ebenso wie der Import des Alphabets. Ich muss manchmal eine Sprache lieben, die auf Lesbarkeit ausgerichtet ist.

C - 133 Zeichen

Verkürzte Version von Casey:

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

Leerzeichen:

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

Transponierte Ausgabe

Hier ist eine Version, die die Ausgabe zum Spaß transponiert. 134 Zeichen.

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

Leerzeichen:

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

Drucke:

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

Meine erste Erfahrung mit J. Die Idee ist einfach, die kanonische (lexikografische) Zahl der erforderlichen Permutation zu verwenden; Leider dauert dies mehr Zeichen als hartcodiert. Aber wenn man einen arithmetischen Ausdruck (unter Verwendung von Kräften und so weiter) finden könnte, der die magischen Zahlen ergibt, könnte er verkürzt werden.

Python, 90 Unicode-Zeichen

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

Laufen Sie unter ideone - http://ideone.com/R2dlI oder codepad - http://codepad.org/lp77NL9w

Javascript 139 121

Neu:

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

alt:

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

Lua - 111 Zeichen

Schlägt C und C ++! :-)

print'abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba'

"Clevere" Version in Lua

129 Zeichen

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

Leerzeichen:

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

C - 163 135 Zeichen

Dies entspricht nicht den Anforderungen, da es mehr als 104 Zeichen umfasst, aber es hat Spaß gemacht, es zu machen. Vielleicht hat jemand ein paar Vorschläge.

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

Kompiliert unter GCC 4.5.1 (andere nicht getestet). Yay für das Weglassen von #includes, Rückgabetypen und Variablendeklarationen! Hardcoding hätte zu einem kürzeren Programm geführt, aber das macht keinen Spaß.

Whitespaced-Version:

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 lahm

Hier ist die lahme, hartcodierte Version, und sie schafft es immer noch nicht.

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

PHP 88 Bytes

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

J - 69 Zeichen

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

Erläuterung:

• (,\:~) y- yIn absteigender Reihenfolge \:~sortieren ( ,) und anhängen ( ) y.

• x (,~|.) y- Kehren Sie ( |.) um yund fügen Sie das an die Vorderseite von an x.

• x F&G y- Ausführen (G y) F (G y), dh Ausführen Fder Ergebnisse der Anwendung Gauf die Argumente.

Alles in allem hängen wir das Alphabet rückwärts an die Zeichenfolgen Dvorak und reverse-QWERTY an, kehren dann die Zeichenfolge QWERTY / Alphabet um und setzen sie vor die Zeichenfolge Dvorak / Alphabet.

Bash, 64

Ich komme sehr spät zur Party, aber ich habe eine 64-Zeichen-Lösung. Das Programm muss auf der Festplatte gespeichert werden, damit es funktioniert

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

Wie es funktioniert:

{a..z}und {z..a}sind ziemlich selbsterklärend, aber im Grunde druckt das nur jedes Zeichen in dem jeweiligen Bereich.

$(sed 1d $0|base64) gibt das Programm aus, ignoriert die erste Zeile und leitet es dann durch einen base64-Encoder (wie es einige andere Beispiele getan haben).

Der Grund dafür ist kürzer als andere ähnliche Beispiele ...

... liegt daran, dass die {a..z}Bereiche kürzer sind als Base64-Codierungen, sodass ich nur die Hälfte der Zeichenfolge mit Base64 codieren muss. Und da ich die Binärdaten aus einer Datei lese, anstatt sie in einer Zeichenfolge zu speichern, muss ich kein Zeichen im Code maskieren.

So erstellen Sie dieses Skript neu:

Wenn der Code von Stack Exchange in Ihren Texteditor nicht richtig kopiert / eingefügt werden kann, führen Sie in Ihrer Befehlszeile (Shell-Agnostiker) Folgendes aus:

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

Dann laufen:

bash alphabetgolf

05AB1E , 25 Bytes

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

Probieren Sie es online!

Erläuterung

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

Es ist traurig, wenn der kürzeste Weg, etwas in einer Sprache zu tun, darin besteht, es hart zu codieren.

#include <iostream>

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

J (77)

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

3 Zeichen mit einer Variablen abgeschnitten:

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

2 weitere Zeichen mit einem Value-Level-Ansatz abgeschnitten:

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

Haskell

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

Perl (51)

Es gibt keine Regel, die besagt, dass ich nicht kann.

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

Q (68)

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

Ausgänge:

"abcdefghijklmnopqrstuvwxyzqwertyuiopasdfghjklzxcvbnmpyfg     
crlaoeuidhtnsqjkxbmwvzzyxwvutsrqponmlkjihgfedcba"

Versucht, eine Verbesserung der Hardcodierung der beiden mittleren zu finden, hat aber keine gefunden.

K - 69 Zeichen

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

Erläuterung:

• 26#a:- Weisen Sie die beiden Tastaturlayouts zu aund übernehmen Sie die ersten 26 Zeichen.

• b:a@<- Sortieren aund zuweisen an b: <Liefert die Permutation für eine aufsteigende Sortierung und @lässt uns indizieren, aum sie zu sortieren.

• b,a,|- Anfügen in einer Zeile b, dann a, dann wird der Rücklauf ( |) von b.

Pyth, 57

G"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"VG

Alphabet, Zeichenfolge, umgekehrtes Alphabet. G ist das Alphabet. Der Ausdruck ist implizit.

Dyalog APL , 60 Bytes

⎕A'QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ',⌽⎕A

Drucke:

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  QWERTYUIOPASDFGHJKLZXCVBNMPYFGCRLAOEUIDHTNSQJKXBMWVZ ZYXWVUTSRQPONMLKJIHGFEDCBA

Was ist nach OP erlaubt:

Bei der Ausgabe wird nicht zwischen Groß- und Kleinschreibung unterschieden. Sie können Zeilenumbrüche oder Leerzeichen beliebig hinzufügen oder weglassen.

Gelee, 36 Bytes (nicht konkurrierend)

Øa;Øq;“pyfgcrlaoeuidhtnsqjkxbmwvz”;U

Probieren Sie es online!

Erläuterung:

Ø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"»

Probieren Sie es online!

AÂ - drückt das gegabelte Alphabet.

"qwertyuiopasdfghjklzxcvbnm""pyfgcrlaoeuidhtnsqjkxbmwvz" - Drückt QWERTY und DROVAK.

» - Druckt Stapel.

05AB1E , 57 Bytes (Wenn Sie sich nicht für Zufall interessieren \ n)

AÂ"qwertyuiopasdfghjklzxcvbnmpyfgcrlaoeuidhtnsqjkxbmwvz"»

Probieren Sie es online!