华为机试—字符串处理专题

最新推荐文章于 2024-03-22 18:02:10 发布
最新推荐文章于 2024-03-22 18:02:10 发布
阅读量1.5k 收藏 8
点赞数 2
分类专栏： 字符串处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryontang/article/details/108144950
版权

文章目录

(leetbook)字符串-125.验证回文串

在这里插入图片描述
主要思想：
1.先把字母和数字用string存储，字母同意用小写字母存储
2.双指针判断直到指针相遇

bool isPalindrome(string s) {
        // 双指针
        // #include <ctype.h>
        // 记一笔 c++的几个内置函数

        //islower(char c) 是否为小写字母
        //isupper(char c) 是否为大写字母
        //isdigit(char c) 是否为数字
        //isalpha(char c) 是否为字母
        //isalnum(char c) 是否为字母或者数字
        //toupper(char c) 字母小转大
        //tolower(char c) 字母大转小

        string tmp;
        for(auto c:s){
            if(islower(c) || isdigit(c)) tmp+=c;
            else if(isupper(c)) tmp+=(c+32); // 全转小写

        }

        // 开始双指针
        int i=0, j=tmp.size()-1;
        while(i<j){
            if(tmp[i]!=tmp[j]) return false;
            i++;
            j--;
        }
        return true;

    }
5. 最长回文子串

在这里插入图片描述
主要思路：

  1. 中心扩展法
  2. 偶数个字符中心就在两个数的中间， 奇数个字符中心就在正中间
  3. 枚举中心的位置从0～size()-2, int i=0;i<=size()-2;i++
    因为我们检查是否是回文串的函数是：在i=size()-1时没法验证expandAroundCenter(s,i,i+1)

暴力法采用双指针两边夹，验证是否是回文子串。

除了枚举字符串的左右边界以外，比较容易想到的是枚举可能出现的回文子串的“中心位置”，从“中心位置”尝试尽可能扩散出去，得到一个回文串。

因此中心扩散法的思路是：遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。

枚举“中心位置”时间复杂度为 O(N)，从“中心位置”扩散得到“回文子串”的时间复杂度为 O(N)，因此时间复杂度可以降到 O(N^2)

// 序列数是奇数s[i] 与 s[i]相等也不影响
      string evenStr = expandAroundCenter(s, i,i);
      // 序列数是偶数
      string oddStr = expandAroundCenter(s,i,i+1);

整体代码如下：

class Solution{
public:
  // 从中心扩展检验是否回文
  string expandAroundCenter(const string& s, int left, int right){
    while(left>=0&&right<s.size()&&s[left]==s[right]){
      --left;
      ++right;
    }
    // 这里要小心，跳出 while 循环时，恰好满足 s.charAt(i) != s.charAt(j)，因此不能取 i，不能取 j
    return s.substr(left+1, right-left-1);
  }

  string longestPalindrome(string s){
     // 特判
    int size = s.size();
    if (size < 2) {
        return s;
    }

    int maxLen = 1;
    string res = s.substr(0, 1);

    // 中心位置枚举到len-2即可
    // 从头开始枚举中心位置 从i=0
    for(int i=0;i<s.size()-1;i++){
      // 序列数是奇数s[i] 与 s[i]相等也不影响
      string evenStr = expandAroundCenter(s, i,i);
      // 序列数是偶数
      string oddStr = expandAroundCenter(s,i,i+1);
      string maxLenStr= oddStr.size()>evenStr.size()?oddStr:evenStr;
      if(maxLenStr.length()>maxLen){
        maxLen=maxLenStr.size();
        res=maxLenStr;
      }
    }
    return res;
  }
};
131.分割回文串(见回溯)
HJ1计算字符串最后一个单词的长度，单词以空格隔开

在这里插入图片描述
主要考察：
gets的输入

gets(): gets()函数用来从标准输入设备（键盘）读取字符串直到换行符结束，但换行符会被丢弃，然后在末尾添加’\0’字符。其调用格式为：
gets(s);
其中s为字符串变量（字符串数组名或字符串指针）。
gets(s)函数与scanf("%s",s)相似，但不完全相同，使用scanf("%s",s) 函数输入字符串时存在一个问题，就是如果输入了空格会认为字符串结束，空格后的字符将作为下一个输入项处理，但gets()函数将接收输入的整个字符串直到遇到换行为止。
也就是说：gets()函数读取到\n（我们输入的回车）于是停止读取，但是它不会把\n包含到字符串里面去。然而，和它配合使用的puts函数，却在输出字符串的时候自动换行。

