`

脑残系列之二：汉字转换数字

面试算法数据结构J#Google 
阅读更多
这是google的一道面试题.

将汉字转换成数字, 如下
一          1
十          10
十一        11
二十        20
二十一      21
一百        100
一百零一    101
一百一十    110
一百一十一  111

当然算法要能将所有的汉字数字转换成阿拉伯数字,同时兼顾性能.

路过的大家不妨试试看... ...

转自：http://topic.csdn.net/u/20081120/17/c66e30f9-ac70-4f8b-b046-eb5fcd8d2d61.html?seed=1739753267

javaeyer有更好的方法吗？ 

        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> queue = 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) == '万'))) {
                    queue.add(tempNum);
                }
            }
            //单位
            else if (unitMap.containsKey(bit + "")) {

                //遇到十 转换为一十、临时变量进队列
                if (bit == '十') {
                    if (tempNum != 0) {
                        tempNum = tempNum * unitMap.get(bit + "");
                    } else {
                        tempNum = 1 * unitMap.get(bit + "");
                    }
                    queue.add(tempNum);
                    tempNum = 0;
                }

                //遇到千、百 临时变量进队列
                if (bit == '千' | bit == '百') {
                    if (tempNum != 0) {
                        tempNum = tempNum * unitMap.get(bit + "");
                    }
                    queue.add(tempNum);
                    tempNum = 0;
                }

                //遇到亿、万 队列中各元素依次累加*单位值、清空队列、新结果值进队列
                if (bit == '亿' | bit == '万') {
                    long tempSum = 0;
                    if (queue.size() != 0) {
                        for (int j = 0; j < queue.size(); j++) {
                            tempSum += queue.get(j);
                        }
                    } else {
                        tempSum = 1;
                    }
                    tempNum = tempSum * unitMap.get(bit + "");
                    queue.clear();//清空队列
                    queue.add(tempNum);//新结果值进队列
                    tempNum = 0;
                }
            }
        }

        //output
        System.out.println();
        long sum = 0;
        for (Long i : queue) {
            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


上面的代码有bug，“一亿三千万”等汉字转换时结果不正确。

更换数据结构和算法如下： 

		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> multiNumList = 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) {
					multiNumList.add(tempNum);
				}
				// 处理"亿"之前的多位数
				long sum = 0;
				for (Long num : multiNumList) {
					sum += num;
				}
				multiNumList.clear();
				dataMap.put("亿", sum);
				tempNum = 0;
			} else if (bit == '万') {
				// 最后一位数进list等待处理
				if (tempNum != 0) {
					multiNumList.add(tempNum);
				}
				// 处理"万"之前的多位数
				long sum = 0;
				for (Long num : multiNumList) {
					sum += num;
				}
				multiNumList.clear();
				dataMap.put("万", sum);
				tempNum = 0;
			} else if (bit == '千' && tempNum > 0) {
				// 存在"亿"或"万"情况，临时变量值*"千"单位值进list等待处理
				if (isExist) {
					multiNumList.add(tempNum * unitMap.get(bit + ""));
					tempNum = 0;
				}
				// 不存在"亿"或"万"情况，临时变量值put到map
				else {
					dataMap.put("千", tempNum);
					tempNum = 0;
				}
			} else if (bit == '百' && tempNum > 0) {
				// 存在"亿"或"万"情况，临时变量值*"百"单位值进list等待处理
				if (isExist) {
					multiNumList.add(tempNum * unitMap.get(bit + ""));
					tempNum = 0;
				}
				// 不存在"亿"或"万"情况，临时变量值put到map
				else {
					dataMap.put("百", tempNum);
					tempNum = 0;
				}
			} else if (bit == '十') {
				// 存在"亿"或"万"情况，临时变量值*"十"单位值进list等待处理
				if (isExist) {
					if (tempNum != 0) {
						multiNumList.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
分享到：
| 脑残系列之一：使用一个循环先输出奇数然后 ...
评论
4 楼 cloverprince 2011-08-20  
记得小学学过，“按级读，数的中间有多少0都只读一个‘零’，每级末尾的0都不读。”
3 楼 javaboy2006 2008-11-24  
jasongreen 写道
stringToken 按优先级拆解 亿、万、千、百、十 是不是更好些

亿和万会存在多位情况，比如：三千五百零一万。拆分可能不是最佳方案。

bonny 写道
靠。没事干了

素质，素质，注意你的素质。
2 楼 bonny 2008-11-24  
靠。没事干了
1 楼 jasongreen 2008-11-24  
stringToken 按优先级拆解 亿、万、千、百、十 是不是更好些
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    繁体字转换器.rar

    繁体字转换器-即时转换版 是一款非常专业、实用、方便的繁体字转换器,可以快速方便地进行繁简&简繁转换,并且具有脑残体转换功能,十分适合脑残人士使用^_^ 有别于传统软件,本软件具有实时自动转换功能,可以直接打出...

    火星文转换器.zip

    火星文，又称脑残体，是一种在网络文化中流行的语言表达方式，它利用各种特殊字符、符号、繁体字以及错别字来替代普通汉字，以此达到一种独特且趣味性的交流效果。这种语言形式在21世纪初期的互联网上特别流行，尤其...

    测你是脑残2

    测测你的脑残指数 规则： 记忆：按顺序点出上派所出现的图片 计算:点出上式答案 辩色：上面方框中字体是什么颜色，就点下面6个当中代表这个颜色的意思的文字的方框 逻辑：根据上面一个或多个天平，选出质量最大的一...

    联想台式机脑残键解决方案.rar

    在IT领域，用户可能会遇到各种硬件或软件问题，其中之一就是"脑残键"现象，尤其在某些特定品牌如联想的台式机上较为常见。"脑残键"并不是正式的技术术语，而是用户对某些功能键意外触发导致电脑异常行为的通俗称呼。...

    Android中的脑残设计总结

    以下是对这些"脑残设计"的详细分析： 1. 轨迹球(Trackball)： 轨迹球类似于PC上的鼠标，原本设计用于导航，特别是在非触控屏幕或带有物理键盘的设备上。然而，随着全触控屏幕的普及，轨迹球变得多余且难以精确控制...

    brainfuck-step:一步一步的脑残翻译

    脑筋急转弯 调试器的基本Brainfuck解释器。 与评估整个代码并返回输出的其他解释器不同， brainfuck-step为每条指令发出一个事件。...类型：数字 默认值：30000 var brainfuckstep = require ( 'brainfuck-step'

    去掉win2012屏幕右侧脑残的悬浮开始菜单

    去掉win2012屏幕右侧脑残的悬浮开始菜单 https://blog.csdn.net/net_wolf/article/details/104070562

    疯人院 v1.0.4

    软件语言：中文 软件类别：笑话 软件大小：9.57 MB 适用固件：2.3.3及更高固件 内置广告：没有广告 适用平台：Android 《疯人院》是一款提供疯狂搞笑内容的手机应用。同时还有脑残对话制作器，让疯友们可以拍下...

    ibrainfuck:IPythonJupyter 的脑残内核

    这是在 IPython 的所有其他前端功能之上的，例如 Markdown 渲染、HTML 渲染、保存笔记本以供以后使用，甚至能够在查看 IBrainfuck 笔记本要求： $PATH Python 3.4 安装了virtualenv第一次安装$ make bf-deps 一旦 ...

    Firebug中文 web_develope中 火狐2.0.0.14.rar

    让Firebug中文版和web_developer中文版配Firefox2.0.0.14这一组绝配为你服务为你解忧。下面教你一些最白菜的东东： 首先：必须安装Firefox2.0.0.14浏览器……555太白菜了，再将你硬盘上叫firebugcn.xpi和web_...

    iNodeSetup3.60-6208破解补丁

    使用方法（考虑到不经常折腾电脑的同学我就写的脑残点儿。另：建议先关闭杀毒软件，特别是360！不解释）： 1：交客户端完全关闭退出（在任务栏上右键客户端图标——&gt;退出）。 2：Ctrl+Alt+Del 打开任务管理器，在...

    自己以前写的脑残程序——英雄之死.exe

    忘了什么功能了，但是务必保存电脑数据以后再启动。 当时好像是为了熟悉VS，写的恶趣味程序哈哈哈哈~

    初中语文文摘社会你配不配做脑残粉

    本文主要探讨了现代社会中“脑残粉”这一现象，特别提到了追星文化与经济条件的关系。文章通过对比过去的追星行为与现在，揭示了随着社会经济发展，追星已经成为一种高消费的行为。 1. **追星文化的演变**：文章...

    Trials-and-Tribulations-Series:试炼与磨难系列将是简单、有趣或令人沮丧的编程挑战，通常有模糊的标准（比如脑残）

    "试炼与磨难系列"是一组编程挑战，旨在测试和提升程序员的技能，这些挑战可能涵盖各种难度级别，从简单到复杂，甚至有时会带有某种荒谬性或令人困惑的元素，就像“脑残”这样的标签所暗示的那样。这个系列的核心在于...

    snaps:snaps 是适用于脑残人士的 AWS 快照

    按扣snaps 是适用于脑残人士的 Amazon WebServices EC2 快照。先决条件Shellaccess 到 Amazon Linux/FreeBSD/...-instance Python 2.6+ 点子博托安装 pip install git+...

    脑残儿--非主流--鄙视--很鄙视

    非主流--脑残儿--非主流--鄙视--很鄙视

    大树系列课程之一——初识投资之路.pptx

    【初识投资之路】——大树系列课程 在投资领域，初学者往往面临众多困惑和挑战。大树系列课程之一——“初识投资之路”旨在引导新手投资者理解投资的基本概念，掌握必要的投资策略，以及如何逐步成长成为一名成熟的...

    [22233]【yii系列点位盘】最新更新yii框架美金版外汇股指手动结算点位盘+非时间盘+风控系统完善+完整数据.zip

    最新更新yii框架美港版外汇股指手动结算点位盘非时间盘+完善风控系统+完整数据 今天给你们来一波yii系列的点位盘吧，都是珍藏好久了，都给你们吧， 本来是打算卖钱的，毕竟点位yii系列，随便站着卖的东西。...

    Node.js-史上最“脑残”的“抢火车票”程序node.js版

    在这个名为"Node.js-史上最“脑残”的“抢火车票”程序node.js版"的项目中，我们可以看到一个利用Node.js实现的简单抢票程序，它可能是对网络请求、异步编程以及并发处理的一种巧妙应用。 在描述中提到的"史上最...

Magicbox
Global site tag (gtag.js) - Google Analytics