Wie Werte von den Zahlen zu lesen, wie Wörter geschrieben?
https://stackoverflow.com/questions/70161
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie wir alle wissen Zahlen geschrieben werden können, entweder in Numerik, oder durch ihre Namen genannt. Zwar gibt es zu vielen Beispiele gefunden werden, die 123 in 123 umwandeln, kann ich nicht gute Beispiele finden, wie es umgekehrt zu konvertieren.
Einige der Einschränkungen:
- Kardinal / nominal oder ordinal: "Eins" und "erster"
- gemeinsamer Rechtschreibfehler: "vierzig" / "vierzig"
- Hunderte / Tausende: 2100 -> "twenty hundert" und auch "Zweitausend und hundert"
- Separatoren: "elfhundert zweiundfünfzig", aber auch "elevenhundred fiftytwo" oder "elevenhundred fiftytwo" und so weiter
- colloquialisms: "Thirty-something"
- Fraktionen: 'ein Drittel', 'zwei Fünftel'
- gemeinsame Namen: 'ein Dutzend', 'Hälfte'
Und es gibt wahrscheinlich mehr Einschränkungen möglich, die noch nicht aufgeführt ist. Angenommen, der Algorithmus sehr robust sein muss, und auch Rechtschreibfehler verstehen.
Was Felder / paper / studies / Algorithmen soll ich lesen lernen, wie das alles zu schreiben? Wo ist die Information?
PS: Mein letzter Parser sollte verstehen, tatsächlich 3 verschiedene Sprachen, Englisch, Russisch und Hebräisch. Und vielleicht zu einem späteren Zeitpunkt werden weitere Sprachen hinzugefügt werden. Hebrew hat auch männliche / weibliche Zahlen, wie „ein Mann“ und „eine Frau“ haben eine andere „ein“ - „ehad“ und „ahat“. Russisch auch einige seiner eigenen Komplexität hat.
Google hat eine große Aufgabe an diesem. Zum Beispiel:
(das Gegenteil ist auch möglich, http://www.google.com / search? q = 999999999999 + in + Englisch )
Lösung
Ich spielte herum mit einem PEG-Parser zu tun, was man wollte (und schreiben kann, dass als separate Antwort später), als ich bemerkte, dass es einen sehr einfachen Algorithmus ist, das eine bemerkenswert gute Arbeit mit gemeinsamen Formen der Zahlen in Englisch der Fall ist, Spanisch und Deutsch, am allerwenigsten.
Arbeiten mit Englisch zum Beispiel, benötigen Sie ein Wörterbuch, das Wort auf Werte in der offensichtlichen Weise abbildet:
"one" -> 1, "two" -> 2, ... "twenty" -> 20,
"dozen" -> 12, "score" -> 20, ...
"hundred" -> 100, "thousand" -> 1000, "million" -> 1000000
... und so weiter
Der Algorithmus ist einfach:
total = 0
prior = null
for each word w
v <- value(w) or next if no value defined
prior <- case
when prior is null: v
when prior > v: prior+v
else prior*v
else
if w in {thousand,million,billion,trillion...}
total <- total + prior
prior <- null
total = total + prior unless prior is null
Zum Beispiel diese schreitet wie folgt:
total prior v unconsumed string
0 _ four score and seven
4 score and seven
0 4
20 and seven
0 80
_ seven
0 80
7
0 87
87
total prior v unconsumed string
0 _ two million four hundred twelve thousand eight hundred seven
2 million four hundred twelve thousand eight hundred seven
0 2
1000000 four hundred twelve thousand eight hundred seven
2000000 _
4 hundred twelve thousand eight hundred seven
2000000 4
100 twelve thousand eight hundred seven
2000000 400
12 thousand eight hundred seven
2000000 412
1000 eight hundred seven
2000000 412000
1000 eight hundred seven
2412000 _
8 hundred seven
2412000 8
100 seven
2412000 800
7
2412000 807
2412807
Und so weiter. Ich sage nicht, es ist perfekt, aber für eine schnelle und schmutzige es funktioniert ganz gut.
Adressierung Ihre spezifische Liste bearbeiten:
- Kardinal / nominal oder ordinal: "Eins" und "first" - setzen sie nur im Wörterbuch
- Englisch / british: "vierzig" / "vierzig" - dito
- hunderte / tausende: 2100 -> "twenty hundert" und auch "Zweitausend und hundert" - arbeitet wie
- Separatoren: „elfhundert zweiundfünfzig“, aber auch „elevenhundred fiftytwo“ oder „elevenhundred fiftytwo“ und so weiter - definiert nur „nächstes Wort“ der längste Präfix zu sein, die ein definiertes Wort übereinstimmt oder auf das nächste nicht-Wort, wenn keine tun, für einen Start
- colloqialisms: "Thirty-something" - funktioniert
- Fragmente: 'ein Drittel', 'zwei Fünftel' - uh, noch nicht ...
- gemeinsame Namen: 'ein Dutzend', 'Hälfte' - funktioniert; Sie können auch Dinge wie „ein halbes Dutzend“
Nummer 6 ist die einzige, die ich, nicht eine Antwort bereit für und das ist wegen der Mehrdeutigkeit zwischen ordinals und Fraktionen (in englischer Sprache mindestens) der Tatsache, fügte hinzu, dass meine letzte Tasse Kaffee war viele Stunden.
Andere Tipps
Es ist kein einfaches Thema, und ich kenne keine Bibliothek, es zu tun. Ich könnte sich hinsetzen und versuchen, so etwas wie dies irgendwann zu schreiben. Ich würde es tun entweder in Prolog, Java oder Haskell, though. Soweit ich sehen kann, gibt es mehrere Probleme:
- Tokenisierung: Manchmal sind Zahlen elfhundert zweiundfünfzig geschrieben, aber ich habe fiftytwo oder elevenhundred-fiftytwo und so weiter gesehen elevenhundred. Man müßte eine Umfrage durchführen zu welchen Formen sind tatsächlich in Gebrauch ist. Dies könnte für Hebräisch besonders schwierig sein.
- Rechtschreibfehler: das ist nicht so schwer. Sie haben eine begrenzte Menge von Wörtern, und ein wenig Levenshtein-Distanz Magie sollte es tun.
- Alternative Formen, wie Sie bereits erwähnt, existieren. Dazu gehören Ordnungs / Kardinalzahlen, sowie vierzig / fourty und ...
- ... gebräuchliche Namen oder häufig verwendete Phrasen und NEs (benannten Entitäten). Möchten Sie 30 aus dem Dreißigjährigen Krieg oder 2 aus dem Zweiten Weltkrieg extrahieren?
- römische Ziffern auch?
- Colloqialisms, wie „dreißig-etwas“ und „drei Euro und Schrapnell“, die ich würde nicht wissen, wie sie zu behandeln.
Wenn Sie daran interessiert sind, könnte ich es versuchen an diesem Wochenende. Meine Idee ist wahrscheinlich mit UIMA und Zeichenüber mit ihm, dann weiter tokenize los / disambiguate und schließlich übersetzen. Es könnte mehr Probleme sein, mal sehen, ob ich mit einem paar weiteren interessanten Dingen kommen kann.
Sorry, dies ist keine wirkliche Antwort doch nur eine Erweiterung auf Ihre Frage. Ich lasse Sie wissen, wenn ich find / schreiben etwas.
By the way, wenn Sie in der Semantik von Zahlen interessiert sind, ich habe gerade ein interessantes Papier von Friederike Moltmann, einige Probleme in Bezug auf die logische Interpretation von Zahlen zu diskutieren.
Ich habe einige Code, den ich vor einiger Zeit schrieb: text2num . Dies hat einige von dem, was Sie wollen, außer es keine Ordnungszahlen verarbeiten. Ich habe tatsächlich diesen Code nicht für alles verwendet, so ist es weitgehend ungetestet!
Mit dem Python Muster-en Bibliothek:
>>> from pattern.en import number
>>> number('two thousand fifty and a half') => 2050.5
Sie sollten bedenken, dass Europa und Amerika anders zählen.
Europäische Norm:
One Thousand
One Million
One Thousand Millions (British also use Milliard)
One Billion
One Thousand Billions
One Trillion
One Thousand Trillions
Hier ist ein kleiner Hinweis darauf.
Eine einfache Möglichkeit, den Unterschied ist die folgende zu sehen:
(American counting Trillion) == (European counting Billion)
Ordnungszahlen sind nicht anwendbar, da sie kippen auf sinnvolle Weise mit anderen Zahlen in der Sprache (... zumindest in englischer Sprache)
verbunden werdenz. 101., 11 Sekunden, etc ...
Es gibt jedoch ein anderes Englisch / American Vorbehalt mit dem Wort ‚und‘
d.
einhundertein (Englisch) 101 (American)
Auch die Verwendung von ‚a‘ eine in Englisch bedeutet
tausend = eintausend
... Auf einer Seite beachten Sie die Google-Rechner hat eine erstaunliche Arbeit dafür.
103.000 mal die Lichtgeschwindigkeit
Und auch ...
zweitausendein hundert plus ein Dutzend
... wtf?!? eine Punktzahl plus ein Dutzend in römischen Ziffern
Hier ist eine äußerst robuste Lösung in Clojure.
AFAIK es ist ein einzigartiger Implementierungsansatz.
;----------------------------------------------------------------------
; numbers.clj
; written by: Mike Mattie codermattie@gmail.com
;----------------------------------------------------------------------
(ns operator.numbers
(:use compojure.core)
(:require
[clojure.string :as string] ))
(def number-word-table {
"zero" 0
"one" 1
"two" 2
"three" 3
"four" 4
"five" 5
"six" 6
"seven" 7
"eight" 8
"nine" 9
"ten" 10
"eleven" 11
"twelve" 12
"thirteen" 13
"fourteen" 14
"fifteen" 15
"sixteen" 16
"seventeen" 17
"eighteen" 18
"nineteen" 19
"twenty" 20
"thirty" 30
"fourty" 40
"fifty" 50
"sixty" 60
"seventy" 70
"eighty" 80
"ninety" 90
})
(def multiplier-word-table {
"hundred" 100
"thousand" 1000
})
(defn sum-words-to-number [ words ]
(apply + (map (fn [ word ] (number-word-table word)) words)) )
; are you down with the sickness ?
(defn words-to-number [ words ]
(let
[ n (count words)
multipliers (filter (fn [x] (not (false? x))) (map-indexed
(fn [ i word ]
(if (contains? multiplier-word-table word)
(vector i (multiplier-word-table word))
false))
words) )
x (ref 0) ]
(loop [ indices (reverse (conj (reverse multipliers) (vector n 1)))
left 0
combine + ]
(let
[ right (first indices) ]
(dosync (alter x combine (* (if (> (- (first right) left) 0)
(sum-words-to-number (subvec words left (first right)))
1)
(second right)) ))
(when (> (count (rest indices)) 0)
(recur (rest indices) (inc (first right))
(if (= (inc (first right)) (first (second indices)))
*
+))) ) )
@x ))
Hier sind einige Beispiele
(operator.numbers/words-to-number ["six" "thousand" "five" "hundred" "twenty" "two"])
(operator.numbers/words-to-number ["fifty" "seven" "hundred"])
(operator.numbers/words-to-number ["hundred"])
Meine LPC Implementierung von einigen Ihrer Anforderungen (American English only):
internal mapping inordinal = ([]);
internal mapping number = ([]);
#define Numbers ([\
"zero" : 0, \
"one" : 1, \
"two" : 2, \
"three" : 3, \
"four" : 4, \
"five" : 5, \
"six" : 6, \
"seven" : 7, \
"eight" : 8, \
"nine" : 9, \
"ten" : 10, \
"eleven" : 11, \
"twelve" : 12, \
"thirteen" : 13, \
"fourteen" : 14, \
"fifteen" : 15, \
"sixteen" : 16, \
"seventeen" : 17, \
"eighteen" : 18, \
"nineteen" : 19, \
"twenty" : 20, \
"thirty" : 30, \
"forty" : 40, \
"fifty" : 50, \
"sixty" : 60, \
"seventy" : 70, \
"eighty" : 80, \
"ninety" : 90, \
"hundred" : 100, \
"thousand" : 1000, \
"million" : 1000000, \
"billion" : 1000000000, \
])
#define Ordinals ([\
"zeroth" : 0, \
"first" : 1, \
"second" : 2, \
"third" : 3, \
"fourth" : 4, \
"fifth" : 5, \
"sixth" : 6, \
"seventh" : 7, \
"eighth" : 8, \
"ninth" : 9, \
"tenth" : 10, \
"eleventh" : 11, \
"twelfth" : 12, \
"thirteenth" : 13, \
"fourteenth" : 14, \
"fifteenth" : 15, \
"sixteenth" : 16, \
"seventeenth" : 17, \
"eighteenth" : 18, \
"nineteenth" : 19, \
"twentieth" : 20, \
"thirtieth" : 30, \
"fortieth" : 40, \
"fiftieth" : 50, \
"sixtieth" : 60, \
"seventieth" : 70, \
"eightieth" : 80, \
"ninetieth" : 90, \
"hundredth" : 100, \
"thousandth" : 1000, \
"millionth" : 1000000, \
"billionth" : 1000000000, \
])
varargs int denumerical(string num, status ordinal) {
if(ordinal) {
if(member(inordinal, num))
return inordinal[num];
} else {
if(member(number, num))
return number[num];
}
int sign = 1;
int total = 0;
int sub = 0;
int value;
string array parts = regexplode(num, " |-");
if(sizeof(parts) >= 2 && parts[0] == "" && parts[1] == "-")
sign = -1;
for(int ix = 0, int iix = sizeof(parts); ix < iix; ix++) {
string part = parts[ix];
switch(part) {
case "negative" :
case "minus" :
sign = -1;
continue;
case "" :
continue;
}
if(ordinal && ix == iix - 1) {
if(part[0] >= '0' && part[0] <= '9' && ends_with(part, "th"))
value = to_int(part[..<3]);
else if(member(Ordinals, part))
value = Ordinals[part];
else
continue;
} else {
if(part[0] >= '0' && part[0] <= '9')
value = to_int(part);
else if(member(Numbers, part))
value = Numbers[part];
else
continue;
}
if(value < 0) {
sign = -1;
value = - value;
}
if(value < 10) {
if(sub >= 1000) {
total += sub;
sub = value;
} else {
sub += value;
}
} else if(value < 100) {
if(sub < 10) {
sub = 100 * sub + value;
} else if(sub >= 1000) {
total += sub;
sub = value;
} else {
sub *= value;
}
} else if(value < sub) {
total += sub;
sub = value;
} else if(sub == 0) {
sub = value;
} else {
sub *= value;
}
}
total += sub;
return sign * total;
}
Nun, ich war zu spät auf der Antwort auf diese Frage, aber ich arbeite ein wenig Testszenario, das sehr gut für mich gearbeitet zu haben scheint. Früher habe ich einen (einfachen, aber hässlich, und groß) regulären Ausdruck all Worte für mich zu finden. Der Ausdruck ist wie folgt:
(?<Value>(?:zero)|(?:one|first)|(?:two|second)|(?:three|third)|(?:four|fourth)|
(?:five|fifth)|(?:six|sixth)|(?:seven|seventh)|(?:eight|eighth)|(?:nine|ninth)|
(?:ten|tenth)|(?:eleven|eleventh)|(?:twelve|twelfth)|(?:thirteen|thirteenth)|
(?:fourteen|fourteenth)|(?:fifteen|fifteenth)|(?:sixteen|sixteenth)|
(?:seventeen|seventeenth)|(?:eighteen|eighteenth)|(?:nineteen|nineteenth)|
(?:twenty|twentieth)|(?:thirty|thirtieth)|(?:forty|fortieth)|(?:fifty|fiftieth)|
(?:sixty|sixtieth)|(?:seventy|seventieth)|(?:eighty|eightieth)|(?:ninety|ninetieth)|
(?<Magnitude>(?:hundred|hundredth)|(?:thousand|thousandth)|(?:million|millionth)|
(?:billion|billionth)))
Hier mit Zeilenumbrüche für die Zwecke der Formatierung ..
Wie auch immer, war meine Methode, um dieses RegEx mit einer Bibliothek wie PCRE auszuführen und dann die genannten Begegnungen zurückgelesen. Und es funktionierte auf all die verschiedenen Beispiele in dieser Frage aufgeführt, abzüglich der „One Half“, Typen, wie ich sie nicht hinzufügen, in, aber wie Sie sehen können, wäre es nicht schwer sein, dies zu tun. Diese befasst sich eine Menge Probleme. Zum Beispiel richtet sie an die folgenden Elemente in der ursprünglichen Frage und anderen Antworten:
- Kardinal / nominal oder ordinal: "Eins" und "erster"
- gemeinsame Rechtschreibfehler. „Vierzig“ / „vierzig“ (Beachten Sie, dass es nicht ausdrücklich auf diese adressiert, dass etwas sein würde, was Sie tun wollen würde, bevor Sie die Zeichenfolge an diesem Parser übergeben Dieser Parser sieht dieses Beispiel als " VIER“...)
- Hunderte / Tausende: 2100 -> "twenty hundert" und auch "Zweitausend und hundert"
- Separatoren: "elfhundert zweiundfünfzig", aber auch "elevenhundred fiftytwo" oder "elevenhundred fiftytwo" und so weiter
- colloqialisms: "Thirty-something" (Dies auch TOTALLY wird nicht angesprochen, wie das, was "etwas" Nun, dieser Code diese Zahl einfach als "30" findet?) ** .
Nun, anstatt zu speichern, dieses Monster von einem regulären Ausdruck in Ihrer Quelle, ich war der Bau dieses RegEx zur Laufzeit unter Berücksichtigung, so etwas wie die Verwendung von folgenden:
char *ones[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve",
"thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
char *tens[] = {"", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"};
char *ordinalones[] = { "", "first", "second", "third", "fourth", "fifth", "", "", "", "", "", "", "twelfth" };
char *ordinaltens[] = { "", "", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetieth" };
and so on...
Der einfache Teil ist hier wir speichern nur die Worte, die Materie. Im Fall von SECHSTEN, werden Sie feststellen, dass es für sie keinen Eintrag vorhanden ist, weil es nur mit TH normaler Zahl ist geheftet ... Aber diejenigen wie TWELVE benötigen unterschiedliche Aufmerksamkeit.
Ok, jetzt haben wir den Code unseren (hässlich) RegEx zu bauen, jetzt führen wir es nur auf unseren Zahlenketten.
Eine Sache, die ich empfehlen würde, ist zu filtern, oder das Wort essen „AND“. Es ist nicht notwendig, und führt nur zu anderen Themen.
Also, was Sie tun werden wollen, ist Setup eine Funktion, die die benannten Treffer für „Magnitude“ in eine Funktion übergibt, der bei allen möglichen Größenwerten sieht und multipliziert Ihr aktuelles Ergebnis von diesem Wert Größenordnung. Dann erstellen Sie eine Funktion, die auf der „Value“ genannt Matches sieht, und gibt einen int (oder was auch immer Sie verwenden), basierend auf dem Wert dort entdeckt.
Alle VALUE Spiele werden hinzugefügt, um Ihr Ergebnis, während magnitutde Matches das Ergebnis durch die mag Wert multiplizieren. Also, zweihundertfünfzigtausend "2", dann "2 * 100", dann "200 + 50", dann "250 * 1000", endete mit 250000 ...
Just for fun, schrieb ich eine vbScript Version dieses und es funktionierte großartig mit allen Beispielen zur Verfügung gestellt. Nun unterstützt er nicht genannt Matches, so dass ich ein wenig härter zu arbeiten, hatte das richtige Ergebnis bekommen, aber ich habe es. Unterm Strich ist, wenn es sich um ein „VALUE“ Spiel ist, ist es Ihre Speicher hinzuzufügen. Wenn es sich um eine Größenordnung Spiel ist, multiplizieren Sie Ihren Akku mit 100, 1000, 1000000, 1000000000, etc ... Dies wird Ihnen mit ein paar ziemlich erstaunliche Ergebnisse liefern, und alles, was Sie zu tun haben, für Dinge zu justieren, wie „eine Hälfte“ ist sie hinzufügen auf Ihre RegEx, legte sie in einer Code-Markierung, und mit ihnen umgehen.
Nun, ich hoffe, dieser Beitrag hilft jemand da draußen. Wenn jemand will, kann ich von vbScript Pseudo-Code schreiben, dass ich mit diesen zu testen, aber es ist nicht schön Code, und NICHT Produktionscode.
Wenn ich darf .. Was ist die letzte Sprache wird dies in geschrieben werden? C ++ oder so etwas wie eine Skript Sprache? Greg Hewgill der Quelle wird ein langer Weg helfen zu verstehen, wie all dies kommt zusammen.
Lassen Sie mich wissen, wenn ich irgendein andere helfen kann. Sorry, ich weiß nur Englisch / Amerikanistik, so kann ich Ihnen nicht mit den anderen Sprachen helfen.
Ich war Umwandlung Ordnungs Ausgabe Aussagen aus dem frühen Neuzeit Büchern (zum Beispiel „2nd edition“, „Editio quarta“) auf ganze Zahlen und benötigte Unterstützung für ordinals 1-100 in Englisch und ordinals 1-10 in einigen romanischen Sprachen. Hier ist, was ich kam mit in Python:
def get_data_mapping():
data_mapping = {
"1st": 1,
"2nd": 2,
"3rd": 3,
"tenth": 10,
"eleventh": 11,
"twelfth": 12,
"thirteenth": 13,
"fourteenth": 14,
"fifteenth": 15,
"sixteenth": 16,
"seventeenth": 17,
"eighteenth": 18,
"nineteenth": 19,
"twentieth": 20,
"new": 2,
"newly": 2,
"nova": 2,
"nouvelle": 2,
"altera": 2,
"andere": 2,
# latin
"primus": 1,
"secunda": 2,
"tertia": 3,
"quarta": 4,
"quinta": 5,
"sexta": 6,
"septima": 7,
"octava": 8,
"nona": 9,
"decima": 10,
# italian
"primo": 1,
"secondo": 2,
"terzo": 3,
"quarto": 4,
"quinto": 5,
"sesto": 6,
"settimo": 7,
"ottavo": 8,
"nono": 9,
"decimo": 10,
# french
"premier": 1,
"deuxième": 2,
"troisième": 3,
"quatrième": 4,
"cinquième": 5,
"sixième": 6,
"septième": 7,
"huitième": 8,
"neuvième": 9,
"dixième": 10,
# spanish
"primero": 1,
"segundo": 2,
"tercero": 3,
"cuarto": 4,
"quinto": 5,
"sexto": 6,
"septimo": 7,
"octavo": 8,
"noveno": 9,
"decimo": 10
}
# create 4th, 5th, ... 20th
for i in xrange(16):
data_mapping[str(4+i) + "th"] = 4+i
# create 21st, 22nd, ... 99th
for i in xrange(79):
last_char = str(i)[-1]
if last_char == "0":
data_mapping[str(20+i) + "th"] = 20+i
elif last_char == "1":
data_mapping[str(20+i) + "st"] = 20+i
elif last_char == "2":
data_mapping[str(20+i) + "nd"] = 20+i
elif last_char == "3":
data_mapping[str(20+i) + "rd"] = 20+i
else:
data_mapping[str(20+i) + "th"] = 20+i
ordinals = [
"first", "second", "third",
"fourth", "fifth", "sixth",
"seventh", "eighth", "ninth"
]
# create first, second ... ninth
for c, i in enumerate(ordinals):
data_mapping[i] = c+1
# create twenty-first, twenty-second ... ninty-ninth
for ci, i in enumerate([
"twenty", "thirty", "forty",
"fifty", "sixty", "seventy",
"eighty", "ninety"
]):
for cj, j in enumerate(ordinals):
data_mapping[i + "-" + j] = 20 + (ci*10) + (cj+1)
data_mapping[i.replace("y", "ieth")] = 20 + (ci*10)
return data_mapping
Versuchen
-
Öffnen Sie eine HTTP-Anfrage an „ http://www.google.com/search ? q = “+ Nummer + "+ in + dezimal".
-
Parse das Ergebnis für Ihre Nummer ein.
-
Cache die Anzahl / Ergebnispaare Lektion die Anforderungen im Laufe der Zeit.
Ein Ort, zu Beginn der Suche ist das Gnu get_date lib , die fast jede englischen Textdaten in einem Zeitstempel analysieren kann. Obwohl es nicht genau das, was Sie suchen, ihre Lösung für ein ähnliches Problem viele nützliche Hinweise liefern könnten.
