Wie das Lesen von Werten aus zahlen, die als geschrieben Worte?

Ich war Herumspielen mit einer PEG-parser zu tun, was Sie wollten (und posten kann, die als separate Antwort später), als ich bemerkte, dass es einen sehr einfachen Algorithmus, der einen erstaunlich guten job mit gemeinsamen Formen der zahlen in Englisch, Spanisch und Deutsch, zumindest.

Arbeiten mit Englisch zum Beispiel, benötigen Sie ein Wörterbuch, die Karten suchten, um Werte in der offensichtlichen Weise:

"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, dieser Verlauf 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, dass es perfekt ist, aber für eine quick-and-dirty es macht sich ganz gut.

Bewältigung Ihrer spezifischen Liste auf Bearbeiten:

1. Kardinal/nominal-oder ordinal -: "eins" und "das erste" -- legte Sie in das Wörterbuch
2. Englisch/britisch: "die vierzig"/"vierzig" -- dito
3. Hunderte/Tausende:
   2100 -> "zwanzig von hundert" und auch "zwei tausend und hundert" -- funktioniert wie
4. Trennzeichen: "eleven hundred fifty two", aber auch "elevenhundred fiftytwo" oder "elf-hundert-fünfzig-zwei" und so weiter - einfach definieren, "next word", um das längste Präfix, das entspricht einem angegebenen Wort oder bis zu dem nächsten nicht-Wort, wenn keiner tun, für einen start
5. colloqialisms: "thirty-something" -- funktioniert
6. Fragmente: 'ein Drittel', 'zwei Fünftel' -- äh, noch nicht...
7. gemeinsamen Namen: 'ein Dutzend', 'halbe' -- arbeiten; Sie können auch Dinge tun, wie "ein halbes Dutzend"

Nummer 6 ist die einzige, die ich habe nicht eine Antwort bereit, und das ist aufgrund der Mehrdeutigkeit zwischen ordinal-und Bruchzahlen (in Englisch zumindest) Hinzugefügt, um die Tatsache, dass meine Letzte Tasse Kaffee war viele Stunden.

Habe ich einige code, den ich schrieb vor einer Weile: text2num. Dies hat einige, was Sie wollen, es sei denn es behandelt nicht die Ordnungszahlen. Ich habe nicht wirklich verwendet diesen code, für nichts, so ist es weitgehend ungetestet!

Sollten Sie im Hinterkopf behalten, dass Europa und Amerika zählen anders.

Europäischen standard:

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.

Einen einfachen Weg, um zu sehen, der Unterschied ist der folgende:

(American counting Trillion) == (European counting Billion)

Hier ist eine extrem robuste Lösung in Clojure.

AFAIK ist es eine einzigartige Umsetzung.

;----------------------------------------------------------------------
; numbers.clj
; written by: Mike Mattie [email protected]
;----------------------------------------------------------------------
(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"])

Gut, ich war zu spät auf die Antwort für diese Frage, aber ich war arbeiten ein kleines test-Szenario, das scheint geklappt zu haben bei mir sehr gut. Ich verwendet einen einfachen, aber hässlich und groß) reguläre Ausdrücke, suchen Sie alle die Worte für mich. 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 Formatierung..

Sowieso, meine Methode war zum ausführen dieser RegEx mit einer Bibliothek wie PCRE, und Lesen Sie dann wieder die mit Namen entspricht. Und es funktionierte auf allen von den verschiedenen aufgeführten Beispiele in dieser Frage, minus die "Eine Hälfte", die Typen, die wie ich nicht hinzufügen, aber wie Sie sehen können, es wäre nicht schwer, dies zu tun. Dies behebt eine Reihe von Problemen. Zum Beispiel, es behebt die folgenden Elemente in der ursprünglichen Frage und den anderen Antworten:

