C++ stringOJ练习题

2023-12-15 19:30:21

目录

把字符串转换成整数?

反转字符串

字符串中的第一个唯一字符

字符串最后一个单词的长度

找出字符串中第一个只出现一次的字符?

字符串相加

字符串最后一个单词长度

字符串相乘

反转字符串3

反转字符串2

验证回文串


把字符串转换成整数?

?

通过遍历字符串并逐位转换,处理空格、正负号和整数溢出的情况。最终返回转换后的整数。?

class Solution {
  public:
    int StrToInt(string str) {
        const int len = str.length();
        if (len == 0) return 0;
        int i = 0;
        while (i < len && str[i] == ' ') {
            ++i;    // 排除开头的空格
        }
        if (i == len) return 0;
        if (!isdigit(str[i]) && str[i] != '+' && str[i] != '-') return 0;
        bool neg = str[i] == '-' ? true : false;
        i = isdigit(str[i]) ? i : i + 1;
        long long ans = 0L;

        while (i < len && isdigit(str[i])) {
            ans = ans * 10 + (str[i++] - '0');

            if (!neg && ans > INT_MAX) {
                ans = INT_MAX;
                break;
            }
            if (neg && ans > 1L + INT_MAX) {
                ans = 1L + INT_MAX;
                break;
            }
        }
        if (i != len) return 0; 
        return !neg ? static_cast<int>(ans) : static_cast<int>(-ans);
    }
};

  1. 首先,定义了一个函数?StrToInt,该函数接受一个字符串参数?str,表示要转换的字符串。

  2. 获取字符串的长度,并检查长度是否为0。如果长度为0,则返回0。

  3. 初始化变量?i?为0,用于遍历字符串。

  4. 使用?while?循环跳过字符串开头的空格,将?i?向后移动。

  5. 检查?i?是否已经达到字符串的末尾,如果是,则返回0。

  6. 检查?str[i]?是否为数字、正号或负号。如果不是,则返回0。

  7. 根据?str[i]?的值,确定是否为负数,并将结果存储在布尔变量?neg?中。

  8. 如果?str[i]?不是数字,则将?i?向后移动一位。

  9. 初始化变量?ans?为0,用于存储转换后的整数。

  10. 进入循环,只要?i?小于字符串的长度且?str[i]?是数字,就执行循环体。

  11. 在循环体内,将?ans?乘以10,并加上?str[i]?减去字符 '0' 的结果,以将字符转换为数字。

  12. 检查转换后的整数是否超出了?INT_MAX?的范围。如果超出了,则将?ans?设置为?INT_MAX?或?1L + INT_MAX,具体取决于?neg?的值。

  13. 将?i?向后移动一位。

  14. 循环结束后,检查?i?是否等于字符串的长度。如果不相等,则表示字符串中包含非数字字符,返回0。

  15. 根据?neg?的值,返回转换后的整数,使用?static_cast<int>?进行类型转换。

?

反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) {
        reverse(s.begin(),s.end());
    }
};

字符串中的第一个唯一字符

?

class Solution {
public:
    int firstUniqChar(string s) {
        int count[26]={0};
        for(auto ch:s){
            count[ch-'a']++;
        }
        for(int i=0;i<s.size();i++){
            if(count[s[i]-'a']==1)
                return i;
        }
        return -1;
    }
};

字符串最后一个单词的长度

?

#include <iostream>
using namespace std;

int main() {
    string str;
    getline(cin,str);
    size_t pos=str.rfind(' ');
    if(pos!=string::npos){
        cout<<str.size()-pos-1<<endl;
    }
    else{
        cout<<str.size()<<endl;
    }
}

找出字符串中第一个只出现一次的字符?

?

#include <iostream>
#include <string>
using namespace std;

int main() {
    string a;
    cin>>a;
    int charCount[256]={0};
    for(auto e:a)
    {
        ++charCount[e];
    }
    int s=-1;
    for(auto e:a)
    {
        if(charCount[e]==1)
        {
            cout<<e;
            s=1;
            break;
        }
    }
    if(s==-1)
        cout<<s;
}
  1. 首先,定义了一个字符串变量?a,用于接收用户的输入。

  2. 创建一个大小为256的整型数组?charCount,用于记录每个字符在字符串中出现的次数。初始时,所有元素都被初始化为0。

  3. 使用?for?循环遍历字符串?a?中的每个字符。

  4. 在循环中,将当前字符?e?对应的?charCount?数组元素加1,以统计字符出现的次数。

  5. 初始化变量?s?为-1,用于标记是否找到了不重复的字符。

  6. 使用另一个?for?循环遍历字符串?a?中的每个字符。

  7. 在循环中,检查当前字符?e?在?charCount?数组中的值。如果值为1,表示该字符只出现了一次,即为第一个不重复的字符。

  8. 输出该字符,并将变量?s?设置为1,表示已找到不重复字符。

  9. 如果循环结束后?s?仍为-1,表示没有找到不重复的字符。

  10. 输出变量?s?的值,即-1。

?

字符串相加

?

