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

Question

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

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

regex_test.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"]

标签： rubyregex

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"

（也可以为and编写units = Regexp.union(units_to_digit.keys)和类似的。参见Regexp::union。）tensteens

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

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]和。当没有匹配时，每个将相等。（例如，will equal when 。）将这些 nil 简单地视为零是很方便的。一种简单的方法是为每个散列添加一个键值对，并且：m[:units]m[:teens]nilm[:nbr_hundreds]nilstr = "one"nil=>0units_to_digittens_to_digitteens_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