在这里插入图片描述

#include <iostream>
#include <string.h>

using namespace std;

int main(){
    char str[5001]; // 题目要求，长度小于5000
    // 输入字符串
    //cin >> str; // 错误遇到空格不读了
    // cin不接受空格和TAB等符号的输入，遇到这些键，字符串会终止，而gets()则接受连续的输入，包括空格，TAB
    // 计算最后一个单词的长度
    gets(str);
    //cout << str << endl;
    int len = 0;
    // Returns the length of the C string str(包括空格，但是不包括the terminating null character)
    for(int i = strlen(str)-1; str[i]!=' ' && i>=0; i--){
        len++;
    }
    cout << len << endl;
    
    return 0;
}
HJ2输出输入字符串中含有该字符的个数

在这里插入图片描述
本地考察两个：

  1. 读入输入字符串防止空格，用gets(str);
  2. 大小写Ascii码相差32
#include <iostream>

using namespace std;

const int N = 10010; // 定义数组长度防止溢出
char str[N];

int main(){
    // 输入字符串 只有数字和字母
    // cin>>str;
    gets(str); 
    
    char x;
    cin >> x;
    
    int count = 0;    // 保证遍历到字符串的末端
    for(int i = 0; str[i]!='\0'; i++){
        if(str[i]==x || str[i]==x+32 || str[i]==x-32) // 大小写
            count++;
    }
    cout << count << endl;
    return 0;
}
HJ4字符串分隔(连续输入多行字符串所以用getline(cin, str))

在这里插入图片描述

主要考察对库函数的调用：
getline(cin, inputLine);
其中 cin 是正在读取的输入流，而 inputLine 是接收输入字符串的 string 变量的名称
为了cin的问题(遇到空格不读取，此外前导空格也不读取)，可以使用一个叫做 getline 的 C++ 函数。此函数可读取整行，包括前导和嵌入的空格，并将其存储在字符串对象中
append()方法的应用

#include <iostream>

using namespace std;

int main(){
    string str;
    while(getline(cin, str)){
        
        // 循环 输出前八个 截取9~自最后的
        while(str.size() >8){
            cout << str.substr(0, 8) << endl; // 从0开始，读取8个长度
            str = str.substr(8); // 从str[8]开始截取后面的，因为第一次[0]~[7]已经cout
        }
        
        // 当长度小于8时，后面补0
        cout << str.append(8-str.size(), '0') << endl;
        
    }
    return 0;

}
HJ13句子逆序

在这里插入图片描述

主要思路:

  1. 整体翻转
  2. 再从头定位每一个单词，逐个翻转

在这里插入图片描述

#include <iostream>
#include <algorithm>

using namespace std;

int main(){
  string str;
  getline(cin, str);
  // 翻转句子所有字符
  reverse(str.begin(), str.end()); // end()是队尾元素
  // 翻转单个单词
  for(int i =0; i<str.size(); i++){
    int j = i;
    // 通过i，j定位单词首尾
    while(j<str.size() &&str[j]!=' ') j++; // 跳出循环时，j定位到相邻两个单词空格
    reverse(str.begin()+i, str.begin()+j);
    
    // 定位到下一个单词
    i=j;
  }
  cout << str << endl;
}
HJ14字符串字典序排列

在这里插入图片描述

主要思路：
利用自定义排序

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

// 自定义bool排序
bool cmp(const string& s1, const string& s2){
    return s1<s2;
}
int main(){
    int n;
    cin >> n; // 接受第一行一个正整数n
    vector<string> res;
    while(n--){
        string word;
        cin >> word; // 接收每行字符串/每次接收一行
        res.push_back(word);
    }
    sort(res.begin(), res.end(), cmp);
    for(auto x:res) cout << x << endl;
    
    return 0;
}
HJ21简单密码破解

在这里插入图片描述
主要思路：

  1. 就挨个字符去做转换，没什么技巧
  2. 在‘Z’有点特殊，‘Z’->‘a’
    大写字母的转换 str[i]+=32+1; // ASCII码
#include <iostream>
#include <string.h>

using namespace std;