class Solution {
public:
    string addStrings(string num1, string num2) {
        int end1=num1.size()-1;
        int end2=num2.size()-1;
        int next=0;
        string str;
        str.reserve(num1.size()>num2.size()?num1.size()+1:num2.size()+1);
        while(end1>=0||end2>=0){
            int val1=end1>=0?num1[end1]-'0':0;
            int val2=end2>=0?num2[end2]-'0':0;
            int ret =val1+val2+next;
            next=ret/10;
            ret=ret%10;
            str+='0'+ret;
            --end1,--end2;
        }
        if(next==1)
            str+='1';
        reverse(str.begin(),str.end());
        return str;
    }
};
  1. 首先,定义了一个函数?addStrings,该函数接受两个字符串参数?num1?和?num2,表示要相加的两个数字。

  2. 初始化变量?end1?和?end2?分别为?num1?和?num2?的最后一个字符的索引。

  3. 初始化变量?next?为0,用于记录进位。

  4. 创建一个空字符串?str,用于存储相加的结果。

  5. 根据两个字符串的长度,预先分配?str?的容量,以避免不必要的内存重新分配。

  6. 进入循环,只要?end1?或?end2?中至少有一个大于等于0,就执行循环体。

  7. 在循环体内,首先获取?num1?和?num2?当前索引位置的字符,并将其转换为对应的数字值。如果已经超出字符串的范围,则将其视为0。

  8. 将?val1val2?和?next?相加,得到?ret,并更新?next?为?ret?除以10的商,更新?ret?为?ret?除以10的余数。

  9. 将?ret?转换为字符,并将其添加到?str?的末尾。

  10. 更新?end1?和?end2,向前移动一位。

  11. 循环结束后,如果?next?为1,说明最高位有进位,将字符 '1' 添加到?str?的末尾。

  12. 将?str?反转,得到正确的相加结果。

  13. 返回?str

?

字符串最后一个单词长度

?

?首先介绍一下接下来会用到的读取字符串的函数getline.

getline?是 C++ 标准库中的一个函数,用于从输入流中读取一行字符串。它有以下几个特点:

  1. 读取一行字符串getline?函数会读取输入流中的一行字符串,直到遇到换行符('\n') 或者文件结束符(EOF)。它将读取的字符串存储到指定的变量中。

  2. 处理空格字符:与?cin?不同,getline?函数会将空格字符(包括空格、制表符等)视为普通字符,而不是作为分隔符。这意味着?getline?可以读取包含空格的字符串,而不会在空格处停止读取。

  3. 保留换行符getline?函数会将换行符('\n') 从输入流中读取并存储在字符串中,即使它是一行的结尾。这与?cin?不同,cin?会将换行符视为分隔符并从输入流中丢弃。

  4. 指定分隔符:除了默认的换行符作为分隔符外,getline?函数还可以接受一个可选的分隔符参数,用于指定其他字符作为行的结束标志。例如,可以使用?getline(cin, str, ',')?来读取以逗号分隔的字符串。

#include <iostream>
using namespace std;

int main() {
    string str;
    getline(cin,str);
    size_t pos=str.rfind(' ');
    if(pos!=string::npos){
        cout<<str.size()-pos-1<<endl;
    }
    else{
        cout<<str.size()<<endl;
    }
}

字符串相乘

?

?

class Solution {
public:
    string multiply(string num1, string num2) {
        if(num1=="0"||num2=="0")
            return "0";
        int n1=num1.size(),n2=num2.size();
        string result(n1+n2,'0');
       for (int i = n1 - 1; i >= 0; i--) {
            for (int j = n2 - 1; j >= 0; j--) {
                int product = (num1[i] - '0') * (num2[j] - '0') + (result[i + j + 1] - '0');
                result[i + j + 1] = product % 10 + '0';
                result[i + j] += product / 10;
            }
        }

        size_t startpos = result.find_first_not_of("0");
        if (string::npos != startpos) {
            return result.substr(startpos);
        }
        return "0";
    }
};

反转字符串3

?

class Solution {
public:
    string reverseWords(string s) {
        int pos=s.find(' ');
        int start=0;
        while(pos!=string::npos)
        {
            reverse(s.begin()+start,s.begin()+pos);
            start=pos+1;
            pos=s.find(' ',pos+1); 
        }
        reverse(s.begin()+start,s.end());
        return s;
    }
};

反转字符串2

?

class Solution {
public:
    string reverseStr(string s, int k) {
        auto start = s.begin();
        while (start < s.end()) {
            if (start + k < s.end()) {
                reverse(start, start + k);
            } else {
                reverse(start, s.end());
            }
            start += 2 * k;
        }
        return s;
    }
};

验证回文串

?

class Solution {
public:
    bool isPalindrome(string s) {
        string judge;
        for(char c:s)
        {
            if(isalnum(c))
                judge+=tolower(c);
        }
        int left=0;
        int right=judge.size()-1;
        while(left<right)
        {
            if(judge[left]!=judge[right])
            {
                return false;
            }
            ++left;--right;
        }
        return true;
    }
};

文章来源:https://blog.csdn.net/m0_73800602/article/details/134842051
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。