记录一道微软面试题

0xac001d09

于 2020-08-05 21:06:53 发布

阅读量367

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/weixin_44424668/article/details/107824833

版权

算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

花了十分钟写一下，其实很简单
在这里插入图片描述

说一下具体的思路

中文权位和节权位

一般而言，中文数字都是数字加权位的，比如三十，四百，前者是数字，后者是权位，常见的中文权位有“十”、“百”、“千”、“万”、“亿”等等，除了这些还有兆、京。

中文的节权位很重要，暂且叫做 $s e c t i o n$ ，中文计数是以万为小节的，万以下就没有节权位了，万以上的节权位还有亿（万万为亿）、兆（亿亿为兆）、京（兆兆为京）等。有了节权位，每个小节内都是独立计数，再最后乘上节权位，但是小节内部，“十百千”就不能同时出现，所以两个权位如果是非节权位，就不能连用，比如“二十百”、“二千千”，这就不太合法（尽管欧美计数是以千为小节）。但是和节权位能连用，比如“二十万”、“二万亿”等。

实现起来还是非常简单的，代码如下

Chinese2Number

import java.io.*;
import java.util.*;

public class Test {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            fill();
            String s = in.next();
            boolean ok = false;
            int n = s.length();
            Deque<Long> deque = new LinkedList<>();
            for (int i = 0; i < n; i++) {
                char c = s.charAt(i);
                // 如果是数字
                if (numberMap.containsKey(c)) {
                    deque.offer(Long.valueOf(numberMap.get(c)));
                } else if (map.containsKey(c)) {
                	// 如果是权位，需要判断是否为节权位
                	// 其实这里还需要check是否为连续的两个非节权位，我懒
                    ok = true;
                    Node node = map.get(c);
                    if (!node.isSec) {
                        Long val = deque.pollLast();
                        deque.addLast(val * node.val);
                    } else {
                    	// 如果是节权位，统计小节的值再乘上权重后放入queue
                        long tmp = 0;
                        while (!deque.isEmpty()) {
                            tmp += deque.pollFirst();
                        }
                        deque.addLast(tmp * node.val);
                    }
                } else {
                	// 碰到其他中文
                    throw new RuntimeException("invalid input, plz check");
                }
            }
            long ans = 0;
	        if (ok) {
	            while (!deque.isEmpty()) {
	                ans += deque.pollLast();
	            }
	        } else {
	            // 如果没有出现权位,比如二零一二
	            // 一种情况是不包括 廿卅，另一种情况是包括
	            // 对于 廿、卅这种，就需要乘p后除以10
	            int p = 1;
	            while (!deque.isEmpty()) {
	                Long tmp = deque.pollLast();
	                if (tmp == 20 || tmp == 30) {
	                    ans += p * tmp / 10;
	                } else {
	                    ans += p * tmp;
	                }
	                p *= 10;
	            }
	        }
            out.println(ans);
        }

        private static final Map<Character, Node> map = new HashMap<>();

        private static final Map<Character, Integer> numberMap = new HashMap<>();

        private static void fill() {
            map.put('十', new Node(10, false));
            map.put('百', new Node(100, false));
            map.put('千', new Node(1000, false));
            map.put('万', new Node(10000, true));
            map.put('亿', new Node(10000000, true));
            numberMap.put('零', 0);
            numberMap.put('一', 1);
            numberMap.put('二', 2);
            numberMap.put('三', 3);
            numberMap.put('四', 4);
            numberMap.put('五', 5);
            numberMap.put('六', 6);
            numberMap.put('七', 7);
            numberMap.put('八', 8);
            numberMap.put('九', 9);
            numberMap.put('廿', 20);
            numberMap.put('卅', 30);
        }

        static class Node{
            int val;    // 10 的倍数
            boolean isSec;

            public Node(int val, boolean isSec) {
                this.val = val;
                this.isSec = isSec;
            }
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
    }
}

Number2Chinese

中文数字对零的使用规则
    1. 以万为小节，小节末尾即使是0，也不使用零，比如 10000 -> 一万
    2. 小节内两个非零数字要加0
    3. 当小节的千位是零的时候，只要不是首小节，都要补零, 比如12000 -> 一万二千, 1200032000

    从阿拉伯数字到中文数字的转换
    1. 以万位单位分节，并确定节权位
    2. 对每个小节内的数字确定权位
    3. 根据上面处理零的规则进行处理

    比如 200001010200，首先以万位单位分节，就是 2000 0101 0200
    第一节2000，节权位是亿，因为这一节的末尾是0，所以根据规则1，在这里不使用零，直接表示位二千亿
    第二节0101，节权位是万，因为两个1之间有0，根据规则2，101表示为一百零一，并且由于此节的千位是0，根据规则，因为这个是第二个小节，所以还需加个零

核心代码

public class Test {
    private static String[] number = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
    private static String[] unit = {"", "十", "百", "千"};          // 权位
    private static String[] section = {"", "万", "亿", "万亿"}; // 节权位

    public static String number2Chinese(long num) {
        StringBuilder sb = new StringBuilder();
        boolean needZero = false;   // 是否需要补0
        int pos = 0;           //节权位的位置
        // 特判
        if (num == 0) {
            return number[0];
        }
        if (num > 9 && num < 20) {
            long section = num % 10;
            if (section == 0) {
                return "十";
            }
            return "十" + number[(int) section];
        }
        while (num > 0) {
            long sec = num % 10000;
            if (needZero) {
                sb.insert(0, number[0]);
            }
            String chnSection = section2Chinese(sec);
            // 判断是否需要节权位，如果是一万的倍数，则不需要添加
            chnSection += (sec != 0) ? section[pos] : section[0];
            sb.insert(0, chnSection);
            // 判断section中的千位上是不是为零，若为零应该添加一个零。
            needZero = (sec < 1000 && sec > 0);
            pos++;
            num /= 10000;
        }
        return sb.toString();
    }

    private static String section2Chinese(long section) {
        StringBuilder sb = new StringBuilder();
        // 单位位置
        int unitPos = 0;
        // 确保连续多个，只补一个中文0
        boolean zero = true;

        while (section > 0) {
            long val = (section % 10);
            if (val == 0) {
                if (!zero) {
                    // 需要补0，zero的作用是确保对连续的多个0，只补一个中文零
                    zero = true;
                    sb.insert(0, number[(int) val]);
                }
            } else {
                // 只要碰到不是0的就就刷新zero
                zero = false;
                //获取数字，再获取权位，组合在一起插入到最前面
                StringBuilder str = new StringBuilder(number[(int) val]);
                str.append(unit[unitPos]);
                sb.insert(0, str);
            }
            unitPos++; //移位
            section /= 10;
        }
        return sb.toString();
    }
}