1. Kardinal/nominal-oder ordinal -: "eins" und "der erste"
2. gemeinsame Rechtschreibfehler: "vierzig"/"vierzig" (Beachten Sie, dass es nicht EXPLIZIT anzusprechen, das wäre was Sie wollen würde, um zu tun, bevor Sie übergeben Sie die Zeichenfolge an dieser parser. Dieser parser sieht dieses Beispiel als "VIER"...)
3. Hunderte/Tausende: 2100 -> "zwanzig von hundert" und auch "zwei tausend und hundert"
4. Trennzeichen: "eleven hundred fifty two", aber auch "elevenhundred fiftytwo" oder "elf-hundert-fünfzig-zwei" und so weiter
5. colloqialisms: "thirty-something" (auch Dies ist nicht VOLLSTÄNDIG beseitigt, als das, was IST "etwas"? Gut, dieser code findet diese Nummer einfach als "30").**

Nun, anstatt zu speichern, dieses monster von einem regulären Ausdruck, in Ihrer Quelle, ich erwäge den Bau dieser RegEx zur Laufzeit, mit so etwas wie die 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...

Ist der einfache Teil hier ist, wir sind nur die Speicherung der Wörter, die wichtig sind. Im Falle der SECHSTEN, werden Sie feststellen, dass es nicht einen Eintrag machen, weil es einfach die normale Nummer mit TH geheftet... Aber wie ZWÖLF unterschiedliche Aufmerksamkeit.

Ok, so jetzt haben wir den code zu bauen (hässlich) RegEx, jetzt wir führen es auf unsere Anzahl Saiten.

Eine Sache, die ich empfehlen würde, ist es zu filtern, oder zu Essen, das Wort "UND". Es ist nicht notwendig und führt nur zu anderen Problemen.

Also, was sind Sie gehen zu wollen, zu tun ist setup eine Funktion, übergibt die benannte Treffer für "Magnitude" in eine Funktion, der schaut auf alle möglichen Größenordnung der Werte und multipliziert Ihre aktuelle Ergebnis durch den Wert der Größe. Dann erstellen Sie eine Funktion, die schaut auf den "Wert" namens entspricht, und gibt ein int (oder was auch immer Sie verwenden), basierend auf dem Wert, der dort entdeckt.

WERT alle Spiele sind HINZUGEFÜGT, um Ihr Ergebnis, während magnitutde entspricht, multiplizieren Sie das Ergebnis mit dem mag-Wert. So, Zwei Hundert Fünfzig Tausend wird zu "2", dann "2 * 100", dann "200 + 50", dann "250 * 1000", der am Ende mit 250000...

Nur zum Spaß, schrieb ich eine vbScript-version und es funktionierte großartig mit allen Beispielen zur Verfügung gestellt. Nun, es unterstützt keine benannten Spiele, so hatte ich ein wenig härter zu arbeiten immer das korrekte Ergebnis, aber ich bekam es. Quintessenz ist, wenn es ein "WERT" passen, fügen Sie es Ihrem Akku. Wenn es zu einer Größenordnung entsprechen, multiplizieren Sie Ihre Akku von 100, 1000, 1000000, 1000000000, etc... Dies wird Ihnen einige ziemlich erstaunliche Ergebnisse, und alles, was Sie tun müssen, um die Anpassung an Dinge wie "die Hälfte" ist, fügen Sie Sie zu Ihrem RegEx, setzen Sie in eine code-Markierung, die für Sie-und mit Ihnen umgehen.

Gut, ich hoffe, dieser Beitrag hilft JEMAND da draußen. Wenn jemand will, kann ich dem Beitrag von vbScript-pseudo-code, die ich verwendet, um dies zu testen, aber es ist nicht schön-code, und NICHT für die Produktion von code.

Wenn ich kann.. Was ist die Letzte Sprache werden diese geschrieben? C++, oder so etwas wie eine Programmiersprache? Greg Hewgill Quelle wird ein langer Weg zu helfen, zu verstehen, wie all dies kommt zusammen.

Lassen Sie mich wissen, wenn ich kann anderen helfen. Sorry, ich kenne nur die englischen/amerikanischen, so kann ich dir nicht helfen, mit den anderen Sprachen.

Versuchen

1. Öffnen Sie eine HTTP-Anfrage an "http://www.google.com/search?q=" + Anzahl + "+in+decimal".

2. Analysieren das Ergebnis für Ihre Nummer.

3. Cache die Zahl /Ergebnis-Paare Lektion die Anforderungen im Laufe der Zeit.