C#基于纯数学方法递归实现货币数字转换中文功能详解

本文实例讲述了c#基于纯数学方法递归实现货币数字转换中文功能。分享给大家供大家参考，具体如下：

最近由于项目的原因，需要写一个货币数字转换中文的算法，先在网了找了一下，结果发现无一列外都是用(replace)替换的方式来实现的，所以想写个另外的算法；因为本人是学数学出身的，所以用纯数学的方法实现。

注意：本文中的算法支持小于1023 (也就是9999亿兆)货币数字转化。

货币中文说明： 在说明代码之前，首先让我们回顾一下货币的读法。

10020002.23  读为 壹仟零贰万零贰元贰角叁分
1020         读为 壹仟零贰拾元整。
100000       读为 拾万元整
0.13         读为 壹角叁分

代码：

测试工程

static void main(string[] args)
{
console.writeline("请输入金额");
string inputnum = console.readline();
while (inputnum != "exit")
{
//货币数字转化类
numcast nc = new numcast();
if (nc.isvalidated<string>(inputnum))
{
try
{
string chinesecharacter = nc.converttochinese(inputnum);
console.writeline(chinesecharacter);
}
catch (exception er)
{
console.writeline(er.message);
}
}
else
{
console.writeline("不合法的数字或格式");
}
console.writeline("\n请输入金额");
inputnum = console.readline();
}
console.readline();
}

货币转化类（numcast类）功能介绍

1. 常量的规定