int main(){
    // 处理输入
    string str;
    // 多个测试用例，所以用while来测试
    while(cin>>str){
        // 进行加密
        for(int i=0; i<str.size();i++){
            // 小写字母转换
            // 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,
            if(str[i]>='a' && str[i]<='c'){
                str[i]='2';
            }
            else if(str[i]>='d' && str[i]<='f'){
                str[i]='3';
            }
            else if(str[i]>='g' && str[i]<='i'){
                str[i]='4';
            }
            else if(str[i]>='j' && str[i]<='l'){
                str[i]='5';
            }
            else if(str[i]>='m' && str[i]<='o'){
                str[i]='6';
            }
            else if(str[i]>='p' && str[i]<='s'){
                str[i]='7';
            }
            else if(str[i]>='t' && str[i]<='v'){
                str[i]='8';
            }
            else if(str[i]>='w' && str[i]<='z'){
                str[i]='9';
            }
            
            if(str[i]=='Z')
                str[i]='a';
            else if(str[i]>='A' && str[i]<='Y'){
                str[i]+=32+1;
            }
        }
        cout << str <<endl;
        
    }
    return 0;
}
HJ23删除字符串中出现次数最少的字符

在这里插入图片描述
主要思路：

  1. 出现次数想到 hash
  2. 思路比较正确，先初始化hash，再在hash中找最小的minumum，然后这类字符不输出
#include <iostream>
#include <unordered_map> // 出现统计次数就想起hash
#include <algorithm>
#include <climits> // INT_MAX

using namespace std;

int main(){
    string str;
    //当 cin>> 从缓冲区中读取数据时，若缓冲区中第一个字符是空格、tab或换行这些分隔符时，
    //cin>> 会将其忽略并清除，继续读取下一个字符，若缓冲区为空，则继续等待
    
    while(cin>>str){ // 有很多组测试用例输入
        unordered_map<char, int> hash;
        int muninum = INT_MAX;
        for(int i =0; i<str.size(); i++){
            hash[str[i]]++; // 初始化
        }
        for(int i =0; i<str.size(); i++){
            muninum = min(hash[str[i]], muninum);
        }
        for(int i =0; i<str.size(); i++){
            if(hash[str[i]]>muninum){
                cout << str[i];
            }
        }
        cout << endl;
    }
}
HJ26字符串排序(思维不错)

在这里插入图片描述
主要思路：

  1. 先把字母字符入vector, 按照26个字母的顺序
  2. 在字符串str中，保持其他字符的位置，对有字母的位置用排好字母序的vector中的对应元素替代
#include <iostream>
#include <vector>

using namespace std;

string String_Sorting(string str){
    vector<char> vec; // 用一个 char 型的向量存储按规则排序后的字符串中的字母字符
    // 规则一：英文字母从 A 到 Z 排列，不区分大小写
    // 规则二：同一个英文字母的大小写同时存在时，按照输入顺序排列
    for(int j=0; j<26; j++){
        for(int i=0; i<str.size(); i++){
            if((str[i]-'a'==j)|| (str[i]-'A')==j){ // 字符相减是ASCII相减
                vec.push_back(str[i]); // 将符合规则的字母字符先后写入向量,比如A在a前面，那么A先入列
            }
        }
    }
    // 规则三：非英文字母的其它字符保持原来的位置
    for(int i=0, k=0;(i<str.size())&&(k<vec.size());i++){
        if((str[i]>='a'&&str[i]<='z')||(str[i]>='A'&&str[i]<='Z')){
            str[i]=vec[k];
            ++k;
        }
    }
    return str;
}
int main(){
    string str;
    while(getline(cin, str)){  // 每一行输入处理，测试用例有很多行
        cout <<String_Sorting(str) << endl;
    }
    return 0;
}
HJ27查找兄弟单词

在这里插入图片描述
主要思想:

  1. 对于输入的梳理，按照测试用例一个个用变量去保存
  2. 如何判断两个字母是兄弟字母，首先复制target到temp，对temp进行sort
    对复制dic[i]到tempdic, 也进行sort排序
    最后如果排序后两者相等，则为兄弟字母
    在进行这个判断之前，所如果emp.size()与tempdic不等，target==dic[i], 那一定不是兄弟字母
  3. 这题有个bug,输出前要对res排字典序
#include <iostream>
#include <string.h>
#include <vector>
#include <algorithm>

using namespace std;

