【发布时间】：2010-10-22 03:13:09
【问题描述】：
.NET 中是否有内置方法可以将数字转换为数字的字符串表示形式？例如，1 变为 1，2 变为 2，等等。
【问题讨论】：
-
我猜这是语言和技术（不仅仅是.NET）独立的问题。
标签： .net
【发布时间】：2010-10-22 03:13:09
【问题描述】：
A conversion from integer to long form English... I could write that ;-) 是一篇关于该主题的不错的文章：
using System;
public class NumberToEnglish {
private static string[] onesMapping =
new string[] {
"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"
};
private static string[] tensMapping =
new string[] {
"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"
};
private static string[] groupMapping =
new string[] {
"Hundred", "Thousand", "Million", "Billion", "Trillion"
};
private static void Main(string[] args) {
Console.WriteLine(EnglishFromNumber(long.Parse(args[0])));
}
private static string EnglishFromNumber(int number) {
return EnglishFromNumber((long) number);
}
private static string EnglishFromNumber(long number) {
if ( number == 0 ) {
return onesMapping[number];
}
string sign = "Positive";
if ( number < 0 ) {
sign = "Negative";
number = Math.Abs(number);
}
string retVal = null;
int group = 0;
while(number > 0) {
int numberToProcess = (int) (number % 1000);
number = number / 1000;
string groupDescription = ProcessGroup(numberToProcess);
if ( groupDescription != null ) {
if ( group > 0 ) {
retVal = groupMapping[group] + " " + retVal;
}
retVal = groupDescription + " " + retVal;
}
group++;
}
return sign + " " + retVal;
}
private static string ProcessGroup(int number) {
int tens = number % 100;
int hundreds = number / 100;
string retVal = null;
if ( hundreds > 0 ) {
retVal = onesMapping[hundreds] + " " + groupMapping[0];
}
if ( tens > 0 ) {
if ( tens < 20 ) {
retVal += ((retVal != null) ? " " : "") + onesMapping[tens];
} else {
int ones = tens % 10;
tens = (tens / 10) - 2; // 20's offset
retVal += ((retVal != null) ? " " : "") + tensMapping[tens];
if ( ones > 0 ) {
retVal += ((retVal != null) ? " " : "") + onesMapping[ones];
}
}
}
return retVal;
}
}
【讨论】：
-
@balabaster：没有你的代码高尔夫版本那么包容，但它更容易阅读
-
@BobTheBuilder：是的，但就像我说的，这不是代码高尔夫的目的：P
啊，可能没有这样的课程，但是有一个代码高尔夫问题，我提供了一个 C# 示例：
但是，它不是最容易阅读的，它只能达到 decimal.MaxValue，所以我编写了一个新版本，可以达到你需要的最高值。
我找不到任何关于高于 vigintillions 的值的信息，但如果你将这些值附加到 thou[] 数组，你可以继续往上走，只要你喜欢。它仍然不支持分数，但我正在考虑在某个时候添加它。
static string NumericStringToWords(string NumericValue)
{
if ("0" == NumericValue) return "zero";
string[] units = { "one", "two", "three", "four", "five",
"six", "seven", "eight", "nine" };
string[] teens = { "eleven", "twelve", "thirteen", "four", "fifteen",
"sixteen", "seventeen", "eighteen", "nineteen" };
string[] tens = { "ten", "twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety" };
string[] thou = { "thousand", "million", "billion", "trillion",
"quadrillion", "quintillion", "sextillion",
"septillion", "octillion", "nonillion", "decillion",
"udecillion", "duodecillion", "tredecillion",
"quattuordecillion", "quindecillion", "sexdecillion",
"septendecillion", "octodecillion", "novemdecillion",
"vigintillion" };
string sign = String.Empty;
if ("-" == NumericValue.Substring(0, 1))
{
sign = "minus ";
NumericValue = NumericValue.Substring(1);
}
int maxLen = thou.Length * 3;
int actLen = NumericValue.Length;
if(actLen > maxLen)
throw new InvalidCastException(String.Format("{0} digit number specified exceeds the maximum length of {1} digits. To evaluate this number, you must first expand the thou[] array.", actLen, maxLen));
//Make sure that the value passed in is indeed numeric... we parse the entire string
//rather than just cast to a numeric type to allow us to handle large number types passed
//in as a string. Otherwise, we're limited to the standard data type sizes.
int n; //We don't care about n, but int.TryParse requires it
if (!NumericValue.All(c => int.TryParse(c.ToString(), out n)))
throw new InvalidCastException();
string fraction = String.Empty;
if (NumericValue.Contains("."))
{
string[] split = NumericValue.Split('.');
NumericValue = split[0];
fraction = split[1];
}
StringBuilder word = new StringBuilder();
ulong loopCount = 0;
while (0 < NumericValue.Length)
{
int startPos = Math.Max(0, NumericValue.Length - 3);
string crntBlock = NumericValue.Substring(startPos);
if (0 < crntBlock.Length)
{
//Grab the hundreds tens & units for the current block
int h = crntBlock.Length > 2 ? int.Parse(crntBlock[crntBlock.Length - 3].ToString()) : 0;
int t = crntBlock.Length > 1 ? int.Parse(crntBlock[crntBlock.Length - 2].ToString()) : 0;
int u = crntBlock.Length > 0 ? int.Parse(crntBlock[crntBlock.Length - 1].ToString()) : 0;
StringBuilder thisBlock = new StringBuilder();
if (0 < u)
thisBlock.Append(1 == t? teens[u - 1] : units[u - 1]);
if (1 != t)
{
if (1 < t && 0 < u) thisBlock.Insert(0, "-");
if (0 < t) thisBlock.Insert(0, tens[t - 1]);
}
if (0 < h)
{
if (t > 0 | u > 0) thisBlock.Insert(0, " and ");
thisBlock.Insert(0, String.Format("{0} hundred", units[h - 1]));
}
//Check to see if we've got any data left and add
//appropriate word separator ("and" or ",")
bool MoreLeft = 3 < NumericValue.Length;
if (MoreLeft && (0 == h) && (0 == loopCount))
thisBlock.Insert(0, " and ");
else if (MoreLeft)
thisBlock.Insert(0, String.Format(" {0}, ", thou[loopCount]));
word.Insert(0, thisBlock);
}
//Remove the block we just evaluated from the
//input string for the next loop
NumericValue = NumericValue.Substring(0, startPos);
loopCount++;
}
return word.Insert(0, sign).ToString();
}
我使用附加到自身的 Decimal.MaxValue 对其进行了测试，以生成大量：
7 octodecillion, 922 septendecillion, 816 sexdecillion, 251 quindecillion, 426 quattuordecillion, 433 tredecillion, 759 duodecillion, 三百五十四 udecillion, 三百九十五十亿, 三十三非亿, 五百七十九 octillion, 228 septillion, 162 六亿, 五百四千亿、两百六十四亿、三百三十七万亿、五千九百三十亿、五亿四千三百万、九十五万、三百三十五
【讨论】：
-
@BobTheBuilder：哈哈，也许吧，但我不确定我会如何写大部分分数。你是把它们写成百分之一、千分之一，还是只是“点零五三九……”，还是写成五分之三等实际分数？
-
.1 = "十分之一", .14 = "百分之十四", .141 = "百分之四十一"等等怎么样？ =P
-
@Neil Williams：实际上，我不确定这在较大的数字或较长的分数上是否会如此有效，因为它可能比使用点零七九...等更容易阅读.
我一直是递归方法的粉丝
public static string NumberToText( int n)
{
if ( n < 0 )
return "Minus " + NumberToText(-n);
else if ( n == 0 )
return "";
else if ( n <= 19 )
return new string[] {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight",
"Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
"Seventeen", "Eighteen", "Nineteen"}[n-1] + " ";
else if ( n <= 99 )
return new string[] {"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy",
"Eighty", "Ninety"}[n / 10 - 2] + " " + NumberToText(n % 10);
else if ( n <= 199 )
return "One Hundred " + NumberToText(n % 100);
else if ( n <= 999 )
return NumberToText(n / 100) + "Hundreds " + NumberToText(n % 100);
else if ( n <= 1999 )
return "One Thousand " + NumberToText(n % 1000);
else if ( n <= 999999 )
return NumberToText(n / 1000) + "Thousands " + NumberToText(n % 1000);
else if ( n <= 1999999 )
return "One Million " + NumberToText(n % 1000000);
else if ( n <= 999999999)
return NumberToText(n / 1000000) + "Millions " + NumberToText(n % 1000000);
else if ( n <= 1999999999 )
return "One Billion " + NumberToText(n % 1000000000);
else
return NumberToText(n / 1000000000) + "Billions " + NumberToText(n % 1000000000);
}
【讨论】：
-
做得很好，您至少应该修改它以接收多头。 +1
-
我喜欢你的代码，因为它比巴拉巴斯特的更容易理解。我对其进行了一些修改，以考虑单个“0”参数（返回“零”），接受 long 而不是 int，并返回 Billion 而不是 Billions，Million 而不是 Millions，等等。好代码！跨度>
-
@Ryan ：我理解你的解决方案，但你能解释一下你在返回新字符串时使用的第二个方括号运算符（如果 n
-
@Neville：它只是一个数组索引器。
这是我使用的修改后的代码：
//Wrapper class for NumberToText(int n) to account for single zero parameter.
public static string ConvertToStringRepresentation(long number)
{
string result = null;
if (number == 0)
{
result = "Zero";
}
else
{
result = NumberToText(number);
}
return result;
}
//Found at http://www.dotnet2themax.com/blogs/fbalena/PermaLink,guid,cdceca73-08cd-4c15-aef7-0f9c8096e20a.aspx.
//Modifications from original source:
// Changed parameter type from int to long.
// Changed labels to be singulars instead of plurals (Billions to Billion, Millions to Million, etc.).
private static string NumberToText(long n)
{
if (n < 0)
return "Minus " + NumberToText(-n);
else if (n == 0)
return "";
else if (n <= 19)
return new string[] {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight",
"Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
"Seventeen", "Eighteen", "Nineteen"}[n - 1] + " ";
else if (n <= 99)
return new string[] {"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy",
"Eighty", "Ninety"}[n / 10 - 2] + " " + NumberToText(n % 10);
else if (n <= 199)
return "One Hundred " + NumberToText(n % 100);
else if (n <= 999)
return NumberToText(n / 100) + "Hundred " + NumberToText(n % 100);
else if (n <= 1999)
return "One Thousand " + NumberToText(n % 1000);
else if (n <= 999999)
return NumberToText(n / 1000) + "Thousand " + NumberToText(n % 1000);
else if (n <= 1999999)
return "One Million " + NumberToText(n % 1000000);
else if (n <= 999999999)
return NumberToText(n / 1000000) + "Million " + NumberToText(n % 1000000);
else if (n <= 1999999999)
return "One Billion " + NumberToText(n % 1000000000);
else
return NumberToText(n / 1000000000) + "Billion " + NumberToText(n % 1000000000);
}
【讨论】：
public string IntToString(int number)//nobody really uses negative numbers
{
if(number == 0)
return "zero";
else
if(number == 1)
return "one";
.......
else
if(number == 2147483647)
return "two billion one hundred forty seven million four hundred eighty three thousand six hundred forty seven";
}
【讨论】：
-
我不是在 Daily WTF 上看到了吗？
-
不，但应该是。我在想什么与所有其他如果是。我应该使用开关。
-
我很想对此投反对票，但这太糟糕了，它实际上推翻了我的决定。+1 幽默感。
-
迟到了，但是OP没有要求任何递归或一般解决方案，这确实解决了OP的问题。 +1 为 rof :)
-
@WPFUser 嘘。否则会被删除。
这个帖子帮了大忙。我最喜欢 Ryan Emerle 的解决方案，因为它很清晰。这是我的版本，我认为它使结构清晰：
public static class Number
{
static string[] first =
{
"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
"Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
"Seventeen", "Eighteen", "Nineteen"
};
static string[] tens =
{
"Twenty", "Thirty", "Fourty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety",
};
/// <summary>
/// Converts the given number to an english sentence.
/// </summary>
/// <param name="n">The number to convert.</param>
/// <returns>The string representation of the number.</returns>
public static string ToSentence(int n)
{
return n == 0 ? first[n] : Step(n);
}
// traverse the number recursively
public static string Step(int n)
{
return n < 0 ? "Minus " + Step(-n):
n == 0 ? "":
n <= 19 ? first[n]:
n <= 99 ? tens[n / 10 - 2] + " " + Step(n % 10):
n <= 199 ? "One Hundred " + Step(n % 100):
n <= 999 ? Step(n / 100) + "Hundred " + Step(n % 100):
n <= 1999 ? "One Thousand " + Step(n % 1000):
n <= 999999 ? Step(n / 1000) + "Thousand " + Step(n % 1000):
n <= 1999999 ? "One Million " + Step(n % 1000000):
n <= 999999999 ? Step(n / 1000000) + "Million " + Step(n % 1000000):
n <= 1999999999 ? "One Billion " + Step(n % 1000000000):
Step(n / 1000000000) + "Billion " + Step(n % 1000000000);
}
}
【讨论】：
-
+1 为清楚起见并将“常量”设为静态值，而不是其他解决方案将它们声明为内联。
这是我对第一个答案的改进版本。我希望它有用。
/// <summary>
/// Converts an <see cref="int"/> to its textual representation
/// </summary>
/// <param name="num">
/// The number to convert to text
/// </param>
/// <returns>
/// A textual representation of the given number
/// </returns>
public static string ToText(this int num)
{
StringBuilder result;
if (num < 0)
{
return string.Format("Minus {0}", ToText(-num));
}
if (num == 0)
{
return "Zero";
}
if (num <= 19)
{
var oneToNineteen = new[]
{
"One",
"Two",
"Three",
"Four",
"Five",
"Six",
"Seven",
"Eight",
"Nine",
"Ten",
"Eleven",
"Twelve",
"Thirteen",
"Fourteen",
"Fifteen",
"Sixteen",
"Seventeen",
"Eighteen",
"Nineteen"
};
return oneToNineteen[num - 1];
}
if (num <= 99)
{
result = new StringBuilder();
var multiplesOfTen = new[]
{
"Twenty",
"Thirty",
"Forty",
"Fifty",
"Sixty",
"Seventy",
"Eighty",
"Ninety"
};
result.Append(multiplesOfTen[(num / 10) - 2]);
if (num % 10 != 0)
{
result.Append(" ");
result.Append(ToText(num % 10));
}
return result.ToString();
}
if (num == 100)
{
return "One Hundred";
}
if (num <= 199)
{
return string.Format("One Hundred and {0}", ToText(num % 100));
}
if (num <= 999)
{
result = new StringBuilder((num / 100).ToText());
result.Append(" Hundred");
if (num % 100 != 0)
{
result.Append(" and ");
result.Append((num % 100).ToText());
}
return result.ToString();
}
if (num <= 999999)
{
result = new StringBuilder((num / 1000).ToText());
result.Append(" Thousand");
if (num % 1000 != 0)
{
switch ((num % 1000) < 100)
{
case true:
result.Append(" and ");
break;
case false:
result.Append(", ");
break;
}
result.Append((num % 1000).ToText());
}
return result.ToString();
}
if (num <= 999999999)
{
result = new StringBuilder((num / 1000000).ToText());
result.Append(" Million");
if (num % 1000000 != 0)
{
switch ((num % 1000000) < 100)
{
case true:
result.Append(" and ");
break;
case false:
result.Append(", ");
break;
}
result.Append((num % 1000000).ToText());
}
return result.ToString();
}
result = new StringBuilder((num / 1000000000).ToText());
result.Append(" Billion");
if (num % 1000000000 != 0)
{
switch ((num % 1000000000) < 100)
{
case true:
result.Append(" and ");
break;
case false:
result.Append(", ");
break;
}
result.Append((num % 1000000000).ToText());
}
return result.ToString();
}
【讨论】：
基于 Ryan Emerle 的解决方案，这会在正确的位置添加破折号，不包括尾随空格，不复数形式，并正确处理零 (0) 的输入：
public static string ToText(long n) {
return _toText(n, true);
}
private static string _toText(long n, bool isFirst = false) {
string result;
if(isFirst && n == 0) {
result = "Zero";
} else if(n < 0) {
result = "Negative " + _toText(-n);
} else if(n == 0) {
result = "";
} else if(n <= 9) {
result = new[] { "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" }[n - 1] + " ";
} else if(n <= 19) {
result = new[] { "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" }[n - 10] + (isFirst ? null : " ");
} else if(n <= 99) {
result = new[] { "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" }[n / 10 - 2] + (n % 10 > 0 ? "-" + _toText(n % 10) : null);
} else if(n <= 999) {
result = _toText(n / 100) + "Hundred " + _toText(n % 100);
} else if(n <= 999999) {
result = _toText(n / 1000) + "Thousand " + _toText(n % 1000);
} else if(n <= 999999999) {
result = _toText(n / 1000000) + "Million " + _toText(n % 1000000);
} else {
result = _toText(n / 1000000000) + "Billion " + _toText(n % 1000000000);
}
if(isFirst) {
result = result.Trim();
}
return result;
}
【讨论】：
.net 中没有内置解决方案，但周围有很好的库。目前最好的肯定是Humanizr：
Console.WriteLine(794663.ToWords()); // => seven hundred and ninety-four thousand six hundred and sixty-three
它还支持序数和罗马表示：
Console.WriteLine(794663.ToOrdinalWords()); // => seven hundred and ninety-four thousand six hundred and sixty third
Console.WriteLine(794.ToRoman()); // => DCCXCIV
Humanizr 也有很多关于string、DateTime、TimeSpan 等的工具。
Console.WriteLine(794.Seconds().Humanize().Underscore().Hyphenate()); // => 13-minutes
【讨论】：
如果有人感兴趣的话，另一个令人讨厌的 VB.NET 版本！必须使用 floor 函数才能正确舍入..
Public Function NumberToText(n As Integer) As String
Dim a As String() = {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"}
Dim tens As String() = {"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy",
"Eighty", "Ninety"}
If (n < 0) Then
Return "Minus " + NumberToText(-n)
ElseIf (n = 0) Then
Return ""
ElseIf (n <= 19) Then
Return a(n - 1) + " "
ElseIf (n <= 99) Then
Return tens(Math.Floor(n / 10) - 2) + " " + NumberToText(n Mod 10)
ElseIf (n <= 199) Then
Return "One Hundred " + NumberToText(n Mod 100)
ElseIf (n <= 999) Then
Return NumberToText(Math.Floor(n / 100)) + "Hundreds " + NumberToText(n Mod 100)
ElseIf (n <= 1999) Then
Return "One Thousand " + NumberToText(n Mod 1000)
ElseIf (n <= 999999) Then
Return NumberToText(Math.Floor(n / 1000)) + "Thousands " + NumberToText(n Mod 1000)
ElseIf (n <= 1999999) Then
Return "One Million " + NumberToText(n Mod 1000000)
ElseIf (n <= 999999999) Then
Return NumberToText(Math.Floor(n / 1000000)) + "Millions " + NumberToText(n Mod 1000000)
ElseIf (n <= 1999999999) Then
Return "One Billion " + NumberToText(n Mod 1000000000)
Else
Return NumberToText(Math.Floor(n / 1000000000)) + "Billions " + NumberToText(n Mod 1000000000)
End If
End Function
【讨论】：
这是一个更完整/改进的解决方案，基于此处发布的几个想法。包括语法/连字符修复，以及可选的大写、长期支持、对零的支持，但仍然非常简洁（VB.Net）：
Function NumberToCapitalizedWords(ByVal n As Long) As String
Return New System.Globalization.CultureInfo("en-US", False).TextInfo.ToTitleCase(NumberToWords(n))
End Function
Function NumberToWords(ByVal n As Long) As String
Return LTrim(NumberToWords(n, False, False))
End Function
Function NumberToWords(ByVal n As Long, ByVal recursed As Boolean, ByVal iesLast As Boolean) As String
If (n < 0) Then
Return "negative" + NumberToWords(-n, False, False)
ElseIf (n = 0) Then
If recursed Then
Return ""
End If
Return "zero"
ElseIf (n < 20) Then
Return If(iesLast, "-", " ") + New String() {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"}(n - 1)
ElseIf (n < 100) Then
Return " " + New String() {"twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"}(n \ 10 - 2) + NumberToWords(n Mod 10, True, True)
ElseIf (n < 1000) Then
Return NumberToWords(n \ 100, True, False) + " hundred" + NumberToWords(n Mod 100, True, False)
Else
Dim log1000 As Integer = Math.Floor(Math.Log(n, 1000))
Return NumberToWords(n \ PowerNoFloat(1000, log1000), True, False) + " " + New String() {"thousand", "million", "billion", "trillion", "quadrillion", "quintillion"}(log1000 - 1) + NumberToWords(n Mod PowerNoFloat(1000, log1000), True, False)
End If
End Function
Function PowerNoFloat(ByRef base As Long, ByRef power As Integer) As Long
If power < 0 Then
Return 0
End If
Dim result As Long = 1
For i As Integer = 1 To power
result *= base
Next
Return result
End Function
【讨论】：
-
我添加了额外的幂函数，因为内置语言函数返回一个双精度值，这可能会导致差异。