Gammon Forum

current word             stack
fifty                    50
three                    53 <pop 50, add 3, push 53>
million                  53000000 <pop 53, *1M>
billion                  53000000000000000
eighty                   80, 53000000000000000
million                  80000000, 53000000000000000
forty                    40, 80000000, 53000000000000000
one                      41, 80000000, 53000000000000000
thousand                 41000, 80000000, 53000000000000000
six                      6, 41000, 80000000, 53000000000000000
hundred                  600, 41000, 80000000, 53000000000000000
twenty                   20, 600, 41000, 80000000, 53000000000000000
two                      22, 600, 41000, 80000000, 53000000000000000

-- DON'T USE THIS -- see amended version below!!!

numbers = {
         one        = bc.number (1),
         two        = bc.number (2),
         three      = bc.number (3),
         four       = bc.number (4),
         five       = bc.number (5),
         six        = bc.number (6),
         seven      = bc.number (7),
         eight      = bc.number (8),
         nine       = bc.number (9),
         ten        = bc.number (10),
         eleven     = bc.number (11),
         twelve     = bc.number (12),
         thirteen   = bc.number (13),
         fourteen   = bc.number (14),
         fifteen    = bc.number (15),
         sixteen    = bc.number (16),
         seventeen  = bc.number (17),
         eighteen   = bc.number (18),
         nineteen   = bc.number (19),
         twenty     = bc.number (20),
         thirty     = bc.number (30),
         forty      = bc.number (40),
         fifty      = bc.number (50),
         sixty      = bc.number (60),
         seventy    = bc.number (70),
         eighty     = bc.number (80),
         ninety     = bc.number (90),
} -- numbers 

units = {
          hundred      = bc.number ("100"),
          thousand     = bc.number ("1000"),
          million      = bc.number ("1000000"),
          billion      = bc.number ("1000000000"),
          trillion     = bc.number ("1000000000000"),
          quadrillion  = bc.number ("1000000000000000"),
          quintillion  = bc.number ("1000000000000000000"),
          sextillion   = bc.number ("1000000000000000000000"),
          septillion   = bc.number ("1000000000000000000000000"),
          octillion    = bc.number ("1000000000000000000000000000"),
          nonillion    = bc.number ("1000000000000000000000000000000"),
          decillion    = bc.number ("1000000000000000000000000000000000"),
          undecillion  = bc.number ("1000000000000000000000000000000000000"),
          duodecillion = bc.number ("1000000000000000000000000000000000000000"),
  } -- units
  
-- convert a number in words to a numeric form
-- See: http://www.gammon.com.au/forum/?id=10155
-- Thanks to David Haley

function convert (s)

  local stack = {}
  local previous_type
  
  s = string.gsub (s:lower (), "%-", " ")  -- convert hyphens to spaces
  
  for word in string.gmatch (s, "%a+") do
    if word ~= "and" then  -- skip "and" (like "hundred and fifty two")
      local top = #stack
      
      -- If the current word is a number (English or numeric), and the previous word 
      --    was also a number, pop the stack and push the addition. 

      -- Otherwise, push the number.

      local number = numbers [word]
      if number then
        if previous_type == "number" then   -- eg. forty three
          local previous_number = table.remove (stack, top)  -- get the three
          number = number + previous_number  -- add forty
        end -- if 
        table.insert (stack, number)   
        previous_type = "number"
      else
      
        -- If the current word is a unit, multiply the number on the top of the stack by the unit's magnitude. 
        local unit = units [word]
        if not unit then
          return nil, "Unexpected word: " .. word
        end -- not unit
        previous_type = "unit"
        
        -- It is an error to get a unit before a number.
        
        if top == 0 then
          return nil, "Cannot have unit before a number: " .. word
        end -- starts of with something like "thousand"
        stack [top] = stack [top] * unit   
       
      end -- if number or not
    end -- if 'and'
  end -- for each word
  
  if #stack == 0 then
    return nil, "No number found"
  end -- nothing
  
  -- When the input has been parsed, sum all numbers on the stack.
  
  local result = bc.number (0)
  for _, item in ipairs (stack) do
    result = result + item
  end -- for
  
  return result
