Question

众所周知，数字可以用数字编写，也可以用名字命名。虽然有很多例子可以将123转换成123，但我找不到如何以相反的方式转换它的好例子。

一些警告：

红衣主教/名义或序数：“一”和“第一”
常见的拼写错误：“四十”/“十四”
数百/数千：2100 - ＆gt; “二十一”，还有“二千一百”
分隔符：“十一二百五十二”，还有“十一五十二”或“十一点五十二”和诸如此类
口语：“三十多岁”
分数：'三分之一'，'五分之二'
俗名：'打打'，'半'

可能还有更多可能尚未列出的警告。假设算法需要非常健壮，甚至可以理解拼写错误。

我应该阅读哪些领域/论文/研究/算法来学习如何写这些？信息在哪里？

PS：我的最终解析器应该真正理解3种不同的语言，英语，俄语和希伯来语。也许在稍后阶段会添加更多语言。希伯来语也有男/女数字，如“一个男人”和“一个女人”有不同的“一个” - “ehad”和“ahat”。俄罗斯也有一些自己的复杂性。

http://www.google.com/search?q=two+thousand+and+one+hundred+plus+five+dozen+and+four+fifths+in+decimal

（反过来也可以http://www.google.com/search?q=999999999999+in+english）

Answer 1

当我注意到有一个非常简单的算法可以很好地处理英语中常见的数字形式时，我正在玩一个PEG解析器来做你想做的事情（可能会在以后单独发布）。西班牙语和德语，至少。

例如，使用英语，您需要一个以明显的方式将单词映射到值的字典：

"one" -> 1, "two" -> 2, ... "twenty" -> 20,
"dozen" -> 12, "score" -> 20, ...
"hundred" -> 100, "thousand" -> 1000, "million" -> 1000000

......等等

算法只是：

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

例如，这进展如下：

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

等等。我并不是说它很完美，但是对于快速而肮脏的它来说它确实很好。

在编辑时解决您的特定列表：

基数/名义或序数：“一”和“第一” - 只是将它们放入词典
english / british：“fourty”/“foury” - ditto
数百/千： 2100 - ＆gt; “二十一”和“二千一百” - 按原样运作
分隔符：“十一二百五十二”，还有“十一五十二”或“十一点五十二”和诸如此类 - 只是将“下一个单词”定义为匹配定义单词的最长前缀，或者如果没有，则为下一个非单词，以便开始
colloqialisms：“三十多岁” - 工作
片段：'三分之一'，'五分之二' - 呃，还没......
俗名：'一打'，'半' - 作品;你甚至可以做“半打”

6号是唯一一个我没有准备好答案的人，这是因为序数和分数之间的模糊性（至少在英语中）加上我最后一杯咖啡许多的事实小时前。

Answer 2

我之前写过一些代码：text2num。这可以做你想要的一些，除了它不处理序数。我实际上并没有将这个代码用于任何事情，所以它基本上没有经过测试！

Answer 3

这不是一个容易的问题，我知道没有图书馆可以做到这一点。我可能会坐下来尝试写一些这样的东西。不过，我会在Prolog，Java或Haskell中做到这一点。据我所知，有几个问题：

标记：有时，数字写成1125，但我已经看过十一五十二或十一二百五十二等等。人们必须对实际使用的形式进行调查。这对希伯来语来说可能特别棘手。
拼写错误：这不是那么难。你的单词数量有限，而Levenshtein-distance魔法应该可以解决这个问题。
存在与您已经提到的替代形式。这包括序数/基数，以及四十四十和......
...常用名称或常用短语和NE（命名实体）。你想从三十年战争中抽取30或从第二次世界大战中抽取2吗？
罗马数字呢？
口语，例如“三十多岁”和“三欧元和弹片”，我不知道该如何对待。

如果你对此感兴趣，我可以在本周末试一试。我的想法可能是使用UIMA并使用它进行标记，然后继续进行标记化/消除歧义并最终翻译。可能会有更多问题，让我们看看我是否能提出一些更有趣的事情。

抱歉，这还不是一个真正的答案，只是您问题的扩展。如果我发现/写东西，我会通知你。

顺便说一句，如果你对数字的语义感兴趣，我刚刚找到了Friederike Moltmann的interesting paper，讨论了关于数字逻辑解释的一些问题。

Answer 4

使用Python pattern-en库：

>>> from pattern.en import number
>>> number('two thousand fifty and a half') => 2050.5

Answer 5

你应该记住，欧洲和美国的情况不同。

欧洲标准：

One Thousand
One Million
One Thousand Millions (British also use Milliard)
One Billion
One Thousand Billions
One Trillion
One Thousand Trillions

Here是一个小参考。

查看差异的简单方法如下：

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

