> > kommt auf
> > 3,2 Mio Punkte, die schlechteste auf 5,4 Mio.
>
> Wie sieht denn der genaue Punkteschlüssel aus, bzw. was war Grundlage
> für die Bepunktung? Ohne die Bepunktungsgrundlage kann ich die
> Ergebnisse nicht richtig nachvollziehen.
Ich habe folgendes Kochbuch einfach nachgebastelt:
http://klausler.com/evolved.html
1. Buchstabenlage:
Wann immer der Tipper eine Taste drückt, werden Punkte vergeben:
5 3 3 3 4 4 3 3 3 5 7
1 0 0 0 2 2 0 0 0 1 7
6 5 5 5 7 7 5 5 5 6
Wird also der Zeigefinger benutzt, gibt das 0 Punkte in der
Grundstellung, der Kleinfinger gestreckt gibt 7 Punkte. In diversen
Internetblogs streitet man darum, ob man Zahlen von 0 bis 90 oder 0 bis
30 usw. benutzen soll, ob Strecken des linken Zeigefingers nach schräg
oben weniger Punkte geben soll als der rechte, weil die Schräge der
Tastatur dies unbequemer macht usw.
2. Fingerwiederholungen:
Wird der gleiche Finger zweimal hintereinander benutzt: 10 Punkte.
3. Reihensprünge:
Wird die gleiche Hand zweimal hintereinander benutzt und liegen die
benutzten Tasten auf unterschiedlichen Reihen: 2 Punkte.
4. Wiederholung unten:
Wird die gleiche Hand zweimal hintereinander benutzt und liegen die
benutzten Tasten auf der gleichen Reihe, und zwar unten: 2 Punkte.
5. Auseinander:
Wird die gleiche Hand zweimal hintereinander benutzt und liegen die
gedrückten Tasten auseinander (also nicht nebeneinander): 1 Punkt.
6. Handeinsatzlänge:
Wird die gleiche Hand mehr als zweimal hintereinander benutzt, werden ab
der dritten Buchstabe 2 Punkte pro Buchstabe vergeben.
====
Und welcher Text wird nun getippt:
Eine Kombination aus "Kritik der reinen Vernunft" von Immanuel Kant,
"Krieg und Frieden" von Leo Tolstoj (Band 1), die zweite Sure des
Korans, und ein Haufen zufällige Zeitungsartikel. Diese Sammlung ist
frisiert indem alle Wörter entfernt worden sind, die fremde Buchstaben
enthalten (wie etwa "frappé"), Eigennamen sind oder einfach komisch
aussehen (meine persönliche Einschätzung, etwa "igitur" oder "venit").
Was übrig geblieben ist - 9960 verschiedene Wörter - sind nach der neuen
Rechtschreibung korrigiert. Das Ergebnis ist der "Körper" (Corpus, wie
die Amerikaner sagen) von etwa 1 Megabyte Buchstaben. Kommas und Punkte
sind wie eigenständige Wörter behandelt - es wird also kein Unterschied
gemacht, ob ein Komma nach einem Z oder nach einem E geschrieben wird,
es gibt die gleiche Anzahl Punkte. Sie nehmen aber in der Bewertung der
Buchstabenlage teil. Es waren um die 14000 Kommas im Text.
Dieses alles ist überaus fragwürdig und sehr subjektiv und zudem auch
noch übervereinfacht. Als Neo-Fan würde ich das Ergebnis einfach als
irrelevant abtun und weiterhin nachts gut schlafen. Eine andere
Möglichkeit ist, dass man sich untereinander streitet, welche Kriterien
nun am wichtigsten sind, und wie man das Programm so ändern kann, dass
"Einwärtsrollen", "Auswärtsrollen", "Digrafen" und so weiter
berücksichtigung finden. Ich denke, darüber kann man ein 100-seitiges
Lehrbuch machen und sich die Köpfe gegenseitig einschlagen.
Das Progrämmchen enthält 98 Zeilen Python-Code, ist also nicht mehr als
ein richtiger Programmierer in einer halben Stunde schreiben kann. (Ich,
der Python noch nicht richtig kannte, habe eine Woche dafür gebraucht.
Mit AWK geht es aber nicht und C kann ich (noch) nicht.)
====
Das hier beigefügte Progrämmchen setzt voraus, dass es eine Datei gibt,
die "tastaturen.txt" heißt. Darin gibt es auf jeder Zeile eine Tastatur
dadurch, dass sämtliche Tasten eine nach der anderen gedrückt werden in
der meist offensichtliche Reihenfolge. Die Neo-Tastatur lautet:
xvlcwkhgfqßuiaeosnrtdyüöäpzbm,.j
Jede Zeile muss genau 32 Zeichen haben, leere Zeilen sind nicht erlaubt.
Das Programm setzt ferner voraus, dass es eine Datei gibt,
"woerter.txt", die pro Zeile eine Zahl (die Häufigkeit) gibt, dann ein
oder mehrere Leerzeichen, dann das Wort. Kommas und Punkte werden allein
gezählt. Meine "woerter.txt" sieht so aus:
14198 ,
4937 .
4961 der
3928 die
3235 und
2132 in
1806 ist
1558 nicht
1514 sie
1412 zu
1340 als
1195 das
1181 von
1100 den
1067 sich
966 des
942 so
933 dass
932 es
879 aber
873 auf
803 ich
...usw.
Diese Datei ist natürlich durch Aufsplittung des Textkörpers entstanden.
Das Tippen sämtlicher Wörter in der angegebenen Häufigkeit ist ja das
gleiche wie das Tippen des Textkörpers selber (ja?).
Das Programm gibt dann die Auswertung mit den ganzen Punkten und so, auf
dem Bildschirm aus. In einer weiteren Datei, "Ergbn.txt" werden die
Tastaturen mit der Gesamtpunktzahl voran ausgegeben. Diese datei soll
dann später mit "sort" sortiert werden und die übelsten verworfen. Die
guten lässt man sich dann vermehren, entweder mit Klauslers Algorithmus
oder auf andere Weise, sodass man die gleiche Anzahl erhält wie vorher.
Danach schält man die Punkte ab (mit AWK z.B.) und speichert das Ding
als "tastaturen.txt" ab. Dann kann es von vorne losgehen. Es ist
empfehlenswert, 1000 Tastaturen per Durchgang durchzunehmen. Ich müsste
noch das Manipulationsprogramm schreiben usw. damit die
Tastaturentwicklung automatisiert werden kann.
Es gibt aber inzwischen andere, mehr interessante Ansätze, sodass das
obige vielleicht bereits wieder hinfällig ist.
#!/usr/bin/env python
#-*- coding: utf-8 -*-
# Zum Lesen und Schreiben von Unicode-Dateien
import codecs
# Die Datei, die die Tastaturen enthält
eintast = codecs.open('tastaturen.txt', encoding = 'utf-8', mode = 'r')
# Ausgabedatei
aus = codecs.open('Ergbn.txt', encoding = 'utf-8', mode = 'a')
# Jede Zeile der Datei ist eine Tastatur mit den 32 Tasten genannt von links
# nach rechts und von oben nach unten
for T in eintast:
# Welcher Finger gehört zu der Buchstabe? Erste Ziffer.
# Li Kleinfinger = 1... li Zeigefinger = 4
# Re Zeigefinger = 5... re Kleinfinger = 8
# In welcher Gruppe liegt der Buchstabe? Zweite Ziffer
# 1 1 1 1 1 4 4 4 4 4 4
# 2 2 2 2 2 5 5 5 5 5 5
# 3 3 3 3 3 6 6 6 6 6
# Unter welcher Hand liegt der Buchstabe? Li = 0, Re = 1
# Dritte Ziffer
# Wieviele Punkte bringt der Buchstabe? Vierte Ziffer
# 5 3 3 3 4 4 3 3 3 5 7
# 1 0 0 0 2 2 0 0 0 1 7
# 6 5 5 5 7 7 5 5 5 6
# Danach wird so zugegriffen:
# dat['e'][0] ist der Finger, der 'e' tippt
# dat['e'][1] ist die Gruppe, in der 'e' liegt
# dat['e'][2] ist die Hand, die 'e' tippt
# dat['e'][3] ist die Punktezahl, die 'e' verursacht
# ist tmp ein eingelesener Buchstabe, ist also:
# dat[tmp][3] dessen Punkte.
dat = {
T[0]: (1, 1, 0, 5),
T[1]: (2, 1, 0, 3),
T[2]: (3, 1, 0, 3),
T[3]: (4, 1, 0, 3),
T[4]: (4, 1, 0, 4),
T[5]: (5, 4, 1, 4),
T[6]: (5, 4, 1, 3),
T[7]: (6, 4, 1, 3),
T[8]: (7, 4, 1, 3),
T[9]: (8, 4, 1, 5),
T[10]: (8, 4, 1, 7),
T[11]: (1, 2, 0, 1),
T[12]: (2, 2, 0, 0),
T[13]: (3, 2, 0, 0),
T[14]: (4, 2, 0, 0),
T[15]: (4, 2, 0, 2),
T[16]: (5, 5, 1, 2),
T[17]: (5, 5, 1, 0),
T[18]: (6, 5, 1, 0),
T[19]: (7, 5, 1, 0),
T[20]: (8, 5, 1, 1),
T[21]: (8, 5, 1, 7),
T[22]: (1, 3, 0, 6),
T[23]: (2, 3, 0, 5),
T[24]: (3, 3, 0, 5),
T[25]: (4, 3, 0, 5),
T[26]: (4, 3, 0, 7),
T[27]: (5, 6, 1, 7),
T[28]: (5, 6, 1, 5),
T[29]: (6, 6, 1, 5),
T[30]: (7, 6, 1, 5),
T[31]: (8, 6, 1, 6)
}
# Die Datei, die die Wörter enthält
# muss für jede Tastatur neu geöffnet
# und wieder geschlossen werden
woerter = open('woerter.txt', 'r')
lpunkte = 0
fpunkte = 0
gpunkte = 0
upunkte = 0
apunkte = 0
epunkte = 0
for zeile in woerter:
# Lagepunkte aufgrund der Lage des Buchstaben
lp = 0
# Fingerpunkte aufgrund von Fingerwiederholungen
fp = 0
# Gruppenwechselpunkte bei Handwiederholungen
gp = 0
# Punkte für Wiederholung auf der unteren Reihe
up = 0
# Punkte für auseinander Liegen der Buchstaben
ap = 0
# Punkte für die Länge eines Handeinsatzes
ep = 0
# Länge eines Handeinsatzes, ist ja mindestens 1 Buchstabe
laenge = 1
zeile = unicode(zeile, 'utf-8')
(zahl, wort) = zeile.split()
zahl = int(zahl)
erster = wort[0]
# Lagepunkte des ersten Buchstaben im Wort
lp += dat[erster][3]
for buchstabe in wort[1:]:
# Lagepunkte der übrigen Buchstaben im Wort
lp += dat[buchstabe][3]
if buchstabe == erster:
continue
# Gleiche Finger:
if dat[buchstabe][0] == dat[erster][0]:
fp += 10
# Ungleiche Finger, ungleiche Reihe (Gruppe):
elif dat[buchstabe][1] != dat[erster][1]:
gp += 2
# Ungleiche Finger, gleiche Reihe und zwar unten:
elif dat[buchstabe][1] == 3 or dat[buchstabe][1] == 6:
up += 2
# Ungleiche Finger, gleiche Reihe, aber auseinander:
elif abs(dat[buchstabe][0] - dat[erster][0]) >= 2:
ap += 1
# Jetzt schauen wir nach Länge des Handeinsatzes:
# Gleiche Hand:
if dat[buchstabe][2] == dat[erster][2]:
laenge += 1
# Handwechsel:
else:
if laenge > 2:
ep = ep + laenge - 2
laenge = 1
erster = buchstabe
# Wir sind mit dem Wort fertig
# epunkte am Ende des Wortes nicht vergessen
if laenge > 2:
ep = ep + laenge - 2
# Nachdem wir so alle Punkte für dieses Wort gesammelt haben,
# multiplizieren wir mit der Worthäufigkeit
lpunkte += lp * zahl
fpunkte += fp * zahl
gpunkte += gp * zahl
upunkte += up * zahl
apunkte += ap * zahl
epunkte += ep * zahl
# Damit sind wir mit einer Tastatur fertig
woerter.close()
punkte = lpunkte + fpunkte + gpunkte + upunkte + apunkte + epunkte
# Öffne eine Datei zur Ausgabe
print T[0], T[1], T[2], T[3], T[4], ' ', T[5], T[6], T[7], T[8], T[9], T[10]
print T[11], T[12], T[13], T[14], T[15], ' ', T[16], T[17], T[18], T[19], T[20], T[21]
print T[22], T[23], T[24], T[25], T[26], ' ', T[27], T[28], T[29], T[30], T[31]
print 'Punkte gesamt.......' + str(punkte).rjust(15,'.')
print 'Buchstabenlage......' + str(lpunkte).rjust(15,'.')
print 'Fingerwiederholungen' + str(fpunkte).rjust(15,'.')
print 'Reihensprünge.......' + str(gpunkte).rjust(15,'.')
print 'Wiederholung unten..' + str(upunkte).rjust(15,'.')
print 'Auseinander.........' + str(apunkte).rjust(15,'.')
print 'Handeinsatzlänge....' + str(epunkte).rjust(15,'.')
aus.write(str(punkte).rjust(15) + ' ' + T)
