LeetCode(五)字符串处理专题

LeetCode 38. Count and Say

报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下：

1.     1
2.     11
3.     21
4.     1211
5.     111221

1 被读作 “one 1” (“一个一”) , 即 11。
11 被读作 “two 1s” (“两个一”）, 即 21。
21 被读作 “one 2”, “one 1” （“一个二” , “一个一”) , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。

注意：整数顺序将表示为一个字符串。

示例 1:

输入: 1
输出: “1”

示例 2:

输入: 4
输出: “1211”

class Solution {
   
public:
    string countAndSay(int n) {
   
        string s = "1";
        for(int i = 1; i < n; i++)
        {
   
            string ns = "";//当前字符串
            for(int j = 0; j < s.size();)
            {
   
                int u = j;
                while(u < s.size() && s[u] == s[j]) u ++;
                ns += to_string(u - j);//j是起始 u是重复的下标
                ns += s[j];
                j = u;//进行下一次操作
            }
            s = ns;
        }
        return s;        
    }
};

LeetCode 49. Group Anagrams

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

说明：
所有输入均为小写字母。
不考虑答案输出的顺序。

class Solution {
   
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
   
        unordered_map<string, vector<string>> hash;//把字符串映射到一个字符串集合
        for(auto s : strs)
        {
   
            string rs = s;
            sort(s.begin(), s.end());
            hash[s].push_back(rs);//把所有字符串归类 统计相同个数
        }
        
        vector<vector<string>> res;
        for(auto &group : hash)
        {
   
            res.push_back(group.second); //group.second是hash的第二维字符串集合
        }
        return res;
    }
};

LeetCode 151. Reverse Words in a String

给定一个字符串，逐个翻转字符串中的每个单词。

示例 1：

输入: “the sky is blue”
输出: “blue is sky the”

示例 2：

输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：
无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

class Solution {
   
public:
    /*
    分两步操作：
    1.将字符串中的每个单词逆序，样例输入变为: "eht yks si eulb"；
    2.将整个字符串逆序，样例输入变为："blue is sky the"；
    */
    string reverseWords(string s) {
   
        int i = 0,k = 0;
        s += " ";
        while(k < s.size() && s[k] == ' ') k++;//过滤开头的空格
        while(k < s.size())
        {
   
            if(s[k] != ' ')
                s[i++] = s[k++];
            else //过滤单词间的空格
            {
   
                s[i++] = ' ';//给一个空格
                while(k < s.size() && s[k] == ' ') k ++;//过滤                
            }
        }
        if(!i) 
        {
   
            s = "";            
            return s;
        }
        s.erase(s.begin() + i - 1, s.end()); //去掉结尾空格(因为)
        for(int i = 0; i <s.size(); i++)
        {
   
            int j = i;
            while(j < s.size() && s[j] != ' ') j ++;
            reverse(s.begin() + i, s.begin() + j);//翻转每个单词
            i = j; //操作下一个单词
        }
        reverse(s.begin(), s.end());        
        return s;
    }
};

LeetCode 165. Compare Version Numbers

比较两个版本号 version1 和 version2。
如果 version1 > version2 返回 1，如果 version1 < version2 返回 -1， 除此之外返回 0。

你可以假设版本字符串非空，并且只包含数字和 . 字符。

. 字符不代表小数点，而是用于分隔数字序列。

例如，2.5 不是“两个半”，也不是“差一半到三”，而是第二版中的第五个小版本。

你可以假设版本号的每一级的默认修订版号为 0。例如，版本号 3.4 的第一级（大版本）和第二级（小版本）修订号分别为 3 和 4。其第三级和第四级修订号均为 0。

示例 1:

输入: version1 = “0.1”, version2 = “1.1”
输出: -1

示例 2:

输入: version1 = “1.0.1”, version2 = “1”
输出: 1

示例 3:

输入: version1 = “7.5.2.4”, version2 = “7.5.3”
输出: -1

示例 4：

输入：version1 = “1.01”, version2 = “1.001”
输出：0
解释：忽略前导零，“01” 和 “001” 表示相同的数字 “1”。

示例 5：

输入：version1 = “1.0”, version2 = “1.0.0”
输出：0
解释：version1 没有第三级修订号，这意味着它的第三级修订号默认为 “0”。

提示：
版本字符串由以点 （.） 分隔的数字字符串组成。这个数字字符串可能有前导零。
版本字符串不以点开始或结束，并且其中不会有两个连续的点。

class Solution {
   
public:
    
    vector<int> get_num(string version)
    {
   
        vector<int> res;
        for(int i = 0; i < version.size(); i++)
        {
   
            int j = i, s= 0;
            while(j < version.size() && version[j] != '.')
            {
   
                s = s * 10 + version[j] - '0';
                j ++;
            }
            i = j;//操作下一个 .
            res.push_back(s);
        }
        while(res.size() && res.back() == 0) res.pop_back();//去除末尾无效 1.0 和 1
        return res;
    }
    
    int compareVersion(string version1, string version2) {
   
        auto n1 = get_num(version1);
        auto n2 =