int main(){
    int n; // 字典中单词的个数
    
    // 测试用例有多个，所以在每个测试用例第一个输入用while
    while(cin>>n){
        vector<string> dic; // 字典
        string word;
        // 字典初始化
        for(int i=0; i<n;i++){
            cin>>word;
            dic.push_back(word);
        }
        
        string target; // 目标单词
        cin>>target;
        int index; // 输出兄弟单词索引
        cin>>index;
        
        // 输入处理完毕，开始处理
        
        // 搜索兄弟单词
        vector <string> res; // 记录所有兄弟单词
        
        // 将目标单词和字典单词排序后比较他们是否相等来判断他们是否是兄弟单词
        string temp = target;
        sort(temp.begin(), temp.end()); // 排序
        int lent = target.size(); // 目标单词的长度
        
        // 对字典中的单词做同样的排序操作，并比较
        for(int i=0; i<n; i++){
            int lendic=dic[i].size();
            
            // 长度不同或者相同，则不是兄弟单词
            if((lendic==lent) && (target!=dic[i])){
                string tempdic = dic[i];
                sort(tempdic.begin(), tempdic.end());
                if(temp==tempdic){
                    res.push_back(dic[i]);
                }
            }
        }
        
        // 现在所有兄弟单词都在res中
        // 坑 一定要对res进行字典排序
        sort(res.begin(), res.end());
        cout<<res.size()<< endl;
        
        // 默认了index - 1  < res.size(), 其实没有
        if(index-1<res.size()){
            cout<<res[index-1]<<endl;
        }
    }
    return 0;
}
HJ29字符串加密解密 同HJ21

在这里插入图片描述
主要思想

  1. 加各种判断，遇到什么字母就转换
  2. 最好是对照着例子转，
    比如加密
    a->B: str[i]= str[i]-32+1;
    B->c: str[i]=str[i]+32+1;
    在‘z’和‘Z’需要特判

比如解密
B<-c: str[i]为c= str[i]-32-1;
a<-B: str[i]为B=str[i]+32-1;
在‘a’和‘A’需要特判

同时对于数字
加密：
‘0’～‘8’ ：str[i]=str[i]+1
在‘9’特判断

解密：
‘1’～‘9’ ：str[i]为1=str[i]-1；
在‘0’特判断

#include <iostream>
#include <string.h>
#include <vector>
using namespace std;

// 字符串加密
void Encrypt(string& aucPassword, string& aucResult){
    int len = aucPassword.size();
    
    for(int i=0; i<len; i++){
        // 遇到大写字母
        if(aucPassword[i]=='Z')
            aucResult[i]='a';
        else if(aucPassword[i]>='A'&&aucPassword[i]<='Y'){
            aucResult[i]=aucPassword[i]+32+1; // A->b
        }
        
        // 遇到小写字母
        else if(aucPassword[i]=='z')
            aucResult[i]='A';
        else if(aucPassword[i]>='a'&&aucPassword[i]<='y'){
            aucResult[i]=aucPassword[i]-32+1; // a->B
        }
        
        // 遇到数字
        else if(aucPassword[i] == '9')
            aucResult[i] = '0';
        else if(aucPassword[i] >= '0' && aucPassword[i] < '9'){
            aucResult[i]=aucPassword[i]+1; // '0'->'1'
        }
    }
}

void unEncrypt(string& result, string& password){
    // 开始解密
    for(int i=0; i<password.size(); i++){
        // 遇到大写字母
        if(password[i]=='A')
            result[i]='z';
        else if(password[i]>='B'&&password[i]<='Z'){
            result[i]=password[i]+32-1; //   a<-B
        }
        
        // 遇到小写字母
        else if(password[i]=='a')
            result[i]='Z';
        else if(password[i]>='b'&&password[i]<='z'){
            result[i]=password[i]-32-1; // A<-b
        }
        
        // 遇到数字
        else if(password[i] == '0')
            result[i] = '9';
        else if(password[i] >= '1' && password[i] <= '9'){
            result[i]=password[i]-1;
        }
    }
}
int main(){
    string str1;
    string str2;
    while(cin >> str1 >> str2){
        string result1 = str1; // 初始化size()一样
        string result2 = str2; // 初始化size()一样
        Encrypt(str1, result1);
        unEncrypt(result2, str2);
        cout << result1 << '\n' << result2 << endl;
    }
    return 0;
}
HJ30字符串合并处理 BIT倒序方法同HJ29(思维不错)

