七日集训day02（字符串）

题目01-2315. 统计星号

链接

https://leetcode.cn/problems/count-asterisks/

思路

直接把不是分组内的星号数量作为结果。
竖线的个数 % 2 == 0 时的竖线就是一个分组的结尾，只需要在这个结尾开始统计星号个数即可。

代码

class Solution {
public:
    int countAsterisks(string s) {
        //统计竖线个数
        int cnt = 0;
        //统计星号个数，作为返回结果
        int res = 0;
        for(int i = 0; i < s.size(); i++)
        {
            //先统计竖线个数
            if(s[i] == '|')
            {
                cnt++;
            }
            else
            {
                //如果当前的竖线是偶数，代表是一组的结尾
                if(cnt % 2 == 0)
                {
                    //那么就开始统计星号的个数，并作为结果
                    res += (s[i] == '*' ? 1 : 0);
                }
            }
        }
        return res;
    }
};

题目02

链接

https://leetcode.cn/problems/repeated-substring-pattern/

代码/思路

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int len = s.size();
        //因为子串至少重一次，所以可以只遍历一半
        for(int i = 1; i * 2 <= len; i++)
        {
            //找出第一个字符串可以分界的位置
            if(len % i == 0)
            {
                //假设可以字符串可以由若干子串重复形成
                bool match = true;
                //验证是否由若干子串组成
                for(int j = i; j < len; j++)
                {
                    if(s[j] != s[j - i])
                    {
                        match = false;
                        break;
                    }
                    
                }
                if(match)
                {
                    return true;
                }
            }
        }
        return false;
    }
};

题目03

链接

https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal/

代码/思路

class Solution {
    void swap(char &a, char &b)
    {
        char t = a;
        a = b;
        b = t;
    }
public:
    bool areAlmostEqual(string s1, string s2) {
        /*
        由于最多只交换一次，所以比较简单
        */
        //如果两个数组的长度都不等，那么肯定不能通过交换使得两数组相等
        if(s1.size() != s2.size())
        {
            return false;
        }
        int len = s1.size();
        //用一个pos数组记录出现差异的位置
        vector<int> pos;
        for(int i = 0; i < len; i++)
        {
            if(s1[i] != s2[i])
            {
                pos.push_back(i);
            }
        }
        //没有差异则代表两个数组相同
        if(pos.size() == 0)
        {
            return true;
        }
        //有差异并且只有两个位置的元素不同
        else if (pos.size() == 2)
        {
            //那么我们可以通过交换两个位置的元素后，来判断是否通过只交换一次来达到两数组相同
            swap(s1[pos[0]], s1[pos[1]]);
            return s1 == s2;
        }
        //以上条件不满足，代表有两个以上的位置元素不相同，则无法通过只交换一次来实现数组相同
        return false;
    }
};

题目04

链接

https://leetcode.cn/problems/check-if-string-is-a-prefix-of-array/

代码//思路

class Solution {
    bool isSubString(const string &s, const string &words, int st)
    {
        //遍历s
        for(int i = st; i < st + words.size(); i++)
        {
            //当s用完了，也就是比较的时候words的长度大于了s能比较的子串长度
            if(i >= s.size())
            {
                return false;
            }
            //找到一个不相等的元素，就返回false
            if(s[i] != words[i - st])
            {
                return false;
            }
        }
        //比较完了，没有不相等的字符就返回true
        return true;
    }
    /*
    思路就是把words的每个元素拿出来与s对应位置的元素进行一一字符比较
    */
public:
    bool isPrefixString(string s, vector<string>& words) {
        //st代表开始比较的位置
        int st = 0;
        //遍历words中的每个元素
        for(int i = 0; i < words.size(); i++)
        {
            //如果当前元素是s的子串
            if(isSubString(s, words[i], st))
            {
                //比较位置改变
                st += words[i].size();
                //当比较位置和s的长度相等，代表比较完成
                if(st == s.size())
                {
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        return false;
    }
};