ruby - 正则表达式匹配人类可读的数字

Question

我在为其中一个 codewars Katas ( https://www.codewars.com/kata/parseint-reloaded/train/ruby ) 编写正则表达式时遇到了一些问题，我希望我能在这里指出正确的方向。我需要一个正则表达式，可以匹配从 1 到 999 的任何人类可读的英文数字字符串。例如:“一”、“三百二”、“五百九十七”等。

当我使用正则表达式进行匹配时，我希望匹配项出现在一致的反向引用位置。到目前为止，我所写的内容在大多数情况下或多或少都有效，但反向引用无处不在。有时当我匹配“百”时。它是 3 美元，有时是 6 美元，这使得提取数字的逻辑变得复杂。其他时候，同一个字符串出现两次。有什么方法可以挽救它并使它变得更好，还是我应该硬着头皮为不同的情况编写多个正则表达式？

正则表达式测试.rb

regex = "^((.+?)( hundred)? )?((.+)[ -])?(.+?)$"

test_cases = [
  'seven hundred ninety six',
  'six hundred twenty-two',
  'one hundred',
  'two hundred one',
  'sixty six',
  'one',
  'sixty'
]

test_cases.each do |test_case|
  puts test_case.match(regex).to_a.inspect
end

输出:

["seven hundred ninety six", "seven hundred ", "seven", " hundred", "ninety ", "ninety", "six"]
["six hundred twenty-two", "six hundred ", "six", " hundred", "twenty-", "twenty", "two"]
["one hundred", "one ", "one", nil, nil, nil, "hundred"]
["two hundred one", "two hundred ", "two", " hundred", nil, nil, "one"]
["sixty six", "sixty ", "sixty", nil, nil, nil, "six"]
["one", nil, nil, nil, nil, nil, "one"]
["sixty", nil, nil, nil, nil, nil, "sixty"]

Answer 1

首先，构造将用于将字符串转换为整数的散列，并使用这些散列的键来定义可能出现在字符串中的单词以插入到正则表达式中。

units_to_digit = %w| one two three four five six seven eight nine |.
  zip((1..9).to_a).to_h
  #=> {"one"=>1, "two"=>2, "three"=>3, "four"=>4, "five"=>5, "six"=>6, "seven"=>7,
  #    "eight"=>8, "nine"=>9}
units = units_to_digit.keys.join('|')
  #=> "one|two|three|four|five|six|seven|eight|nine"

tens_to_digit = %w| twenty thirty forty fifty sixty seventy eighty ninety |.
  zip((2..9).to_a).to_h
  #=> {"twenty"=>2, "thirty"=>3, "forty"=>4, "fifty"=>5, "sixty"=>6, "seventy"=>7,
  #    "eighty"=>8, "ninety"=>9}
tens = tens_to_digit.keys.join('|')
  #=> "twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety"

teens_to_digit =
  %w| ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen |.
  zip((10..19).to_a).to_h
  #=> {"ten"=>10, "eleven"=>11, "twelve"=>12, "thirteen"=>13, "fourteen"=>14,
  #    "fifteen"=>15, "sixteen"=>16, "seventeen"=>17, "eighteen"=>18, "nineteen"=>19}
teens = teens_to_digit.keys.join('|')
  #=>  "ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen"

(也可以编写 units = Regexp.union(units_to_digit.keys) 和类似的 tens 和 teens。参见 Regexp::union .)

接下来，使用命名捕获组构造一个正则表达式。 (出于文档目的，我使用了自由间距模式。如果不使用自由间距模式，则包含单个空格 ([ ]) 的字符类可以各自替换为一个空格。)

regex = /
        \A                            # match beginning of string
        (?:                           # begin a non-capture group
          (?<nbr_hundreds>#{units})   # match nbr of hundreds, named 'nbr_hundreds'
          [ ]hundred                  # match ' hundred'        
        )?                            # close non-capture group and make optional 
        [ ]?                          # optionally match a space
        (?:                           # begin non-capture group
          (?:                         # begin a non-capture group 
            (?<tens>#{tens})          # match 'twenty' to 'ninety', named 'tens'
            (?:                       # begin non-capture group
              [ -]                    # match a space or hyphen
              (?<tens_units>#{units}) # match units, named 'tens_units'
            )?                        # close non-capture group and make optional
          )                           # close non-capture group
          |                           # or
          (?<units>#{units})          # match '1-9', named 'units'
          |                           # or
          (?<teens>#{teens})          # match 'ten', 'eleven',...'nineteen'
        )?                            # close non-capture group and make optional
        \z                            # match end of string
        /x                            # free-spacing regex definition mode   

  #=>   /
  #     \A
  #     (?:
  #       (?<nbr_hundreds>one|two|three|four|five|six|seven|eight|nine)
  #       [ ]hundred
  #     )?
  #     [ ]?
  #     (?:
  #       (?: 
  #         (?<tens>twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety)
  #         (?:
  #           [ -]
  #           (?<tens_units>one|two|three|four|five|six|seven|eight|nine)
  #         )?
  #       )
  #       |
  #       (?<units>one|two|three|four|five|six|seven|eight|nine)
  #       |
  #       (?<teens>ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen)
  #     )?
  #     \z
  #     /x

str.match(regex) 将返回一个 MatchData 对象 m。捕获组的值为 m[:nbr_hundreds]、m[:tens]、m[:tens_units]、 m[:units] 和 m[:teens]。当没有匹配项时，每个都将等于 nil。 (例如，当 str = "one" 时，m[:nbr_hundreds] 将等于 nil。)将这些 nils 简单地视为零。一种简单的方法是将键值对 nil=>0 添加到每个散列 units_to_digit、tens_to_digit 和 teens_to_digit:

units_to_digit[nil] = 0
tens_to_digit[nil] = 0
teens_to_digit[nil] = 0

现在构造一个将 MatchData 对象转换为整数的方法。

def match_data_to_integer(units_to_digit, tens_to_digit, teens_to_digit, m)
  100 * units_to_digit[m[:nbr_hundreds]] +
  10  * tens_to_digit[m[:tens]] +
  teens_to_digit[m[:teens]] +
  units_to_digit[m[:tens_units]] +
  units_to_digit[m[:units]]
end

现在让我们针对一些字符串进行测试。

test_cases = [
  'seven hundred ninety six',
  'six hundred twenty-two',
  'one hundred',
  'two hundred one',
  'sixty six',
  'one',
  'sixty'
]

test_cases.each do |test_case|
  m = test_case.match(regex)
  n = match_data_to_integer(units_to_digit, tens_to_digit, teens_to_digit, m)
  puts "#{test_case} -> #{n}"
end

打印

seven hundred ninety six -> 796
six hundred twenty-two -> 622
one hundred -> 100
two hundred one -> 201
sixty six -> 66
one -> 1
sixty -> 60