在这里插入图片描述
主要思路：

  1. 处理输入用cin, 按照奇偶先分开字符串，再分别sort, 再合并字符串
  2. 对合并的字符串进行BIT倒序操作
    主要是需要先验求一个helper2，这个可以在草稿纸上完成
    有点类似HJ29加密的方法
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const string helper1 = "0123456789abcdefABCDEF";
const string helper2 = "084C2A6E195D3B7F5D3B7F";

string ProcessString(string& mergestr){
    // 奇数 偶数 分别拆开
    string strji, strou;
    for(int i=0; i<mergestr.size(); i++){
        if(i%2==0)
            strou +=mergestr[i];
        else
            strji +=mergestr[i];
    }
    
    // 奇数偶数排序
    sort(strji.begin(), strji.end());
    sort(strou.begin(), strou.end());
    
    // 合并新的
    int index=0;
    for(int i=0; i<mergestr.size(); i++){
        if(i%2==0)
            mergestr[i]=strou[i/2];
        else
            mergestr[i]=strji[i/2];
    }
    
    // 开始加密
    for(int i=0; i<mergestr.size(); i++){
        int idx=helper1.find(mergestr[i]);
        if(idx!=-1) // 说明能找到是数字或者a～f A～F
            mergestr[i]=helper2[idx];
    }
    return mergestr;
}

int main(){
    string str1, str2;
    while(cin>>str1){
        cin>>str2;
        
        string mergestr;
        mergestr=str1+str2;
        
        mergestr=ProcessString(mergestr);
        cout << mergestr<<endl;
    }
    
    return 0;
}
HJ31 单词倒排

在这里插入图片描述
主要思路

  1. 先处理输入，把每个单词用vector保存
  2. 保存后，再在vector中倒序输出
#include <iostream>
#include <vector>

using namespace std;

int main(){
    string str;
    while(getline(cin, str)){
        vector<string> word; // 保存每个单词
        string temp ="";
        for(int i=0; i<str.size(); i++){
            // 字母才用来保存，间隔符就不用了
            if((str[i]>='a'&&str[i]<='z')||(str[i]>='A'&&str[i]<='Z')){
                temp+=str[i];
            }
            else{
                // else遇到空格符了
                // 此时准备push一个单词
                if(temp.size()>0){
                    word.push_back(temp);
                    // temp清空
                    temp="";
                }
            }
                
        }
        // 所有单词都进word了，除了最后一个单词
        if(temp.size()>0){
            word.push_back(temp);
        }
        
        // 倒序输出word
        for(int i=word.size()-1; i>0; i--){
            cout << word[i] <<' '; // 要保持每一个单词后带一个空格，所以第一个单词没有输出
        }
        // 输出第一个单词
        cout<<word[0]<<endl;
    }
    return 0;
}
HJ36字符串加密

在这里插入图片描述

主要思想：

  1. 根据key和26个字母创建 alp加密表（根据key中已经出现的字母，去掉26个字母中在key中出现，剩下的按照字母序添加到alp, 想到hash表实现这种功能）
  2. 根据s中在26个字母表中的位置，对应索引alp中的字母输出
  3. 注意在输出时，s为明文大小写，转换到密文后字母大小写保持
#include <iostream>

using namespace std;

int main(){
    string key, s;
    while(getline(cin, key)){
        getline(cin, s);
        // 创建加密表
        string alp; // 加密表
        // hash表,用数组的0和1,来表示
        //1. 首先根据key来创建加密表
        int p[26]={0}; // 对应26个字母表
        for(int i=0; i<key.size();i++){
            // 小写字母
            if(key[i]>='a'&&key[i]<='z'){
                // hash
                if(p[key[i]-'a']==0){
                    p[key[i]-'a']=1;
                    alp+=key[i]-32; // 统一大写
                }
            }
            // 大写字母
            if(key[i]>='A'&&key[i]<='Z'){
                // hash
                if(p[key[i]-'A']==0){
                    p[key[i]-'A']=1;
                    alp+=key[i]; // 统一大写
                }
            }
        }
        
        // 将字母表剩余字母填充到alp
        for(int i=0; i<26;i++){
            if(p[i]==0)
                alp+= 'A'+i;
        }
        
        // 查表输入明文输出暗文: 明文是小写，暗文就对应小写
        // s
        for(int i=0; i<s.size(); i++){
            if(s[i]>='a' && s[i]<='z'){
                char c = alp[s[i]-'a']+32; // s[i]-'a'即为在26个字母表中的位置，如果为1则在b即，去alp中索引位置为1的字母，由于alp之前全为大写所以这里要加32变小写
                cout << c;
            }
            if(s[i]>='A' && s[i]<='Z'){
                char c = alp[s[i]-'A']; // s[i]-'a'即为在26个字母表中的位置，如果为1则在b即，去alp中索引位置为1的字母
                cout << c;
            }
        }
        cout << endl;
    }
    return 0;
}
HJ52计算字符串的距离（同编辑距离）

