Bash, 93 64 55 characters*

In the fantastic bsd-games package that's available on most Linux operating systems, there's a small command-line toy called number. It turns numbers into English text, that is, it does the exact opposite of this question. It really is the exact opposite: all the rules in the question are followed by number. It's almost too good to be a coincidence.

$ number 42 forty-two. 

Of course, number doesn't answer the question. We want it the other way around. I thought about this for a while, tried string parsing and all that, then realised that I can just call number on all 999.999 numbers and see if something matches the input. If so, the first line where it matches has twice the line number I'm looking for (number prints a line of dots after every number). Simple as that. So, without further ado, here's the complete code for my entry:

seq 0 999999|number -l|awk "/$1/{print (NR-1)/2;exit}" 

It even short-circuits, so converting "two" is quite fast, and even higher numbers are usually decoded in under a second on my box. Here's an example run:

wn@box /tmp> bash unnumber.sh "zero" 0 wn@box /tmp> bash unnumber.sh "fifteen" 15 wn@box /tmp> bash unnumber.sh "ninety" 90 wn@box /tmp> bash unnumber.sh "seven hundred four" 704 wn@box /tmp> bash unnumber.sh "sixty-nine thousand four hundred eleven" 69411 wn@box /tmp> bash unnumber.sh "five hundred twenty thousand two" 520002 

Of course, you'll need to have number installed for this to work.

*: Yes, I know, this is not a code-golf challenge, but shortness is pretty much the only discerning quality of my entry, so... :)

Javascript

(function parse(input) { var pat = "ze/on/tw/th.?r/fo/fi/ix/se/ei/ni/ten/ele".split("/"); var num = "", last = 0, token = input.replace(/-/g, " ").split(" "); for(var i in token) { var t = token[i]; for(var p in pat) if(t.match(RegExp(pat[p])) !== null) num += "+" + p; if(t.indexOf("een") >= 0) num += "+10"; if(t.indexOf("lve") >= 0) num += "+10"; if(t.indexOf("ty") >= 0) num += "*10"; if(t.indexOf("dr") >= 0) { last = 100; num += "*100"; } if(t.indexOf("us") >= 0) { if(last < 1000) num = "(" + num + ")"; last = 0; num += "*1000"; } } alert(eval(num)); })(prompt()); 

Do you like some eval()?

Run this script on your browser's console.

Edit: Thanks for the feedback. Bugs fixed (again).

Python

Just to get the ball rolling.

import re 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,'forty':40,'fifty':50,'sixty':60,'ninety':90} modifier = {'hundred':100,'thousand':1000} while True: text = raw_input() result = 0 tmp = 0 last_multiplier = 1 for word in re.split('[- ]', text): multiplier = modifier.get(word, 1) if multiplier > last_multiplier: result = (result+tmp)*multiplier tmp = 0 else: tmp *= multiplier if multiplier != 1: last_multiplier = multiplier tmp += table.get(word,0) print result+tmp 

Perl + CPAN

Why reinvent the wheel, when it has been done already?

use feature 'say'; use Lingua::EN::Words2Nums; say words2nums $_ while <>; 

This program reads English strings from standard input (or from one or more files specified as command line arguments), one per line, and prints out the corresponding numbers to standard output.

I have tested this code using both the sample inputs from the challenge, as well as an exhaustive test suite consisting of the numbers from 0 to 999999 converted to text using the bsd-games number utility (thanks, Wander Nauta!), and it correctly parses all of them. As a bonus, it also understands such inputs as e.g. minus seven (−7), four and twenty (24), four score and seven (87), one gross (144), a baker's dozen (13), eleventy-one (111) and googol (10¹⁰⁰).

(Note: In addition to the Perl interpreter itself, this program also requires the CPAN module Lingua::EN::Words2Nums. Here are some instructions for installing CPAN modules. Debian / Ubuntu Linux users may also install this module via the APT package manager as liblingua-en-words2nums-perl.)

Python

A general recursive solution, with validity checking. Could be simplified for the range of numbers required, but here's to showing off I guess:

