LeetCode 423. Reconstruct Original Digits from English解题笔记

1. 题目描述

https://leetcode.com/problems/reconstruct-original-digits-from-english/#/description

Given a non-empty string containing an out-of-order English representation of digits 0-9, output the digits in ascending order.

Note:
Input contains only lowercase English letters.
Input is guaranteed to be valid and can be transformed to its original digits. That means invalid inputs such as “abc” or “zerone” are not permitted.
Input length is less than 50,000.
Example 1:
Input: “owoztneoer”

Output: “012”
Example 2:
Input: “fviefuro”

Output: “45”
Subscribe to see which companies asked this question.

2. 基本思路

本质上这道题目是把出现的几个数字通过英文表示，然后打乱顺序，之后再让我们找出这些原始的数据。本质上就是找规律的过程

通过图示的关键字母，通过三轮我们一定可以找出各个数字的出现次数

3. 实现代码

struct DATA{
    string alphaNum_;
    int num_;

    DATA(){}
    DATA(string alphaNum, int num) :alphaNum_(alphaNum), num_(num){}
};

class Solution {
public:
    string originalDigits(string s) {
        vector<int> vecs(26, 0);
        for (auto item : s){
            vecs[item - 'a']++;
        }

        vector<int> nums(10, 0);
        vector<vector<char>> keyNums{ { 'z', 'w', 'u', 'x', 'g' },
            { 'o', 'r', 'f' }, { 's', 'i' }
        };
        for (size_t k = 0; k < keyNums.size(); k++){
            for (size_t i = 0; i < keyNums[k].size(); i++){
                while (vecs[keyNums[k][i] - 'a'] > 0){
                    for (size_t j = 0; j < keymap_[keyNums[k][i]].alphaNum_.size(); j++){
                        vecs[keymap_[keyNums[k][i]].alphaNum_[j] - 'a']--;
                    }
                    nums[keymap_[keyNums[k][i]].num_]++;
                }
            }
        }
        string res;
        for (size_t i = 0; i < nums.size(); i++)
            res += string(nums[i], i + '0');
        return res;
    }

protected:
    static map<char, DATA> keymap_;
};

map<char, DATA> Solution::keymap_{ 
    make_pair<char, DATA>('z', DATA(string("zero"), 0)),
    make_pair<char, DATA>('o', DATA(string("one"), 1)),
    make_pair<char, DATA>('w', DATA(string("two"), 2)),
    make_pair<char, DATA>('r', DATA(string("three"), 3)),
    make_pair<char, DATA>('u', DATA(string("four"), 4)),
    make_pair<char, DATA>('f', DATA(string("five"), 5)),
    make_pair<char, DATA>('x', DATA(string("six"), 6)),
    make_pair<char, DATA>('s', DATA(string("seven"), 7)),
    make_pair<char, DATA>('g', DATA(string("eight"), 8)),
    make_pair<char, DATA>('i', DATA(string("nine"), 9))
};

运行效果：

4. 示例代码

https://discuss.leetcode.com/topic/63386/one-pass-o-n-java-solution-simple-and-clear

public String originalDigits(String s) {
    int[] count = new int[10];
    for (int i = 0; i < s.length(); i++){
        char c = s.charAt(i);
        if (c == 'z') count[0]++;
        if (c == 'w') count[2]++;
        if (c == 'x') count[6]++;
        if (c == 's') count[7]++; //7-6
        if (c == 'g') count[8]++;
        if (c == 'u') count[4]++; 
        if (c == 'f') count[5]++; //5-4
        if (c == 'h') count[3]++; //3-8
        if (c == 'i') count[9]++; //9-8-5-6
        if (c == 'o') count[1]++; //1-0-2-4
    }
    count[7] -= count[6];
    count[5] -= count[4];
    count[3] -= count[8];
    count[9] = count[9] - count[8] - count[5] - count[6];
    count[1] = count[1] - count[0] - count[2] - count[4];
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i <= 9; i++){
        for (int j = 0; j < count[i]; j++){
            sb.append(i);
        }
    }
    return sb.toString();
}

思想是类似的，都是去寻找关键字符特征。但是这种方法的好处是，不需要定义太复杂的数据结构，求解简单明了
这个算法相比于我们算法，省略了对数组的运算操作因而效率更高