在这里插入图片描述
在这里插入图片描述

// 暴搜法+memo
#include <iostream>
#include <string>
#include <vector>
#include <limits.h>

using namespace std;
    
int dfs(int i, int j, vector<vector<int>>& memo, string s1, string s2){
    //有一个已经到头了(此处已经包括处理了两个都到头的情况)
    //dp(i, j)的含义：s1[0,i)左闭右开与s2[0,j)左闭右开, 最少操作数
    if(i==-1) return j+1;
    if(j==-1) return i+1;
    if(memo[i][j]>0) return memo[i][j];
    if(s1[i]==s2[j]){
        memo[i][j]=dfs(i-1,j-1, memo, s1, s2);
    }
    else{
        
        int operator1 = dfs(i-1,j, memo, s1, s2)+1;
        int operator2 = dfs(i,j-1, memo, s1, s2)+1;
        int operator3 = dfs(i-1,j-1, memo, s1, s2)+1;
        memo[i][j]=min(operator1, min(operator2, operator3));
    }
    return memo[i][j];
}
    


int main(){
    
    string s1;
    string s2;
    while(cin>>s1>>s2){
        // s1->s2
        //if(s1.length()==0) return s2.length(); // 加上word2的所有字符
        //if(s2.length()==0) return s1.length(); // 删掉word2的所有字符
        
        vector<vector<int>> memo(s1.length(), vector<int>(s2.length()));
        cout << dfs(s1.length()-1, s2.length()-1,memo, s1, s2) << endl;
    }
    return 0;
}
HJ63DNA序列

在这里插入图片描述
主要思路：
1.m是固定的，返回的子串长度都为m=5
2.因此在str中连续的子串每5个去计数C/G的数量
3.冒泡得到C/G数量最多的一段，然后返回索引，再用substr(index, m)去截取这一段

#include <iostream>
#include <string.h>
#include <limits.h>
#include <vector>
using namespace std;

string maxRatio(string s, int m)
{
  int size = s.size();
  vector<int> k(size, 0);
  vector<int> sum(size, 0);
  for (int i = 0; i < s.size(); i++)
  {
    if (s[i] == 'C' || s[i] == 'G')
    {
      k[i]++;
    }
  }
  // 统计连续k个元素的段的C或者G值
  for (int i = 0; i < s.size() - m; i++)
  {
    for (int j = 0; j < m; j++)
    {
      sum[i] += k[i + j];
    }
  }
  // 找C或者G值最大的那一个连续k个元素段
  int max = INT_MIN;
  int idx = 0;
  for (int i = 0; i < s.size(); i++)
  {
    if (sum[i] > max)
    {
      max = sum[i];
      idx = i;
    }
  }
  return s.substr(idx, m);
}

