C#2.0纯数学方法递归实现货币数字转换中文

2024-07-21 02:28:24

字体：大中小

来源：转载

供稿：网友

　　最近由于项目的原因，需要写一个货币数字转换中文的算法，先在网了找了一下，结果发现无一列外都是用(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;
}