terms = 'zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen'.split() tee = 'twenty thirty forty fifty sixty seventy eighty ninety'.split() for t in tee: terms.append(t) for s in terms[1:10]: terms.append(t+'-'+s) terms = dict(zip(terms, range(100))) modifiers = [('hundred', 100), ('thousand', 1000), ('million', 10**6), ('billion', 10**9)] def read_num(words): if len(words) == 0: return 0 elif len(words) == 1: if words[0] in terms: return terms[words[0]] else: raise ValueError(words[0]+' is not a valid english number.') else: for word, value in reversed(modifiers): if word in words: i = words.index(word) return read_num(words[:i])*value+read_num(words[i+1:]) raise ValueError(' '.join(words)+' is not a valid english number.') while True: try: print(read_num(input().split())) except ValueError as e: print(e) 

VBScript 474

This is a fairly routine answer... unfortunately, so routine that @Snack pretty much posted the same process but before me.

i=split(REPLACE(REPLACE(inputbox(""),"lve","een"),"tho","k")) o=split("z on tw th fo fi si se ei ni ten ele") y=split("red *100) k )*1000 ty *10) een +10)") z="" p=0 for t=0 to UBOUND(i) s=split(i(t),"-") u=ubound(s) r=s(0) for x=0 to UBOUND(o) IF INSTR(r,o(x)) THEN z=z+"+"+CSTR(x) END IF IF u Then IF INSTR(s(1),o(x)) THEN z=z+CSTR(x) END IF END IF next for m=0 to UBOUND(y) IF INSTR(r,y(m))AND u=0 THEN z=z+y(m+1) p=p+1 END IF next next Execute("MSGBOX "+String(p,"(")+z) 

Haskell

Similar to other recursive solutions I guess, but I took the time to make it clean.

Here is the complete source with all explanations : http://ideone.com/fc8zcB

-- Define a type for a parser from a list of tokens to the value they represent. type NParse = [Token] -> Int -- Map of literal tokens (0-9, 11-19 and tens) to their names. literals = [ ("zero", 0), ("one", 1), ("two", 2), ("three", 3), ("four", 4), ("five", 5), ("six", 6), ("seven", 7), ("eight", 8), ("nine", 9), ("eleven", 11), ("twelve", 12), ("thirteen", 13), ("fourteen", 14), ("fifteen", 15), ("sixteen", 16), ("seventeen", 17), ("eighteen", 18), ("nineteen", 19), ("ten", 10), ("twenty", 20), ("thirty", 30), ("fourty", 40), ("fifty", 50), ("sixty", 60), ("seventy", 70), ("eighty", 80), ("ninety", 90) ] -- Splits the input string into tokens. -- We do one special transformation: replace dshes by a new token. Such that "fifty-three" becomes "fifty tens three". prepare :: String -> [Token] -- Let's do the easy stuff and just parse literals first. We just have to look them up in the literals map. -- This is our base parser. parseL :: NParse parseL [tok] = case lookup tok literals of Just x -> x -- We're going to exploit the fact that the input strings have a tree-like structure like so -- thousand -- hundred hundred -- ten ten ten ten -- lit lit lit lit lit lit lit lit -- And recursively parse that tree until we only have literal values. -- -- When parsing the tree -- thousand -- h1 h2 -- The resulting value is 1000 * h1 + h2. -- And this works similarly for all levels of the tree. -- So instead of writing specific parsers for all levels, let's just write a generic one : {- genParse :: NParse : the sub parser -> Int : the left part multiplier -> Token : the boundary token -> NParse : returns a new parser -} genParse :: NParse -> Int -> Token -> NParse genParse delegate mul tok = newParser where newParser [] = 0 newParser str = case splitAround str tok of -- Split around the boundary token, sub-parse the left and right parts, and combine them (l,r) -> (delegate l) * mul + (delegate r) -- And so here's the result: parseNumber :: String -> Int parseNumber = parseM . prepare where -- Here are all intermediary parsers for each level parseT = genParse parseL 1 "tens" -- multiplier is irregular, because the fifty in fifty-three is already multiplied by 10 parseH = genParse parseT 100 "hundred" parseK = genParse parseH 1000 "thousand" parseM = genParse parseK 1000000 "million" -- For fun :D test = (parseNumber "five hundred twenty-three thousand six hundred twelve million two thousand one") == 523612002001 

Common Lisp, 94

(write(cdr(assoc(read-line)(loop for i to 999999 collect(cons(format()"~r"i)i)):test #'equalp))) 

Number to text conversion is built in to CL, but not the other way around. Builds a reverse mapping for the numbers and checks the input on it.