I searched for something like this existing already, failing to find
it, I wrote it myself. If this already existed somewhere in the
framework I appologize for my ignorance.
This method will take any number within the bounds of an int
(int.MinValue - int.MaxValue) inclusive and converts it to an english
number.
For example, it will take "1" and give you "one", "2" yields "two",
"-475918" give you a whopping "negative four hundred seventy five
thousand nine hundred eighteen"
It can also do what I called "positional numbering" for example given
32, with positional boolean set to true, it will return "thirty
second"
so "1" gives "first"
"2" gives "second", etc...
The method is static, as well as it's support array, so just dump them
into a class anywhere.
/// <summary>
/// A matrix of the oddities in the English counting system
/// such as five -> fifth, and all those strange teens
/// </summary>
protected static string[][] _englishDigitMatrix = new string[][]
{
new string[] {"zero", "zeroth", ""},
new string[] {"one", "first", ""},
new string[] {"two", "second", "twenty"},
new string[] {"three", "third", "thirty"},
new string[] {"four", "fourth", "fourty"},
new string[] {"five", "fifth", "fifty"},
new string[] {"six", "sixth", "sixty"},
new string[] {"seven", "seventh", "seventy"},
new string[] {"eight", "eighth", "eighty"},
new string[] {"nine", "nineth", "ninety"},
new string[] {"ten", "", ""},
new string[] {"eleven", "", ""},
new string[] {"twelve", "", ""},
new string[] {"thirteen", "", ""},
new string[] {"fourteen", "", ""},
new string[] {"fifteen", "", ""},
new string[] {"sixteen", "", ""},
new string[] {"seventeen", "", ""},
new string[] {"eighteen", "", ""},
new string[] {"nineteen", "", ""}
};
/// <summary>
/// Converts an integer, within the Max and Min valuse for an int
(inclusive)
/// into English words. The conversion can also use numerical order
positions
/// such as "first" "second", "thirty third" by setting the bool
/// Written by Andrew Arace 10/2004
/// </summary>
/// <param name="number">any integer, positive or negative, within the
bounds of int.</param>
/// <param name="place">true to set to ordered positions, such as
"second" instead of "two"</param>
/// <returns>english string</returns>
protected static string NumberToEnglish(int number, bool order) {
string returnString = string.Empty;
int tempNumber = number;
int countPlace = 0;
int sign = 1;
bool teen = false;
bool single = false;
bool tens = false;
if(number < 0) {
sign *= -1;
returnString += "negative ";
}
//count the billions (int max is over two billion)
countPlace = (tempNumber / 1000000000) * sign;
if(countPlace > 0) {
returnString += NumberToEnglish(countPlace, false) + " billion
";
}
tempNumber -= (1000000000 * countPlace) * sign;
//count the millions
countPlace = (tempNumber / 1000000) * sign;
if(countPlace > 0) {
returnString += NumberToEnglish(countPlace, false) + " million
";
}
tempNumber -= (1000000 * countPlace) * sign;
//count the thousands
countPlace = (tempNumber / 1000) * sign;
if(countPlace > 0) {
returnString += NumberToEnglish(countPlace, false) + "
thousand ";
}
tempNumber -= (1000 * countPlace) * sign;
//any recursion falls in here - in english, the main number
//groupings are in the hundreds - hundreds, hundreds of thousands
//hundreds of millions, etc.
countPlace = (tempNumber / 100) * sign;
if(countPlace > 0) {
returnString += _englishDigitMatrix[countPlace][0] + " hundred
";
}
tempNumber -= (100 * countPlace) * sign;
//count the 10's places
countPlace = (tempNumber / 10) * sign;
if(countPlace > 0) {
tens = true;
if(countPlace == 1) {
teen = true;
}
else {
returnString += _englishDigitMatrix[countPlace][2] + " ";
}
}
tempNumber -= (10 * countPlace) * sign;
//when working with single digits, and also
//teens, the rules change a bit.
tempNumber *= sign; //for the singles, read positives
if(tempNumber >= 0) {
//catch if we have any single digits
if(tempNumber == 0) {
single = false;
}
else {
single = true;
}
//catch the teens, and the number ten as well
if(teen) {
returnString += _englishDigitMatrix[10 + tempNumber][0];
//catch the position order
if(order) {
returnString += "th";
}
}
else if (tempNumber > 0) {
//catch the position order for single digits
if(order) {
returnString += _englishDigitMatrix[tempNumber][1];
}
else {
returnString += _englishDigitMatrix[tempNumber][0];
}
}
else if (tempNumber == 0 && returnString.Length == 0) {
//need to catch the solitary number 0
//nothing will have been caught before this,
//so returnString will be empty.
if(order) {
returnString += _englishDigitMatrix[tempNumber][1];
}
else {
returnString += _englishDigitMatrix[tempNumber][0];
}
}
}
returnString = returnString.Trim();
//check if it ended on a signifier greater than or
//equal to the hundreds - it won't have any order
//qualifiers, we need to add them
if(order) {
if(returnString.EndsWith("billion") ||
returnString.EndsWith("million") ||
returnString.EndsWith("thousand") ||
returnString.EndsWith("hundred")) {
returnString += "th";
}
else if(!single && !teen && tens) {
//must be multiple of 10, greater than or equal to 20
//less than onehundred
returnString = returnString.Substring(0,
returnString.Length-1) + "ieth";
}
}
return returnString;
}
-Andrew Arace
