【字符串处理专题】待做Leetcode.273

字符串处理专题

• Leetcode.273整数转换英文表示

to_string
sort(str.begin(),str.end()); [,)
s.erase(s.begin()+k,s.end()); [,)
s.find('@') 返回int
atoi(s1.substr(i,x-i).c_str()); str.substr(pos,len)

Leetcode.38外观数列 (还行)
Leetcode.49字母异位词分组 (思路巧妙)
Leetcode.151颠倒字符串中的单词 (处理空格是难点)
Leetcode.165比较版本号 (主要是string2int)
Leetcode.929独特的电子邮件地址
Leetcode.5最长回文子串 (y总写的代码是真的优美)
Leetcode.6Z 字形变换 (y总写的代码是真的优美)
Leetcode.3无重复字符的最长子串
Leetcode.208实现 Trie (前缀树) (值得一做！)
Leetcode.273整数转换英文表示（微软面试题…看都不想看）

一、Leetcode.38外观数列

给定一个正整数 n ，输出外观数列的第 n 项。

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。

你可以将其视作是由递归公式定义的数字字符串序列：

countAndSay(1) = “1”
countAndSay(n) 是对 countAndSay(n-1) 的描述，然后转换成另一个数字字符串。

  string countAndSay(int n) {
        string ans="1";
        for(int i=1;i<n;i++){
            string str;
            for(int k=0;k<ans.size();k++){
                int j=k+1;
                while(ans[j]==ans[k])j++;
                str+=to_string(j-k)+ans[k];
                k=j-1;
            }
            ans=str;
        }
        return ans;
    }

二、Leetcode.49字母异位词分组

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

  vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,vector<string>>mp;
        for(int i=0;i<strs.size();i++){
            string str=strs[i];
            string temp=str;
            sort(str.begin(),str.end());
            mp[str].push_back(temp);
        }
        vector<vector<string>>ans;
        for(auto item:mp){
            ans.push_back(item.second);
        }
        return ans;
    }

三、Leetcode.151颠倒字符串中的单词

给你一个字符串 s ，颠倒字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

  string reverseWords(string s) {
        int k=0;
        for(int i=0;i<s.size();i++){
            while(i<s.size()&&s[i]==' ')i++;
            if(i==s.size())break;
            int j=i;
            while(j<s.size()&&s[j]!=' ')j++;
            reverse(s.begin()+i,s.begin()+j);
            if(k)s[k++]=' ';
            while(i<j)s[k++]=s[i++];
        }
        s.erase(s.begin()+k,s.end());
        reverse(s.begin(),s.end());
        return s;
    }

四、Leetcode.165比较版本号

给你两个版本号 version1 和 version2 ，请你比较它们。

版本号由一个或多个修订号组成，各修订号由一个 ‘.’ 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。

比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。例如，版本 1.0 小于版本 1.1 ，因为它们下标为 0 的修订号相同，而下标为 1 的修订号分别为 0 和 1 ，0 < 1 。

  int compareVersion(string s1, string s2) {
        int i=0;int j=0;
        while(i<s1.size()||j<s2.size()){
            int x=i,y=j;
            while(x<s1.size()&&s1[x]!='.')x++;
            while(y<s2.size()&&s2[y]!='.')y++;
            int a=x==i?0:atoi(s1.substr(i,x-i).c_str());
            int b=y==j?0:atoi(s2.substr(j,y-j).c_str());
            if(a<b)return -1;
            else if(a>b)return 1;
            i=x+1;
            j=y+1;
        }
        return 0;
    }

五、Leetcode.929独特的电子邮件地址

每个 有效电子邮件地址 都由一个 本地名 和一个 域名 组成，以 ‘@’ 符号分隔。除小写字母之外，电子邮件地址还可以含有一个或多个 ‘.’ 或 ‘+’ 。

例如，在 alice@leetcode.com中， alice 是 本地名 ，而 leetcode.com 是 域名 。
如果在电子邮件地址的 本地名 部分中的某些字符之间添加句点（‘.’），则发往那里的邮件将会转发到本地名中没有点的同一地址。请注意，此规则 不适用于域名 。

例如，"alice.z@leetcode.com” 和 “alicez@leetcode.com” 会转发到同一电子邮件地址。
如果在 本地名 中添加加号（‘+’），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件。同样，此规则 不适用于域名 。

