这是google的一道面试题.将汉字转换成数字, 如下
一 1
十 10
十一 11
二十 20
二十一 21
一百 100
一百零一 101
一百一十 110
一百一十一 111 当然算法要能将所有的汉字数字转换成阿拉伯数字,同时兼顾性能.路过的大家不妨试试看... ...
一 1
十 10
十一 11
二十 20
二十一 21
一百 100
一百零一 101
一百一十 110
一百一十一 111 当然算法要能将所有的汉字数字转换成阿拉伯数字,同时兼顾性能.路过的大家不妨试试看... ...
int iRes = 0;
while(c = getnext()) {
if( c 是 一到九）{
iRes += (int)(c);
} else if (c 是 百）{
iRes *= 100;
} else if (c 是 十）{
iRes *= 10;
}
.....
}随便写的流程，看看对不对。
using namespace std;
int main()
{
int numW;
int number;
const int iSize=10;
const char *Number[]= {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
const char *Other[]={"元","角","分","元整"};
const char *zi[]={"拾","佰","千","万","拾","百","仟","亿" };
int FNumW(int namber);
int *FFen(int number,int aNum[],int aSize);
cout<<"请输入一个正整数:\n";
cin>>number;
if(number>0)
numW=FNumW(number);
else if(number==0)
numW=1;
cout<<"您输入的金额是:"<<number<<"位数是"<<numW<<"\n";
int aNumber[numW];
FFen(number,aNumber,numW);
cout<<"您输入的金额的大写形式是:\n";
for(int i=0;i<numW;i++)
{
switch(aNumber[i])
{
case 1:
cout<<Number[1];
break;
case 2:
cout<<Number[2];
break;
case 3:
cout<<Number[3];
break;
case 4:
cout<<Number[4];
break;
case 5:
cout<<Number[5];
break;
case 6:
cout<<Number[6];
break;
case 7:
cout<<Number[7];
break;
case 8:
cout<<Number[8];
break;
case 9:
cout<<Number[9];
break;
}
if((numW-i)%5==0&&numW<10)//处理万位。
{
cout<<"万";
}
if(aNumber[i]!=0)
{
switch(numW-i)
{
case 1:
cout<<Other[3];
break;
case 2:
cout<<zi[0];
break;
case 3:
cout<<zi[1];
break;
case 4:
cout<<zi[2];
break;
//case 5: //万位单独处理。
// cout<<zi[3];
// break;
case 6:
cout<<zi[4];
break;
case 7:
cout<<zi[5];
break;
case 8:
cout<<zi[6];
break;
case 9:
cout<<zi[7];
break;
}
}
else if(aNumber[i]==0&&i==numW-1)
{
cout<<Other[3];
}
else if(aNumber[i]==0&&aNumber[i+1]!=0)
{
cout<<Number[0];
}
}
cout<<"\n";
system("pause");
}
int FNumW(int number) //求任意整型数据的位数
{
int numW=0;
while(number!=0)
{
number=number/10;
numW++;
}
return numW;
}
int *FFen(int number,int aNum[],int numW)//用数组保存任意整型数据的每一位数
{
while(number!=0)
{
aNum[numW-1]=number%10;
numW--;
number=number/10;
}
return aNum;
}
C++版的
"陆", "柒", "捌", "玖" };private final static String[] a_strModify = { "", "拾", "佰", "仟", "万", "拾",
"佰", "仟", "亿", "拾", "佰", "仟" };public static void main(String[] args) throws Exception {GetDot dot = new GetDot();String str = "-101.23";
String getSign = dot.getSign(str);
String getFraction = dot.getFraction(str);
String getDot = dot.getDot(str);
String getInteger = dot.getInteger(str);
System.out.println("========" + getSign + getInteger + getDot
+ getFraction);}/*
* 得到符号位,如果输入的是正数就返回" ",否则就返回负号
*/
public String getSign(String pValue) {return pValue.indexOf("-") == 0 ? "负" : " ";
}/*
* 得到小数部分的汉字，如10.23，就输出贰叁
*/
public String getFraction(String pValue) {String strFraction = null;int intDotPos = pValue.indexOf(".");
if (-1 == intDotPos)
return "";
strFraction = pValue.substring(intDotPos + 1);
System.out.println("have it" + strFraction);
StringBuilder sbResulet = new StringBuilder(strFraction.length());for (int i = 0; i < strFraction.length(); i++) {
System.out.println("have it In" + strFraction);sbResulet.append(a_strNumber[strFraction.charAt(i) - 48]);
}
return sbResulet.toString();
}/*
* 得到整数部分的数据
*/
public String getInteger(String pValue) {System.out.println("============");
String strInteger = null;int intDotPos = pValue.indexOf(".");int intSignPos = pValue.indexOf("-");if (intDotPos == -1) {intDotPos = pValue.length();
}strInteger = pValue.substring(intSignPos + 1, intDotPos);
/*
* 反转strInteger
*/
strInteger = new StringBuffer(strInteger).reverse().toString();
System.out.println("StrInteger====" + strInteger);
StringBuilder sbResult = new StringBuilder();for (int i = 0; i < strInteger.length(); i++) {
sbResult.append(a_strModify);
sbResult.append(a_strNumber[strInteger.charAt(i) - 48]);
}
/*
* 在反转
*/sbResult = sbResult.reverse();
return sbResult.toString();
}/*
* 得到小数点
*/
public String getDot(String pValue) {return pValue.indexOf(".") != -1 ? "点" : "";
}
}
private final String BAI="百";
private final String QIAN="千";
private final String WAN="万";
private final String SHIWAN="十万";
private final String BAIWAN="百万";
private final String QIANWAN="千万";
private final String YI="亿";根据数字的位数可以计算出一个周期是9位数字，共计8种单位
个十百千万(十万)(百万)(千万)(亿)
1 2 3 4 5 6 7 8 9
从数字到汉字： 首先得出数字的长度，确定用到的单位集合。
然后倒序加单位，最后一位不加单位，上一位加SHI,在上一位加百，可以将上面的所有单位放进数组中，按照数组下标递增依次给每一位数字加单位。再将数字直接转换成汉字数字就行了。从汉字到数字：
。。找最大的单位，确定数字长度，然后单位从大到小依次从左向右取出单位前的汉字数字排列，最后将汉字数字全部换成数字。
static HashMap<String,Integer> flag = new HashMap<String,Integer>();
static int bz = -1;
static long temp = 0; /**
* @param args
*/
public static void main(String[] args) {
String[] inputs = {"一百一十万万零五百六十四","三千五百万六十三","三十","一十二","三十千万零六百"};
flag.put("亿",10000000);
flag.put("万", 10000);
flag.put("千", 1000);
flag.put("百", 100);
flag.put("十", 10);
flag.put("一", 1);
flag.put("二", 2);
flag.put("三", 3);
flag.put("四", 4);
flag.put("五", 5);
flag.put("六", 6);
flag.put("七", 7);
flag.put("八", 8);
flag.put("九", 9);
for(String input:inputs){
input = input.replaceAll("零", "");
temp = 0;
getNumber(input);
System.out.println(temp);
} }
public static void getNumber(String input){
if(input.length()<1) return;
int i = 0;
for(int k=0;k<input.length();k++){
if(flag.get(input.substring(k,k+1))<10){
i = k;
break;
}
}
for(int j=0;j<i;j++){
if(bz==-1) bz=flag.get(input.substring(j,j+1));
temp=temp*flag.get(input.substring(j,j+1));
if(j==i-1)bz = flag.get(input.substring(j,j+1));
}
input = input.substring(i,input.length());
if(input.length()==0) return;
String t1 = input.substring(0,1);
if(flag.get(t1)>10){
bz = flag.get(t1);
temp = temp*flag.get(t1);
getNumber(input.substring(1, input.length()));
return;
}
if(input.length()>1){
String t2 = input.substring(1,2);
if(bz==-1)bz=flag.get(t2);
if(bz<=flag.get(t2)){
bz=flag.get(t2);
temp +=flag.get(t1);
temp = temp*flag.get(t2);
}else{
bz = flag.get(t2);
temp += flag.get(t1)*flag.get(t2);
}
getNumber(input.substring(2, input.length()));
}else{
temp+=flag.get(t1);
return ;
}
return ;
}
}
匆匆写的
static HashMap<String,Integer> flag = new HashMap<String,Integer>();
static int bz = -1;
static long temp = 0; /**
* @param args
*/
public static void main(String[] args) {
String[] inputs = {"一百一十万万零五百六十四","三千五百万六十三","三十","一十二","三十千万零六百"};
flag.put("亿",10000000);
flag.put("万", 10000);
flag.put("千", 1000);
flag.put("百", 100);
flag.put("十", 10);
flag.put("一", 1);
flag.put("二", 2);
flag.put("三", 3);
flag.put("四", 4);
flag.put("五", 5);
flag.put("六", 6);
flag.put("七", 7);
flag.put("八", 8);
flag.put("九", 9);
for(String input:inputs){
input = input.replaceAll("零", "");
temp = 0;
getNumber(input);
System.out.println(temp);
} }
public static void getNumber(String input){
if(input.length()<1) return;
int i = 0;
for(int k=0;k<input.length();k++){
if(flag.get(input.substring(k,k+1))<10){
i = k;
break;
}
}
for(int j=0;j<i;j++){
if(bz==-1) bz=flag.get(input.substring(j,j+1));
temp=temp*flag.get(input.substring(j,j+1));
if(j==i-1)bz = flag.get(input.substring(j,j+1));
}
input = input.substring(i,input.length());
if(input.length()==0) return;
String t1 = input.substring(0,1);
if(flag.get(t1)>10){
bz = flag.get(t1);
temp = temp*flag.get(t1);
getNumber(input.substring(1, input.length()));
return;
}
if(input.length()>1){
String t2 = input.substring(1,2);
if(bz==-1)bz=flag.get(t2);
if(bz<=flag.get(t2)){
bz=flag.get(t2);
temp +=flag.get(t1);
temp = temp*flag.get(t2);
}else{
bz = flag.get(t2);
temp += flag.get(t1)*flag.get(t2);
}
getNumber(input.substring(2, input.length()));
}else{
temp+=flag.get(t1);
return ;
}
return ;
}
}
如果新读入的汉字(假设它代表的数字为N)比栈顶数字还要大
{
弹出栈中所有比N小的元素，并将这些元素累加，假设结果为S;
将S*N入栈；
}
否则
{
将N直接入栈;
}
最后将栈中所有数字相加就可以。
第1步==>处理“一”，N=1
直接入栈，
此时栈中元素为：1 （右侧是栈顶）
第2步==>处理“亿”，N=100000000
弹出栈中唯一的元素，然后S=1，将S*N=100000000入栈
此时栈中元素为：100000000
第3步==>处理“一”，N=1
直接入栈
栈中元素为：100000000，1
第4步==>处理“千”，N=1000
弹出栈中比N小的元素（只有一个），然后S=1，将S*N=1000入栈
此时栈中元素为：100000000,1000
第5步==>处理“二”，N=2
直接入栈
此时栈中元素为：100000000,1000，2
第6步==>处理“百”，N=100
弹出栈中比N小的元素（只有一个），然后S=2，将S*N=200入栈
此时栈中元素为：100000000,1000，200
第7步==>处理“五”，N=5
直接入栈
此时栈中元素为：100000000,1000,200,5
第8步==>处理“十”，N=10
弹出栈中比N小的元素（只有一个），然后S=5，将S*N=50入栈
此时栈中元素为：100000000,1000，200，50
第9步==>处理“八”，N=8
直接入栈
此时栈中元素为：100000000,1000，200，50，8
第10步==>处理“万”，N=10000
弹出栈中比N小的元素（有四个），然后S=1258，将S*N=12580000入栈
此时栈中元素为：100000000,12580000
…………
弹出栈中比N小的元素（有四个），然后S=1258，将S*N=12580000入栈
此时栈中元素为：100000000,12580000如果“万”后面是“亿”呢？
一亿一千二百五十八万亿
string a,b
if a='一' then b='1'
if a='一' + '1' then b='10'
if a='一'*2 + '一' + '1' then b='20'
if a='一'*2 + '一' + '1'+ '一' then b='21'
if a='一'+ '一' + ','+ '1' + '一' +'1'+'一'*2 then b='100'
if a='一'+ '一' + ','+ '1' + '一' +'1'+'一'*2+'一' then b='101' //汉字一百零一可翻译为一百一
if a='一'+ '一' + ','+ '1' + '一' +'1'+'一'*2+'一'+'一' + '1' then b='110'
if a='一'+ '一' + ','+ '1' + '一' +'1'+'一'*2+'一'+'一' + '1'+'一' then b='111'
这个问题的输入包括那些格式，哪几种？
汉语千变万化，要表达一个数，可能的情况有很多种。
题目中只是举出了几个例子，没有给出标准，只是在最后说要把 所有的 汉字数字 转化成阿拉伯数字所有的汉字数字——这个界定太弱了！不知道有没有统计过阿拉伯数在汉语中有多少种汉字表达方式；对于特别的数，有特别的表达方式，像上面提到的 一千一，还有 贰仟，这些特殊的表达方式又有哪些？
如果一个算法要考虑所有可能的情况，那么这个算法绝大多数情况下会复杂的可怕，
并且很多时候这样的算法根本不存在。
我想，出题人的本意应该是对于常用的汉字数字，将其转化成阿拉伯数字。
倘若出题人真的是要被试解决所有的汉字数字转化问题，那么Google真是遥不可及。
下面是一种算法，适用于标准读法(其他非标准读法如：四万万(四亿)不算标准读法)public class MyTest{
private static final String[] hz = {"零","一","二","三","四","五","六","七","八","九"};
private static final Map<String, Integer> hzsz = new HashMap<String, Integer>();
private static final Map<String, Integer> hzradix = new HashMap<String, Integer>();
static{
for(int i = 0; i < hz.length; i ++){
hzsz.put(hz[i], i);
}
hzradix.put("十", 10);
hzradix.put("百", 100);
hzradix.put("千", 1000);
hzradix.put("万", 10000);
hzradix.put("亿", 100000000);
}
public static void main(String[] args){
String src = "五十亿三千零七十五万零六百二十二";
System.out.println(exchange1(src));
}
public static long exchange1(String src){
String []tmp1 = src.split("亿");
if(tmp1.length == 2){
return (long)exchange2(tmp1[0]) * hzradix.get("亿") + exchange2(tmp1[1]);
}else{
return exchange2(tmp1[0]);
}
}
public static int exchange2(String src){
String []tmp1 = src.split("万");
if(tmp1.length == 2){
return exchange(tmp1[0]) * hzradix.get("万") + exchange(tmp1[1]);
}else{
return exchange(tmp1[0]);
}
}
public static int exchange(String src){//十、百、千
int bg = 0;
for(int i = 0; i < src.length(); i ++){
String c1 = ""+src.charAt(i);
if(hzsz.containsKey(c1)){
if(i + 1 < src.length()){
String c2 = ""+src.charAt(i+1);
if(hzradix.containsKey(c2)){
bg += hzsz.get(c1) * hzradix.get(c2);
}
}else{
bg += hzsz.get(c1);
}
}
}
return bg;
}
}
输出结果：
5030750622
private static final String[] hz = {"零","一","二","三","四","五","六","七","八","九"};
private static final Map<String, Integer> hzsz = new HashMap<String, Integer>();
private static final Map<String, Integer> hzradix = new HashMap<String, Integer>();
static{
for(int i = 0; i < hz.length; i ++){
hzsz.put(hz[i], i);
}
hzradix.put("十", 10);
hzradix.put("百", 100);
hzradix.put("千", 1000);
hzradix.put("万", 10000);
hzradix.put("亿", 100000000);
}
public static void main(String[] args){
String[] srcs = {"一","十","十一","二十","二十一",
"一百","一百零一","一百一十","一百一十一",
"五十亿三千零七十五万零六百二十二",
"十三亿三千零十五万零三百一十二"};
for(int i = 0; i < srcs.length; i ++){
System.out.println(exchange1(srcs[i]));
}
}
public static long exchange1(String src){
String []tmp1 = src.split("亿");
if(tmp1.length == 2){
return (long)exchange2(tmp1[0]) * hzradix.get("亿") + exchange2(tmp1[1]);
}else{
return exchange2(tmp1[0]);
}
}
public static int exchange2(String src){
String []tmp1 = src.split("万");
if(tmp1.length == 2){
return exchange(tmp1[0]) * hzradix.get("万") + exchange(tmp1[1]);
}else{
return exchange(tmp1[0]);
}
}
public static int exchange(String src){//十、百、千
int bg = 0;
for(int i = 0; i < src.length(); i ++){
String c1 = ""+src.charAt(i);
if(hzsz.containsKey(c1)){
if(c1.equals("零")){
continue;
}
if(i + 1 < src.length()){
String c2 = ""+src.charAt(i+1);
if(hzradix.containsKey(c2)){
bg += hzsz.get(c1) * hzradix.get(c2);
}
}else{
bg += hzsz.get(c1);
}
}else if(i == 0 && c1.equals("十") ||//10-19之间的习惯用法
i > 0 && c1.equals("十") && ((""+src.charAt(i-1)).equals("零"))){
bg += 10;
}
}
return bg;
}
}输出结果：
1
10
11
20
21
100
101
110
111
5030750622
1330150312
class ChNumberToDigit
{
//指数
private Dictionary<string, int> exp = new Dictionary<string, int>(3);
//数字
private Dictionary<string, int> num = new Dictionary<string, int>(10); public ChNumberToDigit()
{
//指数
exp["十"] = 1;
exp["百"] = 2;
exp["千"] = 3; //数字
num["零"] = 0;
num["一"] = 1;
num["二"] = 2;
num["三"] = 3;
num["四"] = 4;
num["五"] = 5;
num["六"] = 6;
num["七"] = 7;
num["八"] = 8;
num["九"] = 9;
} /// <summary>
/// 转换函数
/// </summary>
/// <param name="chNumber">中文数字</param>
/// <returns>阿拉伯数字</returns>
public string Convert(string chNumber)
{
if (chNumber.Length > 0)
{
StringBuilder sbDigit = new StringBuilder();
string[] forC1 = chNumber.Split('亿');
for (int i = 0; i < forC1.Length; i++)
{
sbDigit.Append(C1(forC1[i]));
} //去除开始的0
string dig = sbDigit.ToString();
for (int j = 0; j < 8; j++)
{
if (dig.Substring(j, 1) != "0")
{
return dig.Substring(j);
}
}
return dig;
}
return null;
} /// <summary>
/// 小于亿的转换
/// </summary>
/// <param name="chNumber">中文数字</param>
/// <returns>阿拉伯数字</returns>
private string C1(string chNumber)
{
if (chNumber.Length == 0)
return "00000000"; StringBuilder sbDigit = new StringBuilder();
string[] forC2 = chNumber.Split('万');
for (int i = 0; i < forC2.Length; i++)
{
sbDigit.Append(C2(forC2[i]));
} return sbDigit.ToString().PadLeft(8, '0');
} /// <summary>
/// 小于万的转换
/// </summary>
/// <param name="chNumber">中文数字</param>
/// <returns>阿拉伯数字</returns>
private string C2(string chNumber)
{
if (chNumber.Length == 0)
return "0000"; StringBuilder sbDigit = new StringBuilder();
//记录指数，默认为千
int e = 3; //记录是否发现0，如果发现则在下次指数出现后补零
bool hasZero = false;
if (chNumber.Substring(0, 1) == "十")
sbDigit.Append("1");
for (int i = 0; i < chNumber.Length; i++)
{
string d = chNumber.Substring(i, 1); //遇到0则置标志，待发现下一个指数后补
if (d == "零")
{
hasZero = true;
continue;
} if (exp.ContainsKey(d))
{//发现指数
int newExp = exp[d];
//补零
if (hasZero && e - newExp > 1)
{
sbDigit.Insert(sbDigit.Length - 1, Zero(e - newExp - 1));
hasZero = false;
}
e = newExp;
}
else
{//发现数字
sbDigit.Append(num[d]);
}
} //特殊处理尾部
string last = chNumber.Substring(chNumber.Length - 1, 1);
if (exp.ContainsKey(last))
{//以指数结尾，则要在右边补0
sbDigit.Append(Zero(exp[last]));
}
else if (e > 1)
{//以数字结尾，则要根据最后一个出现的指数，在数字前插入足够的0
sbDigit.Insert(sbDigit.Length - 1, Zero(e - 1));
} //长度不足四位，要在左侧补零
return sbDigit.ToString().PadLeft(4, '0');
} /// <summary>
/// 返回指定个数的0
/// </summary>
/// <param name="length">由0组成的字符串长度</param>
/// <returns></returns>
private static string Zero(int length)
{
return string.Empty.PadRight(length, '0');
}
}
{
int prevNum = 0;
decimal result=0;
string fstr1="零一二三四五六七八九";
string fstr2="十百千万亿";
foreach (char c in gb)
{
if (fstr1.IndexOf(c) >= 0)
{
result += prevNum;
prevNum = 0;
prevNum = fstr1.IndexOf(c);
}
else if (fstr2.IndexOf(c) >= 0)
{
prevNum = prevNum == 0 ? 1 : prevNum;
prevNum *= (int )Math.Pow(10, fstr2.IndexOf(c) + 1);
}
}
return result + prevNum;
}
只能是整数
#include <iostream>
using namespace std;int index(int);
int toI(wchar_t);
int toNum(wchar_t[]);int main()
{
wchar_t s0[] = L"零";
wchar_t s1[] = L"一";
wchar_t s2[] = L"十";
wchar_t s3[] = L"十一";
wchar_t s4[] = L"二十";
wchar_t s5[] = L"二十一";
wchar_t s6[] = L"一百";
wchar_t s7[] = L"一百零一";
wchar_t s8[] = L"一百一十";
wchar_t s9[] = L"一百一十一";
cout<<toNum(s0)<<endl;
cout<<toNum(s1)<<endl;
cout<<toNum(s2)<<endl;
cout<<toNum(s3)<<endl;
cout<<toNum(s4)<<endl;
cout<<toNum(s5)<<endl;
cout<<toNum(s6)<<endl;
cout<<toNum(s7)<<endl;
cout<<toNum(s8)<<endl;
cout<<toNum(s9)<<endl;
return 0;
}int index(int n)
{
if(n == 0)
return 1;
else
return 10 * index(n - 1);
}int toI(wchar_t s)
{
wchar_t Si[] = {L'', L'一', L'二', L'三', L'四', L'五', L'六', L'七', L'八', L'九'};
wchar_t St[] = {L'', L'十', L'百', L'千', L'万', L'', L'兆', L'', L'亿'};
int i = 1;
for (; i < 10; i++)
{
if (s == Si[i])
return i;
}
for(i = 0; i < 7; i++)
{
if (s == St[i])
{
return index(i);
}
}
return 0;
}int toNum(wchar_t s[])
{
wchar_t e = L'';
int n = 0, num = 0;
int i = 0;
for (; s[i] != e; i++)
{
if ((toI(s[i]) == 0)&&(n == 0))
num = 0;
else if ((toI(s[i]) > 9)&&(n == 0))
num = 10;
else if ((toI(s[i]) > 9)&&(n != 0))
num = toI(s[i]) * num;
else
num += toI(s[i]);
n++;
}
return num;
}
c++ 版
import java.util.HashMap;public class Test_NumberFormat { private final String UNIT_YI = "亿";
private final String UNIT_WAN = "万";
private final String UNIT_QIAN = "千";
private final String UNIT_BAI = "百";
private final String UNIT_SHI = "十";
private final HashMap<String, Integer> UNIT = new HashMap<String, Integer>();
private final HashMap<String, Integer> NUMBER = new HashMap<String, Integer>(); public Test_NumberFormat() {
UNIT.put(UNIT_YI, 100000000);
UNIT.put(UNIT_WAN, 10000);
UNIT.put(UNIT_QIAN, 1000);
UNIT.put(UNIT_BAI, 100);
UNIT.put(UNIT_SHI, 10);
NUMBER.put("一", 1);
NUMBER.put("二", 2);
NUMBER.put("三", 3);
NUMBER.put("四", 4);
NUMBER.put("五", 5);
NUMBER.put("六", 6);
NUMBER.put("七", 7);
NUMBER.put("八", 8);
NUMBER.put("九", 9);
} public String getArab(String strCHN) { if (strCHN == null || strCHN.trim().equals("")) {
return strCHN;
}
String strCHNTemp = strCHN.replace("零", "");
long result = getArab(strCHNTemp, getUnit(strCHNTemp));
return Long.toString(result);
} private long getArab(String strCHN, String sUNIT) { if (sUNIT == null) {
return NUMBER.get(strCHN);
}
String sArr[] = strCHN.split(sUNIT);
long num = 0;
if (!sArr[0].equals("")) {
num = UNIT.get(sUNIT) * getArab(sArr[0], getUnit(sArr[0]));
} else {
num = UNIT.get(sUNIT);
}
if (sArr.length == 1) {
return num;
}
return num + getArab(sArr[1], getUnit(sArr[1]));
} private String getUnit(String str) { if (str == null || str.trim().equals("")) {
return str;
}
if (str.contains(UNIT_YI)) {
return UNIT_YI;
}
if (str.contains(UNIT_WAN)) {
return UNIT_WAN;
}
if (str.contains(UNIT_QIAN)) {
return UNIT_QIAN;
}
if (str.contains(UNIT_BAI)) {
return UNIT_BAI;
}
if (str.contains(UNIT_SHI)) {
return UNIT_SHI;
}
return null;
}
}
//没有考虑兆及更大单位的情况
java.util.List<String> chnList = new java.util.ArrayList<String>();
chnList.add("一");
chnList.add("十");
chnList.add("一十五");
chnList.add("十五");
chnList.add("二十");
chnList.add("二十三");
chnList.add("一百");
chnList.add("一百零一");
chnList.add("一百一十");
chnList.add("一百一十一");
chnList.add("一千");
chnList.add("一千零一");
chnList.add("一千零三十一");
chnList.add("一万零一");
chnList.add("一万零二十一");
chnList.add("一万零三百二十一");
chnList.add("一万一千三百二十一");
chnList.add("三千零十五万");
chnList.add("三千零一十五万");
chnList.add("三千五百六十八万零一百零一");
chnList.add("五十亿三千零七十五万零六百二十二");
chnList.add("十三亿三千零十五万零三百一十二");
chnList.add("三千零七十八亿三千零十五万零三百一十二");
chnList.add("一千二百五十八亿");
chnList.add("一千二百五十八万亿零三千三百二十一"); for (String chnStr : chnList) {
chn2digit(chnStr);
} public static void chn2digit(String chnStr) {
//init map
java.util.Map<String, Integer> unitMap = new java.util.HashMap<String, Integer>();
unitMap.put("十", 10);
unitMap.put("百", 100);
unitMap.put("千", 1000);
unitMap.put("万", 10000);
unitMap.put("亿", 100000000); java.util.Map<String, Integer> numMap = new java.util.HashMap<String, Integer>();
numMap.put("零", 0);
numMap.put("一", 1);
numMap.put("二", 2);
numMap.put("三", 3);
numMap.put("四", 4);
numMap.put("五", 5);
numMap.put("六", 6);
numMap.put("七", 7);
numMap.put("八", 8);
numMap.put("九", 9); //栈
List<Long> stack = new ArrayList<Long>();
long tempNum = 0;
for (int i = 0; i < chnStr.length(); i++) {
char bit = chnStr.charAt(i);
System.out.print(bit);
//数字
if (numMap.containsKey(bit + "")) { tempNum = tempNum + numMap.get(bit + ""); //一位数、末位数、亿或万的前一位进栈
if (chnStr.length() == 1
| i == chnStr.length() - 1
| (i + 1 < chnStr.length() && (chnStr.charAt(i + 1) == '亿' | chnStr
.charAt(i + 1) == '万'))) {
stack.add(tempNum);
}
}
//单位
else if (unitMap.containsKey(bit + "")) { //遇到十 转换为一十、临时变量进栈
if (bit == '十') {
if (tempNum != 0) {
tempNum = tempNum * unitMap.get(bit + "");
} else {
tempNum = 1 * unitMap.get(bit + "");
}
stack.add(tempNum);
tempNum = 0;
} //遇到千、百 临时变量进栈
if (bit == '千' | bit == '百') {
if (tempNum != 0) {
tempNum = tempNum * unitMap.get(bit + "");
}
stack.add(tempNum);
tempNum = 0;
} //遇到亿、万 栈中元素依次累加*单位值、清空栈、新结果值进栈
if (bit == '亿' | bit == '万') {
long tempSum = 0;
if (stack.size() != 0) {
for (int j = 0; j < stack.size(); j++) {
tempSum += stack.get(j);
}
} else {
tempSum = 1;
}
tempNum = tempSum * unitMap.get(bit + "");
stack.clear();//清空栈
stack.add(tempNum);//新结果值进栈
tempNum = 0;
}
}
} //output
System.out.println();
long sum = 0;
for (Long i : stack) {
sum += i;
}
System.out.println(sum);
}一
1
十
10
一十五
15
十五
15
二十
20
二十三
23
一百
100
一百零一
101
一百一十
110
一百一十一
111
一千
1000
一千零一
1001
一千零三十一
1031
一万零一
10001
一万零二十一
10021
一万零三百二十一
10321
一万一千三百二十一
11321
三千零十五万
30150000
三千零一十五万
30150000
三千五百六十八万零一百零一
35680101
五十亿三千零七十五万零六百二十二
50000030750622
十三亿三千零十五万零三百一十二
13000030150312
三千零七十八亿三千零十五万零三百一十二
3078000030150312
一千二百五十八亿
125800000000
一千二百五十八万亿零三千三百二十一
1258000000003321
java.util.List<String> chnNumList = new java.util.ArrayList<String>();
chnNumList.add("一");
chnNumList.add("十");
chnNumList.add("一十五");
chnNumList.add("十五");
chnNumList.add("二十");
chnNumList.add("二十三");
chnNumList.add("一百");
chnNumList.add("一百零一");
chnNumList.add("一百一十");
chnNumList.add("一百一十一");
chnNumList.add("一千");
chnNumList.add("一千零一");
chnNumList.add("一千零三十一");
chnNumList.add("一万零一");
chnNumList.add("一万零二十一");
chnNumList.add("一万零三百二十一");
chnNumList.add("一万一千三百二十一");
chnNumList.add("三千零十五万");
chnNumList.add("三千零一十五亿");
chnNumList.add("三千五百六十八万零一百零一");
chnNumList.add("五十亿三千零七十五万零六百二十二");
chnNumList.add("十三亿三千零十五万零三百一十二");
chnNumList.add("三千零七十八亿三千零十五万零三百一十二");
chnNumList.add("一千二百五十八亿");
chnNumList.add("二十一亿三千万");
chnNumList.add("一亿三千万");
chnNumList.add("一亿零三千万");
chnNumList.add("一千二百五十八万亿零三千三百二十一"); for (String chnNum : chnNumList) {
chnNum2Digit(chnNum);
}
} // 没有考虑兆及更大单位情况
public static void chnNum2Digit(String chnNum) {
// initialize map
java.util.Map<String, Integer> unitMap = new java.util.HashMap<String, Integer>();
unitMap.put("个", 1);// 仅在数据存储时使用
unitMap.put("十", 10);
unitMap.put("百", 100);
unitMap.put("千", 1000);
unitMap.put("万", 10000);
unitMap.put("亿", 100000000); java.util.Map<String, Integer> numMap = new java.util.HashMap<String, Integer>();
numMap.put("零", 0);
numMap.put("一", 1);
numMap.put("二", 2);
numMap.put("三", 3);
numMap.put("四", 4);
numMap.put("五", 5);
numMap.put("六", 6);
numMap.put("七", 7);
numMap.put("八", 8);
numMap.put("九", 9); // 数据存储结构：
// 单位 数量
// "个" num
// "十" num
// "百" num
// "千" num
// "万" num
// "亿" num
java.util.Map<String, Long> dataMap = new java.util.LinkedHashMap<String, Long>(); // 保存"亿"或"万"之前存在的多位数
java.util.List<Long> mulitNumList = new java.util.ArrayList<Long>(); long tempNum = 0;
for (int i = 0; i < chnNum.length(); i++) {
char bit = chnNum.charAt(i);
System.out.print(bit); // 因为"亿"或"万"存在多位情况，所以需要进行判断
boolean isExist = false;
// 存在"亿"或"万"情况(不计算当前索引位)
if ((chnNum.indexOf('亿', i) != -1 || chnNum.indexOf('万', i) != -1)
&& chnNum.charAt(i) != '亿' && chnNum.charAt(i) != '万') {
isExist = true;
} // 数字
if (numMap.containsKey(bit + "")) {
if (i != chnNum.length() - 1) {
tempNum = tempNum + numMap.get(bit + "");
}
// 最末位数字情况
else {
dataMap.put("个", Long.valueOf(numMap.get(bit + "") + ""));
tempNum = 0;
}
} else if (bit == '亿') {
// 存在"万亿"情况，取出"万"位值*10000,0000后重新put到map
if (i - 1 >= 0 && chnNum.charAt(i - 1) == '万') {
Long dataValue = dataMap.get("万");
if (dataValue != null && dataValue > 0) {
dataMap.put("万", dataValue * unitMap.get(bit + ""));
}
continue;
} // 最后一位数进list等待处理
if (tempNum != 0) {
mulitNumList.add(tempNum);
}
// 处理"亿"之前的多位数
long sum = 0;
for (Long num : mulitNumList) {
sum += num;
}
mulitNumList.clear();
dataMap.put("亿", sum);
tempNum = 0;
} else if (bit == '万') {
// 最后一位数进list等待处理
if (tempNum != 0) {
mulitNumList.add(tempNum);
}
// 处理"万"之前的多位数
long sum = 0;
for (Long num : mulitNumList) {
sum += num;
}
mulitNumList.clear();
dataMap.put("万", sum);
tempNum = 0;
} else if (bit == '千' && tempNum > 0) {
// 存在"亿"或"万"情况，临时变量值*"千"单位值进list等待处理
if (isExist) {
mulitNumList.add(tempNum * unitMap.get(bit + ""));
tempNum = 0;
}
// 不存在"亿"或"万"情况，临时变量值put到map相应位
else {
dataMap.put("千", tempNum);
tempNum = 0;
}
} else if (bit == '百' && tempNum > 0) {
// 存在"亿"或"万"情况，临时变量值*"百"单位值进list等待处理
if (isExist) {
mulitNumList.add(tempNum * unitMap.get(bit + ""));
tempNum = 0;
}
// 不存在"亿"或"万"情况，临时变量值put到map相应位
else {
dataMap.put("百", tempNum);
tempNum = 0;
}
} else if (bit == '十') {
// 存在"亿"或"万"情况，临时变量值*"十"单位值进list等待处理
if (isExist) {
if (tempNum != 0) {
mulitNumList.add(tempNum * unitMap.get(bit + ""));
tempNum = 0;
}
// 将"十"转换成"一十"
else {
tempNum = 1 * unitMap.get(bit + "");
}
}
// 不存在"亿"或"万"情况，临时变量值put到map相应位
else {
if (tempNum != 0) {
dataMap.put("十", tempNum);
}
// 将"十"转换成"一十"
else {
dataMap.put("十", 1l);
}
tempNum = 0;
}
}
} // output
System.out.println();
long sum = 0;
java.util.Set<String> keys = dataMap.keySet();
for (String key : keys) {
Integer unitValue = unitMap.get(key);
Long dataValue = dataMap.get(key);
sum += unitValue * dataValue;
}
System.out.println(sum);
}一
1
十
10
一十五
15
十五
15
二十
20
二十三
23
一百
100
一百零一
101
一百一十
110
一百一十一
111
一千
1000
一千零一
1001
一千零三十一
1031
一万零一
10001
一万零二十一
10021
一万零三百二十一
10321
一万一千三百二十一
11321
三千零十五万
30150000
三千零一十五亿
301500000000
三千五百六十八万零一百零一
35680101
五十亿三千零七十五万零六百二十二
5030750622
十三亿三千零十五万零三百一十二
1330150312
三千零七十八亿三千零十五万零三百一十二
307830150312
一千二百五十八亿
125800000000
二十一亿三千万
2130000000
一亿三千万
130000000
一亿零三千万
130000000
一千二百五十八万亿零三千三百二十一
1258000000003321