Answer 6

序数不适用，因为它们无法以有意义的方式与语言中的其他数字相结合（...至少用英语）

e.g。一百一十一秒，等等......

然而，还有另一个英文/美国警告，其中包含'和'

这个词

即

一百零一（英文）一百（美国）

另外，使用'a'表示英语中的一个

一千=一千

...在旁注中，谷歌的计算器做得非常出色。

one hundred and three thousand times the speed of light

甚至......

two thousand and one hundred plus a dozen

...跆拳道？！？ a score plus a dozen in roman numerals

Answer 7

这是Clojure中非常强大的解决方案。

AFAIK这是一种独特的实施方法。

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

以下是一些例子

(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"])

Answer 8

我的LPC实施您的一些要求（仅限美国英语）：

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

Answer 9

嗯，我对这个问题的回答太迟了，但我正在做一个似乎对我来说效果很好的小测试场景。我使用（简单但丑陋，大）正则表达式为我找到所有单词。表达式如下：

(?<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)))

此处显示的换行符用于格式化目的..

无论如何，我的方法是使用像PCRE这样的库来执行这个RegEx，然后回读命名匹配。它适用于这个问题中列出的所有不同的例子，减去“一半”类型，因为我没有添加它们，但正如你所看到的，这并不难。这解决了很多问题。例如，它解决了原始问题和其他答案中的以下项目：

红衣主教/名义或序数：“一”和“第一”
常见的拼写错误：“四十”/“十四”（请注意，它没有明确地解决这个问题，这是您在将字符串传递给此解析器之前要做的事情。此解析器将此示例视为“四” ...）
数百/数千：2100 - ＆gt; “二十一”，还有“二千一百”
分隔符：“十一二百五十二”，还有“十一五十二”或“十一点五十二”和诸如此类
colloqialisms：“三十多岁”（这也没有完全解决，因为什么是“东西”？嗯，这段代码发现这个数字只是“30”）。**

现在，我不是在源代码中存储正则表达式的怪物，而是考虑在运行时使用以下内容构建此RegEx：

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

这里最简单的部分是我们只存储重要的单词。在SIXTH的情况下，你会注意到它没有一个条目，因为它只是正常的数字，TH加上......但像TWELVE这样的东西需要不同的关注。

好的，现在我们有了构建我们（丑陋）RegEx的代码，现在我们只需要在我们的数字字符串上执行它。

我建议的一件事是过滤或吃“AND”这个词。这不是必要的，只会导致其他问题。

因此，您要做的是设置一个函数，将“Magnitude”的命名匹配传递给一个函数，该函数查看所有可能的幅度值，并将当前结果乘以该值。然后，创建一个查看名为matches的“Value”的函数，并根据在那里发现的值返回一个int（或者你正在使用的任何东西）。

所有VALUE匹配都添加到您的结果中，而magnitutde匹配则将结果乘以mag值。那么，二十五万变为“2”，然后是“2 * 100”，然后是“200 + 50”，然后是“250 * 1000”，最终变成250000 ...

为了好玩，我写了一个vbScript版本，并且它提供的所有示例都很好用。现在，它不支持命名匹配，所以我必须更努力地获得正确的结果，但我得到了它。底线是，如果是“VALUE”匹配，则将其添加到累加器中。如果它是一个幅度匹配，将你的累加器乘以100,1000,1000000,1000000000等...这将为你提供一些非常惊人的结果，你需要做的就是调整像“一半”这样的东西就是添加它们到您的RegEx，为它们添加代码标记，并处理它们。

好吧，我希望这篇文章可以帮助SOMEONE。如果有人想要，我可以通过我用来测试它的vbScript伪代码发布，但是，它不是漂亮的代码，而不是生产代码。

如果可以的话......最终的语言是什么？ C ++，还是像脚本语言？ Greg Hewgill的资料来源将有助于理解所有这些如何融合在一起。

如果我有任何其他帮助，请告诉我。对不起，我只懂英语/美国语，所以我无法用其他语言帮助你。

Answer 10

我正在从早期现代书籍（例如＆＃34;第2版＆＃34;，＆＃34; Editio quarta＆＃34;）转换序数版声明到整数，需要支持英语和序数1的序数1-100 -10用几种浪漫语言。以下是我在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

Answer 11

尝试

打开HTTP请求“http://www.google.com/search?q=”+数字+“+ + +十进制”。
解析您的号码的结果。
缓存数字/结果对，以便随时间推移请求。

Answer 12

开始查看的一个地方是gnu get_date lib，它可以将just about any英文文本日期解析为时间戳。虽然不是你想要的，但他们对类似问题的解决方案可以提供很多有用的线索。

如何从写成单词的数字中读取值？

12 个答案:

欧洲标准：