欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-07 10:01:20
本文实例讲述了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#程序设计有所帮助。