例如 m.y+name@email.com 将转发到 my@email.com。
可以同时使用这两个规则。

给你一个字符串数组 emails，我们会向每个 emails[i] 发送一封电子邮件。返回实际收到邮件的不同地址数目。

  unordered_set<string>hash;
    int numUniqueEmails(vector<string>& emails) {
        for(auto email:emails){
            int pos=email.find('@');
            string name;
            for(int i=0;i<pos;i++){
                if(email[i]=='.')continue;
                else if(email[i]=='+')break;
                else name+=email[i];
            }
            hash.insert(name+'@'+email.substr(pos+1));
        }
        return hash.size();
    }

六、Leetcode.5最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

  string longestPalindrome(string s) {
        string ans="";
        for(int i=0;i<s.size();i++){
            for(int j=i,k=i;j>=0&&k<s.size()&&s[j]==s[k];j--,k++){
                if(ans.size()<k-j+1){
                    ans=s.substr(j,k-j+1);
                }
            }
            for(int j=i,k=i+1;j>=0&&k<s.size()&&s[j]==s[k];j--,k++){
                if(ans.size()<k-j+1){
                    ans=s.substr(j,k-j+1);
                }
            }
        }
        return ans;
    }

七、Leetcode.6Z 字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

  string convert(string s, int numRows) {
        if(numRows==1)return s;
        string ans;
        for(int i=0;i<numRows;i++){
            if(i==0||i==numRows-1){
                for(int j=i;j<s.size();j+=2*(numRows-1))ans+=s[j];
            }
            else{
                for(int j=i,k=2*(numRows-1)-i;j<s.size()||k<s.size();j+=2*(numRows-1),k+=2*(numRows-1)){
                    if(j<s.size())ans+=s[j];
                    if(k<s.size())ans+=s[k];
                }
            }
        }
        return ans;
    }

八、Leetcode.3无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

      int lengthOfLongestSubstring(string s) {
        int j=0;
        int ans=0;
        unordered_map<char,int>hash;
        for(int i=0;i<s.size();i++){
            hash[s[i]]++;
            while(hash[s[i]]>1){
                hash[s[j++]]--;
            }
            ans=max(ans,i-j+1);
        }
        return ans;
    }

九、Leetcode.208实现 Trie (前缀树)

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。

请你实现 Trie 类：

Trie() 初始化前缀树对象。
void insert(String word) 向前缀树中插入字符串 word 。
boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

  struct Node{
        bool is_end;
        Node* son[26];
        Node(){
            is_end=false;
            for(int i=0;i<26;i++)son[i]=NULL;
        }
    }*root;
    Trie() {
        root=new Node();
    }
    
    void insert(string word) {
        auto p=root;
        for(int i=0;i<word.size();i++){
            int u=word[i]-'a';
            if(p->son[u]==NULL)p->son[u]=new Node();
            p=p->son[word[i]-'a'];
        }
        p->is_end=true;
    }
    
    bool search(string word) {
        auto p=root;
        for(int i=0;i<word.size();i++){
            if(p->son[word[i]-'a']==NULL)return false;
            p=p->son[word[i]-'a'];
        }
        return p->is_end;
    }
    
    bool startsWith(string prefix) {
        auto p=root;
        for(int i=0;i<prefix.size();i++){
            if(p->son[prefix[i]-'a']==NULL)return false;
            p=p->son[prefix[i]-'a'];
        }
        return true;
    }

十、Leetcode.273整数转换英文表示

将非负整数 num 转换为其对应的英文表示。

  string small[20]={"Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
    "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
    string decade[10]={"", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
    string big[4]={"Billion", "Million", "Thousand", ""};
    string numberToWords(int num) {
        if(num==0)return small[0];
        string res;
        for(int i=1000000000,j=0;i>0;i/=1000,j++){
            if(num>=i){
                res+=getPart(num/i)+big[j]+' ';
                num%=i;
            }
        }
        while(res.back()==' ')res.pop_back();
        return res;
    }
    string getPart(int num){
        string res;
        if(num>=100){
            res+=small[num/100]+" Hundred ";
            num%=100;
        }
        if(num==0)return res;
        if(num>=20){
            res+=decade[num/10]+" ";
            num%=10;
        }
        if(num==0)return res;
        res+=small[num]+' ';
        return res;
    }