/// <summary>
/// 数位
/// </summary>
public enum numlevel { cent, chiao, yuan, ten, hundred, thousand, tenthousand, hundredmillon, trillion };
/// <summary>
/// 数位的指数
/// </summary>
private int[] numlevelexponent = new int[] { -2, -1, 0, 1, 2, 3, 4, 8, 12 };
/// <summary>
/// 数位的中文字符
/// </summary>
private string[] numleverchinesesign = new string[] { "分", "角", "元", "拾", "佰", "仟", "万", "亿", "兆" };
/// <summary>
/// 大写字符
/// </summary>
private string[] numchinesecharacter = new string[] {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
/// <summary>
/// 整(当没有 角分 时)
/// </summary>
private const string endofint = "整";

2. 数字合法性验证，采用正则表达式验证

/// <summary>
/// 正则表达验证数字是否合法
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public bool isvalidated<t>(t num)
{
regex reg = new regex(@"^(([0])|([1-9]\d{0,23}))(\.\d{1,2})?$");
if (reg.ismatch(num.tostring()))
{
return true;
}
return false;
}

3. 获取数位 例如 1000的数位为 numlevel.thousand

/// <summary>
/// 获取数字的数位使用log
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
private numlevel getnumlevel(double num)
{
double numlevellength;
numlevel nlvl = new numlevel();
if (num > 0)
{
numlevellength = math.floor(math.log10(num));
for (int i = numlevelexponent.length - 1; i >= 0; i--)
{
if (numlevellength >= numlevelexponent[i])
{
nlvl = (numlevel)i;
break;
}
}
}
else
{
nlvl = numlevel.yuan;
}
return nlvl;
}

4. 判断数字之间是否有跳位，也就是中文中间是否要加零，例如1020 就应该加零。

/// <summary>
/// 是否跳位
/// </summary>
/// <returns></returns>
private bool isdumplevel(double num)
{
 if (num > 0)
{
numlevel? currentlevel = getnumlevel(num);
numlevel? nextlevel = null;
int numexponent = this.numlevelexponent[(int)currentlevel];
double postfixnun = math.round(num % (math.pow(10, numexponent)),2);
if(postfixnun> 0)
nextlevel = getnumlevel(postfixnun);
if (currentlevel != null && nextlevel != null)
{
if (currentlevel > nextlevel + 1)
{
return true;
}
}
}
return false;
}

5. 把长数字分割为两个较小的数字数组，例如把9999亿兆，分割为9999亿和0兆，因为计算机不支持过长的数字。

/// <summary>
/// 是否大于兆，如果大于就把字符串分为两部分，
/// 一部分是兆以前的数字
/// 另一部分是兆以后的数字
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
private bool isbigthantillion(string num)
{
bool isbig = false;
if (num.indexof('.') != -1)
{
//如果大于兆
if (num.indexof('.') > numlevelexponent[(int)numlevel.trillion])
{
isbig = true;
}
}
else
{
//如果大于兆
if (num.length > numlevelexponent[(int)numlevel.trillion])
{
isbig = true;
}
}
return isbig;
}
/// <summary>
/// 把数字字符串由‘兆'分开两个
/// </summary>
/// <returns></returns>
private double[] splitnum(string num)
{
//兆的开始位
double[] tillionlevelnums = new double[2];
int trillionlevellength;
if (num.indexof('.') == -1)
trillionlevellength = num.length - numlevelexponent[(int)numlevel.trillion];
else
trillionlevellength = num.indexof('.') - numlevelexponent[(int)numlevel.trillion];
//兆以上的数字
tillionlevelnums[0] = convert.todouble(num.substring(0, trillionlevellength));
//兆以下的数字
tillionlevelnums[1] = convert.todouble(num.substring(trillionlevellength ));
return tillionlevelnums;
}

6. 是否以“壹拾”开头，如果是就可以把它变为“拾”

bool isstartoften = false;
while (num >=10)
{
if (num == 10)
{
isstartoften = true;
break;
}
//num的数位
numlevel currentlevel = getnumlevel(num);
int numexponent = this.numlevelexponent[(int)currentlevel];
num = convert.toint32(math.floor(num / math.pow(10, numexponent)));
if (currentlevel == numlevel.ten && num == 1)
{
isstartoften = true;
break;
}
}
return isstartoften;

7. 合并大于兆连个数组转化成的货币字符串

/// <summary>
/// 合并分开的数组中文货币字符
/// </summary>
/// <param name="tillionnums"></param>
/// <returns></returns>
private string contactnumchinese(double[] tillionnums)
{
string uptillionstr = calculatechinesesign(tillionnums[0], numlevel.trillion, true, isstartoften(tillionnums[0]));
string downtrillionstr = calculatechinesesign(tillionnums[1], null, true,false);
string chinesecharactor = string.empty;
//分开后的字符是否有跳位
if (getnumlevel(tillionnums[1] * 10) == numlevel.trillion)
{
chinesecharactor = uptillionstr + numleverchinesesign[(int)numlevel.trillion] + downtrillionstr;
}
else
{
chinesecharactor = uptillionstr + numleverchinesesign[(int)numlevel.trillion];
if (downtrillionstr != "零元整")
{
chinesecharactor += numchinesecharacter[0] + downtrillionstr;
}
else
{
chinesecharactor += "元整";
}
}
return chinesecharactor;
}

8. 递归计算货币数字的中文

/// <summary>
/// 计算中文字符串
/// </summary>
/// <param name="num">数字</param>
/// <param name="nl">数位级别 比如1000万的 数位级别为万</param>
/// <param name="isexceptten">是否以‘壹拾'开头</param>
/// <returns>中文大写</returns>
public string calculatechinesesign(double num, numlevel? nl ,bool isdump,bool isexceptten)
{
num = math.round(num, 2);
bool isdump = false;
//num的数位
numlevel? currentlevel = getnumlevel(num);
int numexponent = this.numlevelexponent[(int)currentlevel];
string result = string.empty;
//整除后的结果
int prefixnum;
//余数 当为小数的时候 分子分母各乘100
double postfixnun ;
if (num >= 1)
{
prefixnum = convert.toint32(math.floor(num / math.pow(10, numexponent)));
postfixnun = math.round(num % (math.pow(10, numexponent)), 2);
}
else
{
prefixnum = convert.toint32(math.floor(num*100 / math.pow(10, numexponent+2)));
postfixnun = math.round(num * 100 % (math.pow(10, numexponent + 2)), 2);
postfixnun *= 0.01;
}
if (prefixnum < 10 )
{
//避免以‘壹拾'开头
if (!(numchinesecharacter[(int)prefixnum] == numchinesecharacter[1]
&& currentlevel == numlevel.ten && isexceptten))
{
result += numchinesecharacter[(int)prefixnum];
}
else
{
isexceptten = false;
}
//加上单位
if (currentlevel == numlevel.yuan )
{
////当为 “元” 位不为零时 加“元”。
if (nl == null)
{
result += numleverchinesesign[(int)currentlevel];
//当小数点后为零时 加 "整"
if (postfixnun == 0)
{
result += endofint;
}
}
}
else
{
result += numleverchinesesign[(int)currentlevel];
}
 //当真正的个位为零时加上“元”
if (nl == null && postfixnun < 1 && currentlevel > numlevel.yuan && postfixnun > 0)
{
result += numleverchinesesign[(int)numlevel.yuan];
}
}
else
{
//当 前缀数字未被除尽时， 递归下去
numlevel? nextnl = null;
if ((int)currentlevel >= (int)(numlevel.tenthousand))
nextnl = currentlevel;
result += calculatechinesesign((double)prefixnum, nextnl, isdump, isexceptten);
if ((int)currentlevel >= (int)(numlevel.tenthousand))
{
result += numleverchinesesign[(int)currentlevel];
}
}
//是否跳位
// 判断是否加零， 比如302 就要给三百 后面加零，变为 三百零二。
if (isdumplevel(num))
{
result += numchinesecharacter[0];
isdump = true;
}
//余数是否需要递归
if (postfixnun > 0)
{
result += calculatechinesesign(postfixnun, nl, isdump, false);
}
else if (postfixnun == 0 && currentlevel > numlevel.yuan )
{
//当数字是以零元结尾的加上 元整 比如1000000一百万元整
if (nl == null)
{
result += numleverchinesesign[(int)numlevel.yuan];
result += endofint;
}
}
return result;
}

9. 外部调用的转换方法。

/// <summary>
/// 外部调用的转换方法
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public string converttochinese(string num)
{
if (!isvalidated<string>(num))
{
throw new overflowexception("数值格式不正确，请输入小于9999亿兆的数字且最多精确的分的金额！");
}
string chinesecharactor = string.empty;
if (isbigthantillion(num))
{
double[] tillionnums = splitnum(num);
chinesecharactor = contactnumchinese(tillionnums);
}
else
{
double dnum = convert.todouble(num);
chinesecharactor = calculatechinesesign(dnum, null, true, isstartoften(dnum));
}
return chinesecharactor;
}

小结：

个人认为程序的灵魂是算法，大到一个系统中的业务逻辑，小到一个货币数字转中文的算法，处处都体现一种逻辑思想。

是否能把需求抽象成一个好的数学模型，直接关系到程序的实现的复杂度和稳定性。在一些常用功能中想些不一样的算法，对我们开拓思路很有帮助。

更多关于c#相关内容感兴趣的读者可查看本站专题：《c#数学运算技巧总结》、《c#窗体操作技巧汇总》、《c#常见控件用法教程》、《winform控件用法总结》、《c#程序设计之线程使用技巧总结》、《c#数据结构与算法教程》、《c#数组操作技巧总结》及《c#面向对象程序设计入门教程》

希望本文所述对大家c#程序设计有所帮助。