int main()
{
  string str;
  int n;
  while (getline(cin, str))
  {
    cin >> n;
    cout << maxRatio(str, n) << endl;
  }
  return 0;
}
ryontang
关注
专栏目录
2024年华为OD机试备考全攻略：详细题解与刷题策略（适用于Java、C++、Python等编程语言）
m0_57781768的博客
09-16 509
华为OD员工并非华为的正式员工，而是由第三方外包公司（例如德科）派驻到华为工作的技术开发人员。虽然OD员工不直接隶属于华为，但其薪资水平和工作内容与华为的正式员工几乎没有区别。华为通过OD员工来扩充其技术后备力量，并在项目紧急需求时有效缓解人力不足的问题。OD员工的工作内容一般涵盖信息安全、研发开发、日常系统维护等。华为OD岗位的招聘严格，要求求职者具备扎实的编程能力及良好的应试技巧。虽然OD岗位的招聘流程与正式员工有较多相似之处，但其机试和面试的考核要求相对独立。
【华为OD机试真题】20、火星文计算 | 机试真题+思路参考+代码解析（C语言、C++、Java、Py、JS）
KJ.JK
08-09 7108
已知火星人使用的运算符为#、$，其与地球人的等价公式如下： x#y = 2*x+3*y+4 x$y = 3*x+y+2 1、其中x、y是无符号整数 2、地球人公式按C语言规则计算 3、火星人公式中，$的优先级高于#，相同的运算符，按从左到右的顺序计算 现有一段火星人的字符串报文，请你来翻译并计算结果。
华为OD机试题：最长回文子串
cxh21627的博客
06-04 328
给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。所谓回文串，指左右对称的字符串。所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串数据范围：字符串长度1≤s≤350进阶：时间复杂度：O(n)\O(n) ，空间复杂度：O(n)\O(n)输入一个仅包含小写字母的字符串返回最长回文子串的长度输入： cdabbacc 输出：4 说明：abba为最长的回文子串.........
华为机试--字符串
weixin_55435895的博客
07-24 212
刷题哦
华为机试：字符串分隔
HxxxxxxU的博客
03-26 818
题目：连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner=new Scanner(Syste...
华为机试-字符串子序列II
weixin_45019986的博客
07-02 403
理解这个抽象题目，其实就是一个求最长子序列的题目。求最长子序列我们一般使用动态规划来做。 与以往不同的是，我们需要倒序求最长子序列，这样可以求得子序列首字母第一次出现的位置。也就是 。......
华为机试 找字符串
不想在做搬运工
05-11 225
题目   输入：有两组输入，第一组输入带有空格字符，第二组输入不带有空格输入；   输出：第二组字符串在第一组中存在的次数； 例子   输入：“Aabb bwe” “bb”   输出：2 实现代码 #include <iostream> #include<string> using namespace std; int main() { string a,b; getline(cin, a); getline(cin, b); if (a.size() > 102
华为机试：10，java面试常问问题
最新发布
m0_61330806的博客
03-22 559
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书（都整理成文档，小部分截图）[外链图片转存中…(img-verjUgxr-1711101719542)]最新整理电子书[外链图片转存中…(img-qez0Cfbi-1711101719542)]本文已被。
总结15个大厂机试面试问题及答案，连第一个问题都没过！
qq_43080036的博客
10-12 3872
前言 前两天有群友在说，去华为面试的时候遇到了机试部分，但是没有提前做准备，导致凉凉了，所以小编连忙准备了一些各大厂的机试题，以便不时之需。 一：字符串最后一个单词的长度：题目：输入为数个单词，以空格隔开；要求输出最后一个单词的长度。思路：读入字符串，求出字符串具体长度l，然后指针从后往前直到指向空格，记录此时的下标i，则最后一个字符串的长度为l+1-i代码如下： 1 2 3 4 5 6 7 8 9 10 .
华为OD——java开发工程师面试（附回忆版题目）
热门推荐
qq1354452957的博客
02-21 1万+
1月份同学给我推荐了这个岗位，因为没有工作经历，所以还是比较有压力的，只能尽力准备了。 一、机试 在正式机试之前，我在牛客网在线编程练了几十道题，原本的计划是题目练完的，但是看错了机试时间，最后匆忙机试。 1、机试题目 【正则表达式匹配】请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符...
【数据结构与算法】String大数加减乘除（非负整数）
mick_seu的博客
04-12 3908
leetcode上一题使用String完成大数乘法，鉴于之前华为机试也考到过大数减法，这里做一个大数运算的专题。 说到底，大数运算考察的还是对运算的理解，我们完全可以通过模拟手算来进行。 注意string与int间的转换，string[] - '0' 变成int，int + '0' 变成 string[]。 由于我们希望能用下标与数字的位数对应起来，所以需要用 reverse(s.begin
华为机试题——字符串处理
hxysea的专栏
07-31 692
package com.abuge; import java.util.Comparator; import java.util.TreeSet; import org.junit.Test; /** * 2 字符串处理转换 问题描述： 在给定字符串中找出单词（ “单词”由大写字母和小写字母字符构成，其他非字母字符视为单词的间隔，如空格、问号、数字等等； 另外单个字母不算单词
华为机试在线训练-牛客网（40）字符统计
Ctrlturtle的博客
02-28 804
题目描述 如果统计的个数相同，则按照ASII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。 实现以下接口：     输入一个字符串，对字符中的各个英文字符，数字，空格进行统计（可反复调用）     按照统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASII码由小到大排序输出     清空目前的统计结果，重新统计 调用者会保证： 输入的字符串以‘\0’结
最长回文子串
qq_34241578的博客
03-31 158
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 最长回文子串题目描述解题过程解题思路总结 题目描述 给定一个仅包含小写字母的字符串，求它的最长回文子串的长度。 所谓回文串，指左右对称的字符串。 所谓子串，指一个字符串删掉其部分前缀和后缀（也可以不删）的字符串 （注意：记得加上while处理多个测试用例） 输入描述: 输入一个仅包含小写字母的字符串 输出描述: 返回最长回文子串的长度 示例1 输入 cdabbacc 输出 4 说明 abba为最长的回文子串 题目来源：牛客网 解题过
华为机试：字符串系列
baidu_19950899的专栏
09-02 460
1. 字符串过滤 题目描述（60分）： 通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。 比如字符串“abacacde”过滤结果为“abcde”。 要求实现函数：void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
华为OD机试之字符串序列判定（Java源码）
小马哥的博客
05-24 941
[0, 4, 3], [0, 4, 5], [0, 4, 6], [0, 4, 8], [0, 7, 3], [0, 7, 5], [0, 7, 6], [0, 7, 8], [2, 4, 3], [2, 4, 5], [2, 4, 6], [2, 4, 8], [2, 7, 3], [2, 7, 5], [2, 7, 6], [2, 7, 8]] 对应ace索引组合可能出现的情况。[[0, 2], [4, 7], [3, 5, 6, 8]] 对应a c e出现的索引。S串最后一个有效字符在L中的位置。
华为机试训练4-字符串分隔
wanghuan1020的博客
01-27 176
华为机试训练4-字符串分隔题目描述题目分析代码 题目描述 题目描述 连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 输入描述:连续输入字符串(输入多次,每个字符串长度小于100) 输出描述:输出到长度为8的新字符串数组 示例1： 题目分析 字符串分割可以用 substr(start, length) 方法 长度不足 8 后面补零可以使用 padEnd(8, '0') 实现 代码 const readlin
华为机试-14-字符串排列
lozixi的博客
08-09 389
字符串排列 题目：给定n个字符串，请对n个字符串按照字典序排列。 输入描述: 输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。 输出描述: 数据输出n行，输出结果为按照字典序排列的字符串。 示例： 输入 3 cap to cat 输出 cap cat to 代码 import java.util.Scanner...
华为2015实习上机：字符串排序
Sunshine的专栏
04-18 4742
可以看出，下面的程序就是一个快速排序算法，只是增加了对非英文字母的字符的处理： 快速排序参考文章快速排序的几种常见实现 //输入字符串，按照字母的ascii码顺序排序，其他非字母字符在字符串中位置不变 //如，输入Wor#d，输出Wdo#r //快速排序实现 void QuickStrSort(char str[], int left, int right) { char pivot =
python3实现华为机试字符串排序
01-10
在Python3中，可以通过内置函数和方法来实现华为机试中的字符串排序。 首先，读取用户输入的字符串，可以使用input函数。接着，将输入的字符串以空格为分隔符切分为一个字符串列表，使用split()方法。然后，使用sort()方法对列表进行排序，sort()方法默认按照字母的顺序进行排序。最后，使用join()方法将排序后的字符串列表以空格为分隔符合并成一个字符串。 下面是一个示例代码： ```python # 读取用户输入的字符串 input_str = input("请输入一串以空格分隔的字符串：") # 将输入的字符串以空格为分隔符切分为一个字符串列表 str_list = input_str.split() # 使用sort()方法对列表进行排序 str_list.sort() # 使用join()方法将排序后的字符串列表以空格为分隔符合并成一个字符串 output_str = " ".join(str_list) # 输出排序后的字符串结果 print("排序后的字符串为：", output_str) ``` 以上代码实现了字符串的排序功能。用户可以输入一串以空格分隔的字符串，程序将会对字符串进行排序，并输出排序后的结果。 注意：代码中使用的是Python内置的排序方法，它会按照字符串的字母顺序进行排序。如果需要按照其他特定的方式进行排序，可以自定义排序方法或者使用其他排序算法来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值