end -- function convert

test = " fifty-three million billion eighty million forty-one thousand six hundred and twenty-two"

n = assert (convert (test))
print ("Result =", n, "length =", #bc.tostring (n))

Result = 53000000080041622 length = 17

Processing word:        two stack is: 2
Processing word:   trillion stack is: 2000000000000
Processing word:       four stack is: 2000000000000, 4
Processing word:    hundred stack is: 2000000000000, 400
Processing word:     thirty stack is: 2000000000000, 400, 30
Processing word:        two stack is: 2000000000000, 400, 32
Processing word:    billion stack is: 2000000000000, 400, 32000000000
Processing word:      eight stack is: 2000000000000, 400, 32000000000, 8
Processing word:    hundred stack is: 2000000000000, 400, 32000000000, 800
Processing word:    seventy stack is: 2000000000000, 400, 32000000000, 800, 70
Processing word:        six stack is: 2000000000000, 400, 32000000000, 800, 76
Processing word:    million stack is: 2000000000000, 400, 32000000000, 800, 76000000
Processing word:      three stack is: 2000000000000, 400, 32000000000, 800, 76000000, 3
Processing word:    hundred stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300
Processing word:      forty stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 40
Processing word:       five stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45
Processing word:   thousand stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45000
Processing word:       nine stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45000, 9
Processing word:    hundred stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45000, 900
Processing word:     twenty stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45000, 900, 20
Processing word:      three stack is: 2000000000000, 400, 32000000000, 800, 76000000, 300, 45000, 900, 23
Result = 2032076047423 length = 13

-- Convert words to a number
-- Author: Nick Gammon
-- Date: 18th March 2010

-- Does NOT handle decimal places (eg. four point six)

local numbers = {
         zero       = bc.number (0),
         one        = bc.number (1),
         two        = bc.number (2),
         three      = bc.number (3),
         four       = bc.number (4),
         five       = bc.number (5),
         six        = bc.number (6),
         seven      = bc.number (7),
         eight      = bc.number (8),
         nine       = bc.number (9),
         ten        = bc.number (10),
         eleven     = bc.number (11),
         twelve     = bc.number (12),
         thirteen   = bc.number (13),
         fourteen   = bc.number (14),
         fifteen    = bc.number (15),
         sixteen    = bc.number (16),
         seventeen  = bc.number (17),
         eighteen   = bc.number (18),
         nineteen   = bc.number (19),
         twenty     = bc.number (20),
         thirty     = bc.number (30),
         forty      = bc.number (40),
         fifty      = bc.number (50),
         sixty      = bc.number (60),
         seventy    = bc.number (70),
         eighty     = bc.number (80),
         ninety     = bc.number (90),
} -- numbers 

local units = {
          hundred      = bc.number ("100"),
          thousand     = bc.number ("1000"),
          million      = bc.number ("1000000"),
          billion      = bc.number ("1000000000"),
          trillion     = bc.number ("1000000000000"),
          quadrillion  = bc.number ("1000000000000000"),
          quintillion  = bc.number ("1000000000000000000"),
          sextillion   = bc.number ("1000000000000000000000"),
          septillion   = bc.number ("1000000000000000000000000"),
          octillion    = bc.number ("1000000000000000000000000000"),
          nonillion    = bc.number ("1000000000000000000000000000000"),
          decillion    = bc.number ("1000000000000000000000000000000000"),
          undecillion  = bc.number ("1000000000000000000000000000000000000"),
          duodecillion = bc.number ("1000000000000000000000000000000000000000"),
  } -- units
  
-- convert a number in words to a numeric form
-- See: http://www.gammon.com.au/forum/?id=10155
-- Thanks to David Haley

function convert_words_to_numbers (s)

  local stack = {}
  local previous_type
 
  for word in string.gmatch (s:lower (), "[%a%d]+") do
    if word ~= "and" then  -- skip "and" (like "hundred and fifty two")
      local top = #stack
      
      -- If the current word is a number (English or numeric), and the previous word was also a number, pop the stack and push the addition. 
      -- Otherwise, push the number.

      local number = tonumber (word)  -- try for numeric (eg. 22 thousand)

      if number then
        number = bc.number (number)   -- turn into "big number"
      else
        number = numbers [word]
      end -- if a number-word "like: twenty"

      if number then
        if previous_type == "number" then   -- eg. forty three
          local previous_number = table.remove (stack, top)  -- get the three
          number = number + previous_number  -- add forty
        end -- if 
        table.insert (stack, number)   
        previous_type = "number"
      else
      
        -- If the current word is a unit, multiply the number on the top of the stack by the unit's magnitude. 
        local unit = units [word]
        if not unit then
          return nil, "Unexpected word: " .. word
        end -- not unit
        previous_type = "unit"
        
        -- It is an error to get a unit before a number.
        
        if top == 0 then
          return nil, "Cannot have unit before a number: " .. word
        end -- starts of with something like "thousand"

        -- pop until we get something larger on the stack
        local interim_result = bc.number (0)
        while top > 0 and stack [top] < unit do
          interim_result = interim_result + table.remove (stack, top)
          top = #stack
        end -- while
        table.insert (stack, interim_result * unit)
               
      end -- if number or not
    end -- if 'and'

  end -- for each word
  
  if #stack == 0 then
    return nil, "No number found"
  end -- nothing
  
  -- When the input has been parsed, sum all numbers on the stack.
  
  local result = bc.number (0)
  for _, item in ipairs (stack) do
    result = result + item
  end -- for
  
  return result
end -- function convert_words_to_numbers



tests = {

  [bc.number ("2432876345923")] = 
  "two trillion four hundred thirty-two billion eight hundred seventy-six million three hundred forty-five thousand nine hundred twenty-three",

  [bc.number ("44240592621")] = 
  "forty-four billion two hundred forty million five hundred ninety-two thousand six hundred twenty-one",

  [bc.number ("277198501535")] = 
  "two hundred seventy-seven billion one hundred ninety-eight million five hundred one thousand five hundred thirty-five",

  [bc.number ("477708080833")] = 
  "four hundred seventy-seven billion seven hundred eight million eighty thousand eight hundred thirty-three",

  [bc.number ("67707562873705")] = 
  "sixty-seven trillion seven hundred seven billion five hundred sixty-two million eight hundred seventy-three thousand seven hundred five",

  [bc.number ("67707562873705")] = 
  "67 trillion 7 hundred seven billion 5 hundred 62 million eight hundred 73 thousand 705",

}

for number, words in pairs (tests) do
  print ("Converting: ", words)
  n = assert (convert_words_to_numbers (words))
  assert (number == n, "Conversion failed!")
  print ("Result =", n, "length =", #bc.tostring (n))
end -- for

Converting:  sixty-seven trillion seven hundred seven billion five hundred sixty-two million eight hundred seventy-three thousand seven hundred five
Result = 67707562873705 length = 14
Converting:  forty-four billion two hundred forty million five hundred ninety-two thousand six hundred twenty-one
Result = 44240592621 length = 11
Converting:  two trillion four hundred thirty-two billion eight hundred seventy-six million three hundred forty-five thousand nine hundred twenty-three
Result = 2432876345923 length = 13
Converting:  67 trillion 7 hundred seven billion 5 hundred 62 million eight hundred 73 thousand 705
Result = 67707562873705 length = 14
Converting:  two hundred seventy-seven billion one hundred ninety-eight million five hundred one thousand five hundred thirty-five
Result = 277198501535 length = 12
Converting:  four hundred seventy-seven billion seven hundred eight million eighty thousand eight hundred thirty-three
Result = 477708080833 length = 12

local numbers = {
         zero       = bc.number (0),
         one        = bc.number (1),
         two        = bc.number (2),
         three      = bc.number (3),

-- Convert a number to words
-- Author: Nick Gammon
-- Date: 18th March 2010

local inverse_units = {
  {  len = #"1000000000000000000000000000000000000000",    word = "duodecillion " },
  {  len = #"1000000000000000000000000000000000000",       word = "undecillion " },
  {  len = #"1000000000000000000000000000000000",          word = "decillion " },
  {  len = #"1000000000000000000000000000000",             word = "nonillion " },
  {  len = #"1000000000000000000000000000",                word = "octillion " },
  {  len = #"1000000000000000000000000",                   word = "septillion " },
  {  len = #"1000000000000000000000",                      word = "sextillion " },
  {  len = #"1000000000000000000",                         word = "quintillion " },
  {  len = #"1000000000000000",                            word = "quadrillion " },
  {  len = #"1000000000000",                               word = "trillion " },
  {  len = #"1000000000",                                  word = "billion " },
  {  len = #"1000000",                                     word = "million " },
  {  len = #"1000",                                        word = "thousand " },
  } -- inverse_units
  
  
local inverse_numbers = {
    "one ",
    "two ",
    "three ",
    "four ",
    "five ",
    "six ",
    "seven ",
    "eight ",
    "nine ",
    "ten ",
    "eleven ",
    "twelve ",
    "thirteen ",
    "fourteen ",
    "fifteen ",
    "sixteen ",
    "seventeen ",
    "eighteen ",
    "nineteen ",
    "twenty ",
    [30] = "thirty ",
    [40] = "forty ",
    [50] = "fifty ",
    [60] = "sixty ",
    [70] = "seventy ",
    [80] = "eighty ",
    [90] = "ninety ",
 }  -- inverse_numbers
 

-- convert a number in words to a numeric form
-- See: http://www.gammon.com.au/forum/?id=10155

local function convert_up_to_999 (n)

  if n <= 0 then
    return ""
  end -- if zero
  
  local hundreds = math.floor (n / 100)
  local tens = math.floor (n % 100)
  local result = ""

  -- if over 99 we need to say x hundred  
  if hundreds > 0 then
   result = inverse_numbers [hundreds] .. "hundred "
  end -- if
  
  if tens == 0 then
    return result
  end -- if only a digit in the hundreds column
  
  -- up to twenty it is then just five hundred (and) fifteen
  if tens <= 20 then
    return result .. inverse_numbers [tens] 
  end -- if

  -- otherwise we need: thirty (something)
  result = result .. inverse_numbers [math.floor (tens / 10) * 10] 
  
  -- get final digit (eg. thirty four)
  local digits = math.floor (n % 10)

  if digits > 0 then
    result = result ..  inverse_numbers [digits]
  end -- if 
  
  return result
  
end -- convert_up_to_999

function convert_numbers_to_words (n)
  local s = tostring (n)
  -- make multiple of 3
  while #s % 3 > 0 do
    s = "0" .. s
  end -- while
  
  local result = ""
  local start = #inverse_units - #s / 3 + 2
  
  for i = start, #inverse_units do
    local group = tonumber (string.sub (s, 1, 3))
    if group > 0 then
      result = result .. convert_up_to_999 (group) .. inverse_units [i].word
    end -- if not zero
    s = string.sub (s, 4)    
  end -- for
  
  result = result .. convert_up_to_999 (tonumber (s)) 

  if result == "" then
    result = "zero"
  end -- if
  
  return Trim (result)

end -- convert_numbers_to_words



tests = {

  [bc.number ("542")] = 
  "five hundred forty two",
 
  [bc.number ("2432876345923")] = 
  "two trillion four hundred thirty two billion eight hundred seventy six million three hundred forty five thousand nine hundred twenty three",

  [bc.number ("44240592621")] = 
  "forty four billion two hundred forty million five hundred ninety two thousand six hundred twenty one",

  [bc.number ("277198501535")] = 
  "two hundred seventy seven billion one hundred ninety eight million five hundred one thousand five hundred thirty five",

  [bc.number ("477708080833")] = 
  "four hundred seventy seven billion seven hundred eight million eighty thousand eight hundred thirty three",

  [bc.number ("67707562873705")] = 
  "sixty seven trillion seven hundred seven billion five hundred sixty two million eight hundred seventy three thousand seven hundred five",

}

for number, words in pairs (tests) do
  print ("Converting: ", number)
  w = assert (convert_numbers_to_words (number))
  print ("Result   = ", w)
  print ("Expected = ", words)
  assert (words == w, "Conversion failed!")
end -- for

Converting:  477708080833
Result   =  four hundred seventy seven billion seven hundred eight million eighty thousand eight hundred thirty three
Expected =  four hundred seventy seven billion seven hundred eight million eighty thousand eight hundred thirty three
Converting:  2432876345923
Result   =  two trillion four hundred thirty two billion eight hundred seventy six million three hundred forty five thousand nine hundred twenty three
Expected =  two trillion four hundred thirty two billion eight hundred seventy six million three hundred forty five thousand nine hundred twenty three
Converting:  277198501535
Result   =  two hundred seventy seven billion one hundred ninety eight million five hundred one thousand five hundred thirty five
Expected =  two hundred seventy seven billion one hundred ninety eight million five hundred one thousand five hundred thirty five
Converting:  67707562873705
Result   =  sixty seven trillion seven hundred seven billion five hundred sixty two million eight hundred seventy three thousand seven hundred five
Expected =  sixty seven trillion seven hundred seven billion five hundred sixty two million eight hundred seventy three thousand seven hundred five
Converting:  542
Result   =  five hundred forty two
Expected =  five hundred forty two
Converting:  44240592621
Result   =  forty four billion two hundred forty million five hundred ninety two thousand six hundred twenty one
Expected =  forty four billion two hundred forty million five hundred ninety two thousand six hundred twenty one

print (string.rep ("-", 75))

for i = 1, 5000 do
  local s = ""
  for i = 1, math.floor (MtRand () * 40 + 1) do
    s = s .. math.floor (MtRand () * 10)
  end -- for
  
  print ("Converting: '" .. s .. "'")
  local words = assert (convert_numbers_to_words (s))
  print ("Result =", words)
  n = assert (convert_words_to_numbers (words))
  print ("Result    : '" .. n:tostring () .. "'", "length =", #bc.tostring (n))
  if not bc.iszero (n) then
    assert (string.gsub (s, "^0+", "") == n:tostring (), "Conversion failed!")
  end -- if
end -- for

...Code's on Page 3. I'm tired of editing this post :),,,

/print (WordtoNum  "eight hundred sixty six million five hundred thirty six thousand nine hundred eighteen")

--> 806

function convert_up_to_999 (n)

  if n <= 0 then
    return ""
  end -- if zero
  
  local hundreds = math.floor (n / 100)
  local tens = math.floor (n % 100)
  local result = ""

  -- if over 99 we need to say x hundred  
  if hundreds > 0 then
    result = inverse_numbers [hundreds] .. "hundred "
    if tens == 0 then
      return result
    end -- if only a digit in the hundreds column
  
    result = result .. "and "

  end -- if
  

  -- up to twenty it is then just five hundred (and) fifteen
  if tens <= 20 then
    return result .. inverse_numbers [tens] 
  end -- if

  -- otherwise we need: thirty (something)
  result = result .. inverse_numbers [math.floor (tens / 10) * 10] 
  
  -- get final digit (eg. thirty four)
  local digits = math.floor (n % 10)

  if digits > 0 then
    result = string.sub (result, 1, -2) .. "-" ..  inverse_numbers [digits]
  end -- if 
  
  return result
  
end -- convert_up_to_999