最近由于项目的原因需要写一个货币数字转换中文的算法先在网了找了一下结果发现无一列外都是用(Replace)替换的方式来实现的所以想写个另外的算法因为本人是学数学出身的所以用纯数学的方法实现
注意本文中的算法支持小于 (也就是亿兆)货币数字转化
货币中文说明 在说明代码之前首先让我们回顾一下货币的读法
读为 壹仟零贰万零贰元贰角三分
读为 壹仟零贰拾元整
读为 拾万元整
读为 壹角三分
代码
测试工程
static void Main(string[] args)
{
ConsoleWriteLine(请输入金额);
string inputNum = ConsoleReadLine();
while (inputNum != exit)
{
//货币数字转化类
NumCast nc = new NumCast();
if (ncIsValidated<string>(inputNum))
{
try
{
string chineseCharacter = ncConvertToChinese(inputNum);
ConsoleWriteLine(chineseCharacter);
}
catch (Exception er)
{
ConsoleWriteLine(erMessage);
}
}
else
{
ConsoleWriteLine(不合法的数字或格式);
}
ConsoleWriteLine(\n请输入金额);
inputNum = ConsoleReadLine();
}
ConsoleReadLine();
}
测试结果如下
货币转化类(NumCast类)功能介绍
常量的规定
/// <summary>
/// 数位
/// </summary>
public enum NumLevel { Cent Chiao Yuan Ten Hundred Thousand TenThousand hundredMillon Trillion };
/// <summary>
/// 数位的指数
/// </summary>
private int[] NumLevelExponent = new int[] { };
/// <summary>
/// 数位的中文字符
/// </summary>
private string[] NumLeverChineseSign = new string[] { 分 角 元 拾 佰 仟 万 亿 兆 };
/// <summary>
/// 大写字符
/// </summary>
private string[] NumChineseCharacter = new string[] {零壹贰三肆伍陆柒捌玖};
/// <summary>
/// 整(当没有 角分 时)
/// </summary>
private const string EndOfInt = 整;
数字合法性验证采用正则表达式验证
/// <summary>
/// 正则表达验证数字是否合法
/// </summary>
/// <param name=Num></param>
/// <returns></returns>
public bool IsValidated<T>(T Num)
{
Regex reg = new Regex(@^(([])|([]\d{}))(\\d{})?$);
if (regIsMatch(NumToString()))
{
return true;
}
return false;
}
获取数位 例如 的数位为 NumLevelThousand
/// <summary>
/// 获取数字的数位使用log
/// </summary>
/// <param name=Num></param>
/// <returns></returns>
private NumLevel GetNumLevel(double Num)
{
double numLevelLength;
NumLevel NLvl = new NumLevel();
if (Num > )
{
numLevelLength = MathFloor(MathLog(Num));
for (int i = NumLevelExponentLength ; i >= ; i)
{
if (numLevelLength >= NumLevelExponent[i])
{
NLvl = (NumLevel)i;
break;
}
}
}
else
{
NLvl = NumLevelYuan;
}
return NLvl;
}
判断数字之间是否有跳位也就是中文中间是否要加零例如 就应该加零
/// <summary>
/// 是否跳位
/// </summary>
/// <returns></returns>
private bool IsDumpLevel(double Num)
{
if (Num > )
{
NumLevel? currentLevel = GetNumLevel(Num);
NumLevel? nextLevel = null;
int numExponent = thisNumLevelExponent[(int)currentLevel];
double postfixNun = MathRound(Num % (MathPow( numExponent)));
if(postfixNun> )
nextLevel = GetNumLevel(postfixNun);
if (currentLevel != null && nextLevel != null)
{
if (currentLevel > nextLevel + )
{
return true;
}
}
}
return false;
}
把长数字分割为两个较小的数字数组例如把亿兆分割为亿和兆
因为计算机不支持过长的数字
/// <summary>
/// 是否大于兆如果大于就把字符串分为两部分
/// 一部分是兆以前的数字
/// 另一部分是兆以后的数字
/// </summary>
/// <param name=Num></param>
/// <returns></returns>
private bool IsBigThanTillion(string Num)
{
bool isBig = false;
if (NumIndexOf() != )
{
//如果大于兆
if (NumIndexOf() > NumLevelExponent[(int)NumLevelTrillion])
{
isBig = true;
}
}
else
{
//如果大于兆
if (NumLength > NumLevelExponent[(int)NumLevelTrillion])
{
isBig = true;
}
}
return isBig;
}
/// <summary>
/// 把数字字符串由兆分开两个
/// </summary>
/// <returns></returns>
private double[] SplitNum(string Num)
{
//兆的开始位
double[] TillionLevelNums = new double[];
int trillionLevelLength;
if (NumIndexOf() == )
trillionLevelLength = NumLength NumLevelExponent[(int)NumLevelTrillion];
else
trillionLevelLength = NumIndexOf() NumLevelExponent[(int)NumLevelTrillion];
//兆以上的数字
TillionLevelNums[] = ConvertToDouble(NumSubstring( trillionLevelLength));
//兆以下的数字
TillionLevelNums[] = ConvertToDouble(NumSubstring(trillionLevelLength ));
return TillionLevelNums;
}
是否以壹拾开头如果是就可以把它变为拾
bool isStartOfTen = false;
while (Num >=)
{
if (Num == )
{
isStartOfTen = true;
break;
}
//Num的数位
NumLevel currentLevel = GetNumLevel(Num);
int numExponent = thisNumLevelExponent[(int)currentLevel];
Num = ConvertToInt(MathFloor(Num / MathPow( numExponent)));
if (currentLevel == NumLevelTen && Num == )
{
isStartOfTen = true;
break;
}
}
return isStartOfTen;
合并大于兆连个数组转化成的货币字符串
/// <summary>
/// 合并分开的数组中文货币字符
/// </summary>
/// <param name=tillionNums></param>
/// <returns></returns>
private string ContactNumChinese(double[] tillionNums)
{
string uptillionStr = CalculateChineseSign(tillionNums[] NumLevelTrillion true IsStartOfTen(tillionNums[]));
string downtrillionStr = CalculateChineseSign(tillionNums[] null truefalse);
string chineseCharactor = stringEmpty;
//分开后的字符是否有跳位
if (GetNumLevel(tillionNums[] * ) == NumLevelTrillion)
{
chineseCharactor = uptillionStr + NumLeverChineseSign[(int)NumLevelTrillion] + downtrillionStr;
}
else
{
chineseCharactor = uptillionStr + NumLeverChineseSign[(int)NumLevelTrillion];
if (downtrillionStr != 零元整)
{
chineseCharactor += NumChineseCharacter[] + downtrillionStr;
}
else
{
chineseCharactor += 元整;
}
}
return chineseCharactor;
}
递归计算货币数字的中文
/// <summary>
/// 计算中文字符串
/// </summary>
/// <param name=Num>数字</param>
/// <param name=NL>数位级别 比如万的 数位级别为万</param>
/// <param name=IsExceptTen>是否以壹拾开头</param>
/// <returns>中文大写</returns>
public string CalculateChineseSign(double Num NumLevel? NL bool IsDumpbool IsExceptTen)
{
Num = MathRound(Num );
bool isDump = false;
//Num的数位
NumLevel? currentLevel = GetNumLevel(Num);
int numExponent = thisNumLevelExponent[(int)currentLevel];
string Result = stringEmpty;
//整除后的结果
int prefixNum;
//余数 当为小数的时候 分子分母各乘
double postfixNun ;
if (Num >= )
{
prefixNum = ConvertToInt(MathFloor(Num / MathPow( numExponent)));
postfixNun = MathRound(Num % (MathPow( numExponent)) );
}
else
{
prefixNum = ConvertToInt(MathFloor(Num* / MathPow( numExponent+)));
postfixNun = MathRound(Num * % (MathPow( numExponent + )) );
postfixNun *= ;
}
if (prefixNum < )
{
//避免以壹拾开头
if (!(NumChineseCharacter[(int)prefixNum] == NumChineseCharacter[]
&& currentLevel == NumLevelTen && IsExceptTen))
{
Result += NumChineseCharacter[(int)prefixNum];
}
else
{
IsExceptTen = false;
}
//加上单位
if (currentLevel == NumLevelYuan )
{
////当为 元 位不为零时 加元
if (NL == null)
{
Result += NumLeverChineseSign[(int)currentLevel];
//当小数点后为零时 加 整
if (postfixNun == )
{
Result += EndOfInt;
}
}
}
else
{
Result += NumLeverChineseSign[(int)currentLevel];
}
//当真正的个位为零时加上元
if (NL == null && postfixNun < && currentLevel > NumLevelYuan && postfixNun > )
{
Result += NumLeverChineseSign[(int)NumLevelYuan];
}
}
else
{
//当 前缀数字未被除尽时 递归下去
NumLevel? NextNL = null;
if ((int)currentLevel >= (int)(NumLevelTenThousand))
NextNL = currentLevel;
Result += CalculateChineseSign((double)prefixNum NextNL isDump IsExceptTen);
if ((int)currentLevel >= (int)(NumLevelTenThousand))
{
Result += NumLeverChineseSign[(int)currentLevel];
}
}
//是否跳位
// 判断是否加零 比如 就要给三百 后面加零变为 三百零二
if (IsDumpLevel(Num))
{
Result += NumChineseCharacter[];
isDump = true;
}
//余数是否需要递归
if (postfixNun > )
{
Result += CalculateChineseSign(postfixNun NL isDump false);
}
else if (postfixNun == && currentLevel > NumLevelYuan )
{
//当数字是以零元结尾的加上 元整 比如一百万元整
if (NL == null)
{
Result += NumLeverChineseSign[(int)NumLevelYuan];
Result += EndOfInt;
}
}
return Result;
}
外部调用的转换方法
/// <summary>
/// 外部调用的转换方法
/// </summary>
/// <param name=Num></param>
/// <returns></returns>
public string ConvertToChinese(string Num)
{
if (!IsValidated<string>(Num))
{
throw new OverflowException(数值格式不正确请输入小于亿兆的数字且最多精确的分的金额!);
}
string chineseCharactor = stringEmpty;
if (IsBigThanTillion(Num))
{
double[] tillionNums = SplitNum(Num);
chineseCharactor = ContactNumChinese(tillionNums);
}
else
{
double dNum = ConvertToDouble(Num);
chineseCharactor = CalculateChineseSign(dNum null true IsStartOfTen(dNum));
}
return chineseCharactor;
}
小结
个人认为程序的灵魂是算法大到一个系统中的业务逻辑小到一个货币数字转中文的算法处处都体现一种逻辑思想
是否能把需求抽象成一个好的数学模型直接关系到程序的实现的复杂度和稳定性在一些常用功能中想些不一样的算法对我们开拓思路很有帮助